github.com/cilium/cilium@v1.16.2/pkg/bgpv1/types/conversions.go (about)

     1  // SPDX-License-Identifier: Apache-2.0
     2  // Copyright Authors of Cilium
     3  
     4  package types
     5  
     6  import (
     7  	"fmt"
     8  
     9  	"github.com/cilium/cilium/pkg/k8s/apis/cilium.io/v2alpha1"
    10  )
    11  
    12  // SessionState as defined in rfc4271#section-8.2.2
    13  type SessionState uint32
    14  
    15  const (
    16  	SessionUnknown SessionState = iota
    17  	SessionIdle
    18  	SessionConnect
    19  	SessionActive
    20  	SessionOpenSent
    21  	SessionOpenConfirm
    22  	SessionEstablished
    23  )
    24  
    25  func (s SessionState) String() string {
    26  	switch s {
    27  	case SessionUnknown:
    28  		return "unknown"
    29  	case SessionIdle:
    30  		return "idle"
    31  	case SessionConnect:
    32  		return "connect"
    33  	case SessionActive:
    34  		return "active"
    35  	case SessionOpenSent:
    36  		return "open_sent"
    37  	case SessionOpenConfirm:
    38  		return "open_confirm"
    39  	case SessionEstablished:
    40  		return "established"
    41  	default:
    42  		return "unknown"
    43  	}
    44  }
    45  
    46  // Afi is address family identifier
    47  type Afi uint32
    48  
    49  const (
    50  	AfiUnknown Afi = 0
    51  	AfiIPv4    Afi = 1
    52  	AfiIPv6    Afi = 2
    53  	AfiL2VPN   Afi = 25
    54  	AfiLS      Afi = 16388
    55  	AfiOpaque  Afi = 16397
    56  )
    57  
    58  // FromString assigns s to a. An error is returned if s is
    59  // an unknown address family indicator.
    60  func (a *Afi) FromString(s string) error {
    61  	switch s {
    62  	case "ipv4":
    63  		*a = AfiIPv4
    64  	case "ipv6":
    65  		*a = AfiIPv6
    66  	case "l2vpn":
    67  		*a = AfiL2VPN
    68  	case "ls":
    69  		*a = AfiLS
    70  	case "opaque":
    71  		*a = AfiOpaque
    72  	default:
    73  		return fmt.Errorf("Unknown Afi: %s", s)
    74  	}
    75  	return nil
    76  }
    77  
    78  // String returns the stringified form of a.
    79  func (a Afi) String() string {
    80  	switch a {
    81  	case AfiUnknown:
    82  		return "unknown"
    83  	case AfiIPv4:
    84  		return "ipv4"
    85  	case AfiIPv6:
    86  		return "ipv6"
    87  	case AfiL2VPN:
    88  		return "l2vpn"
    89  	case AfiLS:
    90  		return "ls"
    91  	case AfiOpaque:
    92  		return "opaque"
    93  	default:
    94  		return "unknown"
    95  	}
    96  }
    97  
    98  // ParseAfi parses s as an address family identifier.
    99  // If s is unknown, AfiUnknown is returned.
   100  func ParseAfi(s string) Afi {
   101  	var ret Afi
   102  	switch s {
   103  	case "ipv4":
   104  		ret = AfiIPv4
   105  	case "ipv6":
   106  		ret = AfiIPv6
   107  	case "l2vpn":
   108  		ret = AfiL2VPN
   109  	case "ls":
   110  		ret = AfiLS
   111  	case "opaque":
   112  		ret = AfiOpaque
   113  	default:
   114  		ret = AfiUnknown
   115  	}
   116  	return ret
   117  }
   118  
   119  // Safi is subsequent address family identifier
   120  type Safi uint32
   121  
   122  const (
   123  	SafiUnknown                Safi = 0
   124  	SafiUnicast                Safi = 1
   125  	SafiMulticast              Safi = 2
   126  	SafiMplsLabel              Safi = 4
   127  	SafiEncapsulation          Safi = 7
   128  	SafiVpls                   Safi = 65
   129  	SafiEvpn                   Safi = 70
   130  	SafiLs                     Safi = 71
   131  	SafiSrPolicy               Safi = 73
   132  	SafiMup                    Safi = 85
   133  	SafiMplsVpn                Safi = 128
   134  	SafiMplsVpnMulticast       Safi = 129
   135  	SafiRouteTargetConstraints Safi = 132
   136  	SafiFlowSpecUnicast        Safi = 133
   137  	SafiFlowSpecVpn            Safi = 134
   138  	SafiKeyValue               Safi = 241
   139  )
   140  
   141  // FromString assigns safi to s. An error is returned if safi
   142  // is an unknown subsequent address family indicator.
   143  func (s *Safi) FromString(safi string) error {
   144  	switch safi {
   145  	case "unicast":
   146  		*s = SafiUnicast
   147  	case "multicast":
   148  		*s = SafiMulticast
   149  	case "mpls_label":
   150  		*s = SafiMplsLabel
   151  	case "encapsulation":
   152  		*s = SafiEncapsulation
   153  	case "vpls":
   154  		*s = SafiVpls
   155  	case "evpn":
   156  		*s = SafiEvpn
   157  	case "ls":
   158  		*s = SafiLs
   159  	case "sr_policy":
   160  		*s = SafiSrPolicy
   161  	case "mup":
   162  		*s = SafiMup
   163  	case "mpls_vpn":
   164  		*s = SafiMplsVpn
   165  	case "mpls_vpn_multicast":
   166  		*s = SafiMplsVpnMulticast
   167  	case "route_target_constraints":
   168  		*s = SafiRouteTargetConstraints
   169  	case "flowspec_unicast":
   170  		*s = SafiFlowSpecUnicast
   171  	case "flowspec_vpn":
   172  		*s = SafiFlowSpecVpn
   173  	case "key_value":
   174  		*s = SafiKeyValue
   175  	default:
   176  		return fmt.Errorf("Unknown Safi: %s", s)
   177  	}
   178  	return nil
   179  }
   180  
   181  // String returns the stringified form of s.
   182  func (s Safi) String() string {
   183  	switch s {
   184  	case SafiUnknown:
   185  		return "unknown"
   186  	case SafiUnicast:
   187  		return "unicast"
   188  	case SafiMulticast:
   189  		return "multicast"
   190  	case SafiMplsLabel:
   191  		return "mpls_label"
   192  	case SafiEncapsulation:
   193  		return "encapsulation"
   194  	case SafiVpls:
   195  		return "vpls"
   196  	case SafiEvpn:
   197  		return "evpn"
   198  	case SafiLs:
   199  		return "ls"
   200  	case SafiSrPolicy:
   201  		return "sr_policy"
   202  	case SafiMup:
   203  		return "mup"
   204  	case SafiMplsVpn:
   205  		return "mpls_vpn"
   206  	case SafiMplsVpnMulticast:
   207  		return "mpls_vpn_multicast"
   208  	case SafiRouteTargetConstraints:
   209  		return "route_target_constraints"
   210  	case SafiFlowSpecUnicast:
   211  		return "flowspec_unicast"
   212  	case SafiFlowSpecVpn:
   213  		return "flowspec_vpn"
   214  	case SafiKeyValue:
   215  		return "key_value"
   216  	default:
   217  		return "unknown"
   218  	}
   219  }
   220  
   221  // ParseSafi parses s as a subsequent address family identifier.
   222  // If s is unknown, SafiUnknown is returned.
   223  func ParseSafi(s string) Safi {
   224  	var ret Safi
   225  	switch s {
   226  	case "unicast":
   227  		ret = SafiUnicast
   228  	case "multicast":
   229  		ret = SafiMulticast
   230  	case "mpls_label":
   231  		ret = SafiMplsLabel
   232  	case "encapsulation":
   233  		ret = SafiEncapsulation
   234  	case "vpls":
   235  		ret = SafiVpls
   236  	case "evpn":
   237  		ret = SafiEvpn
   238  	case "ls":
   239  		ret = SafiLs
   240  	case "sr_policy":
   241  		ret = SafiSrPolicy
   242  	case "mup":
   243  		ret = SafiMup
   244  	case "mpls_vpn":
   245  		ret = SafiMplsVpn
   246  	case "mpls_vpn_multicast":
   247  		ret = SafiMplsVpnMulticast
   248  	case "route_target_constraints":
   249  		ret = SafiRouteTargetConstraints
   250  	case "flowspec_unicast":
   251  		ret = SafiFlowSpecUnicast
   252  	case "flowspec_vpn":
   253  		ret = SafiFlowSpecVpn
   254  	case "key_value":
   255  		ret = SafiKeyValue
   256  	default:
   257  		ret = SafiUnknown
   258  	}
   259  	return ret
   260  }
   261  
   262  func ToAgentFamily(fam v2alpha1.CiliumBGPFamily) Family {
   263  	return Family{
   264  		Afi:  ParseAfi(fam.Afi),
   265  		Safi: ParseSafi(fam.Safi),
   266  	}
   267  }