diff options
Diffstat (limited to 'packet/bgp/bgp.go')
| -rw-r--r-- | packet/bgp/bgp.go | 9674 |
1 files changed, 0 insertions, 9674 deletions
diff --git a/packet/bgp/bgp.go b/packet/bgp/bgp.go deleted file mode 100644 index 01251167..00000000 --- a/packet/bgp/bgp.go +++ /dev/null @@ -1,9674 +0,0 @@ -// Copyright (C) 2014 Nippon Telegraph and Telephone Corporation. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or -// implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package bgp - -import ( - "bytes" - "encoding/binary" - "encoding/json" - "fmt" - "math" - "net" - "reflect" - "regexp" - "sort" - "strconv" - "strings" -) - -type MarshallingOption struct { - AddPath map[RouteFamily]BGPAddPathMode -} - -func IsAddPathEnabled(decode bool, f RouteFamily, options []*MarshallingOption) bool { - for _, opt := range options { - if opt == nil { - continue - } - if o := opt.AddPath; o != nil { - if decode && o[f]&BGP_ADD_PATH_RECEIVE > 0 { - return true - } else if !decode && o[f]&BGP_ADD_PATH_SEND > 0 { - return true - } - } - } - return false -} - -const ( - AFI_IP = 1 - AFI_IP6 = 2 - AFI_L2VPN = 25 - AFI_OPAQUE = 16397 -) - -const ( - SAFI_UNICAST = 1 - SAFI_MULTICAST = 2 - SAFI_MPLS_LABEL = 4 - SAFI_ENCAPSULATION = 7 - SAFI_VPLS = 65 - SAFI_EVPN = 70 - SAFI_MPLS_VPN = 128 - SAFI_MPLS_VPN_MULTICAST = 129 - SAFI_ROUTE_TARGET_CONSTRAINTS = 132 - SAFI_FLOW_SPEC_UNICAST = 133 - SAFI_FLOW_SPEC_VPN = 134 - SAFI_KEY_VALUE = 241 -) - -const ( - BGP_ORIGIN_ATTR_TYPE_IGP uint8 = 0 - BGP_ORIGIN_ATTR_TYPE_EGP uint8 = 1 - BGP_ORIGIN_ATTR_TYPE_INCOMPLETE uint8 = 2 -) - -const ( - BGP_ASPATH_ATTR_TYPE_SET = 1 - BGP_ASPATH_ATTR_TYPE_SEQ = 2 - BGP_ASPATH_ATTR_TYPE_CONFED_SEQ = 3 - BGP_ASPATH_ATTR_TYPE_CONFED_SET = 4 -) - -// RFC7153 5.1. Registries for the "Type" Field -// RANGE REGISTRATION PROCEDURES -// 0x00-0x3F Transitive First Come First Served -// 0x40-0x7F Non-Transitive First Come First Served -// 0x80-0x8F Transitive Experimental Use -// 0x90-0xBF Transitive Standards Action -// 0xC0-0xCF Non-Transitive Experimental Use -// 0xD0-0xFF Non-Transitive Standards Action -type ExtendedCommunityAttrType uint8 - -const ( - EC_TYPE_TRANSITIVE_TWO_OCTET_AS_SPECIFIC ExtendedCommunityAttrType = 0x00 - EC_TYPE_TRANSITIVE_IP6_SPECIFIC ExtendedCommunityAttrType = 0x00 // RFC5701 - EC_TYPE_TRANSITIVE_IP4_SPECIFIC ExtendedCommunityAttrType = 0x01 - EC_TYPE_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC ExtendedCommunityAttrType = 0x02 - EC_TYPE_TRANSITIVE_OPAQUE ExtendedCommunityAttrType = 0x03 - EC_TYPE_TRANSITIVE_QOS_MARKING ExtendedCommunityAttrType = 0x04 - EC_TYPE_COS_CAPABILITY ExtendedCommunityAttrType = 0x05 - EC_TYPE_EVPN ExtendedCommunityAttrType = 0x06 - EC_TYPE_FLOWSPEC_REDIRECT_MIRROR ExtendedCommunityAttrType = 0x08 - EC_TYPE_NON_TRANSITIVE_TWO_OCTET_AS_SPECIFIC ExtendedCommunityAttrType = 0x40 - EC_TYPE_NON_TRANSITIVE_IP6_SPECIFIC ExtendedCommunityAttrType = 0x40 // RFC5701 - EC_TYPE_NON_TRANSITIVE_IP4_SPECIFIC ExtendedCommunityAttrType = 0x41 - EC_TYPE_NON_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC ExtendedCommunityAttrType = 0x42 - EC_TYPE_NON_TRANSITIVE_OPAQUE ExtendedCommunityAttrType = 0x43 - EC_TYPE_NON_TRANSITIVE_QOS_MARKING ExtendedCommunityAttrType = 0x44 - EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL ExtendedCommunityAttrType = 0x80 - EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2 ExtendedCommunityAttrType = 0x81 // RFC7674 - EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3 ExtendedCommunityAttrType = 0x82 // RFC7674 -) - -// RFC7153 5.2. Registries for the "Sub-Type" Field -// RANGE REGISTRATION PROCEDURES -// 0x00-0xBF First Come First Served -// 0xC0-0xFF IETF Review -type ExtendedCommunityAttrSubType uint8 - -const ( - EC_SUBTYPE_ROUTE_TARGET ExtendedCommunityAttrSubType = 0x02 // EC_TYPE: 0x00, 0x01, 0x02 - EC_SUBTYPE_ROUTE_ORIGIN ExtendedCommunityAttrSubType = 0x03 // EC_TYPE: 0x00, 0x01, 0x02 - EC_SUBTYPE_LINK_BANDWIDTH ExtendedCommunityAttrSubType = 0x04 // EC_TYPE: 0x40 - EC_SUBTYPE_GENERIC ExtendedCommunityAttrSubType = 0x04 // EC_TYPE: 0x02, 0x42 - EC_SUBTYPE_OSPF_DOMAIN_ID ExtendedCommunityAttrSubType = 0x05 // EC_TYPE: 0x00, 0x01, 0x02 - EC_SUBTYPE_OSPF_ROUTE_ID ExtendedCommunityAttrSubType = 0x07 // EC_TYPE: 0x01 - EC_SUBTYPE_BGP_DATA_COLLECTION ExtendedCommunityAttrSubType = 0x08 // EC_TYPE: 0x00, 0x02 - EC_SUBTYPE_SOURCE_AS ExtendedCommunityAttrSubType = 0x09 // EC_TYPE: 0x00, 0x02 - EC_SUBTYPE_L2VPN_ID ExtendedCommunityAttrSubType = 0x0A // EC_TYPE: 0x00, 0x01 - EC_SUBTYPE_VRF_ROUTE_IMPORT ExtendedCommunityAttrSubType = 0x0B // EC_TYPE: 0x01 - EC_SUBTYPE_CISCO_VPN_DISTINGUISHER ExtendedCommunityAttrSubType = 0x10 // EC_TYPE: 0x00, 0x01, 0x02 - - EC_SUBTYPE_OSPF_ROUTE_TYPE ExtendedCommunityAttrSubType = 0x06 // EC_TYPE: 0x03 - EC_SUBTYPE_COLOR ExtendedCommunityAttrSubType = 0x0B // EC_TYPE: 0x03 - EC_SUBTYPE_ENCAPSULATION ExtendedCommunityAttrSubType = 0x0C // EC_TYPE: 0x03 - EC_SUBTYPE_DEFAULT_GATEWAY ExtendedCommunityAttrSubType = 0x0D // EC_TYPE: 0x03 - - EC_SUBTYPE_ORIGIN_VALIDATION ExtendedCommunityAttrSubType = 0x00 // EC_TYPE: 0x43 - - EC_SUBTYPE_FLOWSPEC_TRAFFIC_RATE ExtendedCommunityAttrSubType = 0x06 // EC_TYPE: 0x80 - EC_SUBTYPE_FLOWSPEC_TRAFFIC_ACTION ExtendedCommunityAttrSubType = 0x07 // EC_TYPE: 0x80 - EC_SUBTYPE_FLOWSPEC_REDIRECT ExtendedCommunityAttrSubType = 0x08 // EC_TYPE: 0x80 - EC_SUBTYPE_FLOWSPEC_TRAFFIC_REMARK ExtendedCommunityAttrSubType = 0x09 // EC_TYPE: 0x80 - EC_SUBTYPE_L2_INFO ExtendedCommunityAttrSubType = 0x0A // EC_TYPE: 0x80 - EC_SUBTYPE_FLOWSPEC_REDIRECT_IP6 ExtendedCommunityAttrSubType = 0x0B // EC_TYPE: 0x80 - - EC_SUBTYPE_MAC_MOBILITY ExtendedCommunityAttrSubType = 0x00 // EC_TYPE: 0x06 - EC_SUBTYPE_ESI_LABEL ExtendedCommunityAttrSubType = 0x01 // EC_TYPE: 0x06 - EC_SUBTYPE_ES_IMPORT ExtendedCommunityAttrSubType = 0x02 // EC_TYPE: 0x06 - EC_SUBTYPE_ROUTER_MAC ExtendedCommunityAttrSubType = 0x03 // EC_TYPE: 0x06 - - EC_SUBTYPE_UUID_BASED_RT ExtendedCommunityAttrSubType = 0x11 -) - -type TunnelType uint16 - -const ( - TUNNEL_TYPE_L2TP3 TunnelType = 1 - TUNNEL_TYPE_GRE TunnelType = 2 - TUNNEL_TYPE_IP_IN_IP TunnelType = 7 - TUNNEL_TYPE_VXLAN TunnelType = 8 - TUNNEL_TYPE_NVGRE TunnelType = 9 - TUNNEL_TYPE_MPLS TunnelType = 10 - TUNNEL_TYPE_MPLS_IN_GRE TunnelType = 11 - TUNNEL_TYPE_VXLAN_GRE TunnelType = 12 - TUNNEL_TYPE_MPLS_IN_UDP TunnelType = 13 -) - -func (p TunnelType) String() string { - switch p { - case TUNNEL_TYPE_L2TP3: - return "l2tp3" - case TUNNEL_TYPE_GRE: - return "gre" - case TUNNEL_TYPE_IP_IN_IP: - return "ip-in-ip" - case TUNNEL_TYPE_VXLAN: - return "vxlan" - case TUNNEL_TYPE_NVGRE: - return "nvgre" - case TUNNEL_TYPE_MPLS: - return "mpls" - case TUNNEL_TYPE_MPLS_IN_GRE: - return "mpls-in-gre" - case TUNNEL_TYPE_VXLAN_GRE: - return "vxlan-gre" - case TUNNEL_TYPE_MPLS_IN_UDP: - return "mpls-in-udp" - default: - return fmt.Sprintf("TunnelType(%d)", uint8(p)) - } -} - -type PmsiTunnelType uint8 - -const ( - PMSI_TUNNEL_TYPE_NO_TUNNEL PmsiTunnelType = 0 - PMSI_TUNNEL_TYPE_RSVP_TE_P2MP PmsiTunnelType = 1 - PMSI_TUNNEL_TYPE_MLDP_P2MP PmsiTunnelType = 2 - PMSI_TUNNEL_TYPE_PIM_SSM_TREE PmsiTunnelType = 3 - PMSI_TUNNEL_TYPE_PIM_SM_TREE PmsiTunnelType = 4 - PMSI_TUNNEL_TYPE_BIDIR_PIM_TREE PmsiTunnelType = 5 - PMSI_TUNNEL_TYPE_INGRESS_REPL PmsiTunnelType = 6 - PMSI_TUNNEL_TYPE_MLDP_MP2MP PmsiTunnelType = 7 -) - -func (p PmsiTunnelType) String() string { - switch p { - case PMSI_TUNNEL_TYPE_NO_TUNNEL: - return "no-tunnel" - case PMSI_TUNNEL_TYPE_RSVP_TE_P2MP: - return "rsvp-te-p2mp" - case PMSI_TUNNEL_TYPE_MLDP_P2MP: - return "mldp-p2mp" - case PMSI_TUNNEL_TYPE_PIM_SSM_TREE: - return "pim-ssm-tree" - case PMSI_TUNNEL_TYPE_PIM_SM_TREE: - return "pim-sm-tree" - case PMSI_TUNNEL_TYPE_BIDIR_PIM_TREE: - return "bidir-pim-tree" - case PMSI_TUNNEL_TYPE_INGRESS_REPL: - return "ingress-repl" - case PMSI_TUNNEL_TYPE_MLDP_MP2MP: - return "mldp-mp2mp" - default: - return fmt.Sprintf("PmsiTunnelType(%d)", uint8(p)) - } -} - -type EncapSubTLVType uint8 - -const ( - ENCAP_SUBTLV_TYPE_ENCAPSULATION EncapSubTLVType = 1 - ENCAP_SUBTLV_TYPE_PROTOCOL EncapSubTLVType = 2 - ENCAP_SUBTLV_TYPE_COLOR EncapSubTLVType = 4 -) - -const ( - _ = iota - BGP_MSG_OPEN - BGP_MSG_UPDATE - BGP_MSG_NOTIFICATION - BGP_MSG_KEEPALIVE - BGP_MSG_ROUTE_REFRESH -) - -const ( - BGP_OPT_CAPABILITY = 2 -) - -type BGPCapabilityCode uint8 - -const ( - BGP_CAP_MULTIPROTOCOL BGPCapabilityCode = 1 - BGP_CAP_ROUTE_REFRESH BGPCapabilityCode = 2 - BGP_CAP_CARRYING_LABEL_INFO BGPCapabilityCode = 4 - BGP_CAP_EXTENDED_NEXTHOP BGPCapabilityCode = 5 - BGP_CAP_GRACEFUL_RESTART BGPCapabilityCode = 64 - BGP_CAP_FOUR_OCTET_AS_NUMBER BGPCapabilityCode = 65 - BGP_CAP_ADD_PATH BGPCapabilityCode = 69 - BGP_CAP_ENHANCED_ROUTE_REFRESH BGPCapabilityCode = 70 - BGP_CAP_LONG_LIVED_GRACEFUL_RESTART BGPCapabilityCode = 71 - BGP_CAP_ROUTE_REFRESH_CISCO BGPCapabilityCode = 128 -) - -var CapNameMap = map[BGPCapabilityCode]string{ - BGP_CAP_MULTIPROTOCOL: "multiprotocol", - BGP_CAP_ROUTE_REFRESH: "route-refresh", - BGP_CAP_CARRYING_LABEL_INFO: "carrying-label-info", - BGP_CAP_GRACEFUL_RESTART: "graceful-restart", - BGP_CAP_EXTENDED_NEXTHOP: "extended-nexthop", - BGP_CAP_FOUR_OCTET_AS_NUMBER: "4-octet-as", - BGP_CAP_ADD_PATH: "add-path", - BGP_CAP_ENHANCED_ROUTE_REFRESH: "enhanced-route-refresh", - BGP_CAP_ROUTE_REFRESH_CISCO: "cisco-route-refresh", - BGP_CAP_LONG_LIVED_GRACEFUL_RESTART: "long-lived-graceful-restart", -} - -func (c BGPCapabilityCode) String() string { - if n, y := CapNameMap[c]; y { - return n - } - return fmt.Sprintf("UnknownCapability(%d)", c) -} - -var ( - // Used parsing RouteDistinguisher - _regexpRouteDistinguisher = regexp.MustCompile(`^((\d+)\.(\d+)\.(\d+)\.(\d+)|((\d+)\.)?(\d+)|([\w]+:[\w:]*:[\w]+)):(\d+)$`) - - // Used for operator and value for the FlowSpec numeric type - // Example: - // re.FindStringSubmatch("&==80") - // >>> ["&==80" "&" "==" "80"] - _regexpFlowSpecNumericType = regexp.MustCompile(`(&?)(==|=|>|>=|<|<=|!|!=|=!)?(\d+|-\d|true|false)`) - - // - "=!" is used in the old style format of "tcp-flags" and "fragment". - // - The value field should be one of the followings: - // * Decimal value (e.g., 80) - // * Combination of the small letters, decimals, "-" and "+" - // (e.g., tcp, ipv4, is-fragment+first-fragment) - // * Capital letters (e.g., SA) - _regexpFlowSpecOperator = regexp.MustCompile(`&|=|>|<|!|[\w\-+]+`) - _regexpFlowSpecOperatorValue = regexp.MustCompile(`[\w\-+]+`) - - // Note: "(-*)" and "(.*)" catch the invalid flags - // Example: In this case, "Z" is unsupported flag type. - // re.FindStringSubmatch("&==-SZU") - // >>> ["&==-SZU" "&" "==" "-" "S" "ZU"] - _regexpFlowSpecTCPFlag = regexp.MustCompile("(&?)(==|=|!|!=|=!)?(-*)([FSRPAUCE]+)(.*)") - - // Note: "(.*)" catches the invalid flags - // re.FindStringSubmatch("&!=+first-fragment+last-fragment+invalid-fragment") - // >>> ["&!=+first-fragment+last-fragment+invalid-fragment" "&" "!=" "+first-fragment+last-fragment" "+last-fragment" "+" "last" "+invalid-fragment"] - _regexpFlowSpecFragment = regexp.MustCompile(`(&?)(==|=|!|!=|=!)?(((\+)?(dont|is|first|last|not-a)-fragment)+)(.*)`) - - // re.FindStringSubmatch("192.168.0.0/24") - // >>> ["192.168.0.0/24" "192.168.0.0" "/24" "24"] - // re.FindStringSubmatch("192.168.0.1") - // >>> ["192.168.0.1" "192.168.0.1" "" ""] - _regexpFindIPv4Prefix = regexp.MustCompile(`^([\d.]+)(/(\d{1,2}))?`) - - // re.FindStringSubmatch("2001:dB8::/64") - // >>> ["2001:dB8::/64" "2001:dB8::" "/64" "64" "" ""] - // re.FindStringSubmatch("2001:dB8::/64/8") - // >>> ["2001:dB8::/64/8" "2001:dB8::" "/64" "64" "/8" "8"] - // re.FindStringSubmatch("2001:dB8::1") - // >>> ["2001:dB8::1" "2001:dB8::1" "" "" "" ""] - _regexpFindIPv6Prefix = regexp.MustCompile(`^([a-fA-F\d:.]+)(/(\d{1,3}))?(/(\d{1,3}))?`) -) - -type ParameterCapabilityInterface interface { - DecodeFromBytes([]byte) error - Serialize() ([]byte, error) - Len() int - Code() BGPCapabilityCode -} - -type DefaultParameterCapability struct { - CapCode BGPCapabilityCode `json:"code"` - CapLen uint8 `json:"-"` - CapValue []byte `json:"value,omitempty"` -} - -func (c *DefaultParameterCapability) Code() BGPCapabilityCode { - return c.CapCode -} - -func (c *DefaultParameterCapability) DecodeFromBytes(data []byte) error { - c.CapCode = BGPCapabilityCode(data[0]) - c.CapLen = data[1] - if len(data) < 2+int(c.CapLen) { - return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all OptionParameterCapability bytes available") - } - if c.CapLen > 0 { - c.CapValue = data[2 : 2+c.CapLen] - } - return nil -} - -func (c *DefaultParameterCapability) Serialize() ([]byte, error) { - c.CapLen = uint8(len(c.CapValue)) - buf := make([]byte, 2) - buf[0] = uint8(c.CapCode) - buf[1] = c.CapLen - buf = append(buf, c.CapValue...) - return buf, nil -} - -func (c *DefaultParameterCapability) Len() int { - return int(c.CapLen + 2) -} - -type CapMultiProtocol struct { - DefaultParameterCapability - CapValue RouteFamily -} - -func (c *CapMultiProtocol) DecodeFromBytes(data []byte) error { - c.DefaultParameterCapability.DecodeFromBytes(data) - data = data[2:] - if len(data) < 4 { - return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all CapabilityMultiProtocol bytes available") - } - c.CapValue = AfiSafiToRouteFamily(binary.BigEndian.Uint16(data[0:2]), data[3]) - return nil -} - -func (c *CapMultiProtocol) Serialize() ([]byte, error) { - buf := make([]byte, 4) - afi, safi := RouteFamilyToAfiSafi(c.CapValue) - binary.BigEndian.PutUint16(buf[0:], afi) - buf[3] = safi - c.DefaultParameterCapability.CapValue = buf - return c.DefaultParameterCapability.Serialize() -} - -func (c *CapMultiProtocol) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Code BGPCapabilityCode `json:"code"` - Value RouteFamily `json:"value"` - }{ - Code: c.Code(), - Value: c.CapValue, - }) -} - -func NewCapMultiProtocol(rf RouteFamily) *CapMultiProtocol { - return &CapMultiProtocol{ - DefaultParameterCapability{ - CapCode: BGP_CAP_MULTIPROTOCOL, - }, - rf, - } -} - -type CapRouteRefresh struct { - DefaultParameterCapability -} - -func NewCapRouteRefresh() *CapRouteRefresh { - return &CapRouteRefresh{ - DefaultParameterCapability{ - CapCode: BGP_CAP_ROUTE_REFRESH, - }, - } -} - -type CapCarryingLabelInfo struct { - DefaultParameterCapability -} - -func NewCapCarryingLabelInfo() *CapCarryingLabelInfo { - return &CapCarryingLabelInfo{ - DefaultParameterCapability{ - CapCode: BGP_CAP_CARRYING_LABEL_INFO, - }, - } -} - -type CapExtendedNexthopTuple struct { - NLRIAFI uint16 - NLRISAFI uint16 - NexthopAFI uint16 -} - -func (c *CapExtendedNexthopTuple) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - NLRIAddressFamily RouteFamily `json:"nlri_address_family"` - NexthopAddressFamily uint16 `json:"nexthop_address_family"` - }{ - NLRIAddressFamily: AfiSafiToRouteFamily(c.NLRIAFI, uint8(c.NLRISAFI)), - NexthopAddressFamily: c.NexthopAFI, - }) -} - -func NewCapExtendedNexthopTuple(af RouteFamily, nexthop uint16) *CapExtendedNexthopTuple { - afi, safi := RouteFamilyToAfiSafi(af) - return &CapExtendedNexthopTuple{ - NLRIAFI: afi, - NLRISAFI: uint16(safi), - NexthopAFI: nexthop, - } -} - -type CapExtendedNexthop struct { - DefaultParameterCapability - Tuples []*CapExtendedNexthopTuple -} - -func (c *CapExtendedNexthop) DecodeFromBytes(data []byte) error { - c.DefaultParameterCapability.DecodeFromBytes(data) - data = data[2:] - if len(data) < 6 { - return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all CapabilityExtendedNexthop bytes available") - } - c.Tuples = []*CapExtendedNexthopTuple{} - for len(data) >= 6 { - t := &CapExtendedNexthopTuple{ - binary.BigEndian.Uint16(data[0:2]), - binary.BigEndian.Uint16(data[2:4]), - binary.BigEndian.Uint16(data[4:6]), - } - c.Tuples = append(c.Tuples, t) - data = data[6:] - } - return nil -} - -func (c *CapExtendedNexthop) Serialize() ([]byte, error) { - buf := make([]byte, len(c.Tuples)*6) - for i, t := range c.Tuples { - binary.BigEndian.PutUint16(buf[i*6:i*6+2], t.NLRIAFI) - binary.BigEndian.PutUint16(buf[i*6+2:i*6+4], t.NLRISAFI) - binary.BigEndian.PutUint16(buf[i*6+4:i*6+6], t.NexthopAFI) - } - c.DefaultParameterCapability.CapValue = buf - return c.DefaultParameterCapability.Serialize() -} - -func (c *CapExtendedNexthop) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Code BGPCapabilityCode `json:"code"` - Tuples []*CapExtendedNexthopTuple `json:"tuples"` - }{ - Code: c.Code(), - Tuples: c.Tuples, - }) -} - -func NewCapExtendedNexthop(tuples []*CapExtendedNexthopTuple) *CapExtendedNexthop { - return &CapExtendedNexthop{ - DefaultParameterCapability{ - CapCode: BGP_CAP_EXTENDED_NEXTHOP, - }, - tuples, - } -} - -type CapGracefulRestartTuple struct { - AFI uint16 - SAFI uint8 - Flags uint8 -} - -func (c *CapGracefulRestartTuple) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - RouteFamily RouteFamily `json:"route_family"` - Flags uint8 `json:"flags"` - }{ - RouteFamily: AfiSafiToRouteFamily(c.AFI, c.SAFI), - Flags: c.Flags, - }) -} - -func NewCapGracefulRestartTuple(rf RouteFamily, forward bool) *CapGracefulRestartTuple { - afi, safi := RouteFamilyToAfiSafi(rf) - flags := 0 - if forward { - flags = 0x80 - } - return &CapGracefulRestartTuple{ - AFI: afi, - SAFI: safi, - Flags: uint8(flags), - } -} - -type CapGracefulRestart struct { - DefaultParameterCapability - Flags uint8 - Time uint16 - Tuples []*CapGracefulRestartTuple -} - -func (c *CapGracefulRestart) DecodeFromBytes(data []byte) error { - c.DefaultParameterCapability.DecodeFromBytes(data) - data = data[2:] - if len(data) < 2 { - return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all CapabilityGracefulRestart bytes available") - } - restart := binary.BigEndian.Uint16(data[0:2]) - c.Flags = uint8(restart >> 12) - c.Time = restart & 0xfff - data = data[2:] - - valueLen := int(c.CapLen) - 2 - - if valueLen >= 4 && len(data) >= valueLen { - c.Tuples = make([]*CapGracefulRestartTuple, 0, valueLen/4) - - for i := valueLen; i >= 4; i -= 4 { - t := &CapGracefulRestartTuple{binary.BigEndian.Uint16(data[0:2]), - data[2], data[3]} - c.Tuples = append(c.Tuples, t) - data = data[4:] - } - } - return nil -} - -func (c *CapGracefulRestart) Serialize() ([]byte, error) { - buf := make([]byte, 2) - binary.BigEndian.PutUint16(buf[0:], uint16(c.Flags)<<12|c.Time) - for _, t := range c.Tuples { - tbuf := make([]byte, 4) - binary.BigEndian.PutUint16(tbuf[0:2], t.AFI) - tbuf[2] = t.SAFI - tbuf[3] = t.Flags - buf = append(buf, tbuf...) - } - c.DefaultParameterCapability.CapValue = buf - return c.DefaultParameterCapability.Serialize() -} - -func (c *CapGracefulRestart) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Code BGPCapabilityCode `json:"code"` - Flags uint8 `json:"flags"` - Time uint16 `json:"time"` - Tuples []*CapGracefulRestartTuple `json:"tuples"` - }{ - Code: c.Code(), - Flags: c.Flags, - Time: c.Time, - Tuples: c.Tuples, - }) -} - -func NewCapGracefulRestart(restarting, notification bool, time uint16, tuples []*CapGracefulRestartTuple) *CapGracefulRestart { - flags := 0 - if restarting { - flags = 0x08 - } - if notification { - flags |= 0x04 - } - return &CapGracefulRestart{ - DefaultParameterCapability: DefaultParameterCapability{ - CapCode: BGP_CAP_GRACEFUL_RESTART, - }, - Flags: uint8(flags), - Time: time, - Tuples: tuples, - } -} - -type CapFourOctetASNumber struct { - DefaultParameterCapability - CapValue uint32 -} - -func (c *CapFourOctetASNumber) DecodeFromBytes(data []byte) error { - c.DefaultParameterCapability.DecodeFromBytes(data) - data = data[2:] - if len(data) < 4 { - return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all CapabilityFourOctetASNumber bytes available") - } - c.CapValue = binary.BigEndian.Uint32(data[0:4]) - return nil -} - -func (c *CapFourOctetASNumber) Serialize() ([]byte, error) { - buf := make([]byte, 4) - binary.BigEndian.PutUint32(buf, c.CapValue) - c.DefaultParameterCapability.CapValue = buf - return c.DefaultParameterCapability.Serialize() -} - -func (c *CapFourOctetASNumber) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Code BGPCapabilityCode `json:"code"` - Value uint32 `json:"value"` - }{ - Code: c.Code(), - Value: c.CapValue, - }) -} - -func NewCapFourOctetASNumber(asnum uint32) *CapFourOctetASNumber { - return &CapFourOctetASNumber{ - DefaultParameterCapability{ - CapCode: BGP_CAP_FOUR_OCTET_AS_NUMBER, - }, - asnum, - } -} - -type BGPAddPathMode uint8 - -const ( - BGP_ADD_PATH_NONE BGPAddPathMode = iota - BGP_ADD_PATH_RECEIVE - BGP_ADD_PATH_SEND - BGP_ADD_PATH_BOTH -) - -func (m BGPAddPathMode) String() string { - switch m { - case BGP_ADD_PATH_NONE: - return "none" - case BGP_ADD_PATH_RECEIVE: - return "receive" - case BGP_ADD_PATH_SEND: - return "send" - case BGP_ADD_PATH_BOTH: - return "receive/send" - default: - return fmt.Sprintf("unknown(%d)", m) - } -} - -type CapAddPathTuple struct { - RouteFamily RouteFamily - Mode BGPAddPathMode -} - -func (t *CapAddPathTuple) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - RouteFamily RouteFamily `json:"family"` - Mode uint8 `json:"mode"` - }{ - RouteFamily: t.RouteFamily, - Mode: uint8(t.Mode), - }) -} - -func NewCapAddPathTuple(family RouteFamily, mode BGPAddPathMode) *CapAddPathTuple { - return &CapAddPathTuple{ - RouteFamily: family, - Mode: mode, - } -} - -type CapAddPath struct { - DefaultParameterCapability - Tuples []*CapAddPathTuple -} - -func (c *CapAddPath) DecodeFromBytes(data []byte) error { - c.DefaultParameterCapability.DecodeFromBytes(data) - data = data[2:] - if len(data) < 4 { - return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all CapabilityAddPath bytes available") - } - c.Tuples = []*CapAddPathTuple{} - for len(data) >= 4 { - t := &CapAddPathTuple{ - RouteFamily: AfiSafiToRouteFamily(binary.BigEndian.Uint16(data[:2]), data[2]), - Mode: BGPAddPathMode(data[3]), - } - c.Tuples = append(c.Tuples, t) - data = data[4:] - } - return nil -} - -func (c *CapAddPath) Serialize() ([]byte, error) { - buf := make([]byte, len(c.Tuples)*4) - for i, t := range c.Tuples { - afi, safi := RouteFamilyToAfiSafi(t.RouteFamily) - binary.BigEndian.PutUint16(buf[i*4:i*4+2], afi) - buf[i*4+2] = safi - buf[i*4+3] = byte(t.Mode) - } - c.DefaultParameterCapability.CapValue = buf - return c.DefaultParameterCapability.Serialize() -} - -func (c *CapAddPath) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Code BGPCapabilityCode `json:"code"` - Tuples []*CapAddPathTuple `json:"tuples"` - }{ - Code: c.Code(), - Tuples: c.Tuples, - }) -} - -func NewCapAddPath(tuples []*CapAddPathTuple) *CapAddPath { - return &CapAddPath{ - DefaultParameterCapability: DefaultParameterCapability{ - CapCode: BGP_CAP_ADD_PATH, - }, - Tuples: tuples, - } -} - -type CapEnhancedRouteRefresh struct { - DefaultParameterCapability -} - -func NewCapEnhancedRouteRefresh() *CapEnhancedRouteRefresh { - return &CapEnhancedRouteRefresh{ - DefaultParameterCapability{ - CapCode: BGP_CAP_ENHANCED_ROUTE_REFRESH, - }, - } -} - -type CapRouteRefreshCisco struct { - DefaultParameterCapability -} - -func NewCapRouteRefreshCisco() *CapRouteRefreshCisco { - return &CapRouteRefreshCisco{ - DefaultParameterCapability{ - CapCode: BGP_CAP_ROUTE_REFRESH_CISCO, - }, - } -} - -type CapLongLivedGracefulRestartTuple struct { - AFI uint16 - SAFI uint8 - Flags uint8 - RestartTime uint32 -} - -func (c *CapLongLivedGracefulRestartTuple) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - RouteFamily RouteFamily `json:"route_family"` - Flags uint8 `json:"flags"` - RestartTime uint32 `json:"restart_time"` - }{ - RouteFamily: AfiSafiToRouteFamily(c.AFI, c.SAFI), - Flags: c.Flags, - RestartTime: c.RestartTime, - }) -} - -func NewCapLongLivedGracefulRestartTuple(rf RouteFamily, forward bool, restartTime uint32) *CapLongLivedGracefulRestartTuple { - afi, safi := RouteFamilyToAfiSafi(rf) - flags := 0 - if forward { - flags = 0x80 - } - return &CapLongLivedGracefulRestartTuple{ - AFI: afi, - SAFI: safi, - Flags: uint8(flags), - RestartTime: restartTime, - } -} - -type CapLongLivedGracefulRestart struct { - DefaultParameterCapability - Tuples []*CapLongLivedGracefulRestartTuple -} - -func (c *CapLongLivedGracefulRestart) DecodeFromBytes(data []byte) error { - c.DefaultParameterCapability.DecodeFromBytes(data) - data = data[2:] - - valueLen := int(c.CapLen) - if valueLen%7 != 0 || len(data) < valueLen { - return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "invalid length of long lived graceful restart capablity") - } - for i := valueLen; i >= 7; i -= 7 { - t := &CapLongLivedGracefulRestartTuple{ - binary.BigEndian.Uint16(data), - data[2], - data[3], - uint32(data[4])<<16 | uint32(data[5])<<8 | uint32(data[6]), - } - c.Tuples = append(c.Tuples, t) - data = data[7:] - } - return nil -} - -func (c *CapLongLivedGracefulRestart) Serialize() ([]byte, error) { - buf := make([]byte, 7*len(c.Tuples)) - for idx, t := range c.Tuples { - binary.BigEndian.PutUint16(buf[idx*7:], t.AFI) - buf[idx*7+2] = t.SAFI - buf[idx*7+3] = t.Flags - buf[idx*7+4] = uint8((t.RestartTime >> 16) & 0xff) - buf[idx*7+5] = uint8((t.RestartTime >> 8) & 0xff) - buf[idx*7+6] = uint8(t.RestartTime & 0xff) - } - c.DefaultParameterCapability.CapValue = buf - return c.DefaultParameterCapability.Serialize() -} - -func (c *CapLongLivedGracefulRestart) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Code BGPCapabilityCode `json:"code"` - Tuples []*CapLongLivedGracefulRestartTuple `json:"tuples"` - }{ - Code: c.Code(), - Tuples: c.Tuples, - }) -} - -func NewCapLongLivedGracefulRestart(tuples []*CapLongLivedGracefulRestartTuple) *CapLongLivedGracefulRestart { - return &CapLongLivedGracefulRestart{ - DefaultParameterCapability: DefaultParameterCapability{ - CapCode: BGP_CAP_LONG_LIVED_GRACEFUL_RESTART, - }, - Tuples: tuples, - } -} - -type CapUnknown struct { - DefaultParameterCapability -} - -func NewCapUnknown(code BGPCapabilityCode, value []byte) *CapUnknown { - return &CapUnknown{ - DefaultParameterCapability{ - CapCode: code, - CapValue: value, - }, - } -} - -func DecodeCapability(data []byte) (ParameterCapabilityInterface, error) { - if len(data) < 2 { - return nil, NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all ParameterCapability bytes available") - } - var c ParameterCapabilityInterface - switch BGPCapabilityCode(data[0]) { - case BGP_CAP_MULTIPROTOCOL: - c = &CapMultiProtocol{} - case BGP_CAP_ROUTE_REFRESH: - c = &CapRouteRefresh{} - case BGP_CAP_CARRYING_LABEL_INFO: - c = &CapCarryingLabelInfo{} - case BGP_CAP_EXTENDED_NEXTHOP: - c = &CapExtendedNexthop{} - case BGP_CAP_GRACEFUL_RESTART: - c = &CapGracefulRestart{} - case BGP_CAP_FOUR_OCTET_AS_NUMBER: - c = &CapFourOctetASNumber{} - case BGP_CAP_ADD_PATH: - c = &CapAddPath{} - case BGP_CAP_ENHANCED_ROUTE_REFRESH: - c = &CapEnhancedRouteRefresh{} - case BGP_CAP_ROUTE_REFRESH_CISCO: - c = &CapRouteRefreshCisco{} - case BGP_CAP_LONG_LIVED_GRACEFUL_RESTART: - c = &CapLongLivedGracefulRestart{} - default: - c = &CapUnknown{} - } - err := c.DecodeFromBytes(data) - return c, err -} - -type OptionParameterInterface interface { - Serialize() ([]byte, error) -} - -type OptionParameterCapability struct { - ParamType uint8 - ParamLen uint8 - Capability []ParameterCapabilityInterface -} - -func (o *OptionParameterCapability) DecodeFromBytes(data []byte) error { - if uint8(len(data)) < o.ParamLen { - return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_OPTIONAL_PARAMETER, nil, "Not all OptionParameterCapability bytes available") - } - for len(data) >= 2 { - c, err := DecodeCapability(data) - if err != nil { - return err - } - o.Capability = append(o.Capability, c) - data = data[c.Len():] - } - return nil -} - -func (o *OptionParameterCapability) Serialize() ([]byte, error) { - buf := make([]byte, 2) - buf[0] = o.ParamType - for _, p := range o.Capability { - pbuf, err := p.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, pbuf...) - } - o.ParamLen = uint8(len(buf) - 2) - buf[1] = o.ParamLen - return buf, nil -} - -func NewOptionParameterCapability(capability []ParameterCapabilityInterface) *OptionParameterCapability { - return &OptionParameterCapability{ - ParamType: BGP_OPT_CAPABILITY, - Capability: capability, - } -} - -type OptionParameterUnknown struct { - ParamType uint8 - ParamLen uint8 - Value []byte -} - -func (o *OptionParameterUnknown) Serialize() ([]byte, error) { - buf := make([]byte, 2) - buf[0] = o.ParamType - if o.ParamLen == 0 { - o.ParamLen = uint8(len(o.Value)) - } - buf[1] = o.ParamLen - return append(buf, o.Value...), nil -} - -type BGPOpen struct { - Version uint8 - MyAS uint16 - HoldTime uint16 - ID net.IP - OptParamLen uint8 - OptParams []OptionParameterInterface -} - -func (msg *BGPOpen) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - if len(data) < 10 { - return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "Not all BGP Open message bytes available") - } - msg.Version = data[0] - msg.MyAS = binary.BigEndian.Uint16(data[1:3]) - msg.HoldTime = binary.BigEndian.Uint16(data[3:5]) - msg.ID = net.IP(data[5:9]).To4() - msg.OptParamLen = data[9] - data = data[10:] - if len(data) < int(msg.OptParamLen) { - return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "Not all BGP Open message bytes available") - } - - msg.OptParams = []OptionParameterInterface{} - for rest := msg.OptParamLen; rest > 0; { - if rest < 2 { - return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "Malformed BGP Open message") - } - paramtype := data[0] - paramlen := data[1] - if rest < paramlen+2 { - return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "Malformed BGP Open message") - } - rest -= paramlen + 2 - - if paramtype == BGP_OPT_CAPABILITY { - p := &OptionParameterCapability{} - p.ParamType = paramtype - p.ParamLen = paramlen - p.DecodeFromBytes(data[2 : 2+paramlen]) - msg.OptParams = append(msg.OptParams, p) - } else { - p := &OptionParameterUnknown{} - p.ParamType = paramtype - p.ParamLen = paramlen - p.Value = data[2 : 2+paramlen] - msg.OptParams = append(msg.OptParams, p) - } - data = data[2+paramlen:] - } - return nil -} - -func (msg *BGPOpen) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 10) - buf[0] = msg.Version - binary.BigEndian.PutUint16(buf[1:3], msg.MyAS) - binary.BigEndian.PutUint16(buf[3:5], msg.HoldTime) - copy(buf[5:9], msg.ID.To4()) - pbuf := make([]byte, 0) - for _, p := range msg.OptParams { - onepbuf, err := p.Serialize() - if err != nil { - return nil, err - } - pbuf = append(pbuf, onepbuf...) - } - msg.OptParamLen = uint8(len(pbuf)) - buf[9] = msg.OptParamLen - return append(buf, pbuf...), nil -} - -func NewBGPOpenMessage(myas uint16, holdtime uint16, id string, optparams []OptionParameterInterface) *BGPMessage { - return &BGPMessage{ - Header: BGPHeader{Type: BGP_MSG_OPEN}, - Body: &BGPOpen{4, myas, holdtime, net.ParseIP(id).To4(), 0, optparams}, - } -} - -type AddrPrefixInterface interface { - DecodeFromBytes([]byte, ...*MarshallingOption) error - Serialize(...*MarshallingOption) ([]byte, error) - AFI() uint16 - SAFI() uint8 - Len(...*MarshallingOption) int - String() string - MarshalJSON() ([]byte, error) - // Create a flat map to describe attributes and their - // values. This can be used to create structured outputs. - Flat() map[string]string - PathIdentifier() uint32 - SetPathIdentifier(uint32) - PathLocalIdentifier() uint32 - SetPathLocalIdentifier(uint32) -} - -func LabelString(nlri AddrPrefixInterface) string { - label := "" - switch n := nlri.(type) { - case *LabeledIPAddrPrefix: - label = n.Labels.String() - case *LabeledIPv6AddrPrefix: - label = n.Labels.String() - case *LabeledVPNIPAddrPrefix: - label = n.Labels.String() - case *LabeledVPNIPv6AddrPrefix: - label = n.Labels.String() - case *EVPNNLRI: - switch route := n.RouteTypeData.(type) { - case *EVPNEthernetAutoDiscoveryRoute: - label = fmt.Sprintf("[%d]", route.Label) - case *EVPNMacIPAdvertisementRoute: - var l []string - for _, i := range route.Labels { - l = append(l, strconv.Itoa(int(i))) - } - label = fmt.Sprintf("[%s]", strings.Join(l, ",")) - case *EVPNIPPrefixRoute: - label = fmt.Sprintf("[%d]", route.Label) - } - } - return label -} - -type PrefixDefault struct { - id uint32 - localId uint32 -} - -func (p *PrefixDefault) PathIdentifier() uint32 { - return p.id -} - -func (p *PrefixDefault) SetPathIdentifier(id uint32) { - p.id = id -} - -func (p *PrefixDefault) PathLocalIdentifier() uint32 { - return p.localId -} - -func (p *PrefixDefault) SetPathLocalIdentifier(id uint32) { - p.localId = id -} - -func (p *PrefixDefault) decodePathIdentifier(data []byte) ([]byte, error) { - if len(data) < 4 { - code := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - subcode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST) - return nil, NewMessageError(code, subcode, nil, "prefix misses path identifier field") - } - p.SetPathIdentifier(binary.BigEndian.Uint32(data[:4])) - return data[4:], nil -} - -func (p *PrefixDefault) serializeIdentifier() ([]byte, error) { - buf := make([]byte, 4) - binary.BigEndian.PutUint32(buf, p.PathLocalIdentifier()) - return buf, nil -} - -type IPAddrPrefixDefault struct { - PrefixDefault - Length uint8 - Prefix net.IP -} - -func (r *IPAddrPrefixDefault) decodePrefix(data []byte, bitlen uint8, addrlen uint8) error { - bytelen := (int(bitlen) + 7) / 8 - if len(data) < bytelen { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST) - return NewMessageError(eCode, eSubCode, nil, "network bytes is short") - } - b := make([]byte, addrlen) - copy(b, data[:bytelen]) - // clear trailing bits in the last byte. rfc doesn't require - // this but some bgp implementations need this... - rem := bitlen % 8 - if rem != 0 { - mask := 0xff00 >> rem - lastByte := b[bytelen-1] & byte(mask) - b[bytelen-1] = lastByte - } - r.Prefix = b - return nil -} - -func (r *IPAddrPrefixDefault) serializePrefix(bitLen uint8) ([]byte, error) { - byteLen := (int(bitLen) + 7) / 8 - buf := make([]byte, byteLen) - copy(buf, r.Prefix) - return buf, nil -} - -func (r *IPAddrPrefixDefault) String() string { - return fmt.Sprintf("%s/%d", r.Prefix.String(), r.Length) -} - -func (r *IPAddrPrefixDefault) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Prefix string `json:"prefix"` - }{ - Prefix: r.String(), - }) -} - -type IPAddrPrefix struct { - IPAddrPrefixDefault - addrlen uint8 -} - -func (r *IPAddrPrefix) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - if r.addrlen == 0 { - r.addrlen = 4 - } - f := RF_IPv4_UC - if r.addrlen == 16 { - f = RF_IPv6_UC - } - if IsAddPathEnabled(true, f, options) { - var err error - data, err = r.decodePathIdentifier(data) - if err != nil { - return err - } - } - if len(data) < 1 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST) - return NewMessageError(eCode, eSubCode, nil, "prefix misses length field") - } - r.Length = data[0] - return r.decodePrefix(data[1:], r.Length, r.addrlen) -} - -func (r *IPAddrPrefix) Serialize(options ...*MarshallingOption) ([]byte, error) { - f := RF_IPv4_UC - if r.addrlen == 16 { - f = RF_IPv6_UC - } - var buf []byte - if IsAddPathEnabled(false, f, options) { - var err error - buf, err = r.serializeIdentifier() - if err != nil { - return nil, err - } - } - buf = append(buf, r.Length) - pbuf, err := r.serializePrefix(r.Length) - if err != nil { - return nil, err - } - return append(buf, pbuf...), nil -} - -func (r *IPAddrPrefix) AFI() uint16 { - return AFI_IP -} - -func (r *IPAddrPrefix) SAFI() uint8 { - return SAFI_UNICAST -} - -func (r *IPAddrPrefix) Len(options ...*MarshallingOption) int { - return 1 + ((int(r.Length) + 7) / 8) -} - -func NewIPAddrPrefix(length uint8, prefix string) *IPAddrPrefix { - p := &IPAddrPrefix{ - IPAddrPrefixDefault{ - Length: length, - }, - 4, - } - p.IPAddrPrefixDefault.decodePrefix(net.ParseIP(prefix).To4(), length, 4) - return p -} - -func isIPv4MappedIPv6(ip net.IP) bool { - return len(ip) == net.IPv6len && ip.To4() != nil -} - -type IPv6AddrPrefix struct { - IPAddrPrefix -} - -func (r *IPv6AddrPrefix) AFI() uint16 { - return AFI_IP6 -} - -func (r *IPv6AddrPrefix) String() string { - prefix := r.Prefix.String() - if isIPv4MappedIPv6(r.Prefix) { - prefix = "::ffff:" + prefix - } - return fmt.Sprintf("%s/%d", prefix, r.Length) -} - -func NewIPv6AddrPrefix(length uint8, prefix string) *IPv6AddrPrefix { - p := &IPv6AddrPrefix{ - IPAddrPrefix{ - IPAddrPrefixDefault{ - Length: length, - }, - 16, - }, - } - p.IPAddrPrefixDefault.decodePrefix(net.ParseIP(prefix), length, 16) - return p -} - -const ( - BGP_RD_TWO_OCTET_AS = iota - BGP_RD_IPV4_ADDRESS - BGP_RD_FOUR_OCTET_AS -) - -type RouteDistinguisherInterface interface { - DecodeFromBytes([]byte) error - Serialize() ([]byte, error) - Len() int - String() string - MarshalJSON() ([]byte, error) -} - -type DefaultRouteDistinguisher struct { - Type uint16 -} - -func (rd *DefaultRouteDistinguisher) serialize(value []byte) ([]byte, error) { - buf := make([]byte, 8) - binary.BigEndian.PutUint16(buf, rd.Type) - copy(buf[2:], value) - return buf, nil -} - -func (rd *DefaultRouteDistinguisher) Len() int { - return 8 -} - -type RouteDistinguisherTwoOctetAS struct { - DefaultRouteDistinguisher - Admin uint16 - Assigned uint32 -} - -func (rd *RouteDistinguisherTwoOctetAS) DecodeFromBytes(data []byte) error { - rd.Admin = binary.BigEndian.Uint16(data[0:2]) - rd.Assigned = binary.BigEndian.Uint32(data[2:6]) - return nil -} - -func (rd *RouteDistinguisherTwoOctetAS) Serialize() ([]byte, error) { - buf := make([]byte, 6) - binary.BigEndian.PutUint16(buf[0:2], rd.Admin) - binary.BigEndian.PutUint32(buf[2:6], rd.Assigned) - return rd.serialize(buf) -} - -func (rd *RouteDistinguisherTwoOctetAS) String() string { - return fmt.Sprintf("%d:%d", rd.Admin, rd.Assigned) -} - -func (rd *RouteDistinguisherTwoOctetAS) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type uint16 `json:"type"` - Admin uint16 `json:"admin"` - Assigned uint32 `json:"assigned"` - }{ - Type: rd.Type, - Admin: rd.Admin, - Assigned: rd.Assigned, - }) -} - -func NewRouteDistinguisherTwoOctetAS(admin uint16, assigned uint32) *RouteDistinguisherTwoOctetAS { - return &RouteDistinguisherTwoOctetAS{ - DefaultRouteDistinguisher: DefaultRouteDistinguisher{ - Type: BGP_RD_TWO_OCTET_AS, - }, - Admin: admin, - Assigned: assigned, - } -} - -type RouteDistinguisherIPAddressAS struct { - DefaultRouteDistinguisher - Admin net.IP - Assigned uint16 -} - -func (rd *RouteDistinguisherIPAddressAS) DecodeFromBytes(data []byte) error { - rd.Admin = data[0:4] - rd.Assigned = binary.BigEndian.Uint16(data[4:6]) - return nil -} - -func (rd *RouteDistinguisherIPAddressAS) Serialize() ([]byte, error) { - buf := make([]byte, 6) - copy(buf[0:4], rd.Admin.To4()) - binary.BigEndian.PutUint16(buf[4:6], rd.Assigned) - return rd.serialize(buf) -} - -func (rd *RouteDistinguisherIPAddressAS) String() string { - return fmt.Sprintf("%s:%d", rd.Admin.String(), rd.Assigned) -} - -func (rd *RouteDistinguisherIPAddressAS) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type uint16 `json:"type"` - Admin string `json:"admin"` - Assigned uint16 `json:"assigned"` - }{ - Type: rd.Type, - Admin: rd.Admin.String(), - Assigned: rd.Assigned, - }) -} - -func NewRouteDistinguisherIPAddressAS(admin string, assigned uint16) *RouteDistinguisherIPAddressAS { - return &RouteDistinguisherIPAddressAS{ - DefaultRouteDistinguisher: DefaultRouteDistinguisher{ - Type: BGP_RD_IPV4_ADDRESS, - }, - Admin: net.ParseIP(admin).To4(), - Assigned: assigned, - } -} - -type RouteDistinguisherFourOctetAS struct { - DefaultRouteDistinguisher - Admin uint32 - Assigned uint16 -} - -func (rd *RouteDistinguisherFourOctetAS) DecodeFromBytes(data []byte) error { - rd.Admin = binary.BigEndian.Uint32(data[0:4]) - rd.Assigned = binary.BigEndian.Uint16(data[4:6]) - return nil -} - -func (rd *RouteDistinguisherFourOctetAS) Serialize() ([]byte, error) { - buf := make([]byte, 6) - binary.BigEndian.PutUint32(buf[0:4], rd.Admin) - binary.BigEndian.PutUint16(buf[4:6], rd.Assigned) - return rd.serialize(buf) -} - -func (rd *RouteDistinguisherFourOctetAS) String() string { - fst := rd.Admin >> 16 & 0xffff - snd := rd.Admin & 0xffff - return fmt.Sprintf("%d.%d:%d", fst, snd, rd.Assigned) -} - -func (rd *RouteDistinguisherFourOctetAS) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type uint16 `json:"type"` - Admin uint32 `json:"admin"` - Assigned uint16 `json:"assigned"` - }{ - Type: rd.Type, - Admin: rd.Admin, - Assigned: rd.Assigned, - }) -} - -func NewRouteDistinguisherFourOctetAS(admin uint32, assigned uint16) *RouteDistinguisherFourOctetAS { - return &RouteDistinguisherFourOctetAS{ - DefaultRouteDistinguisher: DefaultRouteDistinguisher{ - Type: BGP_RD_FOUR_OCTET_AS, - }, - Admin: admin, - Assigned: assigned, - } -} - -type RouteDistinguisherUnknown struct { - DefaultRouteDistinguisher - Value []byte -} - -func (rd *RouteDistinguisherUnknown) DecodeFromBytes(data []byte) error { - rd.Value = data[0:6] - return nil -} - -func (rd *RouteDistinguisherUnknown) Serialize() ([]byte, error) { - return rd.DefaultRouteDistinguisher.serialize(rd.Value) -} - -func (rd *RouteDistinguisherUnknown) String() string { - return fmt.Sprintf("%v", rd.Value) -} - -func (rd *RouteDistinguisherUnknown) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type uint16 `json:"type"` - Value []byte `json:"value"` - }{ - Type: rd.Type, - Value: rd.Value, - }) -} - -func GetRouteDistinguisher(data []byte) RouteDistinguisherInterface { - typ := binary.BigEndian.Uint16(data[0:2]) - switch typ { - case BGP_RD_TWO_OCTET_AS: - return NewRouteDistinguisherTwoOctetAS(binary.BigEndian.Uint16(data[2:4]), binary.BigEndian.Uint32(data[4:8])) - case BGP_RD_IPV4_ADDRESS: - return NewRouteDistinguisherIPAddressAS(net.IP(data[2:6]).String(), binary.BigEndian.Uint16(data[6:8])) - case BGP_RD_FOUR_OCTET_AS: - return NewRouteDistinguisherFourOctetAS(binary.BigEndian.Uint32(data[2:6]), binary.BigEndian.Uint16(data[6:8])) - } - rd := &RouteDistinguisherUnknown{ - DefaultRouteDistinguisher: DefaultRouteDistinguisher{ - Type: typ, - }, - } - return rd -} - -func parseRdAndRt(input string) ([]string, error) { - elems := _regexpRouteDistinguisher.FindStringSubmatch(input) - if len(elems) != 11 { - return nil, fmt.Errorf("failed to parse") - } - return elems, nil -} - -func ParseRouteDistinguisher(rd string) (RouteDistinguisherInterface, error) { - elems, err := parseRdAndRt(rd) - if err != nil { - return nil, err - } - assigned, _ := strconv.ParseUint(elems[10], 10, 32) - ip := net.ParseIP(elems[1]) - switch { - case ip.To4() != nil: - return NewRouteDistinguisherIPAddressAS(elems[1], uint16(assigned)), nil - case elems[6] == "" && elems[7] == "": - asn, _ := strconv.ParseUint(elems[8], 10, 16) - return NewRouteDistinguisherTwoOctetAS(uint16(asn), uint32(assigned)), nil - default: - fst, _ := strconv.ParseUint(elems[7], 10, 16) - snd, _ := strconv.ParseUint(elems[8], 10, 16) - asn := fst<<16 | snd - return NewRouteDistinguisherFourOctetAS(uint32(asn), uint16(assigned)), nil - } -} - -// -// RFC3107 Carrying Label Information in BGP-4 -// -// 3. Carrying Label Mapping Information -// -// b) Label: -// -// The Label field carries one or more labels (that corresponds to -// the stack of labels [MPLS-ENCAPS(RFC3032)]). Each label is encoded as -// 4 octets, where the high-order 20 bits contain the label value, and -// the low order bit contains "Bottom of Stack" -// -// RFC3032 MPLS Label Stack Encoding -// -// 2.1. Encoding the Label Stack -// -// 0 1 2 3 -// 0 ... 9 0 ... 9 0 1 2 3 4 ... 9 0 1 -// +-----+-+-+---+-+-+-+-+-+-----+-+-+-+ -// | Label | Exp |S| TTL | -// +-----+-+-+---+-+-+-+-+-+-----+-+-+-+ -// - -// RFC3107 Carrying Label Information in BGP-4 -// -// 3. Carrying Label Mapping Information -// -// The label information carried (as part of NLRI) in the Withdrawn -// Routes field should be set to 0x800000. -const WITHDRAW_LABEL = uint32(0x800000) -const ZERO_LABEL = uint32(0) // some platform uses this as withdraw label - -type MPLSLabelStack struct { - Labels []uint32 -} - -func (l *MPLSLabelStack) DecodeFromBytes(data []byte) error { - labels := []uint32{} - foundBottom := false - for len(data) >= 3 { - label := uint32(data[0])<<16 | uint32(data[1])<<8 | uint32(data[2]) - if label == WITHDRAW_LABEL || label == ZERO_LABEL { - l.Labels = []uint32{label} - return nil - } - data = data[3:] - labels = append(labels, label>>4) - if label&1 == 1 { - foundBottom = true - break - } - } - - if !foundBottom { - l.Labels = []uint32{} - return nil - } - l.Labels = labels - return nil -} - -func (l *MPLSLabelStack) Serialize() ([]byte, error) { - buf := make([]byte, len(l.Labels)*3) - for i, label := range l.Labels { - if label == WITHDRAW_LABEL { - return []byte{128, 0, 0}, nil - } - label = label << 4 - buf[i*3] = byte((label >> 16) & 0xff) - buf[i*3+1] = byte((label >> 8) & 0xff) - buf[i*3+2] = byte(label & 0xff) - } - buf[len(buf)-1] |= 1 - return buf, nil -} - -func (l *MPLSLabelStack) Len() int { return 3 * len(l.Labels) } - -func (l *MPLSLabelStack) String() string { - if len(l.Labels) == 0 { - return "" - } - s := bytes.NewBuffer(make([]byte, 0, 64)) - s.WriteString("[") - ss := make([]string, 0, len(l.Labels)) - for _, label := range l.Labels { - ss = append(ss, fmt.Sprintf("%d", label)) - } - s.WriteString(strings.Join(ss, ", ")) - s.WriteString("]") - return s.String() -} - -func NewMPLSLabelStack(labels ...uint32) *MPLSLabelStack { - if len(labels) == 0 { - labels = []uint32{0} - } - return &MPLSLabelStack{labels} -} - -func ParseMPLSLabelStack(buf string) (*MPLSLabelStack, error) { - elems := strings.Split(buf, "/") - labels := make([]uint32, 0, len(elems)) - if len(elems) == 0 { - goto ERR - } - for _, elem := range elems { - i, err := strconv.ParseUint(elem, 10, 32) - if err != nil { - goto ERR - } - if i > ((1 << 20) - 1) { - goto ERR - } - labels = append(labels, uint32(i)) - } - return NewMPLSLabelStack(labels...), nil -ERR: - return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "invalid mpls label stack format") -} - -// -// RFC3107 Carrying Label Information in BGP-4 -// -// 3. Carrying Label Mapping Information -// -// +----------------------+ -// | Length (1 octet) | -// +----------------------+ -// | Label (3 octets) | -// +----------------------+ -// ....................... -// +----------------------+ -// | Prefix (variable) | -// +----------------------+ -// -// RFC4364 BGP/MPLS IP VPNs -// -// 4.3.4. How VPN-IPv4 NLRI Is Carried in BGP -// -// The labeled VPN-IPv4 NLRI itself is encoded as specified in -// [MPLS-BGP(RFC3107)], where the prefix consists of an 8-byte RD -// followed by an IPv4 prefix. -// - -type LabeledVPNIPAddrPrefix struct { - IPAddrPrefixDefault - Labels MPLSLabelStack - RD RouteDistinguisherInterface - addrlen uint8 -} - -func (l *LabeledVPNIPAddrPrefix) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - f := RF_IPv4_VPN - if l.addrlen == 16 { - f = RF_IPv6_VPN - } - if IsAddPathEnabled(true, f, options) { - var err error - data, err = l.decodePathIdentifier(data) - if err != nil { - return err - } - } - if len(data) < 1 { - return NewMessageError(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST), nil, "prefix misses length field") - } - l.Length = uint8(data[0]) - data = data[1:] - l.Labels.DecodeFromBytes(data) - if int(l.Length)-8*(l.Labels.Len()) < 0 { - l.Labels.Labels = []uint32{} - } - data = data[l.Labels.Len():] - l.RD = GetRouteDistinguisher(data) - data = data[l.RD.Len():] - restbits := int(l.Length) - 8*(l.Labels.Len()+l.RD.Len()) - return l.decodePrefix(data, uint8(restbits), l.addrlen) -} - -func (l *LabeledVPNIPAddrPrefix) Serialize(options ...*MarshallingOption) ([]byte, error) { - f := RF_IPv4_VPN - if l.addrlen == 16 { - f = RF_IPv6_VPN - } - var buf []byte - if IsAddPathEnabled(false, f, options) { - var err error - buf, err = l.serializeIdentifier() - if err != nil { - return nil, err - } - } - buf = append(buf, l.Length) - lbuf, err := l.Labels.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, lbuf...) - rbuf, err := l.RD.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, rbuf...) - restbits := int(l.Length) - 8*(l.Labels.Len()+l.RD.Len()) - pbuf, err := l.serializePrefix(uint8(restbits)) - if err != nil { - return nil, err - } - buf = append(buf, pbuf...) - return buf, nil -} - -func (l *LabeledVPNIPAddrPrefix) AFI() uint16 { - return AFI_IP -} - -func (l *LabeledVPNIPAddrPrefix) SAFI() uint8 { - return SAFI_MPLS_VPN -} - -func (l *LabeledVPNIPAddrPrefix) IPPrefixLen() uint8 { - return l.Length - 8*uint8(l.Labels.Len()+l.RD.Len()) -} - -func (l *LabeledVPNIPAddrPrefix) Len(options ...*MarshallingOption) int { - return 1 + l.Labels.Len() + l.RD.Len() + int((l.IPPrefixLen()+7)/8) -} - -func (l *LabeledVPNIPAddrPrefix) String() string { - return fmt.Sprintf("%s:%s", l.RD, l.IPPrefix()) -} - -func (l *LabeledVPNIPAddrPrefix) IPPrefix() string { - masklen := l.IPAddrPrefixDefault.Length - uint8(8*(l.Labels.Len()+l.RD.Len())) - return fmt.Sprintf("%s/%d", l.IPAddrPrefixDefault.Prefix, masklen) -} - -func (l *LabeledVPNIPAddrPrefix) MarshalJSON() ([]byte, error) { - masklen := l.IPAddrPrefixDefault.Length - uint8(8*(l.Labels.Len()+l.RD.Len())) - return json.Marshal(struct { - Prefix string `json:"prefix"` - Labels []uint32 `json:"labels"` - RD RouteDistinguisherInterface `json:"rd"` - }{ - Prefix: fmt.Sprintf("%s/%d", l.IPAddrPrefixDefault.Prefix, masklen), - Labels: l.Labels.Labels, - RD: l.RD, - }) -} - -func NewLabeledVPNIPAddrPrefix(length uint8, prefix string, label MPLSLabelStack, rd RouteDistinguisherInterface) *LabeledVPNIPAddrPrefix { - rdlen := 0 - if rd != nil { - rdlen = rd.Len() - } - return &LabeledVPNIPAddrPrefix{ - IPAddrPrefixDefault{ - Length: length + uint8(8*(label.Len()+rdlen)), - Prefix: net.ParseIP(prefix).To4(), - }, - label, - rd, - 4, - } -} - -type LabeledVPNIPv6AddrPrefix struct { - LabeledVPNIPAddrPrefix -} - -func (l *LabeledVPNIPv6AddrPrefix) AFI() uint16 { - return AFI_IP6 -} - -func NewLabeledVPNIPv6AddrPrefix(length uint8, prefix string, label MPLSLabelStack, rd RouteDistinguisherInterface) *LabeledVPNIPv6AddrPrefix { - rdlen := 0 - if rd != nil { - rdlen = rd.Len() - } - return &LabeledVPNIPv6AddrPrefix{ - LabeledVPNIPAddrPrefix{ - IPAddrPrefixDefault{ - Length: length + uint8(8*(label.Len()+rdlen)), - Prefix: net.ParseIP(prefix), - }, - label, - rd, - 16, - }, - } -} - -type LabeledIPAddrPrefix struct { - IPAddrPrefixDefault - Labels MPLSLabelStack - addrlen uint8 -} - -func (r *LabeledIPAddrPrefix) AFI() uint16 { - return AFI_IP -} - -func (r *LabeledIPAddrPrefix) SAFI() uint8 { - return SAFI_MPLS_LABEL -} - -func (l *LabeledIPAddrPrefix) IPPrefixLen() uint8 { - return l.Length - 8*uint8(l.Labels.Len()) -} - -func (l *LabeledIPAddrPrefix) Len(options ...*MarshallingOption) int { - return 1 + l.Labels.Len() + int((l.IPPrefixLen()+7)/8) -} - -func (l *LabeledIPAddrPrefix) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - f := RF_IPv4_MPLS - if l.addrlen == 16 { - f = RF_IPv6_MPLS - } - if IsAddPathEnabled(true, f, options) { - var err error - data, err = l.decodePathIdentifier(data) - if err != nil { - return err - } - } - l.Length = uint8(data[0]) - data = data[1:] - l.Labels.DecodeFromBytes(data) - - if int(l.Length)-8*(l.Labels.Len()) < 0 { - l.Labels.Labels = []uint32{} - } - restbits := int(l.Length) - 8*(l.Labels.Len()) - data = data[l.Labels.Len():] - return l.decodePrefix(data, uint8(restbits), l.addrlen) -} - -func (l *LabeledIPAddrPrefix) Serialize(options ...*MarshallingOption) ([]byte, error) { - f := RF_IPv4_MPLS - if l.addrlen == 16 { - f = RF_IPv6_MPLS - } - var buf []byte - if IsAddPathEnabled(false, f, options) { - var err error - buf, err = l.serializeIdentifier() - if err != nil { - return nil, err - } - } - buf = append(buf, l.Length) - restbits := int(l.Length) - 8*(l.Labels.Len()) - lbuf, err := l.Labels.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, lbuf...) - pbuf, err := l.serializePrefix(uint8(restbits)) - if err != nil { - return nil, err - } - buf = append(buf, pbuf...) - return buf, nil -} - -func (l *LabeledIPAddrPrefix) String() string { - prefix := l.Prefix.String() - if isIPv4MappedIPv6(l.Prefix) { - prefix = "::ffff:" + prefix - } - return fmt.Sprintf("%s/%d", prefix, int(l.Length)-l.Labels.Len()*8) -} - -func (l *LabeledIPAddrPrefix) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Prefix string `json:"prefix"` - Labels []uint32 `json:"labels"` - }{ - Prefix: l.String(), - Labels: l.Labels.Labels, - }) -} - -func NewLabeledIPAddrPrefix(length uint8, prefix string, label MPLSLabelStack) *LabeledIPAddrPrefix { - return &LabeledIPAddrPrefix{ - IPAddrPrefixDefault{ - Length: length + uint8(label.Len()*8), - Prefix: net.ParseIP(prefix).To4(), - }, - label, - 4, - } -} - -type LabeledIPv6AddrPrefix struct { - LabeledIPAddrPrefix -} - -func (l *LabeledIPv6AddrPrefix) AFI() uint16 { - return AFI_IP6 -} - -func NewLabeledIPv6AddrPrefix(length uint8, prefix string, label MPLSLabelStack) *LabeledIPv6AddrPrefix { - return &LabeledIPv6AddrPrefix{ - LabeledIPAddrPrefix{ - IPAddrPrefixDefault{ - Length: length + uint8(label.Len()*8), - Prefix: net.ParseIP(prefix), - }, - label, - 16, - }, - } -} - -type RouteTargetMembershipNLRI struct { - PrefixDefault - Length uint8 - AS uint32 - RouteTarget ExtendedCommunityInterface -} - -func (n *RouteTargetMembershipNLRI) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - if IsAddPathEnabled(true, RF_RTC_UC, options) { - var err error - data, err = n.decodePathIdentifier(data) - if err != nil { - return err - } - } - if len(data) < 1 { - return NewMessageError(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST), nil, "prefix misses length field") - } - n.Length = data[0] - data = data[1 : n.Length/8+1] - if len(data) == 0 { - return nil - } else if len(data) != 12 { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all RouteTargetMembershipNLRI bytes available") - } - n.AS = binary.BigEndian.Uint32(data[0:4]) - rt, err := ParseExtended(data[4:]) - n.RouteTarget = rt - if err != nil { - return err - } - return nil -} - -func (n *RouteTargetMembershipNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) { - var buf []byte - if IsAddPathEnabled(false, RF_RTC_UC, options) { - var err error - buf, err = n.serializeIdentifier() - if err != nil { - return nil, err - } - } - if n.RouteTarget == nil { - return append(buf, 0), nil - } - offset := len(buf) - buf = append(buf, make([]byte, 5)...) - buf[offset] = 96 - binary.BigEndian.PutUint32(buf[offset+1:], n.AS) - ebuf, err := n.RouteTarget.Serialize() - if err != nil { - return nil, err - } - return append(buf, ebuf...), nil -} - -func (n *RouteTargetMembershipNLRI) AFI() uint16 { - return AFI_IP -} - -func (n *RouteTargetMembershipNLRI) SAFI() uint8 { - return SAFI_ROUTE_TARGET_CONSTRAINTS -} - -func (n *RouteTargetMembershipNLRI) Len(options ...*MarshallingOption) int { - if n.AS == 0 && n.RouteTarget == nil { - return 1 - } - return 13 -} - -func (n *RouteTargetMembershipNLRI) String() string { - target := "default" - if n.RouteTarget != nil { - target = n.RouteTarget.String() - } - return fmt.Sprintf("%d:%s", n.AS, target) -} - -func (n *RouteTargetMembershipNLRI) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Prefix string `json:"prefix"` - }{ - Prefix: n.String(), - }) -} - -func NewRouteTargetMembershipNLRI(as uint32, target ExtendedCommunityInterface) *RouteTargetMembershipNLRI { - l := 12 * 8 - if as == 0 && target == nil { - l = 1 - } - return &RouteTargetMembershipNLRI{ - Length: uint8(l), - AS: as, - RouteTarget: target, - } -} - -type ESIType uint8 - -const ( - ESI_ARBITRARY ESIType = iota - ESI_LACP - ESI_MSTP - ESI_MAC - ESI_ROUTERID - ESI_AS -) - -type EthernetSegmentIdentifier struct { - Type ESIType - Value []byte -} - -func (esi *EthernetSegmentIdentifier) DecodeFromBytes(data []byte) error { - esi.Type = ESIType(data[0]) - esi.Value = data[1:10] - switch esi.Type { - case ESI_LACP, ESI_MSTP, ESI_ROUTERID, ESI_AS: - if esi.Value[8] != 0x00 { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("invalid %s. last octet must be 0x00 (0x%02x)", esi.Type.String(), esi.Value[8])) - } - } - return nil -} - -func (esi *EthernetSegmentIdentifier) Serialize() ([]byte, error) { - buf := make([]byte, 10) - buf[0] = uint8(esi.Type) - copy(buf[1:], esi.Value) - return buf, nil -} - -func isZeroBuf(buf []byte) bool { - for _, b := range buf { - if b != 0 { - return false - } - } - return true -} - -func (esi *EthernetSegmentIdentifier) String() string { - toHexArray := func(data []byte) string { - // Converts byte slice into the colon separated hex values and the - // number of elements are 9 at most (excluding Type field). - values := make([]string, 0, 9) - for _, v := range data { - values = append(values, fmt.Sprintf("%02x", v)) - } - return strings.Join(values, ":") - } - - s := bytes.NewBuffer(make([]byte, 0, 64)) - s.WriteString(fmt.Sprintf("%s | ", esi.Type.String())) - switch esi.Type { - case ESI_LACP: - s.WriteString(fmt.Sprintf("system mac %s, ", net.HardwareAddr(esi.Value[:6]).String())) - s.WriteString(fmt.Sprintf("port key %d", binary.BigEndian.Uint16(esi.Value[6:8]))) - case ESI_MSTP: - s.WriteString(fmt.Sprintf("bridge mac %s, ", net.HardwareAddr(esi.Value[:6]).String())) - s.WriteString(fmt.Sprintf("priority %d", binary.BigEndian.Uint16(esi.Value[6:8]))) - case ESI_MAC: - s.WriteString(fmt.Sprintf("system mac %s, ", net.HardwareAddr(esi.Value[:6]).String())) - s.WriteString(fmt.Sprintf("local discriminator %d", uint32(esi.Value[6])<<16|uint32(esi.Value[7])<<8|uint32(esi.Value[8]))) - case ESI_ROUTERID: - s.WriteString(fmt.Sprintf("router id %s, ", net.IP(esi.Value[:4]))) - s.WriteString(fmt.Sprintf("local discriminator %d", binary.BigEndian.Uint32(esi.Value[4:8]))) - case ESI_AS: - s.WriteString(fmt.Sprintf("as %d, ", binary.BigEndian.Uint32(esi.Value[:4]))) - s.WriteString(fmt.Sprintf("local discriminator %d", binary.BigEndian.Uint32(esi.Value[4:8]))) - case ESI_ARBITRARY: - if isZeroBuf(esi.Value) { - return "single-homed" - } - fallthrough - default: - s.WriteString(toHexArray(esi.Value)) - } - return s.String() -} - -// Decode Ethernet Segment Identifier (ESI) from string slice. -// -// The first element of args should be the Type field (e.g., "ARBITRARY", -// "arbitrary", "ESI_ARBITRARY" or "esi_arbitrary") and "single-homed" is -// the special keyword for all zeroed ESI. -// For the "ARBITRARY" Value field (Type 0), it should be the colon separated -// hex values and the number of elements should be 9 at most. -// e.g.) args := []string{"ARBITRARY", "11:22:33:44:55:66:77:88:99"} -// For the other types, the Value field format is the similar to the string -// format of ESI. -// e.g.) args := []string{"lacp", "aa:bb:cc:dd:ee:ff", "100"} -func ParseEthernetSegmentIdentifier(args []string) (EthernetSegmentIdentifier, error) { - esi := EthernetSegmentIdentifier{} - argLen := len(args) - if argLen == 0 || args[0] == "single-homed" { - return esi, nil - } - - typeStr := strings.TrimPrefix(strings.ToUpper(args[0]), "ESI_") - switch typeStr { - case "ARBITRARY": - esi.Type = ESI_ARBITRARY - case "LACP": - esi.Type = ESI_LACP - case "MSTP": - esi.Type = ESI_MSTP - case "MAC": - esi.Type = ESI_MAC - case "ROUTERID": - esi.Type = ESI_ROUTERID - case "AS": - esi.Type = ESI_AS - default: - typ, err := strconv.ParseUint(args[0], 10, 8) - if err != nil { - return esi, fmt.Errorf("invalid esi type: %s", args[0]) - } - esi.Type = ESIType(typ) - } - - invalidEsiValuesError := fmt.Errorf("invalid esi values for type %s: %s", esi.Type.String(), args[1:]) - esi.Value = make([]byte, 9) - switch esi.Type { - case ESI_LACP: - fallthrough - case ESI_MSTP: - if argLen < 3 { - return esi, invalidEsiValuesError - } - // MAC - mac, err := net.ParseMAC(args[1]) - if err != nil { - return esi, invalidEsiValuesError - } - copy(esi.Value[0:6], mac) - // Port Key or Bridge Priority - i, err := strconv.ParseUint(args[2], 10, 16) - if err != nil { - return esi, invalidEsiValuesError - } - binary.BigEndian.PutUint16(esi.Value[6:8], uint16(i)) - case ESI_MAC: - if argLen < 3 { - return esi, invalidEsiValuesError - } - // MAC - mac, err := net.ParseMAC(args[1]) - if err != nil { - return esi, invalidEsiValuesError - } - copy(esi.Value[0:6], mac) - // Local Discriminator - i, err := strconv.ParseUint(args[2], 10, 32) - if err != nil { - return esi, invalidEsiValuesError - } - iBuf := make([]byte, 4) - binary.BigEndian.PutUint32(iBuf, uint32(i)) - copy(esi.Value[6:9], iBuf[1:4]) - case ESI_ROUTERID: - if argLen < 3 { - return esi, invalidEsiValuesError - } - // Router ID - ip := net.ParseIP(args[1]) - if ip == nil || ip.To4() == nil { - return esi, invalidEsiValuesError - } - copy(esi.Value[0:4], ip.To4()) - // Local Discriminator - i, err := strconv.ParseUint(args[2], 10, 32) - if err != nil { - return esi, invalidEsiValuesError - } - binary.BigEndian.PutUint32(esi.Value[4:8], uint32(i)) - case ESI_AS: - if argLen < 3 { - return esi, invalidEsiValuesError - } - // AS - as, err := strconv.ParseUint(args[1], 10, 32) - if err != nil { - return esi, invalidEsiValuesError - } - binary.BigEndian.PutUint32(esi.Value[0:4], uint32(as)) - // Local Discriminator - i, err := strconv.ParseUint(args[2], 10, 32) - if err != nil { - return esi, invalidEsiValuesError - } - binary.BigEndian.PutUint32(esi.Value[4:8], uint32(i)) - case ESI_ARBITRARY: - fallthrough - default: - if argLen < 2 { - // Assumes the Value field is omitted - break - } - values := make([]byte, 0, 9) - for _, e := range strings.SplitN(args[1], ":", 9) { - v, err := strconv.ParseUint(e, 16, 16) - if err != nil { - return esi, invalidEsiValuesError - } - values = append(values, byte(v)) - } - copy(esi.Value, values) - } - - return esi, nil -} - -// -// I-D bess-evpn-overlay-01 -// -// 5.1.3 Constructing EVPN BGP Routes -// -// For the balance of this memo, the MPLS label field will be -// referred to as the VNI/VSID field. The VNI/VSID field is used for -// both local and global VNIs/VSIDs, and for either case the entire 24- -// bit field is used to encode the VNI/VSID value. -// -// We can't use type MPLSLabelStack for EVPN NLRI, because EVPN NLRI's MPLS -// field can be filled with VXLAN VNI. In that case, we must avoid modifying -// bottom of stack bit. -// - -func labelDecode(data []byte) (uint32, error) { - if len(data) < 3 { - return 0, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all Label bytes available") - } - return uint32(data[0])<<16 | uint32(data[1])<<8 | uint32(data[2]), nil -} - -func labelSerialize(label uint32) ([]byte, error) { - if label > 0xffffff { - return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Out of range Label: %d", label)) - } - buf := make([]byte, 3) - buf[0] = byte((label >> 16) & 0xff) - buf[1] = byte((label >> 8) & 0xff) - buf[2] = byte(label & 0xff) - return buf, nil -} - -type EVPNEthernetAutoDiscoveryRoute struct { - RD RouteDistinguisherInterface - ESI EthernetSegmentIdentifier - ETag uint32 - Label uint32 -} - -func (er *EVPNEthernetAutoDiscoveryRoute) Len() int { - // RD(8) + ESI(10) + ETag(4) + Label(3) - return 25 -} - -func (er *EVPNEthernetAutoDiscoveryRoute) DecodeFromBytes(data []byte) error { - er.RD = GetRouteDistinguisher(data) - data = data[er.RD.Len():] - err := er.ESI.DecodeFromBytes(data) - if err != nil { - return err - } - data = data[10:] - er.ETag = binary.BigEndian.Uint32(data[0:4]) - data = data[4:] - if er.Label, err = labelDecode(data); err != nil { - return err - } - return nil -} - -func (er *EVPNEthernetAutoDiscoveryRoute) Serialize() ([]byte, error) { - var buf []byte - var err error - if er.RD != nil { - buf, err = er.RD.Serialize() - if err != nil { - return nil, err - } - } else { - buf = make([]byte, 8) - } - tbuf, err := er.ESI.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, tbuf...) - - tbuf = make([]byte, 4) - binary.BigEndian.PutUint32(tbuf, er.ETag) - buf = append(buf, tbuf...) - - tbuf, err = labelSerialize(er.Label) - if err != nil { - return nil, err - } - buf = append(buf, tbuf...) - - return buf, nil -} - -func (er *EVPNEthernetAutoDiscoveryRoute) String() string { - // RFC7432: BGP MPLS-Based Ethernet VPN - // 7.1. Ethernet Auto-discovery Route - // For the purpose of BGP route key processing, only the Ethernet - // Segment Identifier and the Ethernet Tag ID are considered to be part - // of the prefix in the NLRI. The MPLS Label field is to be treated as - // a route attribute as opposed to being part of the route. - return fmt.Sprintf("[type:A-D][rd:%s][esi:%s][etag:%d]", er.RD, er.ESI.String(), er.ETag) -} - -func (er *EVPNEthernetAutoDiscoveryRoute) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - RD RouteDistinguisherInterface `json:"rd"` - ESI string `json:"esi"` - Etag uint32 `json:"etag"` - Label uint32 `json:"label"` - }{ - RD: er.RD, - ESI: er.ESI.String(), - Etag: er.ETag, - Label: er.Label, - }) -} - -func (er *EVPNEthernetAutoDiscoveryRoute) rd() RouteDistinguisherInterface { - return er.RD -} - -func NewEVPNEthernetAutoDiscoveryRoute(rd RouteDistinguisherInterface, esi EthernetSegmentIdentifier, etag uint32, label uint32) *EVPNNLRI { - return NewEVPNNLRI(EVPN_ROUTE_TYPE_ETHERNET_AUTO_DISCOVERY, &EVPNEthernetAutoDiscoveryRoute{ - RD: rd, - ESI: esi, - ETag: etag, - Label: label, - }) -} - -type EVPNMacIPAdvertisementRoute struct { - RD RouteDistinguisherInterface - ESI EthernetSegmentIdentifier - ETag uint32 - MacAddressLength uint8 - MacAddress net.HardwareAddr - IPAddressLength uint8 - IPAddress net.IP - Labels []uint32 -} - -func (er *EVPNMacIPAdvertisementRoute) Len() int { - // RD(8) + ESI(10) + ETag(4) + MacAddressLength(1) + MacAddress(6) - // + IPAddressLength(1) + IPAddress(0, 4 or 16) + Labels(3 or 6) - return 30 + int(er.IPAddressLength)/8 + len(er.Labels)*3 -} - -func (er *EVPNMacIPAdvertisementRoute) DecodeFromBytes(data []byte) error { - er.RD = GetRouteDistinguisher(data) - data = data[er.RD.Len():] - err := er.ESI.DecodeFromBytes(data) - if err != nil { - return err - } - data = data[10:] - er.ETag = binary.BigEndian.Uint32(data[0:4]) - data = data[4:] - er.MacAddressLength = data[0] - er.MacAddress = net.HardwareAddr(data[1:7]) - er.IPAddressLength = data[7] - data = data[8:] - if er.IPAddressLength == 32 || er.IPAddressLength == 128 { - er.IPAddress = net.IP(data[0:((er.IPAddressLength) / 8)]) - } else if er.IPAddressLength != 0 { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid IP address length: %d", er.IPAddressLength)) - } - data = data[(er.IPAddressLength / 8):] - var label uint32 - if label, err = labelDecode(data); err != nil { - return err - } - er.Labels = append(er.Labels, label) - data = data[3:] - if len(data) == 3 { - if label, err = labelDecode(data); err != nil { - return err - } - er.Labels = append(er.Labels, label) - } - return nil -} - -func (er *EVPNMacIPAdvertisementRoute) Serialize() ([]byte, error) { - var buf []byte - var err error - if er.RD != nil { - buf, err = er.RD.Serialize() - if err != nil { - return nil, err - } - } else { - buf = make([]byte, 8) - } - - tbuf, err := er.ESI.Serialize() - if err != nil { - return nil, err - } - - buf = append(buf, tbuf...) - tbuf = make([]byte, 4) - binary.BigEndian.PutUint32(tbuf, er.ETag) - buf = append(buf, tbuf...) - tbuf = make([]byte, 7) - tbuf[0] = er.MacAddressLength - copy(tbuf[1:], er.MacAddress) - buf = append(buf, tbuf...) - - buf = append(buf, er.IPAddressLength) - switch er.IPAddressLength { - case 0: - // IP address omitted - case 32: - buf = append(buf, []byte(er.IPAddress.To4())...) - case 128: - buf = append(buf, []byte(er.IPAddress.To16())...) - default: - return nil, fmt.Errorf("Invalid IP address length: %d", er.IPAddressLength) - } - - for _, l := range er.Labels { - tbuf, err = labelSerialize(l) - if err != nil { - return nil, err - } - buf = append(buf, tbuf...) - } - return buf, nil -} - -func (er *EVPNMacIPAdvertisementRoute) String() string { - // RFC7432: BGP MPLS-Based Ethernet VPN - // 7.2. MAC/IP Advertisement Route - // For the purpose of BGP route key processing, only the Ethernet Tag - // ID, MAC Address Length, MAC Address, IP Address Length, and IP - // Address fields are considered to be part of the prefix in the NLRI. - // The Ethernet Segment Identifier, MPLS Label1, and MPLS Label2 fields - // are to be treated as route attributes as opposed to being part of the - // "route". - return fmt.Sprintf("[type:macadv][rd:%s][etag:%d][mac:%s][ip:%s]", er.RD, er.ETag, er.MacAddress, er.IPAddress) -} - -func (er *EVPNMacIPAdvertisementRoute) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - RD RouteDistinguisherInterface `json:"rd"` - ESI string `json:"esi"` - Etag uint32 `json:"etag"` - MacAddress string `json:"mac"` - IPAddress string `json:"ip"` - Labels []uint32 `json:"labels"` - }{ - RD: er.RD, - ESI: er.ESI.String(), - Etag: er.ETag, - MacAddress: er.MacAddress.String(), - IPAddress: er.IPAddress.String(), - Labels: er.Labels, - }) -} - -func (er *EVPNMacIPAdvertisementRoute) rd() RouteDistinguisherInterface { - return er.RD -} - -func NewEVPNMacIPAdvertisementRoute(rd RouteDistinguisherInterface, esi EthernetSegmentIdentifier, etag uint32, macAddress string, ipAddress string, labels []uint32) *EVPNNLRI { - mac, _ := net.ParseMAC(macAddress) - var ipLen uint8 - ip := net.ParseIP(ipAddress) - if ip != nil { - if ipv4 := ip.To4(); ipv4 != nil { - ipLen = 32 - ip = ipv4 - } else { - ipLen = 128 - } - } - return NewEVPNNLRI(EVPN_ROUTE_TYPE_MAC_IP_ADVERTISEMENT, &EVPNMacIPAdvertisementRoute{ - RD: rd, - ESI: esi, - ETag: etag, - MacAddressLength: 6, - MacAddress: mac, - IPAddressLength: ipLen, - IPAddress: ip, - Labels: labels, - }) -} - -type EVPNMulticastEthernetTagRoute struct { - RD RouteDistinguisherInterface - ETag uint32 - IPAddressLength uint8 - IPAddress net.IP -} - -func (er *EVPNMulticastEthernetTagRoute) Len() int { - // RD(8) + ETag(4) + IPAddressLength(1) + IPAddress(4 or 16) - return 13 + int(er.IPAddressLength)/8 -} - -func (er *EVPNMulticastEthernetTagRoute) DecodeFromBytes(data []byte) error { - er.RD = GetRouteDistinguisher(data) - data = data[er.RD.Len():] - er.ETag = binary.BigEndian.Uint32(data[0:4]) - er.IPAddressLength = data[4] - data = data[5:] - if er.IPAddressLength == 32 || er.IPAddressLength == 128 { - er.IPAddress = net.IP(data[:er.IPAddressLength/8]) - } else { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid IP address length: %d", er.IPAddressLength)) - } - return nil -} - -func (er *EVPNMulticastEthernetTagRoute) Serialize() ([]byte, error) { - var buf []byte - var err error - if er.RD != nil { - buf, err = er.RD.Serialize() - if err != nil { - return nil, err - } - } else { - buf = make([]byte, 8) - } - tbuf := make([]byte, 4) - binary.BigEndian.PutUint32(tbuf, er.ETag) - buf = append(buf, tbuf...) - buf = append(buf, er.IPAddressLength) - switch er.IPAddressLength { - case 32: - buf = append(buf, []byte(er.IPAddress.To4())...) - case 128: - buf = append(buf, []byte(er.IPAddress.To16())...) - default: - return nil, fmt.Errorf("Invalid IP address length: %d", er.IPAddressLength) - } - if err != nil { - return nil, err - } - return buf, nil -} - -func (er *EVPNMulticastEthernetTagRoute) String() string { - // RFC7432: BGP MPLS-Based Ethernet VPN - // 7.3. Inclusive Multicast Ethernet Tag Route - // ...(snip)... For the purpose of BGP route key - // processing, only the Ethernet Tag ID, IP Address Length, and - // Originating Router's IP Address fields are considered to be part of - // the prefix in the NLRI. - return fmt.Sprintf("[type:multicast][rd:%s][etag:%d][ip:%s]", er.RD, er.ETag, er.IPAddress) -} - -func (er *EVPNMulticastEthernetTagRoute) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - RD RouteDistinguisherInterface `json:"rd"` - Etag uint32 `json:"etag"` - IPAddress string `json:"ip"` - }{ - RD: er.RD, - Etag: er.ETag, - IPAddress: er.IPAddress.String(), - }) -} - -func (er *EVPNMulticastEthernetTagRoute) rd() RouteDistinguisherInterface { - return er.RD -} - -func NewEVPNMulticastEthernetTagRoute(rd RouteDistinguisherInterface, etag uint32, ipAddress string) *EVPNNLRI { - ipLen := uint8(32) - ip := net.ParseIP(ipAddress) - if ipv4 := ip.To4(); ipv4 != nil { - ip = ipv4 - } else { - ipLen = 128 - } - return NewEVPNNLRI(EVPN_INCLUSIVE_MULTICAST_ETHERNET_TAG, &EVPNMulticastEthernetTagRoute{ - RD: rd, - ETag: etag, - IPAddressLength: ipLen, - IPAddress: ip, - }) -} - -type EVPNEthernetSegmentRoute struct { - RD RouteDistinguisherInterface - ESI EthernetSegmentIdentifier - IPAddressLength uint8 - IPAddress net.IP -} - -func (er *EVPNEthernetSegmentRoute) Len() int { - // RD(8) + ESI(10) + IPAddressLength(1) + IPAddress(4 or 16) - return 19 + int(er.IPAddressLength)/8 -} - -func (er *EVPNEthernetSegmentRoute) DecodeFromBytes(data []byte) error { - er.RD = GetRouteDistinguisher(data) - data = data[er.RD.Len():] - er.ESI.DecodeFromBytes(data) - data = data[10:] - er.IPAddressLength = data[0] - data = data[1:] - if er.IPAddressLength == 32 || er.IPAddressLength == 128 { - er.IPAddress = net.IP(data[:er.IPAddressLength/8]) - } else { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid IP address length: %d", er.IPAddressLength)) - } - return nil -} - -func (er *EVPNEthernetSegmentRoute) Serialize() ([]byte, error) { - var buf []byte - var err error - if er.RD != nil { - buf, err = er.RD.Serialize() - if err != nil { - return nil, err - } - } else { - buf = make([]byte, 8) - } - tbuf, err := er.ESI.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, tbuf...) - buf = append(buf, er.IPAddressLength) - switch er.IPAddressLength { - case 32: - buf = append(buf, []byte(er.IPAddress.To4())...) - case 128: - buf = append(buf, []byte(er.IPAddress.To16())...) - default: - return nil, fmt.Errorf("Invalid IP address length: %d", er.IPAddressLength) - } - return buf, nil -} - -func (er *EVPNEthernetSegmentRoute) String() string { - // RFC7432: BGP MPLS-Based Ethernet VPN - // 7.4. Ethernet Segment Route - // For the purpose of BGP route key processing, only the Ethernet - // Segment ID, IP Address Length, and Originating Router's IP Address - // fields are considered to be part of the prefix in the NLRI. - return fmt.Sprintf("[type:esi][rd:%s][esi:%s][ip:%s]", er.RD, er.ESI.String(), er.IPAddress) -} - -func (er *EVPNEthernetSegmentRoute) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - RD RouteDistinguisherInterface `json:"rd"` - ESI string `json:"esi"` - IPAddress string `json:"ip"` - }{ - RD: er.RD, - ESI: er.ESI.String(), - IPAddress: er.IPAddress.String(), - }) -} - -func (er *EVPNEthernetSegmentRoute) rd() RouteDistinguisherInterface { - return er.RD -} - -func NewEVPNEthernetSegmentRoute(rd RouteDistinguisherInterface, esi EthernetSegmentIdentifier, ipAddress string) *EVPNNLRI { - ipLen := uint8(32) - ip := net.ParseIP(ipAddress) - if ipv4 := ip.To4(); ipv4 != nil { - ip = ipv4 - } else { - ipLen = 128 - } - return NewEVPNNLRI(EVPN_ETHERNET_SEGMENT_ROUTE, &EVPNEthernetSegmentRoute{ - RD: rd, - ESI: esi, - IPAddressLength: ipLen, - IPAddress: ip, - }) -} - -type EVPNIPPrefixRoute struct { - RD RouteDistinguisherInterface - ESI EthernetSegmentIdentifier - ETag uint32 - IPPrefixLength uint8 - IPPrefix net.IP - GWIPAddress net.IP - Label uint32 -} - -func (er *EVPNIPPrefixRoute) Len() int { - if er.IPPrefix.To4() != nil { - return 34 - } - return 58 -} - -func (er *EVPNIPPrefixRoute) DecodeFromBytes(data []byte) error { - addrLen := net.IPv4len - switch len(data) { - case 34: - // RD(8) + ESI(10) + ETag(4) + IPPrefixLength(1) + IPv4 Prefix(4) + GW IPv4(4) + Label(3) - case 58: - // RD(8) + ESI(10) + ETag(4) + IPPrefixLength(1) + IPv6 Prefix(16) + GW IPv6(16) + Label(3) - addrLen = net.IPv6len - default: - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all EVPN IP Prefix Route bytes available") - } - - er.RD = GetRouteDistinguisher(data[0:8]) - - err := er.ESI.DecodeFromBytes(data[8:18]) - if err != nil { - return err - } - - er.ETag = binary.BigEndian.Uint32(data[18:22]) - - er.IPPrefixLength = data[22] - - offset := 23 // RD(8) + ESI(10) + ETag(4) + IPPrefixLength(1) - er.IPPrefix = data[offset : offset+addrLen] - offset += addrLen - - er.GWIPAddress = data[offset : offset+addrLen] - offset += addrLen - - if er.Label, err = labelDecode(data[offset : offset+3]); err != nil { - return err - } - //offset += 3 - - return nil -} - -func (er *EVPNIPPrefixRoute) Serialize() ([]byte, error) { - buf := make([]byte, 23) // RD(8) + ESI(10) + ETag(4) + IPPrefixLength(1) - - if er.RD != nil { - tbuf, err := er.RD.Serialize() - if err != nil { - return nil, err - } - copy(buf[0:8], tbuf) - } - - tbuf, err := er.ESI.Serialize() - if err != nil { - return nil, err - } - copy(buf[8:18], tbuf) - - binary.BigEndian.PutUint32(buf[18:22], er.ETag) - - buf[22] = er.IPPrefixLength - - if er.IPPrefix == nil { - return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("IP Prefix is nil")) - } else if er.IPPrefix.To4() != nil { - buf = append(buf, er.IPPrefix.To4()...) - if er.GWIPAddress == nil { - // draft-ietf-bess-evpn-prefix-advertisement: IP Prefix Advertisement in EVPN - // The GW IP field SHOULD be zero if it is not used as an Overlay Index. - er.GWIPAddress = net.IPv4zero - } - buf = append(buf, er.GWIPAddress.To4()...) - } else { - buf = append(buf, er.IPPrefix.To16()...) - if er.GWIPAddress == nil { - er.GWIPAddress = net.IPv6zero - } - buf = append(buf, er.GWIPAddress.To16()...) - } - - tbuf, err = labelSerialize(er.Label) - if err != nil { - return nil, err - } - buf = append(buf, tbuf...) - - return buf, nil -} - -func (er *EVPNIPPrefixRoute) String() string { - // draft-ietf-bess-evpn-prefix-advertisement: IP Prefix Advertisement in EVPN - // 3.1 IP Prefix Route Encoding - // The RD, Eth-Tag ID, IP Prefix Length and IP Prefix will be part of - // the route key used by BGP to compare routes. The rest of the fields - // will not be part of the route key. - return fmt.Sprintf("[type:Prefix][rd:%s][etag:%d][prefix:%s/%d]", er.RD, er.ETag, er.IPPrefix, er.IPPrefixLength) -} - -func (er *EVPNIPPrefixRoute) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - RD RouteDistinguisherInterface `json:"rd"` - ESI string `json:"esi"` - Etag uint32 `json:"etag"` - Prefix string `json:"prefix"` - Gateway string `json:"gateway"` - Label uint32 `json:"label"` - }{ - RD: er.RD, - ESI: er.ESI.String(), - Etag: er.ETag, - Prefix: fmt.Sprintf("%s/%d", er.IPPrefix, er.IPPrefixLength), - Gateway: er.GWIPAddress.String(), - Label: er.Label, - }) -} - -func (er *EVPNIPPrefixRoute) rd() RouteDistinguisherInterface { - return er.RD -} - -func NewEVPNIPPrefixRoute(rd RouteDistinguisherInterface, esi EthernetSegmentIdentifier, etag uint32, ipPrefixLength uint8, ipPrefix string, gateway string, label uint32) *EVPNNLRI { - ip := net.ParseIP(ipPrefix) - gw := net.ParseIP(gateway) - if ipv4 := ip.To4(); ipv4 != nil { - ip = ipv4 - gw = gw.To4() - } - return NewEVPNNLRI(EVPN_IP_PREFIX, &EVPNIPPrefixRoute{ - RD: rd, - ESI: esi, - ETag: etag, - IPPrefixLength: ipPrefixLength, - IPPrefix: ip, - GWIPAddress: gw, - Label: label, - }) -} - -type EVPNRouteTypeInterface interface { - Len() int - DecodeFromBytes([]byte) error - Serialize() ([]byte, error) - String() string - rd() RouteDistinguisherInterface - MarshalJSON() ([]byte, error) -} - -func getEVPNRouteType(t uint8) (EVPNRouteTypeInterface, error) { - switch t { - case EVPN_ROUTE_TYPE_ETHERNET_AUTO_DISCOVERY: - return &EVPNEthernetAutoDiscoveryRoute{}, nil - case EVPN_ROUTE_TYPE_MAC_IP_ADVERTISEMENT: - return &EVPNMacIPAdvertisementRoute{}, nil - case EVPN_INCLUSIVE_MULTICAST_ETHERNET_TAG: - return &EVPNMulticastEthernetTagRoute{}, nil - case EVPN_ETHERNET_SEGMENT_ROUTE: - return &EVPNEthernetSegmentRoute{}, nil - case EVPN_IP_PREFIX: - return &EVPNIPPrefixRoute{}, nil - } - return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Unknown EVPN Route type: %d", t)) -} - -const ( - EVPN_ROUTE_TYPE_ETHERNET_AUTO_DISCOVERY = 1 - EVPN_ROUTE_TYPE_MAC_IP_ADVERTISEMENT = 2 - EVPN_INCLUSIVE_MULTICAST_ETHERNET_TAG = 3 - EVPN_ETHERNET_SEGMENT_ROUTE = 4 - EVPN_IP_PREFIX = 5 -) - -type EVPNNLRI struct { - PrefixDefault - RouteType uint8 - Length uint8 - RouteTypeData EVPNRouteTypeInterface -} - -func (n *EVPNNLRI) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - if IsAddPathEnabled(true, RF_EVPN, options) { - var err error - data, err = n.decodePathIdentifier(data) - if err != nil { - return err - } - } - if len(data) < 2 { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all EVPNNLRI bytes available") - } - n.RouteType = data[0] - n.Length = data[1] - data = data[2:] - if len(data) < int(n.Length) { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all EVPNNLRI Route type bytes available") - } - r, err := getEVPNRouteType(n.RouteType) - if err != nil { - return err - } - n.RouteTypeData = r - return n.RouteTypeData.DecodeFromBytes(data[:n.Length]) -} - -func (n *EVPNNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) { - var buf []byte - if IsAddPathEnabled(false, RF_EVPN, options) { - var err error - buf, err = n.serializeIdentifier() - if err != nil { - return nil, err - } - } - offset := len(buf) - buf = append(buf, make([]byte, 2)...) - buf[offset] = n.RouteType - tbuf, err := n.RouteTypeData.Serialize() - buf[offset+1] = n.Length - if err != nil { - return nil, err - } - return append(buf, tbuf...), nil -} - -func (n *EVPNNLRI) AFI() uint16 { - return AFI_L2VPN -} - -func (n *EVPNNLRI) SAFI() uint8 { - return SAFI_EVPN -} - -func (n *EVPNNLRI) Len(options ...*MarshallingOption) int { - return int(n.Length) + 2 -} - -func (n *EVPNNLRI) String() string { - if n.RouteTypeData != nil { - return n.RouteTypeData.String() - } - return fmt.Sprintf("%d:%d", n.RouteType, n.Length) -} - -func (n *EVPNNLRI) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type uint8 `json:"type"` - Value EVPNRouteTypeInterface `json:"value"` - }{ - Type: n.RouteType, - Value: n.RouteTypeData, - }) -} - -func (n *EVPNNLRI) RD() RouteDistinguisherInterface { - return n.RouteTypeData.rd() -} - -func NewEVPNNLRI(routeType uint8, routeTypeData EVPNRouteTypeInterface) *EVPNNLRI { - var l uint8 - if routeTypeData != nil { - l = uint8(routeTypeData.Len()) - } - return &EVPNNLRI{ - RouteType: routeType, - Length: l, - RouteTypeData: routeTypeData, - } -} - -type EncapNLRI struct { - IPAddrPrefixDefault - addrlen uint8 -} - -func (n *EncapNLRI) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - if n.addrlen == 0 { - n.addrlen = 4 - } - f := RF_IPv4_ENCAP - if n.addrlen == 16 { - f = RF_IPv6_ENCAP - } - if IsAddPathEnabled(true, f, options) { - var err error - data, err = n.decodePathIdentifier(data) - if err != nil { - return err - } - } - if len(data) < 4 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST) - return NewMessageError(eCode, eSubCode, nil, "prefix misses length field") - } - n.Length = data[0] - if n.addrlen == 0 { - n.addrlen = 4 - } - return n.decodePrefix(data[1:], n.Length, n.addrlen) -} - -func (n *EncapNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) { - var buf []byte - f := RF_IPv4_ENCAP - if n.addrlen == 16 { - f = RF_IPv6_ENCAP - } - if IsAddPathEnabled(false, f, options) { - var err error - buf, err = n.serializeIdentifier() - if err != nil { - return nil, err - } - } - if n.Prefix.To4() != nil { - buf = append(buf, net.IPv4len*8) - n.Prefix = n.Prefix.To4() - } else { - buf = append(buf, net.IPv6len*8) - } - n.Length = buf[len(buf)-1] - pbuf, err := n.serializePrefix(n.Length) - if err != nil { - return nil, err - } - return append(buf, pbuf...), nil -} - -func (n *EncapNLRI) String() string { - return n.Prefix.String() -} - -func (n *EncapNLRI) AFI() uint16 { - return AFI_IP -} - -func (n *EncapNLRI) SAFI() uint8 { - return SAFI_ENCAPSULATION -} - -func (n *EncapNLRI) Len(options ...*MarshallingOption) int { - return 1 + len(n.Prefix) -} - -func NewEncapNLRI(endpoint string) *EncapNLRI { - return &EncapNLRI{ - IPAddrPrefixDefault{Length: 32, Prefix: net.ParseIP(endpoint).To4()}, - 4, - } -} - -type Encapv6NLRI struct { - EncapNLRI -} - -func (n *Encapv6NLRI) AFI() uint16 { - return AFI_IP6 -} - -func NewEncapv6NLRI(endpoint string) *Encapv6NLRI { - return &Encapv6NLRI{ - EncapNLRI{ - IPAddrPrefixDefault{Length: 128, Prefix: net.ParseIP(endpoint)}, - 16, - }, - } -} - -type BGPFlowSpecType uint8 - -const ( - FLOW_SPEC_TYPE_UNKNOWN BGPFlowSpecType = iota - FLOW_SPEC_TYPE_DST_PREFIX - FLOW_SPEC_TYPE_SRC_PREFIX - FLOW_SPEC_TYPE_IP_PROTO - FLOW_SPEC_TYPE_PORT - FLOW_SPEC_TYPE_DST_PORT - FLOW_SPEC_TYPE_SRC_PORT - FLOW_SPEC_TYPE_ICMP_TYPE - FLOW_SPEC_TYPE_ICMP_CODE - FLOW_SPEC_TYPE_TCP_FLAG - FLOW_SPEC_TYPE_PKT_LEN - FLOW_SPEC_TYPE_DSCP - FLOW_SPEC_TYPE_FRAGMENT - FLOW_SPEC_TYPE_LABEL - FLOW_SPEC_TYPE_ETHERNET_TYPE // 14 - FLOW_SPEC_TYPE_SRC_MAC - FLOW_SPEC_TYPE_DST_MAC - FLOW_SPEC_TYPE_LLC_DSAP - FLOW_SPEC_TYPE_LLC_SSAP - FLOW_SPEC_TYPE_LLC_CONTROL - FLOW_SPEC_TYPE_SNAP - FLOW_SPEC_TYPE_VID - FLOW_SPEC_TYPE_COS - FLOW_SPEC_TYPE_INNER_VID - FLOW_SPEC_TYPE_INNER_COS -) - -var FlowSpecNameMap = map[BGPFlowSpecType]string{ - FLOW_SPEC_TYPE_UNKNOWN: "unknown", - FLOW_SPEC_TYPE_DST_PREFIX: "destination", - FLOW_SPEC_TYPE_SRC_PREFIX: "source", - FLOW_SPEC_TYPE_IP_PROTO: "protocol", - FLOW_SPEC_TYPE_PORT: "port", - FLOW_SPEC_TYPE_DST_PORT: "destination-port", - FLOW_SPEC_TYPE_SRC_PORT: "source-port", - FLOW_SPEC_TYPE_ICMP_TYPE: "icmp-type", - FLOW_SPEC_TYPE_ICMP_CODE: "icmp-code", - FLOW_SPEC_TYPE_TCP_FLAG: "tcp-flags", - FLOW_SPEC_TYPE_PKT_LEN: "packet-length", - FLOW_SPEC_TYPE_DSCP: "dscp", - FLOW_SPEC_TYPE_FRAGMENT: "fragment", - FLOW_SPEC_TYPE_LABEL: "label", - FLOW_SPEC_TYPE_ETHERNET_TYPE: "ether-type", - FLOW_SPEC_TYPE_SRC_MAC: "source-mac", - FLOW_SPEC_TYPE_DST_MAC: "destination-mac", - FLOW_SPEC_TYPE_LLC_DSAP: "llc-dsap", - FLOW_SPEC_TYPE_LLC_SSAP: "llc-ssap", - FLOW_SPEC_TYPE_LLC_CONTROL: "llc-control", - FLOW_SPEC_TYPE_SNAP: "snap", - FLOW_SPEC_TYPE_VID: "vid", - FLOW_SPEC_TYPE_COS: "cos", - FLOW_SPEC_TYPE_INNER_VID: "inner-vid", - FLOW_SPEC_TYPE_INNER_COS: "inner-cos", -} - -var FlowSpecValueMap = map[string]BGPFlowSpecType{ - FlowSpecNameMap[FLOW_SPEC_TYPE_DST_PREFIX]: FLOW_SPEC_TYPE_DST_PREFIX, - FlowSpecNameMap[FLOW_SPEC_TYPE_SRC_PREFIX]: FLOW_SPEC_TYPE_SRC_PREFIX, - FlowSpecNameMap[FLOW_SPEC_TYPE_IP_PROTO]: FLOW_SPEC_TYPE_IP_PROTO, - FlowSpecNameMap[FLOW_SPEC_TYPE_PORT]: FLOW_SPEC_TYPE_PORT, - FlowSpecNameMap[FLOW_SPEC_TYPE_DST_PORT]: FLOW_SPEC_TYPE_DST_PORT, - FlowSpecNameMap[FLOW_SPEC_TYPE_SRC_PORT]: FLOW_SPEC_TYPE_SRC_PORT, - FlowSpecNameMap[FLOW_SPEC_TYPE_ICMP_TYPE]: FLOW_SPEC_TYPE_ICMP_TYPE, - FlowSpecNameMap[FLOW_SPEC_TYPE_ICMP_CODE]: FLOW_SPEC_TYPE_ICMP_CODE, - FlowSpecNameMap[FLOW_SPEC_TYPE_TCP_FLAG]: FLOW_SPEC_TYPE_TCP_FLAG, - FlowSpecNameMap[FLOW_SPEC_TYPE_PKT_LEN]: FLOW_SPEC_TYPE_PKT_LEN, - FlowSpecNameMap[FLOW_SPEC_TYPE_DSCP]: FLOW_SPEC_TYPE_DSCP, - FlowSpecNameMap[FLOW_SPEC_TYPE_FRAGMENT]: FLOW_SPEC_TYPE_FRAGMENT, - FlowSpecNameMap[FLOW_SPEC_TYPE_LABEL]: FLOW_SPEC_TYPE_LABEL, - FlowSpecNameMap[FLOW_SPEC_TYPE_ETHERNET_TYPE]: FLOW_SPEC_TYPE_ETHERNET_TYPE, - FlowSpecNameMap[FLOW_SPEC_TYPE_SRC_MAC]: FLOW_SPEC_TYPE_SRC_MAC, - FlowSpecNameMap[FLOW_SPEC_TYPE_DST_MAC]: FLOW_SPEC_TYPE_DST_MAC, - FlowSpecNameMap[FLOW_SPEC_TYPE_LLC_DSAP]: FLOW_SPEC_TYPE_LLC_DSAP, - FlowSpecNameMap[FLOW_SPEC_TYPE_LLC_SSAP]: FLOW_SPEC_TYPE_LLC_SSAP, - FlowSpecNameMap[FLOW_SPEC_TYPE_LLC_CONTROL]: FLOW_SPEC_TYPE_LLC_CONTROL, - FlowSpecNameMap[FLOW_SPEC_TYPE_SNAP]: FLOW_SPEC_TYPE_SNAP, - FlowSpecNameMap[FLOW_SPEC_TYPE_VID]: FLOW_SPEC_TYPE_VID, - FlowSpecNameMap[FLOW_SPEC_TYPE_COS]: FLOW_SPEC_TYPE_COS, - FlowSpecNameMap[FLOW_SPEC_TYPE_INNER_VID]: FLOW_SPEC_TYPE_INNER_VID, - FlowSpecNameMap[FLOW_SPEC_TYPE_INNER_COS]: FLOW_SPEC_TYPE_INNER_COS, -} - -// Joins the given and args into a single string and normalize it. -// Example: -// args := []string{" & <=80", " tcp != udp ", " =! SA & =U! F", " = is-fragment+last-fragment"} -// fmt.Printf("%q", normalizeFlowSpecOpValues(args)) -// >>> ["<=80" "tcp" "!=udp" "=!SA" "&=U" "!F" "=is-fragment+last-fragment"] -func normalizeFlowSpecOpValues(args []string) []string { - // Extracts keywords from the given args. - sub := "" - subs := make([]string, 0) - for _, s := range _regexpFlowSpecOperator.FindAllString(strings.Join(args, " "), -1) { - sub += s - if _regexpFlowSpecOperatorValue.MatchString(s) { - subs = append(subs, sub) - sub = "" - } - } - - // RFC5575 says "It should be unset in the first operator byte of a - // sequence". - if len(subs) > 0 { - subs[0] = strings.TrimPrefix(subs[0], "&") - } - - return subs -} - -// Parses the FlowSpec numeric operator using the given submatch which should be -// the return value of func (*Regexp) FindStringSubmatch. -func parseFlowSpecNumericOperator(submatch []string) (operator uint8, err error) { - if submatch[1] == "&" { - operator = DEC_NUM_OP_AND - } - value, ok := DECNumOpValueMap[submatch[2]] - if !ok { - return 0, fmt.Errorf("invalid numeric operator: %s%s", submatch[1], submatch[2]) - } - operator |= uint8(value) - return operator, nil -} - -// Parses the pairs of operator and value for the FlowSpec numeric type. The -// given validationFunc is applied to evaluate whether the parsed value is -// valid or not (e.g., if exceeds range or not). -// Note: Each of the args should be formatted in single pair of operator and -// value before calling this function. -// e.g.) "&==100", ">=200" or "&<300" -func parseFlowSpecNumericOpValues(typ BGPFlowSpecType, args []string, validationFunc func(uint64) error) (FlowSpecComponentInterface, error) { - argsLen := len(args) - items := make([]*FlowSpecComponentItem, 0, argsLen) - for idx, arg := range args { - m := _regexpFlowSpecNumericType.FindStringSubmatch(arg) - if len(m) < 4 { - return nil, fmt.Errorf("invalid argument for %s: %s in %q", typ.String(), arg, args) - } - operator, err := parseFlowSpecNumericOperator(m) - if err != nil { - return nil, err - } - // "true" and "false" is operator, but here handles them as value. - var value uint64 - switch m[3] { - case "true", "false": - if idx != argsLen-1 { - return nil, fmt.Errorf("%s should be the last of each rule", m[3]) - } - operator = uint8(DECNumOpValueMap[m[3]]) - default: - if value, err = strconv.ParseUint(m[3], 10, 64); err != nil { - return nil, fmt.Errorf("invalid numeric value: %s", m[3]) - } - if err = validationFunc(value); err != nil { - return nil, err - } - } - items = append(items, NewFlowSpecComponentItem(operator, value)) - } - - // Marks end-of-list bit - items[argsLen-1].Op |= uint8(DEC_NUM_OP_END) - - return NewFlowSpecComponent(typ, items), nil -} - -func flowSpecNumeric1ByteParser(_ RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - args = normalizeFlowSpecOpValues(args) - - f := func(i uint64) error { - if i <= 0xff { // 1 byte - return nil - } - return fmt.Errorf("%s range exceeded", typ.String()) - } - - return parseFlowSpecNumericOpValues(typ, args, f) -} - -func flowSpecNumeric2BytesParser(_ RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - args = normalizeFlowSpecOpValues(args) - - f := func(i uint64) error { - if i <= 0xffff { // 2 bytes - return nil - } - return fmt.Errorf("%s range exceeded", typ.String()) - } - - return parseFlowSpecNumericOpValues(typ, args, f) -} - -// Parses the FlowSpec bitmask operand using the given submatch which should be -// the return value of func (*Regexp) FindStringSubmatch. -func parseFlowSpecBitmaskOperand(submatch []string) (operand uint8, err error) { - if submatch[1] == "&" { - operand = BITMASK_FLAG_OP_AND - } - value, ok := BitmaskFlagOpValueMap[submatch[2]] - if !ok { - return 0, fmt.Errorf("invalid bitmask operand: %s%s", submatch[1], submatch[2]) - } - operand |= uint8(value) - return operand, nil -} - -func flowSpecPrefixParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - // args[0]: IP Prefix or IP Address (suppose prefix length is 32) - // args[1]: Offset in bit (IPv6 only) - // - // Example: - // - IPv4 Prefix - // args := []string{"192.168.0.0/24"} - // - IPv4 Address - // args := []string{"192.168.0.1"} - // - IPv6 Prefix - // args := []string{"2001:db8:1::/64"} - // - IPv6 Prefix with offset - // args := []string{"0:db8:1::/64/16"} - // args := []string{"0:db8:1::/64", "16"} - // - IPv6 Address - // args := []string{"2001:db8:1::1"} - // - IPv6 Address with offset - // args := []string{"0:db8:1::1", "16"} - afi, _ := RouteFamilyToAfiSafi(rf) - switch afi { - case AFI_IP: - if len(args) > 1 { - return nil, fmt.Errorf("cannot specify offset for ipv4 prefix") - } - invalidIPv4PrefixError := fmt.Errorf("invalid ipv4 prefix: %s", args[0]) - m := _regexpFindIPv4Prefix.FindStringSubmatch(args[0]) - if len(m) < 4 { - return nil, invalidIPv4PrefixError - } - prefix := net.ParseIP(m[1]) - if prefix.To4() == nil { - return nil, invalidIPv4PrefixError - } - var prefixLen uint64 = 32 - if m[3] != "" { - var err error - prefixLen, err = strconv.ParseUint(m[3], 10, 8) - if err != nil || prefixLen > 32 { - return nil, invalidIPv4PrefixError - } - } - switch typ { - case FLOW_SPEC_TYPE_DST_PREFIX: - return NewFlowSpecDestinationPrefix(NewIPAddrPrefix(uint8(prefixLen), prefix.String())), nil - case FLOW_SPEC_TYPE_SRC_PREFIX: - return NewFlowSpecSourcePrefix(NewIPAddrPrefix(uint8(prefixLen), prefix.String())), nil - } - return nil, fmt.Errorf("invalid traffic filtering rule type: %s", typ.String()) - case AFI_IP6: - if len(args) > 2 { - return nil, fmt.Errorf("invalid arguments for ipv6 prefix: %q", args) - } - invalidIPv6PrefixError := fmt.Errorf("invalid ipv6 prefix: %s", args[0]) - m := _regexpFindIPv6Prefix.FindStringSubmatch(args[0]) - if len(m) < 4 { - return nil, invalidIPv6PrefixError - } - prefix := net.ParseIP(m[1]) - if prefix.To16() == nil { - return nil, invalidIPv6PrefixError - } - var prefixLen uint64 = 128 - if m[3] != "" { - var err error - prefixLen, err = strconv.ParseUint(m[3], 10, 8) - if err != nil || prefixLen > 128 { - return nil, invalidIPv6PrefixError - } - } - var offset uint64 - if len(args) == 1 && m[5] != "" { - var err error - offset, err = strconv.ParseUint(m[5], 10, 8) - if err != nil || offset > 128 { - return nil, fmt.Errorf("invalid ipv6 prefix offset: %s", m[5]) - } - } else if len(args) == 2 { - if m[5] != "" { - return nil, fmt.Errorf("multiple ipv6 prefix offset arguments detected: %q", args) - } - var err error - offset, err = strconv.ParseUint(args[1], 10, 8) - if err != nil || offset > 128 { - return nil, fmt.Errorf("invalid ipv6 prefix offset: %s", args[1]) - } - } - switch typ { - case FLOW_SPEC_TYPE_DST_PREFIX: - return NewFlowSpecDestinationPrefix6(NewIPv6AddrPrefix(uint8(prefixLen), prefix.String()), uint8(offset)), nil - case FLOW_SPEC_TYPE_SRC_PREFIX: - return NewFlowSpecSourcePrefix6(NewIPv6AddrPrefix(uint8(prefixLen), prefix.String()), uint8(offset)), nil - } - return nil, fmt.Errorf("invalid traffic filtering rule type: %s", typ.String()) - } - return nil, fmt.Errorf("invalid address family: %s", rf.String()) -} - -func flowSpecIpProtoParser(_ RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - // args: List of pairs of Operator and IP protocol type - // - // Example: - // - TCP or UDP - // args := []string{"tcp", "==udp"} - // - Not TCP and not UDP - // args := []string{"!=tcp", "&!=udp"} - args = normalizeFlowSpecOpValues(args) - s := strings.Join(args, " ") - for i, name := range ProtocolNameMap { - s = strings.Replace(s, name, fmt.Sprintf("%d", i), -1) - } - args = strings.Split(s, " ") - - f := func(i uint64) error { - if i <= 0xff { // 1 byte - return nil - } - return fmt.Errorf("%s range exceeded", typ.String()) - } - - return parseFlowSpecNumericOpValues(typ, args, f) -} - -func flowSpecTcpFlagParser(_ RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - // args: List of pairs of Operand and TCP Flags - // - // Example: - // - SYN or SYN/ACK - // args := []string{"==S", "==SA"} - // - Not FIN and not URG - // args := []string{"!=F", "&!=U"} - args = normalizeFlowSpecOpValues(args) - - argsLen := len(args) - items := make([]*FlowSpecComponentItem, 0, argsLen) - - for _, arg := range args { - m := _regexpFlowSpecTCPFlag.FindStringSubmatch(arg) - if len(m) < 6 { - return nil, fmt.Errorf("invalid argument for %s: %s in %q", typ.String(), arg, args) - } else if mLast := m[len(m)-1]; mLast != "" || m[3] != "" { - return nil, fmt.Errorf("invalid argument for %s: %s in %q", typ.String(), arg, args) - } - operand, err := parseFlowSpecBitmaskOperand(m) - if err != nil { - return nil, err - } - var value uint64 - for flag, name := range TCPFlagNameMap { - if strings.Contains(m[4], name) { - value |= uint64(flag) - } - } - items = append(items, NewFlowSpecComponentItem(operand, value)) - } - - // Marks end-of-list bit - items[argsLen-1].Op |= BITMASK_FLAG_OP_END - - return NewFlowSpecComponent(typ, items), nil -} - -func flowSpecDscpParser(_ RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - args = normalizeFlowSpecOpValues(args) - - f := func(i uint64) error { - if i < 64 { // 6 bits - return nil - } - return fmt.Errorf("%s range exceeded", typ.String()) - } - - return parseFlowSpecNumericOpValues(typ, args, f) -} - -func flowSpecFragmentParser(_ RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - // args: List of pairs of Operator and Fragment flags - // - // Example: - // - is-fragment or last-fragment - // args := []string{"==is-fragment", "==last-fragment"} - // - is-fragment and last-fragment (exact match) - // args := []string{"==is-fragment+last-fragment"} - args = normalizeFlowSpecOpValues(args) - - argsLen := len(args) - items := make([]*FlowSpecComponentItem, 0, argsLen) - - for _, arg := range args { - m := _regexpFlowSpecFragment.FindStringSubmatch(arg) - if len(m) < 4 { - return nil, fmt.Errorf("invalid argument for %s: %s in %q", typ.String(), arg, args) - } else if mLast := m[len(m)-1]; mLast != "" { - return nil, fmt.Errorf("invalid argument for %s: %s in %q", typ.String(), arg, args) - } - operand, err := parseFlowSpecBitmaskOperand(m) - if err != nil { - return nil, err - } - var value uint64 - // Example: - // m[3] = "first-fragment+last-fragment" - for flag, name := range FragmentFlagNameMap { - if strings.Contains(m[3], name) { - value |= uint64(flag) - } - } - items = append(items, NewFlowSpecComponentItem(operand, value)) - } - - // Marks end-of-list bit - items[argsLen-1].Op |= BITMASK_FLAG_OP_END - - return NewFlowSpecComponent(typ, items), nil -} - -func flowSpecLabelParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - afi, _ := RouteFamilyToAfiSafi(rf) - if afi == AFI_IP { - return nil, fmt.Errorf("%s is not supported for ipv4", typ.String()) - } - - args = normalizeFlowSpecOpValues(args) - - f := func(i uint64) error { - if i <= 0xfffff { // 20 bits - return nil - } - return fmt.Errorf("flow label range exceeded") - } - - return parseFlowSpecNumericOpValues(typ, args, f) -} - -func flowSpecEtherTypeParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - // args: List of pairs of Operator and Ether Types - // - // Example: - // - ARP or IPv4 - // args := []string{"==arp", "==ipv4"} - // - Not IPv4 and not IPv6 - // args := []string{"!=ipv4", "&!=ipv6"} - if rf != RF_FS_L2_VPN { - return nil, fmt.Errorf("%s is supported for only l2vpn", typ.String()) - } - - args = normalizeFlowSpecOpValues(args) - s := strings.Join(args, " ") - for i, name := range EthernetTypeNameMap { - s = strings.Replace(s, name, fmt.Sprintf("%d", i), -1) - } - args = strings.Split(s, " ") - - f := func(i uint64) error { - if i <= 0xffff { // 2 bytes - return nil - } - return fmt.Errorf("%s range exceeded", typ.String()) - } - - return parseFlowSpecNumericOpValues(typ, args, f) -} - -func flowSpecMacParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - // args[0]: MAC address - if rf != RF_FS_L2_VPN { - return nil, fmt.Errorf("%s is supported for only l2vpn", typ.String()) - } - - mac, err := net.ParseMAC(args[0]) - if err != nil { - return nil, fmt.Errorf("invalid mac address: %s", args[0]) - } - - switch typ { - case FLOW_SPEC_TYPE_DST_MAC: - return NewFlowSpecDestinationMac(mac), nil - case FLOW_SPEC_TYPE_SRC_MAC: - return NewFlowSpecSourceMac(mac), nil - } - return nil, fmt.Errorf("invalid traffic filtering rule type: %s", typ.String()) -} - -func flowSpecLlcParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - if rf != RF_FS_L2_VPN { - return nil, fmt.Errorf("%s is supported for only l2vpn", typ.String()) - } - - return flowSpecNumeric1ByteParser(rf, typ, args) -} - -func flowSpecSnapParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - if rf != RF_FS_L2_VPN { - return nil, fmt.Errorf("%s is supported for only l2vpn", typ.String()) - } - - args = normalizeFlowSpecOpValues(args) - - f := func(i uint64) error { - if i <= 0xffffffffff { // 5 bytes - return nil - } - return fmt.Errorf("%s range exceeded", typ.String()) - } - - return parseFlowSpecNumericOpValues(typ, args, f) -} - -func flowSpecVlanIDParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - if rf != RF_FS_L2_VPN { - return nil, fmt.Errorf("%s is supported for only l2vpn", typ.String()) - } - - args = normalizeFlowSpecOpValues(args) - s := strings.Join(args, " ") - for i, name := range EthernetTypeNameMap { - s = strings.Replace(s, name, fmt.Sprintf("%d", i), -1) - } - args = strings.Split(s, " ") - - f := func(i uint64) error { - if i <= 4095 { // 12 bits - return nil - } - return fmt.Errorf("%s range exceeded", typ.String()) - } - - return parseFlowSpecNumericOpValues(typ, args, f) -} - -func flowSpecVlanCosParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) { - if rf != RF_FS_L2_VPN { - return nil, fmt.Errorf("%s is supported for only l2vpn", typ.String()) - } - - args = normalizeFlowSpecOpValues(args) - s := strings.Join(args, " ") - for i, name := range EthernetTypeNameMap { - s = strings.Replace(s, name, fmt.Sprintf("%d", i), -1) - } - args = strings.Split(s, " ") - - f := func(i uint64) error { - if i <= 7 { // 3 bits - return nil - } - return fmt.Errorf("%s range exceeded", typ.String()) - } - - return parseFlowSpecNumericOpValues(typ, args, f) -} - -var flowSpecParserMap = map[BGPFlowSpecType]func(RouteFamily, BGPFlowSpecType, []string) (FlowSpecComponentInterface, error){ - FLOW_SPEC_TYPE_DST_PREFIX: flowSpecPrefixParser, - FLOW_SPEC_TYPE_SRC_PREFIX: flowSpecPrefixParser, - FLOW_SPEC_TYPE_IP_PROTO: flowSpecIpProtoParser, - FLOW_SPEC_TYPE_PORT: flowSpecNumeric2BytesParser, - FLOW_SPEC_TYPE_DST_PORT: flowSpecNumeric2BytesParser, - FLOW_SPEC_TYPE_SRC_PORT: flowSpecNumeric2BytesParser, - FLOW_SPEC_TYPE_ICMP_TYPE: flowSpecNumeric1ByteParser, - FLOW_SPEC_TYPE_ICMP_CODE: flowSpecNumeric1ByteParser, - FLOW_SPEC_TYPE_TCP_FLAG: flowSpecTcpFlagParser, - FLOW_SPEC_TYPE_PKT_LEN: flowSpecNumeric2BytesParser, - FLOW_SPEC_TYPE_DSCP: flowSpecDscpParser, - FLOW_SPEC_TYPE_FRAGMENT: flowSpecFragmentParser, - FLOW_SPEC_TYPE_LABEL: flowSpecLabelParser, - FLOW_SPEC_TYPE_ETHERNET_TYPE: flowSpecEtherTypeParser, - FLOW_SPEC_TYPE_DST_MAC: flowSpecMacParser, - FLOW_SPEC_TYPE_SRC_MAC: flowSpecMacParser, - FLOW_SPEC_TYPE_LLC_DSAP: flowSpecLlcParser, - FLOW_SPEC_TYPE_LLC_SSAP: flowSpecLlcParser, - FLOW_SPEC_TYPE_LLC_CONTROL: flowSpecLlcParser, - FLOW_SPEC_TYPE_SNAP: flowSpecSnapParser, - FLOW_SPEC_TYPE_VID: flowSpecVlanIDParser, - FLOW_SPEC_TYPE_COS: flowSpecVlanCosParser, - FLOW_SPEC_TYPE_INNER_VID: flowSpecVlanIDParser, - FLOW_SPEC_TYPE_INNER_COS: flowSpecVlanCosParser, -} - -func extractFlowSpecArgs(args []string) map[BGPFlowSpecType][]string { - m := make(map[BGPFlowSpecType][]string, len(FlowSpecValueMap)) - var typ BGPFlowSpecType - for _, arg := range args { - if t, ok := FlowSpecValueMap[arg]; ok { - typ = t - m[typ] = make([]string, 0) - } else { - m[typ] = append(m[typ], arg) - } - } - return m -} - -func ParseFlowSpecComponents(rf RouteFamily, arg string) ([]FlowSpecComponentInterface, error) { - _, safi := RouteFamilyToAfiSafi(rf) - switch safi { - case SAFI_FLOW_SPEC_UNICAST, SAFI_FLOW_SPEC_VPN: - // Valid - default: - return nil, fmt.Errorf("invalid address family: %s", rf.String()) - } - - typeArgs := extractFlowSpecArgs(strings.Split(arg, " ")) - rules := make([]FlowSpecComponentInterface, 0, len(typeArgs)) - for typ, args := range typeArgs { - parser, ok := flowSpecParserMap[typ] - if !ok { - return nil, fmt.Errorf("unsupported traffic filtering rule type: %s", typ.String()) - } - if len(args) == 0 { - return nil, fmt.Errorf("specify traffic filtering rules for %s", typ.String()) - } - rule, err := parser(rf, typ, args) - if err != nil { - return nil, err - } - rules = append(rules, rule) - } - return rules, nil -} - -func (t BGPFlowSpecType) String() string { - name, ok := FlowSpecNameMap[t] - if !ok { - return fmt.Sprintf("%s(%d)", FlowSpecNameMap[FLOW_SPEC_TYPE_UNKNOWN], t) - } - return name -} - -type FlowSpecComponentInterface interface { - DecodeFromBytes([]byte, ...*MarshallingOption) error - Serialize(...*MarshallingOption) ([]byte, error) - Len(...*MarshallingOption) int - Type() BGPFlowSpecType - String() string -} - -type flowSpecPrefix struct { - Prefix AddrPrefixInterface - typ BGPFlowSpecType -} - -func (p *flowSpecPrefix) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - p.typ = BGPFlowSpecType(data[0]) - return p.Prefix.DecodeFromBytes(data[1:], options...) -} - -func (p *flowSpecPrefix) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := []byte{byte(p.Type())} - bbuf, err := p.Prefix.Serialize(options...) - if err != nil { - return nil, err - } - return append(buf, bbuf...), nil -} - -func (p *flowSpecPrefix) Len(options ...*MarshallingOption) int { - buf, _ := p.Serialize(options...) - return len(buf) -} - -func (p *flowSpecPrefix) Type() BGPFlowSpecType { - return p.typ -} - -func (p *flowSpecPrefix) String() string { - return fmt.Sprintf("[%s: %s]", p.Type(), p.Prefix.String()) -} - -func (p *flowSpecPrefix) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPFlowSpecType `json:"type"` - Value AddrPrefixInterface `json:"value"` - }{ - Type: p.Type(), - Value: p.Prefix, - }) -} - -type flowSpecPrefix6 struct { - Prefix AddrPrefixInterface - Offset uint8 - typ BGPFlowSpecType -} - -// draft-ietf-idr-flow-spec-v6-06 -// <type (1 octet), prefix length (1 octet), prefix offset(1 octet), prefix> -func (p *flowSpecPrefix6) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - p.typ = BGPFlowSpecType(data[0]) - p.Offset = data[2] - prefix := append([]byte{data[1]}, data[3:]...) - return p.Prefix.DecodeFromBytes(prefix, options...) -} - -func (p *flowSpecPrefix6) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := []byte{byte(p.Type())} - bbuf, err := p.Prefix.Serialize(options...) - if err != nil { - return nil, err - } - buf = append(buf, bbuf[0]) - buf = append(buf, p.Offset) - return append(buf, bbuf[1:]...), nil -} - -func (p *flowSpecPrefix6) Len(options ...*MarshallingOption) int { - buf, _ := p.Serialize(options...) - return len(buf) -} - -func (p *flowSpecPrefix6) Type() BGPFlowSpecType { - return p.typ -} - -func (p *flowSpecPrefix6) String() string { - return fmt.Sprintf("[%s: %s/%d]", p.Type(), p.Prefix.String(), p.Offset) -} - -func (p *flowSpecPrefix6) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPFlowSpecType `json:"type"` - Value AddrPrefixInterface `json:"value"` - Offset uint8 `json:"offset"` - }{ - Type: p.Type(), - Value: p.Prefix, - Offset: p.Offset, - }) -} - -type FlowSpecDestinationPrefix struct { - flowSpecPrefix -} - -func NewFlowSpecDestinationPrefix(prefix AddrPrefixInterface) *FlowSpecDestinationPrefix { - return &FlowSpecDestinationPrefix{flowSpecPrefix{prefix, FLOW_SPEC_TYPE_DST_PREFIX}} -} - -type FlowSpecSourcePrefix struct { - flowSpecPrefix -} - -func NewFlowSpecSourcePrefix(prefix AddrPrefixInterface) *FlowSpecSourcePrefix { - return &FlowSpecSourcePrefix{flowSpecPrefix{prefix, FLOW_SPEC_TYPE_SRC_PREFIX}} -} - -type FlowSpecDestinationPrefix6 struct { - flowSpecPrefix6 -} - -func NewFlowSpecDestinationPrefix6(prefix AddrPrefixInterface, offset uint8) *FlowSpecDestinationPrefix6 { - return &FlowSpecDestinationPrefix6{flowSpecPrefix6{prefix, offset, FLOW_SPEC_TYPE_DST_PREFIX}} -} - -type FlowSpecSourcePrefix6 struct { - flowSpecPrefix6 -} - -func NewFlowSpecSourcePrefix6(prefix AddrPrefixInterface, offset uint8) *FlowSpecSourcePrefix6 { - return &FlowSpecSourcePrefix6{flowSpecPrefix6{prefix, offset, FLOW_SPEC_TYPE_SRC_PREFIX}} -} - -type flowSpecMac struct { - Mac net.HardwareAddr - typ BGPFlowSpecType -} - -func (p *flowSpecMac) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - if len(data) < 2 || len(data) < 2+int(data[1]) { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all mac bits available") - } - p.typ = BGPFlowSpecType(data[0]) - p.Mac = net.HardwareAddr(data[2 : 2+int(data[1])]) - return nil -} - -func (p *flowSpecMac) Serialize(options ...*MarshallingOption) ([]byte, error) { - if len(p.Mac) == 0 { - return nil, fmt.Errorf("mac unset") - } - buf := []byte{byte(p.Type()), byte(len(p.Mac))} - return append(buf, []byte(p.Mac)...), nil -} - -func (p *flowSpecMac) Len(options ...*MarshallingOption) int { - return 2 + len(p.Mac) -} - -func (p *flowSpecMac) Type() BGPFlowSpecType { - return p.typ -} - -func (p *flowSpecMac) String() string { - return fmt.Sprintf("[%s: %s]", p.Type(), p.Mac.String()) -} - -func (p *flowSpecMac) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPFlowSpecType `json:"type"` - Value string `json:"value"` - }{ - Type: p.Type(), - Value: p.Mac.String(), - }) -} - -type FlowSpecSourceMac struct { - flowSpecMac -} - -func NewFlowSpecSourceMac(mac net.HardwareAddr) *FlowSpecSourceMac { - return &FlowSpecSourceMac{flowSpecMac{Mac: mac, typ: FLOW_SPEC_TYPE_SRC_MAC}} -} - -type FlowSpecDestinationMac struct { - flowSpecMac -} - -func NewFlowSpecDestinationMac(mac net.HardwareAddr) *FlowSpecDestinationMac { - return &FlowSpecDestinationMac{flowSpecMac{Mac: mac, typ: FLOW_SPEC_TYPE_DST_MAC}} -} - -type FlowSpecComponentItem struct { - Op uint8 `json:"op"` - Value uint64 `json:"value"` -} - -func (v *FlowSpecComponentItem) Len() int { - return 1 << ((uint32(v.Op) >> 4) & 0x3) -} - -func (v *FlowSpecComponentItem) Serialize() ([]byte, error) { - if v.Op > math.MaxUint8 { - return nil, fmt.Errorf("invalid op size: %d", v.Op) - } - - order := uint32(math.Log2(float64(v.Len()))) - buf := make([]byte, 1+(1<<order)) - buf[0] = byte(uint32(v.Op) | order<<4) - switch order { - case 0: - buf[1] = byte(v.Value) - case 1: - binary.BigEndian.PutUint16(buf[1:], uint16(v.Value)) - case 2: - binary.BigEndian.PutUint32(buf[1:], uint32(v.Value)) - case 3: - binary.BigEndian.PutUint64(buf[1:], uint64(v.Value)) - default: - return nil, fmt.Errorf("invalid value size(too big): %d", v.Value) - } - return buf, nil -} - -func NewFlowSpecComponentItem(op uint8, value uint64) *FlowSpecComponentItem { - v := &FlowSpecComponentItem{op, value} - order := uint32(math.Log2(float64(v.Len()))) - // we don't know if not initialized properly or initialized to - // zero... - if order == 0 { - order = func() uint32 { - for i := 0; i < 3; i++ { - if v.Value < (1 << ((1 << uint(i)) * 8)) { - return uint32(i) - } - } - // return invalid order - return 4 - }() - } - if order > 3 { - return nil - } - v.Op = uint8(uint32(v.Op) | order<<4) - return v -} - -type FlowSpecComponent struct { - Items []*FlowSpecComponentItem - typ BGPFlowSpecType -} - -func (p *FlowSpecComponent) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - p.typ = BGPFlowSpecType(data[0]) - data = data[1:] - p.Items = make([]*FlowSpecComponentItem, 0) - for { - if len(data) < 2 { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all flowspec component bytes available") - } - op := data[0] - end := op & 0x80 - l := 1 << ((op >> 4) & 0x3) // (min, max) = (1, 8) - v := make([]byte, 8) - copy(v[8-l:], data[1:1+l]) - i := binary.BigEndian.Uint64(v) - item := &FlowSpecComponentItem{op, i} - p.Items = append(p.Items, item) - if end > 0 { - break - } - data = data[1+l:] - } - return nil -} - -func (p *FlowSpecComponent) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := []byte{byte(p.Type())} - for _, v := range p.Items { - bbuf, err := v.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, bbuf...) - } - return buf, nil -} - -func (p *FlowSpecComponent) Len(options ...*MarshallingOption) int { - l := 1 - for _, item := range p.Items { - l += item.Len() + 1 - } - return l -} - -func (p *FlowSpecComponent) Type() BGPFlowSpecType { - return p.typ -} - -func formatRaw(op uint8, value uint64) string { - return fmt.Sprintf("op:%b,value:%d", op, value) -} - -func formatNumeric(op uint8, value uint64) string { - cmpFlag := DECNumOp(op & 0x7) // lower 3 bits - if cmpFlag == DEC_NUM_OP_TRUE || cmpFlag == DEC_NUM_OP_FALSE { - // Omit value field - return DECNumOp(op).String() - } - return fmt.Sprint(DECNumOp(op).String(), value) -} - -func formatProto(op uint8, value uint64) string { - cmpFlag := DECNumOp(op & 0x7) // lower 3 bits - if cmpFlag == DEC_NUM_OP_TRUE || cmpFlag == DEC_NUM_OP_FALSE { - // Omit value field - return DECNumOp(op).String() - } - return fmt.Sprint(DECNumOp(op).String(), Protocol(value).String()) -} - -func formatTCPFlag(op uint8, value uint64) string { - return fmt.Sprint(BitmaskFlagOp(op).String(), TCPFlag(value).String()) -} - -func formatFragment(op uint8, value uint64) string { - return fmt.Sprint(BitmaskFlagOp(op).String(), FragmentFlag(value).String()) -} - -func formatEtherType(op uint8, value uint64) string { - cmpFlag := DECNumOp(op & 0x7) // lower 3 bits - if cmpFlag == DEC_NUM_OP_TRUE || cmpFlag == DEC_NUM_OP_FALSE { - // Omit value field - return DECNumOp(op).String() - } - return fmt.Sprint(DECNumOp(op).String(), EthernetType(value).String()) -} - -var flowSpecFormatMap = map[BGPFlowSpecType]func(op uint8, value uint64) string{ - FLOW_SPEC_TYPE_UNKNOWN: formatRaw, - FLOW_SPEC_TYPE_IP_PROTO: formatProto, - FLOW_SPEC_TYPE_PORT: formatNumeric, - FLOW_SPEC_TYPE_DST_PORT: formatNumeric, - FLOW_SPEC_TYPE_SRC_PORT: formatNumeric, - FLOW_SPEC_TYPE_ICMP_TYPE: formatNumeric, - FLOW_SPEC_TYPE_ICMP_CODE: formatNumeric, - FLOW_SPEC_TYPE_TCP_FLAG: formatTCPFlag, - FLOW_SPEC_TYPE_PKT_LEN: formatNumeric, - FLOW_SPEC_TYPE_DSCP: formatNumeric, - FLOW_SPEC_TYPE_FRAGMENT: formatFragment, - FLOW_SPEC_TYPE_LABEL: formatNumeric, - FLOW_SPEC_TYPE_ETHERNET_TYPE: formatEtherType, - FLOW_SPEC_TYPE_LLC_DSAP: formatNumeric, - FLOW_SPEC_TYPE_LLC_SSAP: formatNumeric, - FLOW_SPEC_TYPE_LLC_CONTROL: formatNumeric, - FLOW_SPEC_TYPE_SNAP: formatNumeric, - FLOW_SPEC_TYPE_VID: formatNumeric, - FLOW_SPEC_TYPE_COS: formatNumeric, - FLOW_SPEC_TYPE_INNER_VID: formatNumeric, - FLOW_SPEC_TYPE_INNER_COS: formatNumeric, -} - -func (p *FlowSpecComponent) String() string { - f := flowSpecFormatMap[FLOW_SPEC_TYPE_UNKNOWN] - if _, ok := flowSpecFormatMap[p.typ]; ok { - f = flowSpecFormatMap[p.typ] - } - - items := make([]string, 0, len(p.Items)) - for _, i := range p.Items { - items = append(items, f(i.Op, i.Value)) - } - // Removes leading and tailing spaces - value := strings.TrimSpace(strings.Join(items, "")) - - return fmt.Sprintf("[%s: %s]", p.typ, value) -} - -func (p *FlowSpecComponent) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPFlowSpecType `json:"type"` - Value []*FlowSpecComponentItem `json:"value"` - }{ - Type: p.Type(), - Value: p.Items, - }) -} - -func NewFlowSpecComponent(typ BGPFlowSpecType, items []*FlowSpecComponentItem) *FlowSpecComponent { - // Set end-of-list bit on the last item and unset them on the others. - for i, v := range items { - if i == len(items)-1 { - v.Op |= 0x80 - } else { - v.Op &^= 0x80 - } - - } - return &FlowSpecComponent{ - Items: items, - typ: typ, - } -} - -type FlowSpecUnknown struct { - Value []byte -} - -func (p *FlowSpecUnknown) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - p.Value = data - return nil -} - -func (p *FlowSpecUnknown) Serialize(options ...*MarshallingOption) ([]byte, error) { - return p.Value, nil -} - -func (p *FlowSpecUnknown) Len(options ...*MarshallingOption) int { - return len(p.Value) -} - -func (p *FlowSpecUnknown) Type() BGPFlowSpecType { - if len(p.Value) > 0 { - return BGPFlowSpecType(p.Value[0]) - } - return FLOW_SPEC_TYPE_UNKNOWN -} - -func (p *FlowSpecUnknown) String() string { - return fmt.Sprintf("[unknown:%v]", p.Value) -} - -func (p *FlowSpecUnknown) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPFlowSpecType `json:"type"` - Value string `json:"value"` - }{ - Type: p.Type(), - Value: string(p.Value), - }) -} - -type FlowSpecNLRI struct { - PrefixDefault - Value []FlowSpecComponentInterface - rf RouteFamily - rd RouteDistinguisherInterface -} - -func (n *FlowSpecNLRI) AFI() uint16 { - afi, _ := RouteFamilyToAfiSafi(n.rf) - return afi -} - -func (n *FlowSpecNLRI) SAFI() uint8 { - _, safi := RouteFamilyToAfiSafi(n.rf) - return safi -} - -func (n *FlowSpecNLRI) RD() RouteDistinguisherInterface { - return n.rd -} - -func (n *FlowSpecNLRI) decodeFromBytes(rf RouteFamily, data []byte, options ...*MarshallingOption) error { - if IsAddPathEnabled(true, rf, options) { - var err error - data, err = n.decodePathIdentifier(data) - if err != nil { - return err - } - } - var length int - if (data[0]>>4) == 0xf && len(data) > 2 { - length = int(binary.BigEndian.Uint16(data[0:2])) - data = data[2:] - } else if len(data) > 1 { - length = int(data[0]) - data = data[1:] - } else { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all flowspec component bytes available") - } - - n.rf = rf - - if n.SAFI() == SAFI_FLOW_SPEC_VPN { - if length < 8 { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all flowspec component bytes available") - } - n.rd = GetRouteDistinguisher(data[:8]) - data = data[8:] - length -= 8 - } - - for l := length; l > 0; { - if len(data) == 0 { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all flowspec component bytes available") - } - t := BGPFlowSpecType(data[0]) - var i FlowSpecComponentInterface - switch t { - case FLOW_SPEC_TYPE_DST_PREFIX: - switch { - case rf>>16 == AFI_IP: - i = NewFlowSpecDestinationPrefix(NewIPAddrPrefix(0, "")) - case rf>>16 == AFI_IP6: - i = NewFlowSpecDestinationPrefix6(NewIPv6AddrPrefix(0, ""), 0) - default: - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid address family: %v", rf)) - } - case FLOW_SPEC_TYPE_SRC_PREFIX: - switch { - case rf>>16 == AFI_IP: - i = NewFlowSpecSourcePrefix(NewIPAddrPrefix(0, "")) - case rf>>16 == AFI_IP6: - i = NewFlowSpecSourcePrefix6(NewIPv6AddrPrefix(0, ""), 0) - default: - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid address family: %v", rf)) - } - case FLOW_SPEC_TYPE_SRC_MAC: - switch rf { - case RF_FS_L2_VPN: - i = NewFlowSpecSourceMac(nil) - default: - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid address family: %v", rf)) - } - case FLOW_SPEC_TYPE_DST_MAC: - switch rf { - case RF_FS_L2_VPN: - i = NewFlowSpecDestinationMac(nil) - default: - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid address family: %v", rf)) - } - case FLOW_SPEC_TYPE_IP_PROTO, FLOW_SPEC_TYPE_PORT, FLOW_SPEC_TYPE_DST_PORT, FLOW_SPEC_TYPE_SRC_PORT, - FLOW_SPEC_TYPE_ICMP_TYPE, FLOW_SPEC_TYPE_ICMP_CODE, FLOW_SPEC_TYPE_TCP_FLAG, FLOW_SPEC_TYPE_PKT_LEN, - FLOW_SPEC_TYPE_DSCP, FLOW_SPEC_TYPE_FRAGMENT, FLOW_SPEC_TYPE_LABEL, FLOW_SPEC_TYPE_ETHERNET_TYPE, - FLOW_SPEC_TYPE_LLC_DSAP, FLOW_SPEC_TYPE_LLC_SSAP, FLOW_SPEC_TYPE_LLC_CONTROL, FLOW_SPEC_TYPE_SNAP, - FLOW_SPEC_TYPE_VID, FLOW_SPEC_TYPE_COS, FLOW_SPEC_TYPE_INNER_VID, FLOW_SPEC_TYPE_INNER_COS: - i = NewFlowSpecComponent(t, nil) - default: - i = &FlowSpecUnknown{} - } - - err := i.DecodeFromBytes(data, options...) - if err != nil { - i = &FlowSpecUnknown{data} - } - l -= i.Len(options...) - data = data[i.Len(options...):] - n.Value = append(n.Value, i) - } - - // Sort Traffic Filtering Rules in types order to avoid the unordered rules - // are determined different. - sort.SliceStable(n.Value, func(i, j int) bool { return n.Value[i].Type() < n.Value[j].Type() }) - - return nil -} - -func (n *FlowSpecNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 0, 32) - if n.SAFI() == SAFI_FLOW_SPEC_VPN { - if n.rd == nil { - return nil, fmt.Errorf("RD is nil") - } - b, err := n.rd.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, b...) - } - for _, v := range n.Value { - b, err := v.Serialize(options...) - if err != nil { - return nil, err - } - buf = append(buf, b...) - } - length := n.Len(options...) - if length > 0xfff { - return nil, fmt.Errorf("Too large: %d", length) - } else if length < 0xf0 { - length -= 1 - buf = append([]byte{byte(length)}, buf...) - } else { - length -= 2 - b := make([]byte, 2) - binary.BigEndian.PutUint16(buf, uint16(length)) - buf = append(b, buf...) - } - - if IsAddPathEnabled(false, n.rf, options) { - id, err := n.serializeIdentifier() - if err != nil { - return nil, err - } - return append(id, buf...), nil - } - return buf, nil -} - -func (n *FlowSpecNLRI) Len(options ...*MarshallingOption) int { - l := 0 - if n.SAFI() == SAFI_FLOW_SPEC_VPN { - l += n.RD().Len() - } - for _, v := range n.Value { - l += v.Len(options...) - } - if l < 0xf0 { - return l + 1 - } else { - return l + 2 - } -} - -func (n *FlowSpecNLRI) String() string { - buf := bytes.NewBuffer(make([]byte, 0, 32)) - if n.SAFI() == SAFI_FLOW_SPEC_VPN { - buf.WriteString(fmt.Sprintf("[rd: %s]", n.rd)) - } - for _, v := range n.Value { - buf.WriteString(v.String()) - } - return buf.String() -} - -func (n *FlowSpecNLRI) MarshalJSON() ([]byte, error) { - if n.rd != nil { - return json.Marshal(struct { - RD RouteDistinguisherInterface `json:"rd"` - Value []FlowSpecComponentInterface `json:"value"` - }{ - RD: n.rd, - Value: n.Value, - }) - } - return json.Marshal(struct { - Value []FlowSpecComponentInterface `json:"value"` - }{ - Value: n.Value, - }) - -} - -// -// CompareFlowSpecNLRI(n, m) returns -// -1 when m has precedence -// 0 when n and m have same precedence -// 1 when n has precedence -// -func CompareFlowSpecNLRI(n, m *FlowSpecNLRI) (int, error) { - family := AfiSafiToRouteFamily(n.AFI(), n.SAFI()) - if family != AfiSafiToRouteFamily(m.AFI(), m.SAFI()) { - return 0, fmt.Errorf("address family mismatch") - } - longer := n.Value - shorter := m.Value - invert := 1 - if n.SAFI() == SAFI_FLOW_SPEC_VPN { - k, _ := n.Serialize() - l, _ := m.Serialize() - if result := bytes.Compare(k, l); result != 0 { - return result, nil - } - } - if len(n.Value) < len(m.Value) { - longer = m.Value - shorter = n.Value - invert = -1 - } - for idx, v := range longer { - if len(shorter) < idx+1 { - return invert, nil - } - w := shorter[idx] - if v.Type() < w.Type() { - return invert, nil - } else if v.Type() > w.Type() { - return invert * -1, nil - } else if v.Type() == FLOW_SPEC_TYPE_DST_PREFIX || v.Type() == FLOW_SPEC_TYPE_SRC_PREFIX { - // RFC5575 5.1 - // - // For IP prefix values (IP destination and source prefix) precedence is - // given to the lowest IP value of the common prefix length; if the - // common prefix is equal, then the most specific prefix has precedence. - var p, q *IPAddrPrefixDefault - var pCommon, qCommon uint64 - if n.AFI() == AFI_IP { - if v.Type() == FLOW_SPEC_TYPE_DST_PREFIX { - p = &v.(*FlowSpecDestinationPrefix).Prefix.(*IPAddrPrefix).IPAddrPrefixDefault - q = &w.(*FlowSpecDestinationPrefix).Prefix.(*IPAddrPrefix).IPAddrPrefixDefault - } else { - p = &v.(*FlowSpecSourcePrefix).Prefix.(*IPAddrPrefix).IPAddrPrefixDefault - q = &w.(*FlowSpecSourcePrefix).Prefix.(*IPAddrPrefix).IPAddrPrefixDefault - } - min := p.Length - if q.Length < p.Length { - min = q.Length - } - pCommon = uint64(binary.BigEndian.Uint32([]byte(p.Prefix.To4())) >> (32 - min)) - qCommon = uint64(binary.BigEndian.Uint32([]byte(q.Prefix.To4())) >> (32 - min)) - } else if n.AFI() == AFI_IP6 { - if v.Type() == FLOW_SPEC_TYPE_DST_PREFIX { - p = &v.(*FlowSpecDestinationPrefix6).Prefix.(*IPv6AddrPrefix).IPAddrPrefixDefault - q = &w.(*FlowSpecDestinationPrefix6).Prefix.(*IPv6AddrPrefix).IPAddrPrefixDefault - } else { - p = &v.(*FlowSpecSourcePrefix6).Prefix.(*IPv6AddrPrefix).IPAddrPrefixDefault - q = &w.(*FlowSpecSourcePrefix6).Prefix.(*IPv6AddrPrefix).IPAddrPrefixDefault - } - min := uint(p.Length) - if q.Length < p.Length { - min = uint(q.Length) - } - var mask uint - if min-64 > 0 { - mask = min - 64 - } - pCommon = binary.BigEndian.Uint64([]byte(p.Prefix.To16()[:8])) >> mask - qCommon = binary.BigEndian.Uint64([]byte(q.Prefix.To16()[:8])) >> mask - if pCommon == qCommon && mask == 0 { - mask = 64 - min - pCommon = binary.BigEndian.Uint64([]byte(p.Prefix.To16()[8:])) >> mask - qCommon = binary.BigEndian.Uint64([]byte(q.Prefix.To16()[8:])) >> mask - } - } - - if pCommon < qCommon { - return invert, nil - } else if pCommon > qCommon { - return invert * -1, nil - } else if p.Length > q.Length { - return invert, nil - } else if p.Length < q.Length { - return invert * -1, nil - } - - } else { - // RFC5575 5.1 - // - // For all other component types, unless otherwise specified, the - // comparison is performed by comparing the component data as a binary - // string using the memcmp() function as defined by the ISO C standard. - // For strings of different lengths, the common prefix is compared. If - // equal, the longest string is considered to have higher precedence - // than the shorter one. - p, _ := v.Serialize() - q, _ := w.Serialize() - min := len(p) - if len(q) < len(p) { - min = len(q) - } - if result := bytes.Compare(p[:min], q[:min]); result < 0 { - return invert, nil - } else if result > 0 { - return invert * -1, nil - } else if len(p) > len(q) { - return invert, nil - } else if len(q) > len(p) { - return invert * -1, nil - } - } - } - return 0, nil -} - -type FlowSpecIPv4Unicast struct { - FlowSpecNLRI -} - -func (n *FlowSpecIPv4Unicast) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - return n.decodeFromBytes(AfiSafiToRouteFamily(n.AFI(), n.SAFI()), data, options...) -} - -func NewFlowSpecIPv4Unicast(value []FlowSpecComponentInterface) *FlowSpecIPv4Unicast { - sort.SliceStable(value, func(i, j int) bool { return value[i].Type() < value[j].Type() }) - return &FlowSpecIPv4Unicast{ - FlowSpecNLRI: FlowSpecNLRI{ - Value: value, - rf: RF_FS_IPv4_UC, - }, - } -} - -type FlowSpecIPv4VPN struct { - FlowSpecNLRI -} - -func (n *FlowSpecIPv4VPN) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - return n.decodeFromBytes(AfiSafiToRouteFamily(n.AFI(), n.SAFI()), data, options...) -} - -func NewFlowSpecIPv4VPN(rd RouteDistinguisherInterface, value []FlowSpecComponentInterface) *FlowSpecIPv4VPN { - sort.SliceStable(value, func(i, j int) bool { return value[i].Type() < value[j].Type() }) - return &FlowSpecIPv4VPN{ - FlowSpecNLRI: FlowSpecNLRI{ - Value: value, - rf: RF_FS_IPv4_VPN, - rd: rd, - }, - } -} - -type FlowSpecIPv6Unicast struct { - FlowSpecNLRI -} - -func (n *FlowSpecIPv6Unicast) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - return n.decodeFromBytes(AfiSafiToRouteFamily(n.AFI(), n.SAFI()), data, options...) -} - -func NewFlowSpecIPv6Unicast(value []FlowSpecComponentInterface) *FlowSpecIPv6Unicast { - sort.SliceStable(value, func(i, j int) bool { return value[i].Type() < value[j].Type() }) - return &FlowSpecIPv6Unicast{ - FlowSpecNLRI: FlowSpecNLRI{ - Value: value, - rf: RF_FS_IPv6_UC, - }, - } -} - -type FlowSpecIPv6VPN struct { - FlowSpecNLRI -} - -func (n *FlowSpecIPv6VPN) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - return n.decodeFromBytes(AfiSafiToRouteFamily(n.AFI(), n.SAFI()), data, options...) -} - -func NewFlowSpecIPv6VPN(rd RouteDistinguisherInterface, value []FlowSpecComponentInterface) *FlowSpecIPv6VPN { - sort.SliceStable(value, func(i, j int) bool { return value[i].Type() < value[j].Type() }) - return &FlowSpecIPv6VPN{ - FlowSpecNLRI: FlowSpecNLRI{ - Value: value, - rf: RF_FS_IPv6_VPN, - rd: rd, - }, - } -} - -type FlowSpecL2VPN struct { - FlowSpecNLRI -} - -func (n *FlowSpecL2VPN) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - return n.decodeFromBytes(AfiSafiToRouteFamily(n.AFI(), n.SAFI()), data) -} - -func NewFlowSpecL2VPN(rd RouteDistinguisherInterface, value []FlowSpecComponentInterface) *FlowSpecL2VPN { - sort.SliceStable(value, func(i, j int) bool { return value[i].Type() < value[j].Type() }) - return &FlowSpecL2VPN{ - FlowSpecNLRI: FlowSpecNLRI{ - Value: value, - rf: RF_FS_L2_VPN, - rd: rd, - }, - } -} - -type OpaqueNLRI struct { - PrefixDefault - Length uint16 - Key []byte - Value []byte -} - -func (n *OpaqueNLRI) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - if len(data) < 2 { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all OpaqueNLRI bytes available") - } - if IsAddPathEnabled(true, RF_OPAQUE, options) { - var err error - data, err = n.decodePathIdentifier(data) - if err != nil { - return err - } - } - n.Length = binary.BigEndian.Uint16(data[0:2]) - if len(data)-2 < int(n.Length) { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all OpaqueNLRI bytes available") - } - n.Key = data[2 : 2+n.Length] - n.Value = data[2+n.Length:] - return nil -} - -func (n *OpaqueNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) { - if len(n.Key) > math.MaxUint16 { - return nil, fmt.Errorf("Key length too big") - } - buf := make([]byte, 2) - binary.BigEndian.PutUint16(buf, uint16(len(n.Key))) - buf = append(buf, n.Key...) - buf = append(buf, n.Value...) - if IsAddPathEnabled(false, RF_OPAQUE, options) { - id, err := n.serializeIdentifier() - if err != nil { - return nil, err - } - return append(id, buf...), nil - } - return buf, nil -} - -func (n *OpaqueNLRI) AFI() uint16 { - return AFI_OPAQUE -} - -func (n *OpaqueNLRI) SAFI() uint8 { - return SAFI_KEY_VALUE -} - -func (n *OpaqueNLRI) Len(options ...*MarshallingOption) int { - return 2 + len(n.Key) + len(n.Value) -} - -func (n *OpaqueNLRI) String() string { - return fmt.Sprintf("%s", n.Key) -} - -func (n *OpaqueNLRI) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Key string `json:"key"` - Value string `json:"value"` - }{ - Key: string(n.Key), - Value: string(n.Value), - }) -} - -func NewOpaqueNLRI(key, value []byte) *OpaqueNLRI { - return &OpaqueNLRI{ - Key: key, - Value: value, - } -} - -func AfiSafiToRouteFamily(afi uint16, safi uint8) RouteFamily { - return RouteFamily(int(afi)<<16 | int(safi)) -} - -func RouteFamilyToAfiSafi(rf RouteFamily) (uint16, uint8) { - return uint16(int(rf) >> 16), uint8(int(rf) & 0xff) -} - -type RouteFamily int - -func (f RouteFamily) String() string { - if n, y := AddressFamilyNameMap[f]; y { - return n - } - return fmt.Sprintf("UnknownFamily(%d)", f) -} - -const ( - RF_IPv4_UC RouteFamily = AFI_IP<<16 | SAFI_UNICAST - RF_IPv6_UC RouteFamily = AFI_IP6<<16 | SAFI_UNICAST - RF_IPv4_MC RouteFamily = AFI_IP<<16 | SAFI_MULTICAST - RF_IPv6_MC RouteFamily = AFI_IP6<<16 | SAFI_MULTICAST - RF_IPv4_VPN RouteFamily = AFI_IP<<16 | SAFI_MPLS_VPN - RF_IPv6_VPN RouteFamily = AFI_IP6<<16 | SAFI_MPLS_VPN - RF_IPv4_VPN_MC RouteFamily = AFI_IP<<16 | SAFI_MPLS_VPN_MULTICAST - RF_IPv6_VPN_MC RouteFamily = AFI_IP6<<16 | SAFI_MPLS_VPN_MULTICAST - RF_IPv4_MPLS RouteFamily = AFI_IP<<16 | SAFI_MPLS_LABEL - RF_IPv6_MPLS RouteFamily = AFI_IP6<<16 | SAFI_MPLS_LABEL - RF_VPLS RouteFamily = AFI_L2VPN<<16 | SAFI_VPLS - RF_EVPN RouteFamily = AFI_L2VPN<<16 | SAFI_EVPN - RF_RTC_UC RouteFamily = AFI_IP<<16 | SAFI_ROUTE_TARGET_CONSTRAINTS - RF_IPv4_ENCAP RouteFamily = AFI_IP<<16 | SAFI_ENCAPSULATION - RF_IPv6_ENCAP RouteFamily = AFI_IP6<<16 | SAFI_ENCAPSULATION - RF_FS_IPv4_UC RouteFamily = AFI_IP<<16 | SAFI_FLOW_SPEC_UNICAST - RF_FS_IPv4_VPN RouteFamily = AFI_IP<<16 | SAFI_FLOW_SPEC_VPN - RF_FS_IPv6_UC RouteFamily = AFI_IP6<<16 | SAFI_FLOW_SPEC_UNICAST - RF_FS_IPv6_VPN RouteFamily = AFI_IP6<<16 | SAFI_FLOW_SPEC_VPN - RF_FS_L2_VPN RouteFamily = AFI_L2VPN<<16 | SAFI_FLOW_SPEC_VPN - RF_OPAQUE RouteFamily = AFI_OPAQUE<<16 | SAFI_KEY_VALUE -) - -var AddressFamilyNameMap = map[RouteFamily]string{ - RF_IPv4_UC: "ipv4-unicast", - RF_IPv6_UC: "ipv6-unicast", - RF_IPv4_MC: "ipv4-multicast", - RF_IPv6_MC: "ipv6-multicast", - RF_IPv4_MPLS: "ipv4-labelled-unicast", - RF_IPv6_MPLS: "ipv6-labelled-unicast", - RF_IPv4_VPN: "l3vpn-ipv4-unicast", - RF_IPv6_VPN: "l3vpn-ipv6-unicast", - RF_IPv4_VPN_MC: "l3vpn-ipv4-multicast", - RF_IPv6_VPN_MC: "l3vpn-ipv6-multicast", - RF_VPLS: "l2vpn-vpls", - RF_EVPN: "l2vpn-evpn", - RF_RTC_UC: "rtc", - RF_IPv4_ENCAP: "ipv4-encap", - RF_IPv6_ENCAP: "ipv6-encap", - RF_FS_IPv4_UC: "ipv4-flowspec", - RF_FS_IPv4_VPN: "l3vpn-ipv4-flowspec", - RF_FS_IPv6_UC: "ipv6-flowspec", - RF_FS_IPv6_VPN: "l3vpn-ipv6-flowspec", - RF_FS_L2_VPN: "l2vpn-flowspec", - RF_OPAQUE: "opaque", -} - -var AddressFamilyValueMap = map[string]RouteFamily{ - AddressFamilyNameMap[RF_IPv4_UC]: RF_IPv4_UC, - AddressFamilyNameMap[RF_IPv6_UC]: RF_IPv6_UC, - AddressFamilyNameMap[RF_IPv4_MC]: RF_IPv4_MC, - AddressFamilyNameMap[RF_IPv6_MC]: RF_IPv6_MC, - AddressFamilyNameMap[RF_IPv4_MPLS]: RF_IPv4_MPLS, - AddressFamilyNameMap[RF_IPv6_MPLS]: RF_IPv6_MPLS, - AddressFamilyNameMap[RF_IPv4_VPN]: RF_IPv4_VPN, - AddressFamilyNameMap[RF_IPv6_VPN]: RF_IPv6_VPN, - AddressFamilyNameMap[RF_IPv4_VPN_MC]: RF_IPv4_VPN_MC, - AddressFamilyNameMap[RF_IPv6_VPN_MC]: RF_IPv6_VPN_MC, - AddressFamilyNameMap[RF_VPLS]: RF_VPLS, - AddressFamilyNameMap[RF_EVPN]: RF_EVPN, - AddressFamilyNameMap[RF_RTC_UC]: RF_RTC_UC, - AddressFamilyNameMap[RF_IPv4_ENCAP]: RF_IPv4_ENCAP, - AddressFamilyNameMap[RF_IPv6_ENCAP]: RF_IPv6_ENCAP, - AddressFamilyNameMap[RF_FS_IPv4_UC]: RF_FS_IPv4_UC, - AddressFamilyNameMap[RF_FS_IPv4_VPN]: RF_FS_IPv4_VPN, - AddressFamilyNameMap[RF_FS_IPv6_UC]: RF_FS_IPv6_UC, - AddressFamilyNameMap[RF_FS_IPv6_VPN]: RF_FS_IPv6_VPN, - AddressFamilyNameMap[RF_FS_L2_VPN]: RF_FS_L2_VPN, - AddressFamilyNameMap[RF_OPAQUE]: RF_OPAQUE, -} - -func GetRouteFamily(name string) (RouteFamily, error) { - if v, ok := AddressFamilyValueMap[name]; ok { - return v, nil - } - return RouteFamily(0), fmt.Errorf("%s isn't a valid route family name", name) -} - -func NewPrefixFromRouteFamily(afi uint16, safi uint8, prefixStr ...string) (prefix AddrPrefixInterface, err error) { - family := AfiSafiToRouteFamily(afi, safi) - - f := func(s string) AddrPrefixInterface { - addr, net, _ := net.ParseCIDR(s) - len, _ := net.Mask.Size() - switch family { - case RF_IPv4_UC, RF_IPv4_MC: - return NewIPAddrPrefix(uint8(len), addr.String()) - } - return NewIPv6AddrPrefix(uint8(len), addr.String()) - } - - switch family { - case RF_IPv4_UC, RF_IPv4_MC: - if len(prefixStr) > 0 { - prefix = f(prefixStr[0]) - } else { - prefix = NewIPAddrPrefix(0, "") - } - case RF_IPv6_UC, RF_IPv6_MC: - if len(prefixStr) > 0 { - prefix = f(prefixStr[0]) - } else { - prefix = NewIPv6AddrPrefix(0, "") - } - case RF_IPv4_VPN: - prefix = NewLabeledVPNIPAddrPrefix(0, "", *NewMPLSLabelStack(), nil) - case RF_IPv6_VPN: - prefix = NewLabeledVPNIPv6AddrPrefix(0, "", *NewMPLSLabelStack(), nil) - case RF_IPv4_MPLS: - prefix = NewLabeledIPAddrPrefix(0, "", *NewMPLSLabelStack()) - case RF_IPv6_MPLS: - prefix = NewLabeledIPv6AddrPrefix(0, "", *NewMPLSLabelStack()) - case RF_EVPN: - prefix = NewEVPNNLRI(0, nil) - case RF_RTC_UC: - prefix = &RouteTargetMembershipNLRI{} - case RF_IPv4_ENCAP: - prefix = NewEncapNLRI("") - case RF_IPv6_ENCAP: - prefix = NewEncapv6NLRI("") - case RF_FS_IPv4_UC: - prefix = &FlowSpecIPv4Unicast{FlowSpecNLRI{rf: RF_FS_IPv4_UC}} - case RF_FS_IPv4_VPN: - prefix = &FlowSpecIPv4VPN{FlowSpecNLRI{rf: RF_FS_IPv4_VPN}} - case RF_FS_IPv6_UC: - prefix = &FlowSpecIPv6Unicast{FlowSpecNLRI{rf: RF_FS_IPv6_UC}} - case RF_FS_IPv6_VPN: - prefix = &FlowSpecIPv6VPN{FlowSpecNLRI{rf: RF_FS_IPv6_VPN}} - case RF_FS_L2_VPN: - prefix = &FlowSpecL2VPN{FlowSpecNLRI{rf: RF_FS_L2_VPN}} - case RF_OPAQUE: - prefix = &OpaqueNLRI{} - default: - err = fmt.Errorf("unknown route family. AFI: %d, SAFI: %d", afi, safi) - } - return prefix, err -} - -type BGPAttrFlag uint8 - -const ( - BGP_ATTR_FLAG_EXTENDED_LENGTH BGPAttrFlag = 1 << 4 - BGP_ATTR_FLAG_PARTIAL BGPAttrFlag = 1 << 5 - BGP_ATTR_FLAG_TRANSITIVE BGPAttrFlag = 1 << 6 - BGP_ATTR_FLAG_OPTIONAL BGPAttrFlag = 1 << 7 -) - -func (f BGPAttrFlag) String() string { - strs := make([]string, 0, 4) - if f&BGP_ATTR_FLAG_EXTENDED_LENGTH > 0 { - strs = append(strs, "EXTENDED_LENGTH") - } - if f&BGP_ATTR_FLAG_PARTIAL > 0 { - strs = append(strs, "PARTIAL") - } - if f&BGP_ATTR_FLAG_TRANSITIVE > 0 { - strs = append(strs, "TRANSITIVE") - } - if f&BGP_ATTR_FLAG_OPTIONAL > 0 { - strs = append(strs, "OPTIONAL") - } - return strings.Join(strs, "|") -} - -type BGPAttrType uint8 - -const ( - _ BGPAttrType = iota - BGP_ATTR_TYPE_ORIGIN - BGP_ATTR_TYPE_AS_PATH - BGP_ATTR_TYPE_NEXT_HOP - BGP_ATTR_TYPE_MULTI_EXIT_DISC - BGP_ATTR_TYPE_LOCAL_PREF - BGP_ATTR_TYPE_ATOMIC_AGGREGATE - BGP_ATTR_TYPE_AGGREGATOR - BGP_ATTR_TYPE_COMMUNITIES - BGP_ATTR_TYPE_ORIGINATOR_ID - BGP_ATTR_TYPE_CLUSTER_LIST - _ - _ - _ - BGP_ATTR_TYPE_MP_REACH_NLRI // = 14 - BGP_ATTR_TYPE_MP_UNREACH_NLRI - BGP_ATTR_TYPE_EXTENDED_COMMUNITIES - BGP_ATTR_TYPE_AS4_PATH - BGP_ATTR_TYPE_AS4_AGGREGATOR - _ - _ - _ - BGP_ATTR_TYPE_PMSI_TUNNEL // = 22 - BGP_ATTR_TYPE_TUNNEL_ENCAP - _ - BGP_ATTR_TYPE_IP6_EXTENDED_COMMUNITIES // = 25 - BGP_ATTR_TYPE_AIGP // = 26 - BGP_ATTR_TYPE_LARGE_COMMUNITY BGPAttrType = 32 -) - -// NOTIFICATION Error Code RFC 4271 4.5. -const ( - _ = iota - BGP_ERROR_MESSAGE_HEADER_ERROR - BGP_ERROR_OPEN_MESSAGE_ERROR - BGP_ERROR_UPDATE_MESSAGE_ERROR - BGP_ERROR_HOLD_TIMER_EXPIRED - BGP_ERROR_FSM_ERROR - BGP_ERROR_CEASE - BGP_ERROR_ROUTE_REFRESH_MESSAGE_ERROR -) - -// NOTIFICATION Error Subcode for BGP_ERROR_MESSAGE_HEADER_ERROR -const ( - _ = iota - BGP_ERROR_SUB_CONNECTION_NOT_SYNCHRONIZED - BGP_ERROR_SUB_BAD_MESSAGE_LENGTH - BGP_ERROR_SUB_BAD_MESSAGE_TYPE -) - -// NOTIFICATION Error Subcode for BGP_ERROR_OPEN_MESSAGE_ERROR -const ( - _ = iota - BGP_ERROR_SUB_UNSUPPORTED_VERSION_NUMBER - BGP_ERROR_SUB_BAD_PEER_AS - BGP_ERROR_SUB_BAD_BGP_IDENTIFIER - BGP_ERROR_SUB_UNSUPPORTED_OPTIONAL_PARAMETER - BGP_ERROR_SUB_DEPRECATED_AUTHENTICATION_FAILURE - BGP_ERROR_SUB_UNACCEPTABLE_HOLD_TIME - BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY -) - -// NOTIFICATION Error Subcode for BGP_ERROR_UPDATE_MESSAGE_ERROR -const ( - _ = iota - BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST - BGP_ERROR_SUB_UNRECOGNIZED_WELL_KNOWN_ATTRIBUTE - BGP_ERROR_SUB_MISSING_WELL_KNOWN_ATTRIBUTE - BGP_ERROR_SUB_ATTRIBUTE_FLAGS_ERROR - BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR - BGP_ERROR_SUB_INVALID_ORIGIN_ATTRIBUTE - BGP_ERROR_SUB_DEPRECATED_ROUTING_LOOP - BGP_ERROR_SUB_INVALID_NEXT_HOP_ATTRIBUTE - BGP_ERROR_SUB_OPTIONAL_ATTRIBUTE_ERROR - BGP_ERROR_SUB_INVALID_NETWORK_FIELD - BGP_ERROR_SUB_MALFORMED_AS_PATH -) - -// NOTIFICATION Error Subcode for BGP_ERROR_HOLD_TIMER_EXPIRED -const ( - _ = iota - BGP_ERROR_SUB_HOLD_TIMER_EXPIRED -) - -// NOTIFICATION Error Subcode for BGP_ERROR_FSM_ERROR -const ( - _ = iota - BGP_ERROR_SUB_RECEIVE_UNEXPECTED_MESSAGE_IN_OPENSENT_STATE - BGP_ERROR_SUB_RECEIVE_UNEXPECTED_MESSAGE_IN_OPENCONFIRM_STATE - BGP_ERROR_SUB_RECEIVE_UNEXPECTED_MESSAGE_IN_ESTABLISHED_STATE -) - -// NOTIFICATION Error Subcode for BGP_ERROR_CEASE (RFC 4486) -const ( - _ = iota - BGP_ERROR_SUB_MAXIMUM_NUMBER_OF_PREFIXES_REACHED - BGP_ERROR_SUB_ADMINISTRATIVE_SHUTDOWN - BGP_ERROR_SUB_PEER_DECONFIGURED - BGP_ERROR_SUB_ADMINISTRATIVE_RESET - BGP_ERROR_SUB_CONNECTION_REJECTED - BGP_ERROR_SUB_OTHER_CONFIGURATION_CHANGE - BGP_ERROR_SUB_CONNECTION_COLLISION_RESOLUTION - BGP_ERROR_SUB_OUT_OF_RESOURCES - BGP_ERROR_SUB_HARD_RESET //draft-ietf-idr-bgp-gr-notification-07 -) - -// Constants for BGP_ERROR_SUB_ADMINISTRATIVE_SHUTDOWN and BGP_ERROR_SUB_ADMINISTRATIVE_RESET -const ( - BGP_ERROR_ADMINISTRATIVE_COMMUNICATION_MAX = 128 -) - -// NOTIFICATION Error Subcode for BGP_ERROR_ROUTE_REFRESH -const ( - _ = iota - BGP_ERROR_SUB_INVALID_MESSAGE_LENGTH -) - -type NotificationErrorCode uint16 - -func (c NotificationErrorCode) String() string { - code := uint8(uint16(c) >> 8) - subcode := uint8(uint16(c) & 0xff) - UNDEFINED := "undefined" - codeStr := UNDEFINED - subcodeList := []string{} - switch code { - case BGP_ERROR_MESSAGE_HEADER_ERROR: - codeStr = "header" - subcodeList = []string{ - UNDEFINED, - "connection not synchronized", - "bad message length", - "bad message type"} - case BGP_ERROR_OPEN_MESSAGE_ERROR: - codeStr = "open" - subcodeList = []string{ - UNDEFINED, - "unsupported version number", - "bad peer as", - "bad bgp identifier", - "unsupported optional parameter", - "deprecated authentication failure", - "unacceptable hold time", - "unsupported capability"} - case BGP_ERROR_UPDATE_MESSAGE_ERROR: - codeStr = "update" - subcodeList = []string{ - UNDEFINED, - "malformed attribute list", - "unrecognized well known attribute", - "missing well known attribute", - "attribute flags error", - "attribute length error", - "invalid origin attribute", - "deprecated routing loop", - "invalid next hop attribute", - "optional attribute error", - "invalid network field", - "sub malformed as path"} - case BGP_ERROR_HOLD_TIMER_EXPIRED: - codeStr = "hold timer expired" - subcodeList = []string{ - UNDEFINED, - "hold timer expired"} - case BGP_ERROR_FSM_ERROR: - codeStr = "fsm" - subcodeList = []string{ - UNDEFINED, - "receive unexpected message in opensent state", - "receive unexpected message in openconfirm state", - "receive unexpected message in established state"} - case BGP_ERROR_CEASE: - codeStr = "cease" - subcodeList = []string{ - UNDEFINED, - "maximum number of prefixes reached", - "administrative shutdown", - "peer deconfigured", - "administrative reset", - "connection rejected", - "other configuration change", - "connection collision resolution", - "out of resources"} - case BGP_ERROR_ROUTE_REFRESH_MESSAGE_ERROR: - codeStr = "route refresh" - subcodeList = []string{"invalid message length"} - } - subcodeStr := func(idx uint8, l []string) string { - if len(l) == 0 || int(idx) > len(l)-1 { - return UNDEFINED - } - return l[idx] - }(subcode, subcodeList) - return fmt.Sprintf("code %v(%v) subcode %v(%v)", code, codeStr, subcode, subcodeStr) -} - -func NewNotificationErrorCode(code, subcode uint8) NotificationErrorCode { - return NotificationErrorCode(uint16(code)<<8 | uint16(subcode)) -} - -var PathAttrFlags map[BGPAttrType]BGPAttrFlag = map[BGPAttrType]BGPAttrFlag{ - BGP_ATTR_TYPE_ORIGIN: BGP_ATTR_FLAG_TRANSITIVE, - BGP_ATTR_TYPE_AS_PATH: BGP_ATTR_FLAG_TRANSITIVE, - BGP_ATTR_TYPE_NEXT_HOP: BGP_ATTR_FLAG_TRANSITIVE, - BGP_ATTR_TYPE_MULTI_EXIT_DISC: BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_LOCAL_PREF: BGP_ATTR_FLAG_TRANSITIVE, - BGP_ATTR_TYPE_ATOMIC_AGGREGATE: BGP_ATTR_FLAG_TRANSITIVE, - BGP_ATTR_TYPE_AGGREGATOR: BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_COMMUNITIES: BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_ORIGINATOR_ID: BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_CLUSTER_LIST: BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_MP_REACH_NLRI: BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_MP_UNREACH_NLRI: BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_EXTENDED_COMMUNITIES: BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_AS4_PATH: BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_AS4_AGGREGATOR: BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_PMSI_TUNNEL: BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_TUNNEL_ENCAP: BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_IP6_EXTENDED_COMMUNITIES: BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_AIGP: BGP_ATTR_FLAG_OPTIONAL, - BGP_ATTR_TYPE_LARGE_COMMUNITY: BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL, -} - -// getPathAttrFlags returns BGP Path Attribute flags value from its type and -// length (byte length of value field). -func getPathAttrFlags(typ BGPAttrType, length int) BGPAttrFlag { - flags := PathAttrFlags[typ] - if length > 255 { - flags |= BGP_ATTR_FLAG_EXTENDED_LENGTH - } - return flags -} - -type PathAttributeInterface interface { - DecodeFromBytes([]byte, ...*MarshallingOption) error - Serialize(...*MarshallingOption) ([]byte, error) - Len(...*MarshallingOption) int - GetFlags() BGPAttrFlag - GetType() BGPAttrType - String() string - MarshalJSON() ([]byte, error) - Flat() map[string]string -} - -type PathAttribute struct { - Flags BGPAttrFlag - Type BGPAttrType - Length uint16 // length of Value -} - -func (p *PathAttribute) Len(options ...*MarshallingOption) int { - if p.Flags&BGP_ATTR_FLAG_EXTENDED_LENGTH != 0 { - return 4 + int(p.Length) - } - return 3 + int(p.Length) -} - -func (p *PathAttribute) GetFlags() BGPAttrFlag { - return p.Flags -} - -func (p *PathAttribute) GetType() BGPAttrType { - return p.Type -} - -func (p *PathAttribute) DecodeFromBytes(data []byte, options ...*MarshallingOption) (value []byte, err error) { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - if len(data) < 2 { - return nil, NewMessageError(eCode, eSubCode, data, "attribute header length is short") - } - p.Flags = BGPAttrFlag(data[0]) - p.Type = BGPAttrType(data[1]) - if eMsg := validatePathAttributeFlags(p.Type, p.Flags); eMsg != "" { - return nil, NewMessageError(eCode, BGP_ERROR_SUB_ATTRIBUTE_FLAGS_ERROR, data, eMsg) - } - - if p.Flags&BGP_ATTR_FLAG_EXTENDED_LENGTH != 0 { - if len(data) < 4 { - return nil, NewMessageError(eCode, eSubCode, data, "attribute header length is short") - } - p.Length = binary.BigEndian.Uint16(data[2:4]) - data = data[4:] - } else { - if len(data) < 3 { - return nil, NewMessageError(eCode, eSubCode, data, "attribute header length is short") - } - p.Length = uint16(data[2]) - data = data[3:] - } - if len(data) < int(p.Length) { - return nil, NewMessageError(eCode, eSubCode, data, "attribute value length is short") - } - - return data[:p.Length], nil -} - -func (p *PathAttribute) Serialize(value []byte, options ...*MarshallingOption) ([]byte, error) { - // Note: Do not update "p.Flags" and "p.Length" to avoid data race. - flags := p.Flags - length := uint16(len(value)) - if flags&BGP_ATTR_FLAG_EXTENDED_LENGTH == 0 && length > 255 { - flags |= BGP_ATTR_FLAG_EXTENDED_LENGTH - } - var buf []byte - if flags&BGP_ATTR_FLAG_EXTENDED_LENGTH != 0 { - buf = append(make([]byte, 4), value...) - binary.BigEndian.PutUint16(buf[2:4], length) - } else { - buf = append(make([]byte, 3), value...) - buf[2] = byte(length) - } - buf[0] = uint8(flags) - buf[1] = uint8(p.Type) - return buf, nil -} - -type PathAttributeOrigin struct { - PathAttribute - Value uint8 -} - -func (p *PathAttributeOrigin) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - if p.Length != 1 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST) - return NewMessageError(eCode, eSubCode, nil, "Origin attribute length is incorrect") - } - p.Value = value[0] - return nil -} - -func (p *PathAttributeOrigin) Serialize(options ...*MarshallingOption) ([]byte, error) { - return p.PathAttribute.Serialize([]byte{p.Value}, options...) -} - -func (p *PathAttributeOrigin) String() string { - typ := "-" - switch p.Value { - case BGP_ORIGIN_ATTR_TYPE_IGP: - typ = "i" - case BGP_ORIGIN_ATTR_TYPE_EGP: - typ = "e" - case BGP_ORIGIN_ATTR_TYPE_INCOMPLETE: - typ = "?" - } - return fmt.Sprintf("{Origin: %s}", typ) -} - -func (p *PathAttributeOrigin) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value uint8 `json:"value"` - }{ - Type: p.GetType(), - Value: p.Value, - }) -} - -func NewPathAttributeOrigin(value uint8) *PathAttributeOrigin { - t := BGP_ATTR_TYPE_ORIGIN - return &PathAttributeOrigin{ - PathAttribute: PathAttribute{ - Flags: PathAttrFlags[t], - Type: t, - Length: 1, - }, - Value: value, - } -} - -type AsPathParamFormat struct { - start string - end string - separator string -} - -var asPathParamFormatMap = map[uint8]*AsPathParamFormat{ - BGP_ASPATH_ATTR_TYPE_SET: {"{", "}", ","}, - BGP_ASPATH_ATTR_TYPE_SEQ: {"", "", " "}, - BGP_ASPATH_ATTR_TYPE_CONFED_SET: {"(", ")", " "}, - BGP_ASPATH_ATTR_TYPE_CONFED_SEQ: {"[", "]", ","}, -} - -type AsPathParamInterface interface { - GetType() uint8 - GetAS() []uint32 - Serialize() ([]byte, error) - DecodeFromBytes([]byte) error - Len() int - ASLen() int - MarshalJSON() ([]byte, error) - String() string -} - -func AsPathString(aspath *PathAttributeAsPath) string { - s := bytes.NewBuffer(make([]byte, 0, 64)) - for i, param := range aspath.Value { - segType := param.GetType() - asList := param.GetAS() - if i != 0 { - s.WriteString(" ") - } - - sep := " " - switch segType { - case BGP_ASPATH_ATTR_TYPE_CONFED_SEQ: - s.WriteString("(") - case BGP_ASPATH_ATTR_TYPE_CONFED_SET: - s.WriteString("[") - sep = "," - case BGP_ASPATH_ATTR_TYPE_SET: - s.WriteString("{") - sep = "," - } - for j, as := range asList { - s.WriteString(fmt.Sprintf("%d", as)) - if j != len(asList)-1 { - s.WriteString(sep) - } - } - switch segType { - case BGP_ASPATH_ATTR_TYPE_CONFED_SEQ: - s.WriteString(")") - case BGP_ASPATH_ATTR_TYPE_CONFED_SET: - s.WriteString("]") - case BGP_ASPATH_ATTR_TYPE_SET: - s.WriteString("}") - } - } - return s.String() -} - -type AsPathParam struct { - Type uint8 - Num uint8 - AS []uint16 -} - -func (a *AsPathParam) GetType() uint8 { - return a.Type -} - -func (a *AsPathParam) GetAS() []uint32 { - nums := make([]uint32, 0, len(a.AS)) - for _, as := range a.AS { - nums = append(nums, uint32(as)) - } - return nums -} - -func (a *AsPathParam) Serialize() ([]byte, error) { - buf := make([]byte, 2+len(a.AS)*2) - buf[0] = uint8(a.Type) - buf[1] = a.Num - for j, as := range a.AS { - binary.BigEndian.PutUint16(buf[2+j*2:], as) - } - return buf, nil -} - -func (a *AsPathParam) DecodeFromBytes(data []byte) error { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_AS_PATH) - if len(data) < 2 { - return NewMessageError(eCode, eSubCode, nil, "AS param header length is short") - } - a.Type = data[0] - a.Num = data[1] - data = data[2:] - if len(data) < int(a.Num*2) { - return NewMessageError(eCode, eSubCode, nil, "AS param data length is short") - } - for i := 0; i < int(a.Num); i++ { - a.AS = append(a.AS, binary.BigEndian.Uint16(data)) - data = data[2:] - } - return nil -} - -func (a *AsPathParam) Len() int { - return 2 + len(a.AS)*2 -} - -func (a *AsPathParam) ASLen() int { - switch a.Type { - case BGP_ASPATH_ATTR_TYPE_SEQ: - return len(a.AS) - case BGP_ASPATH_ATTR_TYPE_SET: - return 1 - case BGP_ASPATH_ATTR_TYPE_CONFED_SET, BGP_ASPATH_ATTR_TYPE_CONFED_SEQ: - return 0 - } - return 0 -} - -func (a *AsPathParam) String() string { - format, ok := asPathParamFormatMap[a.Type] - if !ok { - return fmt.Sprintf("%v", a.AS) - } - aspath := make([]string, 0, len(a.AS)) - for _, asn := range a.AS { - aspath = append(aspath, fmt.Sprintf("%d", asn)) - } - s := bytes.NewBuffer(make([]byte, 0, 32)) - s.WriteString(format.start) - s.WriteString(strings.Join(aspath, format.separator)) - s.WriteString(format.end) - return s.String() -} - -func (a *AsPathParam) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type uint8 `json:"segment_type"` - Num uint8 `json:"num"` - AS []uint16 `json:"asns"` - }{ - Type: a.Type, - Num: a.Num, - AS: a.AS, - }) -} - -func NewAsPathParam(segType uint8, as []uint16) *AsPathParam { - return &AsPathParam{ - Type: segType, - Num: uint8(len(as)), - AS: as, - } -} - -type As4PathParam struct { - Type uint8 - Num uint8 - AS []uint32 -} - -func (a *As4PathParam) GetType() uint8 { - return a.Type -} - -func (a *As4PathParam) GetAS() []uint32 { - return a.AS -} - -func (a *As4PathParam) Serialize() ([]byte, error) { - buf := make([]byte, 2+len(a.AS)*4) - buf[0] = a.Type - buf[1] = a.Num - for j, as := range a.AS { - binary.BigEndian.PutUint32(buf[2+j*4:], as) - } - return buf, nil -} - -func (a *As4PathParam) DecodeFromBytes(data []byte) error { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_AS_PATH) - if len(data) < 2 { - return NewMessageError(eCode, eSubCode, nil, "AS4 param header length is short") - } - a.Type = data[0] - a.Num = data[1] - data = data[2:] - if len(data) < int(a.Num)*4 { - return NewMessageError(eCode, eSubCode, nil, "AS4 param data length is short") - } - for i := 0; i < int(a.Num); i++ { - a.AS = append(a.AS, binary.BigEndian.Uint32(data)) - data = data[4:] - } - return nil -} - -func (a *As4PathParam) Len() int { - return 2 + len(a.AS)*4 -} - -func (a *As4PathParam) ASLen() int { - switch a.Type { - case BGP_ASPATH_ATTR_TYPE_SEQ: - return len(a.AS) - case BGP_ASPATH_ATTR_TYPE_SET: - return 1 - case BGP_ASPATH_ATTR_TYPE_CONFED_SET, BGP_ASPATH_ATTR_TYPE_CONFED_SEQ: - return 0 - } - return 0 -} - -func (a *As4PathParam) String() string { - format, ok := asPathParamFormatMap[a.Type] - if !ok { - return fmt.Sprintf("%v", a.AS) - } - aspath := make([]string, 0, len(a.AS)) - for _, asn := range a.AS { - aspath = append(aspath, fmt.Sprintf("%d", asn)) - } - s := bytes.NewBuffer(make([]byte, 0, 32)) - s.WriteString(format.start) - s.WriteString(strings.Join(aspath, format.separator)) - s.WriteString(format.end) - return s.String() -} - -func (a *As4PathParam) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type uint8 `json:"segment_type"` - Num uint8 `json:"num"` - AS []uint32 `json:"asns"` - }{ - Type: a.Type, - Num: a.Num, - AS: a.AS, - }) -} - -func NewAs4PathParam(segType uint8, as []uint32) *As4PathParam { - return &As4PathParam{ - Type: segType, - Num: uint8(len(as)), - AS: as, - } -} - -type PathAttributeAsPath struct { - PathAttribute - Value []AsPathParamInterface -} - -func (p *PathAttributeAsPath) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - if p.Length == 0 { - // ibgp or something - return nil - } - isAs4, err := validateAsPathValueBytes(value) - if err != nil { - err.(*MessageError).Data, _ = p.PathAttribute.Serialize(value, options...) - return err - } - for len(value) > 0 { - var tuple AsPathParamInterface - if isAs4 { - tuple = &As4PathParam{} - } else { - tuple = &AsPathParam{} - } - err := tuple.DecodeFromBytes(value) - if err != nil { - return err - } - p.Value = append(p.Value, tuple) - value = value[tuple.Len():] - } - return nil -} - -func (p *PathAttributeAsPath) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 0) - for _, v := range p.Value { - vbuf, err := v.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, vbuf...) - } - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeAsPath) String() string { - params := make([]string, 0, len(p.Value)) - for _, param := range p.Value { - params = append(params, param.String()) - } - return strings.Join(params, " ") -} - -func (p *PathAttributeAsPath) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value []AsPathParamInterface `json:"as_paths"` - }{ - Type: p.GetType(), - Value: p.Value, - }) -} - -func NewPathAttributeAsPath(value []AsPathParamInterface) *PathAttributeAsPath { - var l int - for _, v := range value { - l += v.Len() - } - t := BGP_ATTR_TYPE_AS_PATH - return &PathAttributeAsPath{ - PathAttribute: PathAttribute{ - Flags: getPathAttrFlags(t, l), - Type: t, - Length: uint16(l), - }, - Value: value, - } -} - -type PathAttributeNextHop struct { - PathAttribute - Value net.IP -} - -func (p *PathAttributeNextHop) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - if p.Length != 4 && p.Length != 16 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - return NewMessageError(eCode, eSubCode, nil, "nexthop length isn't correct") - } - p.Value = value - return nil -} - -func (p *PathAttributeNextHop) Serialize(options ...*MarshallingOption) ([]byte, error) { - return p.PathAttribute.Serialize(p.Value, options...) -} - -func (p *PathAttributeNextHop) String() string { - return fmt.Sprintf("{Nexthop: %s}", p.Value) -} - -func (p *PathAttributeNextHop) MarshalJSON() ([]byte, error) { - value := "0.0.0.0" - if p.Value != nil { - value = p.Value.String() - } - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value string `json:"nexthop"` - }{ - Type: p.GetType(), - Value: value, - }) -} - -func NewPathAttributeNextHop(value string) *PathAttributeNextHop { - t := BGP_ATTR_TYPE_NEXT_HOP - return &PathAttributeNextHop{ - PathAttribute: PathAttribute{ - Flags: PathAttrFlags[t], - Type: t, - Length: 4, - }, - Value: net.ParseIP(value).To4(), - } -} - -type PathAttributeMultiExitDisc struct { - PathAttribute - Value uint32 -} - -func (p *PathAttributeMultiExitDisc) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - if p.Length != 4 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - return NewMessageError(eCode, eSubCode, nil, "med length isn't correct") - } - p.Value = binary.BigEndian.Uint32(value) - return nil -} - -func (p *PathAttributeMultiExitDisc) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 4) - binary.BigEndian.PutUint32(buf, p.Value) - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeMultiExitDisc) String() string { - return fmt.Sprintf("{Med: %d}", p.Value) -} - -func (p *PathAttributeMultiExitDisc) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value uint32 `json:"metric"` - }{ - Type: p.GetType(), - Value: p.Value, - }) -} - -func NewPathAttributeMultiExitDisc(value uint32) *PathAttributeMultiExitDisc { - t := BGP_ATTR_TYPE_MULTI_EXIT_DISC - return &PathAttributeMultiExitDisc{ - PathAttribute: PathAttribute{ - Flags: PathAttrFlags[t], - Type: t, - Length: 4, - }, - Value: value, - } -} - -type PathAttributeLocalPref struct { - PathAttribute - Value uint32 -} - -func (p *PathAttributeLocalPref) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - if p.Length != 4 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - return NewMessageError(eCode, eSubCode, nil, "local pref length isn't correct") - } - p.Value = binary.BigEndian.Uint32(value) - return nil -} - -func (p *PathAttributeLocalPref) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 4) - binary.BigEndian.PutUint32(buf, p.Value) - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeLocalPref) String() string { - return fmt.Sprintf("{LocalPref: %d}", p.Value) -} - -func (p *PathAttributeLocalPref) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value uint32 `json:"value"` - }{ - Type: p.GetType(), - Value: p.Value, - }) -} - -func NewPathAttributeLocalPref(value uint32) *PathAttributeLocalPref { - t := BGP_ATTR_TYPE_LOCAL_PREF - return &PathAttributeLocalPref{ - PathAttribute: PathAttribute{ - Flags: PathAttrFlags[t], - Type: t, - Length: 4, - }, - Value: value, - } -} - -type PathAttributeAtomicAggregate struct { - PathAttribute -} - -func (p *PathAttributeAtomicAggregate) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - _, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - if p.Length != 0 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - return NewMessageError(eCode, eSubCode, nil, "atomic aggregate should have no value") - } - return nil -} - -func (p *PathAttributeAtomicAggregate) Serialize(options ...*MarshallingOption) ([]byte, error) { - return p.PathAttribute.Serialize(nil, options...) -} - -func (p *PathAttributeAtomicAggregate) String() string { - return "{AtomicAggregate}" -} - -func (p *PathAttributeAtomicAggregate) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - }{ - Type: p.GetType(), - }) -} - -func NewPathAttributeAtomicAggregate() *PathAttributeAtomicAggregate { - t := BGP_ATTR_TYPE_ATOMIC_AGGREGATE - return &PathAttributeAtomicAggregate{ - PathAttribute: PathAttribute{ - Flags: PathAttrFlags[t], - Type: t, - Length: 0, - }, - } -} - -type PathAttributeAggregatorParam struct { - AS uint32 - Askind reflect.Kind - Address net.IP -} - -type PathAttributeAggregator struct { - PathAttribute - Value PathAttributeAggregatorParam -} - -func (p *PathAttributeAggregator) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - switch p.Length { - case 6: - p.Value.Askind = reflect.Uint16 - p.Value.AS = uint32(binary.BigEndian.Uint16(value[0:2])) - p.Value.Address = value[2:] - case 8: - p.Value.Askind = reflect.Uint32 - p.Value.AS = binary.BigEndian.Uint32(value[0:4]) - p.Value.Address = value[4:] - default: - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - return NewMessageError(eCode, eSubCode, nil, "aggregator length isn't correct") - } - return nil -} - -func (p *PathAttributeAggregator) Serialize(options ...*MarshallingOption) ([]byte, error) { - var buf []byte - switch p.Value.Askind { - case reflect.Uint16: - buf = make([]byte, 6) - binary.BigEndian.PutUint16(buf, uint16(p.Value.AS)) - copy(buf[2:], p.Value.Address) - case reflect.Uint32: - buf = make([]byte, 8) - binary.BigEndian.PutUint32(buf, p.Value.AS) - copy(buf[4:], p.Value.Address) - } - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeAggregator) String() string { - return fmt.Sprintf("{Aggregate: {AS: %d, Address: %s}}", p.Value.AS, p.Value.Address) -} - -func (p *PathAttributeAggregator) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - AS uint32 `json:"as"` - Address string `json:"address"` - }{ - Type: p.GetType(), - AS: p.Value.AS, - Address: p.Value.Address.String(), - }) -} - -func NewPathAttributeAggregator(as interface{}, address string) *PathAttributeAggregator { - v := reflect.ValueOf(as) - asKind := v.Kind() - var l uint16 - switch asKind { - case reflect.Uint16: - l = 6 - case reflect.Uint32: - l = 8 - default: - // Invalid type - return nil - } - t := BGP_ATTR_TYPE_AGGREGATOR - return &PathAttributeAggregator{ - PathAttribute: PathAttribute{ - Flags: PathAttrFlags[t], - Type: t, - Length: l, - }, - Value: PathAttributeAggregatorParam{ - AS: uint32(v.Uint()), - Askind: asKind, - Address: net.ParseIP(address).To4(), - }, - } -} - -type PathAttributeCommunities struct { - PathAttribute - Value []uint32 -} - -func (p *PathAttributeCommunities) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - if p.Length%4 != 0 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - return NewMessageError(eCode, eSubCode, nil, "communities length isn't correct") - } - for len(value) >= 4 { - p.Value = append(p.Value, binary.BigEndian.Uint32(value)) - value = value[4:] - } - return nil -} - -func (p *PathAttributeCommunities) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, len(p.Value)*4) - for i, v := range p.Value { - binary.BigEndian.PutUint32(buf[i*4:], v) - } - return p.PathAttribute.Serialize(buf, options...) -} - -type WellKnownCommunity uint32 - -const ( - COMMUNITY_INTERNET WellKnownCommunity = 0x00000000 - COMMUNITY_PLANNED_SHUT WellKnownCommunity = 0xffff0000 - COMMUNITY_ACCEPT_OWN WellKnownCommunity = 0xffff0001 - COMMUNITY_ROUTE_FILTER_TRANSLATED_v4 WellKnownCommunity = 0xffff0002 - COMMUNITY_ROUTE_FILTER_v4 WellKnownCommunity = 0xffff0003 - COMMUNITY_ROUTE_FILTER_TRANSLATED_v6 WellKnownCommunity = 0xffff0004 - COMMUNITY_ROUTE_FILTER_v6 WellKnownCommunity = 0xffff0005 - COMMUNITY_LLGR_STALE WellKnownCommunity = 0xffff0006 - COMMUNITY_NO_LLGR WellKnownCommunity = 0xffff0007 - COMMUNITY_BLACKHOLE WellKnownCommunity = 0xffff029a - COMMUNITY_NO_EXPORT WellKnownCommunity = 0xffffff01 - COMMUNITY_NO_ADVERTISE WellKnownCommunity = 0xffffff02 - COMMUNITY_NO_EXPORT_SUBCONFED WellKnownCommunity = 0xffffff03 - COMMUNITY_NO_PEER WellKnownCommunity = 0xffffff04 -) - -var WellKnownCommunityNameMap = map[WellKnownCommunity]string{ - COMMUNITY_INTERNET: "internet", - COMMUNITY_PLANNED_SHUT: "planned-shut", - COMMUNITY_ACCEPT_OWN: "accept-own", - COMMUNITY_ROUTE_FILTER_TRANSLATED_v4: "route-filter-translated-v4", - COMMUNITY_ROUTE_FILTER_v4: "route-filter-v4", - COMMUNITY_ROUTE_FILTER_TRANSLATED_v6: "route-filter-translated-v6", - COMMUNITY_ROUTE_FILTER_v6: "route-filter-v6", - COMMUNITY_LLGR_STALE: "llgr-stale", - COMMUNITY_NO_LLGR: "no-llgr", - COMMUNITY_BLACKHOLE: "blackhole", - COMMUNITY_NO_EXPORT: "no-export", - COMMUNITY_NO_ADVERTISE: "no-advertise", - COMMUNITY_NO_EXPORT_SUBCONFED: "no-export-subconfed", - COMMUNITY_NO_PEER: "no-peer", -} - -var WellKnownCommunityValueMap = map[string]WellKnownCommunity{ - WellKnownCommunityNameMap[COMMUNITY_INTERNET]: COMMUNITY_INTERNET, - WellKnownCommunityNameMap[COMMUNITY_PLANNED_SHUT]: COMMUNITY_PLANNED_SHUT, - WellKnownCommunityNameMap[COMMUNITY_ACCEPT_OWN]: COMMUNITY_ACCEPT_OWN, - WellKnownCommunityNameMap[COMMUNITY_ROUTE_FILTER_TRANSLATED_v4]: COMMUNITY_ROUTE_FILTER_TRANSLATED_v4, - WellKnownCommunityNameMap[COMMUNITY_ROUTE_FILTER_v4]: COMMUNITY_ROUTE_FILTER_v4, - WellKnownCommunityNameMap[COMMUNITY_ROUTE_FILTER_TRANSLATED_v6]: COMMUNITY_ROUTE_FILTER_TRANSLATED_v6, - WellKnownCommunityNameMap[COMMUNITY_ROUTE_FILTER_v6]: COMMUNITY_ROUTE_FILTER_v6, - WellKnownCommunityNameMap[COMMUNITY_LLGR_STALE]: COMMUNITY_LLGR_STALE, - WellKnownCommunityNameMap[COMMUNITY_NO_LLGR]: COMMUNITY_NO_LLGR, - WellKnownCommunityNameMap[COMMUNITY_NO_EXPORT]: COMMUNITY_NO_EXPORT, - WellKnownCommunityNameMap[COMMUNITY_BLACKHOLE]: COMMUNITY_BLACKHOLE, - WellKnownCommunityNameMap[COMMUNITY_NO_ADVERTISE]: COMMUNITY_NO_ADVERTISE, - WellKnownCommunityNameMap[COMMUNITY_NO_EXPORT_SUBCONFED]: COMMUNITY_NO_EXPORT_SUBCONFED, - WellKnownCommunityNameMap[COMMUNITY_NO_PEER]: COMMUNITY_NO_PEER, -} - -func (p *PathAttributeCommunities) String() string { - l := []string{} - for _, v := range p.Value { - n, ok := WellKnownCommunityNameMap[WellKnownCommunity(v)] - if ok { - l = append(l, n) - } else { - l = append(l, fmt.Sprintf("%d:%d", (0xffff0000&v)>>16, 0xffff&v)) - } - } - return fmt.Sprintf("{Communities: %s}", strings.Join(l, ", ")) -} - -func (p *PathAttributeCommunities) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value []uint32 `json:"communities"` - }{ - Type: p.GetType(), - Value: p.Value, - }) -} - -func NewPathAttributeCommunities(value []uint32) *PathAttributeCommunities { - l := len(value) * 4 - t := BGP_ATTR_TYPE_COMMUNITIES - return &PathAttributeCommunities{ - PathAttribute: PathAttribute{ - Flags: getPathAttrFlags(t, l), - Type: t, - Length: uint16(l), - }, - Value: value, - } -} - -type PathAttributeOriginatorId struct { - PathAttribute - Value net.IP -} - -func (p *PathAttributeOriginatorId) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - if p.Length != 4 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - return NewMessageError(eCode, eSubCode, nil, "originator id length isn't correct") - } - p.Value = value - return nil -} - -func (p *PathAttributeOriginatorId) String() string { - return fmt.Sprintf("{Originator: %s}", p.Value) -} - -func (p *PathAttributeOriginatorId) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value string `json:"value"` - }{ - Type: p.GetType(), - Value: p.Value.String(), - }) -} - -func (p *PathAttributeOriginatorId) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 4) - copy(buf, p.Value) - return p.PathAttribute.Serialize(buf, options...) -} - -func NewPathAttributeOriginatorId(value string) *PathAttributeOriginatorId { - t := BGP_ATTR_TYPE_ORIGINATOR_ID - return &PathAttributeOriginatorId{ - PathAttribute: PathAttribute{ - Flags: PathAttrFlags[t], - Type: t, - Length: 4, - }, - Value: net.ParseIP(value).To4(), - } -} - -type PathAttributeClusterList struct { - PathAttribute - Value []net.IP -} - -func (p *PathAttributeClusterList) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - if p.Length%4 != 0 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - return NewMessageError(eCode, eSubCode, nil, "clusterlist length isn't correct") - } - for len(value) >= 4 { - p.Value = append(p.Value, value[:4]) - value = value[4:] - } - return nil -} - -func (p *PathAttributeClusterList) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, len(p.Value)*4) - for i, v := range p.Value { - copy(buf[i*4:], v) - } - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeClusterList) String() string { - return fmt.Sprintf("{ClusterList: %v}", p.Value) -} - -func (p *PathAttributeClusterList) MarshalJSON() ([]byte, error) { - value := make([]string, 0, len(p.Value)) - for _, v := range p.Value { - value = append(value, v.String()) - } - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value []string `json:"value"` - }{ - Type: p.GetType(), - Value: value, - }) -} - -func NewPathAttributeClusterList(value []string) *PathAttributeClusterList { - l := len(value) * 4 - list := make([]net.IP, len(value)) - for i, v := range value { - list[i] = net.ParseIP(v).To4() - } - t := BGP_ATTR_TYPE_CLUSTER_LIST - return &PathAttributeClusterList{ - PathAttribute: PathAttribute{ - Flags: getPathAttrFlags(t, l), - Type: t, - Length: uint16(l), - }, - Value: list, - } -} - -type PathAttributeMpReachNLRI struct { - PathAttribute - Nexthop net.IP - LinkLocalNexthop net.IP - AFI uint16 - SAFI uint8 - Value []AddrPrefixInterface -} - -func (p *PathAttributeMpReachNLRI) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - eData, _ := p.PathAttribute.Serialize(value, options...) - if p.Length < 3 { - return NewMessageError(eCode, eSubCode, value, "mpreach header length is short") - } - afi := binary.BigEndian.Uint16(value[0:2]) - safi := value[2] - p.AFI = afi - p.SAFI = safi - _, err = NewPrefixFromRouteFamily(afi, safi) - if err != nil { - return NewMessageError(eCode, BGP_ERROR_SUB_INVALID_NETWORK_FIELD, eData, err.Error()) - } - nexthoplen := int(value[3]) - if len(value) < 4+nexthoplen { - return NewMessageError(eCode, eSubCode, value, "mpreach nexthop length is short") - } - nexthopbin := value[4 : 4+nexthoplen] - if nexthoplen > 0 { - v4addrlen := 4 - v6addrlen := 16 - offset := 0 - if safi == SAFI_MPLS_VPN { - offset = 8 - } - switch nexthoplen { - case 2 * (offset + v6addrlen): - p.LinkLocalNexthop = nexthopbin[offset+v6addrlen+offset : 2*(offset+v6addrlen)] - fallthrough - case offset + v6addrlen: - p.Nexthop = nexthopbin[offset : offset+v6addrlen] - case offset + v4addrlen: - p.Nexthop = nexthopbin[offset : offset+v4addrlen] - default: - return NewMessageError(eCode, eSubCode, value, "mpreach nexthop length is incorrect") - } - } - value = value[4+nexthoplen:] - // skip reserved - if len(value) == 0 { - return NewMessageError(eCode, eSubCode, value, "no skip byte") - } - value = value[1:] - addpathLen := 0 - if IsAddPathEnabled(true, AfiSafiToRouteFamily(afi, safi), options) { - addpathLen = 4 - } - for len(value) > 0 { - prefix, err := NewPrefixFromRouteFamily(afi, safi) - if err != nil { - return NewMessageError(eCode, BGP_ERROR_SUB_INVALID_NETWORK_FIELD, eData, err.Error()) - } - err = prefix.DecodeFromBytes(value, options...) - if err != nil { - return err - } - if prefix.Len(options...)+addpathLen > len(value) { - return NewMessageError(eCode, eSubCode, value, "prefix length is incorrect") - } - value = value[prefix.Len(options...)+addpathLen:] - p.Value = append(p.Value, prefix) - } - return nil -} - -func (p *PathAttributeMpReachNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) { - afi := p.AFI - safi := p.SAFI - nexthoplen := 4 - if afi == AFI_IP6 || p.Nexthop.To4() == nil { - nexthoplen = 16 - } - offset := 0 - switch safi { - case SAFI_MPLS_VPN: - offset = 8 - nexthoplen += offset - case SAFI_FLOW_SPEC_VPN, SAFI_FLOW_SPEC_UNICAST: - nexthoplen = 0 - } - if p.LinkLocalNexthop != nil { - nexthoplen *= 2 - } - buf := make([]byte, 4+nexthoplen) - binary.BigEndian.PutUint16(buf[0:], afi) - buf[2] = safi - buf[3] = uint8(nexthoplen) - if nexthoplen != 0 { - if p.Nexthop.To4() == nil { - copy(buf[4+offset:], p.Nexthop.To16()) - if p.LinkLocalNexthop != nil { - copy(buf[4+offset+16:], p.LinkLocalNexthop.To16()) - } - } else { - copy(buf[4+offset:], p.Nexthop) - } - } - buf = append(buf, make([]byte, 1)...) - for _, prefix := range p.Value { - pbuf, err := prefix.Serialize(options...) - if err != nil { - return nil, err - } - buf = append(buf, pbuf...) - } - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeMpReachNLRI) MarshalJSON() ([]byte, error) { - nexthop := p.Nexthop.String() - if p.Nexthop == nil { - switch p.AFI { - case AFI_IP: - nexthop = "0.0.0.0" - case AFI_IP6: - nexthop = "::" - default: - nexthop = "fictitious" - } - } - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Nexthop string `json:"nexthop"` - AFI uint16 `json:"afi"` - SAFI uint8 `json:"safi"` - Value []AddrPrefixInterface `json:"value"` - }{ - Type: p.GetType(), - Nexthop: nexthop, - AFI: p.AFI, - SAFI: p.SAFI, - Value: p.Value, - }) -} - -func (p *PathAttributeMpReachNLRI) String() string { - return fmt.Sprintf("{MpReach(%s): {Nexthop: %s, NLRIs: %s}}", AfiSafiToRouteFamily(p.AFI, p.SAFI), p.Nexthop, p.Value) -} - -func NewPathAttributeMpReachNLRI(nexthop string, nlri []AddrPrefixInterface) *PathAttributeMpReachNLRI { - // AFI(2) + SAFI(1) + NexthopLength(1) + Nexthop(variable) - // + Reserved(1) + NLRI(variable) - l := 5 - var afi uint16 - var safi uint8 - if len(nlri) > 0 { - afi = nlri[0].AFI() - safi = nlri[0].SAFI() - } - nh := net.ParseIP(nexthop) - if nh.To4() != nil && afi != AFI_IP6 { - nh = nh.To4() - switch safi { - case SAFI_MPLS_VPN: - l += 12 - case SAFI_FLOW_SPEC_VPN, SAFI_FLOW_SPEC_UNICAST: - // Should not have Nexthop - default: - l += 4 - } - } else { - switch safi { - case SAFI_MPLS_VPN: - l += 24 - case SAFI_FLOW_SPEC_VPN, SAFI_FLOW_SPEC_UNICAST: - // Should not have Nexthop - default: - l += 16 - } - } - var nlriLen int - for _, n := range nlri { - l += n.Len() - nBuf, _ := n.Serialize() - nlriLen += len(nBuf) - } - t := BGP_ATTR_TYPE_MP_REACH_NLRI - return &PathAttributeMpReachNLRI{ - PathAttribute: PathAttribute{ - Flags: getPathAttrFlags(t, l), - Type: t, - Length: uint16(l), - }, - Nexthop: nh, - AFI: afi, - SAFI: safi, - Value: nlri, - } -} - -type PathAttributeMpUnreachNLRI struct { - PathAttribute - AFI uint16 - SAFI uint8 - Value []AddrPrefixInterface -} - -func (p *PathAttributeMpUnreachNLRI) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - eData, _ := p.PathAttribute.Serialize(value, options...) - if p.Length < 3 { - return NewMessageError(eCode, eSubCode, value, "unreach header length is incorrect") - } - afi := binary.BigEndian.Uint16(value[0:2]) - safi := value[2] - _, err = NewPrefixFromRouteFamily(afi, safi) - if err != nil { - return NewMessageError(eCode, BGP_ERROR_SUB_INVALID_NETWORK_FIELD, eData, err.Error()) - } - value = value[3:] - p.AFI = afi - p.SAFI = safi - addpathLen := 0 - if IsAddPathEnabled(true, AfiSafiToRouteFamily(afi, safi), options) { - addpathLen = 4 - } - for len(value) > 0 { - prefix, err := NewPrefixFromRouteFamily(afi, safi) - if err != nil { - return NewMessageError(eCode, BGP_ERROR_SUB_INVALID_NETWORK_FIELD, eData, err.Error()) - } - err = prefix.DecodeFromBytes(value, options...) - if err != nil { - return err - } - if prefix.Len(options...)+addpathLen > len(value) { - return NewMessageError(eCode, eSubCode, eData, "prefix length is incorrect") - } - value = value[prefix.Len(options...)+addpathLen:] - p.Value = append(p.Value, prefix) - } - return nil -} - -func (p *PathAttributeMpUnreachNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 3) - binary.BigEndian.PutUint16(buf, p.AFI) - buf[2] = p.SAFI - for _, prefix := range p.Value { - pbuf, err := prefix.Serialize(options...) - if err != nil { - return nil, err - } - buf = append(buf, pbuf...) - } - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeMpUnreachNLRI) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - AFI uint16 `json:"afi"` - SAFI uint8 `json:"safi"` - Value []AddrPrefixInterface `json:"value"` - }{ - Type: p.GetType(), - AFI: p.AFI, - SAFI: p.SAFI, - Value: p.Value, - }) -} - -func (p *PathAttributeMpUnreachNLRI) String() string { - if len(p.Value) > 0 { - return fmt.Sprintf("{MpUnreach(%s): {NLRIs: %s}}", AfiSafiToRouteFamily(p.AFI, p.SAFI), p.Value) - } - return fmt.Sprintf("{MpUnreach(%s): End-of-Rib}", AfiSafiToRouteFamily(p.AFI, p.SAFI)) -} - -func NewPathAttributeMpUnreachNLRI(nlri []AddrPrefixInterface) *PathAttributeMpUnreachNLRI { - // AFI(2) + SAFI(1) + NLRI(variable) - l := 3 - var afi uint16 - var safi uint8 - if len(nlri) > 0 { - afi = nlri[0].AFI() - safi = nlri[0].SAFI() - } - for _, n := range nlri { - l += n.Len() - } - t := BGP_ATTR_TYPE_MP_UNREACH_NLRI - return &PathAttributeMpUnreachNLRI{ - PathAttribute: PathAttribute{ - Flags: getPathAttrFlags(t, l), - Type: t, - Length: uint16(l), - }, - AFI: afi, - SAFI: safi, - Value: nlri, - } -} - -type ExtendedCommunityInterface interface { - Serialize() ([]byte, error) - String() string - GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) - MarshalJSON() ([]byte, error) - Flat() map[string]string -} - -type TwoOctetAsSpecificExtended struct { - SubType ExtendedCommunityAttrSubType - AS uint16 - LocalAdmin uint32 - IsTransitive bool -} - -func (e *TwoOctetAsSpecificExtended) Serialize() ([]byte, error) { - buf := make([]byte, 8) - if e.IsTransitive { - buf[0] = byte(EC_TYPE_TRANSITIVE_TWO_OCTET_AS_SPECIFIC) - } else { - buf[0] = byte(EC_TYPE_NON_TRANSITIVE_TWO_OCTET_AS_SPECIFIC) - } - buf[1] = byte(e.SubType) - binary.BigEndian.PutUint16(buf[2:], e.AS) - binary.BigEndian.PutUint32(buf[4:], e.LocalAdmin) - return buf, nil -} - -func (e *TwoOctetAsSpecificExtended) String() string { - return fmt.Sprintf("%d:%d", e.AS, e.LocalAdmin) -} - -func (e *TwoOctetAsSpecificExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Value string `json:"value"` - }{ - Type: t, - Subtype: s, - Value: e.String(), - }) -} - -func (e *TwoOctetAsSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - t := EC_TYPE_TRANSITIVE_TWO_OCTET_AS_SPECIFIC - if !e.IsTransitive { - t = EC_TYPE_NON_TRANSITIVE_TWO_OCTET_AS_SPECIFIC - } - return t, e.SubType -} - -func NewTwoOctetAsSpecificExtended(subtype ExtendedCommunityAttrSubType, as uint16, localAdmin uint32, isTransitive bool) *TwoOctetAsSpecificExtended { - return &TwoOctetAsSpecificExtended{ - SubType: subtype, - AS: as, - LocalAdmin: localAdmin, - IsTransitive: isTransitive, - } -} - -type IPv4AddressSpecificExtended struct { - SubType ExtendedCommunityAttrSubType - IPv4 net.IP - LocalAdmin uint16 - IsTransitive bool -} - -func (e *IPv4AddressSpecificExtended) Serialize() ([]byte, error) { - buf := make([]byte, 8) - if e.IsTransitive { - buf[0] = byte(EC_TYPE_TRANSITIVE_IP4_SPECIFIC) - } else { - buf[0] = byte(EC_TYPE_NON_TRANSITIVE_IP4_SPECIFIC) - } - buf[1] = byte(e.SubType) - copy(buf[2:6], e.IPv4) - binary.BigEndian.PutUint16(buf[6:], e.LocalAdmin) - return buf, nil -} - -func (e *IPv4AddressSpecificExtended) String() string { - return fmt.Sprintf("%s:%d", e.IPv4.String(), e.LocalAdmin) -} - -func (e *IPv4AddressSpecificExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Value string `json:"value"` - }{ - Type: t, - Subtype: s, - Value: e.String(), - }) -} - -func (e *IPv4AddressSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - t := EC_TYPE_TRANSITIVE_IP4_SPECIFIC - if !e.IsTransitive { - t = EC_TYPE_NON_TRANSITIVE_IP4_SPECIFIC - } - return t, e.SubType -} - -func NewIPv4AddressSpecificExtended(subtype ExtendedCommunityAttrSubType, ip string, localAdmin uint16, isTransitive bool) *IPv4AddressSpecificExtended { - ipv4 := net.ParseIP(ip) - if ipv4.To4() == nil { - return nil - } - return &IPv4AddressSpecificExtended{ - SubType: subtype, - IPv4: ipv4.To4(), - LocalAdmin: localAdmin, - IsTransitive: isTransitive, - } -} - -type IPv6AddressSpecificExtended struct { - SubType ExtendedCommunityAttrSubType - IPv6 net.IP - LocalAdmin uint16 - IsTransitive bool -} - -func (e *IPv6AddressSpecificExtended) Serialize() ([]byte, error) { - buf := make([]byte, 20) - if e.IsTransitive { - buf[0] = byte(EC_TYPE_TRANSITIVE_IP6_SPECIFIC) - } else { - buf[0] = byte(EC_TYPE_NON_TRANSITIVE_IP6_SPECIFIC) - } - buf[1] = byte(e.SubType) - copy(buf[2:18], e.IPv6) - binary.BigEndian.PutUint16(buf[18:], e.LocalAdmin) - return buf, nil -} - -func (e *IPv6AddressSpecificExtended) String() string { - return fmt.Sprintf("%s:%d", e.IPv6.String(), e.LocalAdmin) -} - -func (e *IPv6AddressSpecificExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Value string `json:"value"` - }{ - Type: t, - Subtype: s, - Value: e.String(), - }) -} - -func (e *IPv6AddressSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - t := EC_TYPE_TRANSITIVE_IP6_SPECIFIC - if !e.IsTransitive { - t = EC_TYPE_NON_TRANSITIVE_IP6_SPECIFIC - } - return t, e.SubType -} - -func NewIPv6AddressSpecificExtended(subtype ExtendedCommunityAttrSubType, ip string, localAdmin uint16, isTransitive bool) *IPv6AddressSpecificExtended { - ipv6 := net.ParseIP(ip) - if ipv6.To16() == nil { - return nil - } - return &IPv6AddressSpecificExtended{ - SubType: subtype, - IPv6: ipv6.To16(), - LocalAdmin: localAdmin, - IsTransitive: isTransitive, - } -} - -type FourOctetAsSpecificExtended struct { - SubType ExtendedCommunityAttrSubType - AS uint32 - LocalAdmin uint16 - IsTransitive bool -} - -func (e *FourOctetAsSpecificExtended) Serialize() ([]byte, error) { - buf := make([]byte, 8) - if e.IsTransitive { - buf[0] = byte(EC_TYPE_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC) - } else { - buf[0] = byte(EC_TYPE_NON_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC) - } - buf[1] = byte(e.SubType) - binary.BigEndian.PutUint32(buf[2:], e.AS) - binary.BigEndian.PutUint16(buf[6:], e.LocalAdmin) - return buf, nil -} - -func (e *FourOctetAsSpecificExtended) String() string { - buf := make([]byte, 4) - binary.BigEndian.PutUint32(buf, e.AS) - asUpper := binary.BigEndian.Uint16(buf[0:2]) - asLower := binary.BigEndian.Uint16(buf[2:]) - return fmt.Sprintf("%d.%d:%d", asUpper, asLower, e.LocalAdmin) -} - -func (e *FourOctetAsSpecificExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Value string `json:"value"` - }{ - Type: t, - Subtype: s, - Value: e.String(), - }) -} - -func (e *FourOctetAsSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - t := EC_TYPE_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC - if !e.IsTransitive { - t = EC_TYPE_NON_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC - } - return t, e.SubType -} - -func NewFourOctetAsSpecificExtended(subtype ExtendedCommunityAttrSubType, as uint32, localAdmin uint16, isTransitive bool) *FourOctetAsSpecificExtended { - return &FourOctetAsSpecificExtended{ - SubType: subtype, - AS: as, - LocalAdmin: localAdmin, - IsTransitive: isTransitive, - } -} - -func ParseExtendedCommunity(subtype ExtendedCommunityAttrSubType, com string) (ExtendedCommunityInterface, error) { - if subtype == EC_SUBTYPE_ORIGIN_VALIDATION { - var state ValidationState - switch com { - case VALIDATION_STATE_VALID.String(): - state = VALIDATION_STATE_VALID - case VALIDATION_STATE_NOT_FOUND.String(): - state = VALIDATION_STATE_NOT_FOUND - case VALIDATION_STATE_INVALID.String(): - state = VALIDATION_STATE_INVALID - default: - return nil, fmt.Errorf("invalid validation state") - } - return &ValidationExtended{ - State: state, - }, nil - } - elems, err := parseRdAndRt(com) - if err != nil { - return nil, err - } - localAdmin, _ := strconv.ParseUint(elems[10], 10, 32) - ip := net.ParseIP(elems[1]) - isTransitive := true - switch { - case ip.To4() != nil: - return NewIPv4AddressSpecificExtended(subtype, elems[1], uint16(localAdmin), isTransitive), nil - case ip.To16() != nil: - return NewIPv6AddressSpecificExtended(subtype, elems[1], uint16(localAdmin), isTransitive), nil - case elems[6] == "" && elems[7] == "": - asn, _ := strconv.ParseUint(elems[8], 10, 16) - return NewTwoOctetAsSpecificExtended(subtype, uint16(asn), uint32(localAdmin), isTransitive), nil - default: - fst, _ := strconv.ParseUint(elems[7], 10, 16) - snd, _ := strconv.ParseUint(elems[8], 10, 16) - asn := fst<<16 | snd - return NewFourOctetAsSpecificExtended(subtype, uint32(asn), uint16(localAdmin), isTransitive), nil - } -} - -func ParseRouteTarget(rt string) (ExtendedCommunityInterface, error) { - return ParseExtendedCommunity(EC_SUBTYPE_ROUTE_TARGET, rt) -} - -func SerializeExtendedCommunities(comms []ExtendedCommunityInterface) ([][]byte, error) { - var bufs [][]byte - var err error - for _, c := range comms { - buf, err := c.Serialize() - if err != nil { - return nil, err - } - bufs = append(bufs, buf) - } - return bufs, err -} - -type ValidationState uint8 - -const ( - VALIDATION_STATE_VALID ValidationState = 0 - VALIDATION_STATE_NOT_FOUND ValidationState = 1 - VALIDATION_STATE_INVALID ValidationState = 2 -) - -func (s ValidationState) String() string { - switch s { - case VALIDATION_STATE_VALID: - return "valid" - case VALIDATION_STATE_NOT_FOUND: - return "not-found" - case VALIDATION_STATE_INVALID: - return "invalid" - } - return fmt.Sprintf("unknown validation state(%d)", s) -} - -type ValidationExtended struct { - State ValidationState -} - -func (e *ValidationExtended) Serialize() ([]byte, error) { - buf := make([]byte, 8) - typ, subType := e.GetTypes() - buf[0] = byte(typ) - buf[1] = byte(subType) - buf[7] = byte(e.State) - return buf, nil -} - -func (e *ValidationExtended) String() string { - return e.State.String() -} - -func (e *ValidationExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_NON_TRANSITIVE_OPAQUE, EC_SUBTYPE_ORIGIN_VALIDATION -} - -func (e *ValidationExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - SubType ExtendedCommunityAttrSubType `json:"subtype"` - State ValidationState `json:"value"` - }{ - Type: t, - SubType: s, - State: e.State, - }) -} - -func NewValidationExtended(state ValidationState) *ValidationExtended { - return &ValidationExtended{ - State: state, - } -} - -type ColorExtended struct { - Color uint32 -} - -func (e *ColorExtended) Serialize() ([]byte, error) { - buf := make([]byte, 8) - typ, subType := e.GetTypes() - buf[0] = byte(typ) - buf[1] = byte(subType) - binary.BigEndian.PutUint32(buf[4:8], uint32(e.Color)) - return buf, nil -} - -func (e *ColorExtended) String() string { - return fmt.Sprintf("%d", e.Color) -} - -func (e *ColorExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_TRANSITIVE_OPAQUE, EC_SUBTYPE_COLOR -} - -func (e *ColorExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - SubType ExtendedCommunityAttrSubType `json:"subtype"` - Color uint32 `json:"color"` - }{ - Type: t, - SubType: s, - Color: e.Color, - }) -} - -func NewColorExtended(color uint32) *ColorExtended { - return &ColorExtended{ - Color: color, - } -} - -type EncapExtended struct { - TunnelType TunnelType -} - -func (e *EncapExtended) Serialize() ([]byte, error) { - buf := make([]byte, 8) - typ, subType := e.GetTypes() - buf[0] = byte(typ) - buf[1] = byte(subType) - binary.BigEndian.PutUint16(buf[6:8], uint16(e.TunnelType)) - return buf, nil -} - -func (e *EncapExtended) String() string { - switch e.TunnelType { - case TUNNEL_TYPE_L2TP3: - return "L2TPv3 over IP" - case TUNNEL_TYPE_GRE: - return "GRE" - case TUNNEL_TYPE_IP_IN_IP: - return "IP in IP" - case TUNNEL_TYPE_VXLAN: - return "VXLAN" - case TUNNEL_TYPE_NVGRE: - return "NVGRE" - case TUNNEL_TYPE_MPLS: - return "MPLS" - case TUNNEL_TYPE_MPLS_IN_GRE: - return "MPLS in GRE" - case TUNNEL_TYPE_VXLAN_GRE: - return "VXLAN GRE" - case TUNNEL_TYPE_MPLS_IN_UDP: - return "MPLS in UDP" - default: - return fmt.Sprintf("tunnel: %d", e.TunnelType) - } -} - -func (e *EncapExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_TRANSITIVE_OPAQUE, EC_SUBTYPE_ENCAPSULATION -} - -func (e *EncapExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - SubType ExtendedCommunityAttrSubType `json:"subtype"` - TunnelType TunnelType `json:"tunnel_type"` - }{ - Type: t, - SubType: s, - TunnelType: e.TunnelType, - }) -} - -func NewEncapExtended(tunnelType TunnelType) *EncapExtended { - return &EncapExtended{ - TunnelType: tunnelType, - } -} - -type DefaultGatewayExtended struct { -} - -func (e *DefaultGatewayExtended) Serialize() ([]byte, error) { - buf := make([]byte, 8) - typ, subType := e.GetTypes() - buf[0] = byte(typ) - buf[1] = byte(subType) - return buf, nil -} - -func (e *DefaultGatewayExtended) String() string { - return "default-gateway" -} - -func (e *DefaultGatewayExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_TRANSITIVE_OPAQUE, EC_SUBTYPE_DEFAULT_GATEWAY -} - -func (e *DefaultGatewayExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - SubType ExtendedCommunityAttrSubType `json:"subtype"` - }{ - Type: t, - SubType: s, - }) -} - -func NewDefaultGatewayExtended() *DefaultGatewayExtended { - return &DefaultGatewayExtended{} -} - -type OpaqueExtended struct { - IsTransitive bool - Value []byte -} - -func (e *OpaqueExtended) Serialize() ([]byte, error) { - if len(e.Value) != 7 { - return nil, fmt.Errorf("invalid value length for opaque extended community: %d", len(e.Value)) - } - buf := make([]byte, 8) - if e.IsTransitive { - buf[0] = byte(EC_TYPE_TRANSITIVE_OPAQUE) - } else { - buf[0] = byte(EC_TYPE_NON_TRANSITIVE_OPAQUE) - } - copy(buf[1:], e.Value) - return buf, nil -} - -func (e *OpaqueExtended) String() string { - buf := make([]byte, 8) - copy(buf[1:], e.Value) - return fmt.Sprintf("%d", binary.BigEndian.Uint64(buf)) -} - -func (e *OpaqueExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - var subType ExtendedCommunityAttrSubType - if len(e.Value) > 0 { - // Use the first byte of value as the sub type - subType = ExtendedCommunityAttrSubType(e.Value[0]) - } - if e.IsTransitive { - return EC_TYPE_TRANSITIVE_OPAQUE, subType - } - return EC_TYPE_NON_TRANSITIVE_OPAQUE, subType -} - -func (e *OpaqueExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Value []byte `json:"value"` - }{ - Type: t, - Subtype: s, - Value: e.Value, - }) -} - -func NewOpaqueExtended(isTransitive bool, value []byte) *OpaqueExtended { - v := make([]byte, 7) - copy(v, value) - return &OpaqueExtended{ - IsTransitive: isTransitive, - Value: v, - } -} - -func parseOpaqueExtended(data []byte) (ExtendedCommunityInterface, error) { - typ := ExtendedCommunityAttrType(data[0]) - isTransitive := false - switch typ { - case EC_TYPE_TRANSITIVE_OPAQUE: - isTransitive = true - case EC_TYPE_NON_TRANSITIVE_OPAQUE: - // isTransitive = false - default: - return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("invalid opaque extended community type: %d", data[0])) - } - subType := ExtendedCommunityAttrSubType(data[1]) - - if isTransitive { - switch subType { - case EC_SUBTYPE_COLOR: - return &ColorExtended{ - Color: binary.BigEndian.Uint32(data[4:8]), - }, nil - case EC_SUBTYPE_ENCAPSULATION: - return &EncapExtended{ - TunnelType: TunnelType(binary.BigEndian.Uint16(data[6:8])), - }, nil - case EC_SUBTYPE_DEFAULT_GATEWAY: - return &DefaultGatewayExtended{}, nil - } - } else { - switch subType { - case EC_SUBTYPE_ORIGIN_VALIDATION: - return &ValidationExtended{ - State: ValidationState(data[7]), - }, nil - } - } - return NewOpaqueExtended(isTransitive, data[1:8]), nil -} - -type ESILabelExtended struct { - Label uint32 - IsSingleActive bool -} - -func (e *ESILabelExtended) Serialize() ([]byte, error) { - buf := make([]byte, 8) - buf[0] = byte(EC_TYPE_EVPN) - buf[1] = byte(EC_SUBTYPE_ESI_LABEL) - if e.IsSingleActive { - buf[2] = byte(1) - } - buf[3] = 0 - buf[4] = 0 - buf[5] = byte((e.Label >> 16) & 0xff) - buf[6] = byte((e.Label >> 8) & 0xff) - buf[7] = byte(e.Label & 0xff) - return buf, nil -} - -func (e *ESILabelExtended) String() string { - buf := bytes.NewBuffer(make([]byte, 0, 32)) - buf.WriteString(fmt.Sprintf("esi-label: %d", e.Label)) - if e.IsSingleActive { - buf.WriteString(", single-active") - } - return buf.String() -} - -func (e *ESILabelExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Label uint32 `json:"label"` - IsSingleActive bool `json:"is_single_active"` - }{ - Type: t, - Subtype: s, - Label: e.Label, - IsSingleActive: e.IsSingleActive, - }) -} - -func (e *ESILabelExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_EVPN, EC_SUBTYPE_ESI_LABEL -} - -func NewESILabelExtended(label uint32, isSingleActive bool) *ESILabelExtended { - return &ESILabelExtended{ - Label: label, - IsSingleActive: isSingleActive, - } -} - -type ESImportRouteTarget struct { - ESImport net.HardwareAddr -} - -func (e *ESImportRouteTarget) Serialize() ([]byte, error) { - buf := make([]byte, 8) - buf[0] = byte(EC_TYPE_EVPN) - buf[1] = byte(EC_SUBTYPE_ES_IMPORT) - copy(buf[2:], e.ESImport) - return buf, nil -} - -func (e *ESImportRouteTarget) String() string { - return fmt.Sprintf("es-import rt: %s", e.ESImport.String()) -} - -func (e *ESImportRouteTarget) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Value string `json:"value"` - }{ - Type: t, - Subtype: s, - Value: e.ESImport.String(), - }) -} - -func (e *ESImportRouteTarget) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_EVPN, EC_SUBTYPE_ES_IMPORT -} - -func NewESImportRouteTarget(mac string) *ESImportRouteTarget { - esImport, err := net.ParseMAC(mac) - if err != nil { - return nil - } - return &ESImportRouteTarget{ - ESImport: esImport, - } -} - -type MacMobilityExtended struct { - Sequence uint32 - IsSticky bool -} - -func (e *MacMobilityExtended) Serialize() ([]byte, error) { - buf := make([]byte, 8) - buf[0] = byte(EC_TYPE_EVPN) - buf[1] = byte(EC_SUBTYPE_MAC_MOBILITY) - if e.IsSticky { - buf[2] = byte(1) - } - binary.BigEndian.PutUint32(buf[4:], e.Sequence) - return buf, nil -} - -func (e *MacMobilityExtended) String() string { - buf := bytes.NewBuffer(make([]byte, 0, 32)) - buf.WriteString(fmt.Sprintf("mac-mobility: %d", e.Sequence)) - if e.IsSticky { - buf.WriteString(", sticky") - } - return buf.String() -} - -func (e *MacMobilityExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Sequence uint32 `json:"sequence"` - IsSticky bool `json:"is_sticky"` - }{ - Type: t, - Subtype: s, - Sequence: e.Sequence, - IsSticky: e.IsSticky, - }) -} - -func (e *MacMobilityExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_EVPN, EC_SUBTYPE_MAC_MOBILITY -} - -func NewMacMobilityExtended(seq uint32, isSticky bool) *MacMobilityExtended { - return &MacMobilityExtended{ - Sequence: seq, - IsSticky: isSticky, - } -} - -type RouterMacExtended struct { - Mac net.HardwareAddr -} - -func (e *RouterMacExtended) Serialize() ([]byte, error) { - buf := make([]byte, 2, 8) - buf[0] = byte(EC_TYPE_EVPN) - buf[1] = byte(EC_SUBTYPE_ROUTER_MAC) - buf = append(buf, e.Mac...) - return buf, nil -} - -func (e *RouterMacExtended) String() string { - return fmt.Sprintf("router's mac: %s", e.Mac.String()) -} - -func (e *RouterMacExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Mac string `json:"mac"` - }{ - Type: t, - Subtype: s, - Mac: e.Mac.String(), - }) -} - -func (e *RouterMacExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_EVPN, EC_SUBTYPE_ROUTER_MAC -} - -func NewRoutersMacExtended(mac string) *RouterMacExtended { - hw, err := net.ParseMAC(mac) - if err != nil { - return nil - } - return &RouterMacExtended{ - Mac: hw, - } -} - -func parseEvpnExtended(data []byte) (ExtendedCommunityInterface, error) { - if ExtendedCommunityAttrType(data[0]) != EC_TYPE_EVPN { - return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("ext comm type is not EC_TYPE_EVPN: %d", data[0])) - } - subType := ExtendedCommunityAttrSubType(data[1]) - switch subType { - case EC_SUBTYPE_ESI_LABEL: - var isSingleActive bool - if data[2] > 0 { - isSingleActive = true - } - label := uint32(data[5])<<16 | uint32(data[6])<<8 | uint32(data[7]) - return &ESILabelExtended{ - IsSingleActive: isSingleActive, - Label: label, - }, nil - case EC_SUBTYPE_ES_IMPORT: - return &ESImportRouteTarget{ - ESImport: net.HardwareAddr(data[2:8]), - }, nil - case EC_SUBTYPE_MAC_MOBILITY: - var isSticky bool - if data[2] > 0 { - isSticky = true - } - seq := binary.BigEndian.Uint32(data[4:8]) - return &MacMobilityExtended{ - Sequence: seq, - IsSticky: isSticky, - }, nil - case EC_SUBTYPE_ROUTER_MAC: - return &RouterMacExtended{ - Mac: net.HardwareAddr(data[2:8]), - }, nil - } - return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("unknown evpn subtype: %d", subType)) -} - -type TrafficRateExtended struct { - AS uint16 - Rate float32 -} - -func (e *TrafficRateExtended) Serialize() ([]byte, error) { - buf := make([]byte, 8) - buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL) - buf[1] = byte(EC_SUBTYPE_FLOWSPEC_TRAFFIC_RATE) - binary.BigEndian.PutUint16(buf[2:4], e.AS) - binary.BigEndian.PutUint32(buf[4:8], math.Float32bits(e.Rate)) - return buf, nil -} - -func (e *TrafficRateExtended) String() string { - buf := bytes.NewBuffer(make([]byte, 0, 32)) - if e.Rate == 0 { - buf.WriteString("discard") - } else { - buf.WriteString(fmt.Sprintf("rate: %f", e.Rate)) - } - if e.AS != 0 { - buf.WriteString(fmt.Sprintf("(as: %d)", e.AS)) - } - return buf.String() -} - -func (e *TrafficRateExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - As uint16 `json:"as"` - Rate float32 `json:"rate"` - }{t, s, e.AS, e.Rate}) -} - -func (e *TrafficRateExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL, EC_SUBTYPE_FLOWSPEC_TRAFFIC_RATE -} - -func NewTrafficRateExtended(as uint16, rate float32) *TrafficRateExtended { - return &TrafficRateExtended{ - AS: as, - Rate: rate, - } -} - -type TrafficActionExtended struct { - Terminal bool - Sample bool -} - -func (e *TrafficActionExtended) Serialize() ([]byte, error) { - buf := make([]byte, 8) - buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL) - buf[1] = byte(EC_SUBTYPE_FLOWSPEC_TRAFFIC_ACTION) - if e.Terminal { - buf[7] = 0x01 - } - if e.Sample { - buf[7] = buf[7] | 0x2 - } - return buf, nil -} - -func (e *TrafficActionExtended) String() string { - ss := make([]string, 0, 2) - if e.Terminal { - ss = append(ss, "terminal") - } - if e.Sample { - ss = append(ss, "sample") - } - return fmt.Sprintf("action: %s", strings.Join(ss, "-")) -} - -func (e *TrafficActionExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Terminal bool `json:"terminal"` - Sample bool `json:"sample"` - }{t, s, e.Terminal, e.Sample}) -} - -func (e *TrafficActionExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL, EC_SUBTYPE_FLOWSPEC_TRAFFIC_ACTION -} - -func NewTrafficActionExtended(terminal bool, sample bool) *TrafficActionExtended { - return &TrafficActionExtended{ - Terminal: terminal, - Sample: sample, - } -} - -type RedirectTwoOctetAsSpecificExtended struct { - TwoOctetAsSpecificExtended -} - -func (e *RedirectTwoOctetAsSpecificExtended) Serialize() ([]byte, error) { - buf, err := e.TwoOctetAsSpecificExtended.Serialize() - buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL) - buf[1] = byte(EC_SUBTYPE_FLOWSPEC_REDIRECT) - return buf, err -} - -func (e *RedirectTwoOctetAsSpecificExtended) String() string { - return fmt.Sprintf("redirect: %s", e.TwoOctetAsSpecificExtended.String()) -} - -func (e *RedirectTwoOctetAsSpecificExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Value string `json:"value"` - }{t, s, e.TwoOctetAsSpecificExtended.String()}) -} - -func (e *RedirectTwoOctetAsSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL, EC_SUBTYPE_FLOWSPEC_REDIRECT -} - -func NewRedirectTwoOctetAsSpecificExtended(as uint16, localAdmin uint32) *RedirectTwoOctetAsSpecificExtended { - return &RedirectTwoOctetAsSpecificExtended{*NewTwoOctetAsSpecificExtended(EC_SUBTYPE_ROUTE_TARGET, as, localAdmin, false)} -} - -type RedirectIPv4AddressSpecificExtended struct { - IPv4AddressSpecificExtended -} - -func (e *RedirectIPv4AddressSpecificExtended) Serialize() ([]byte, error) { - buf, err := e.IPv4AddressSpecificExtended.Serialize() - buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2) - buf[1] = byte(EC_SUBTYPE_FLOWSPEC_REDIRECT) - return buf, err -} - -func (e *RedirectIPv4AddressSpecificExtended) String() string { - return fmt.Sprintf("redirect: %s", e.IPv4AddressSpecificExtended.String()) -} - -func (e *RedirectIPv4AddressSpecificExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Value string `json:"value"` - }{t, s, e.IPv4AddressSpecificExtended.String()}) -} - -func (e *RedirectIPv4AddressSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2, EC_SUBTYPE_FLOWSPEC_REDIRECT -} - -func NewRedirectIPv4AddressSpecificExtended(ipv4 string, localAdmin uint16) *RedirectIPv4AddressSpecificExtended { - e := NewIPv4AddressSpecificExtended(EC_SUBTYPE_ROUTE_TARGET, ipv4, localAdmin, false) - if e == nil { - return nil - } - return &RedirectIPv4AddressSpecificExtended{*e} -} - -type RedirectIPv6AddressSpecificExtended struct { - IPv6AddressSpecificExtended -} - -func (e *RedirectIPv6AddressSpecificExtended) Serialize() ([]byte, error) { - buf, err := e.IPv6AddressSpecificExtended.Serialize() - buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL) - buf[1] = byte(EC_SUBTYPE_FLOWSPEC_REDIRECT_IP6) - return buf, err -} - -func (e *RedirectIPv6AddressSpecificExtended) String() string { - return fmt.Sprintf("redirect: %s", e.IPv6AddressSpecificExtended.String()) -} - -func (e *RedirectIPv6AddressSpecificExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Value string `json:"value"` - }{t, s, e.IPv6AddressSpecificExtended.String()}) -} - -func (e *RedirectIPv6AddressSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL, EC_SUBTYPE_FLOWSPEC_REDIRECT_IP6 -} - -func NewRedirectIPv6AddressSpecificExtended(ipv6 string, localAdmin uint16) *RedirectIPv6AddressSpecificExtended { - e := NewIPv6AddressSpecificExtended(EC_SUBTYPE_ROUTE_TARGET, ipv6, localAdmin, false) - if e == nil { - return nil - } - return &RedirectIPv6AddressSpecificExtended{*e} -} - -type RedirectFourOctetAsSpecificExtended struct { - FourOctetAsSpecificExtended -} - -func (e *RedirectFourOctetAsSpecificExtended) Serialize() ([]byte, error) { - buf, err := e.FourOctetAsSpecificExtended.Serialize() - buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3) - buf[1] = byte(EC_SUBTYPE_FLOWSPEC_REDIRECT) - return buf, err -} - -func (e *RedirectFourOctetAsSpecificExtended) String() string { - return fmt.Sprintf("redirect: %s", e.FourOctetAsSpecificExtended.String()) -} - -func (e *RedirectFourOctetAsSpecificExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Value string `json:"value"` - }{t, s, e.FourOctetAsSpecificExtended.String()}) -} - -func (e *RedirectFourOctetAsSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3, EC_SUBTYPE_FLOWSPEC_REDIRECT -} - -func NewRedirectFourOctetAsSpecificExtended(as uint32, localAdmin uint16) *RedirectFourOctetAsSpecificExtended { - return &RedirectFourOctetAsSpecificExtended{*NewFourOctetAsSpecificExtended(EC_SUBTYPE_ROUTE_TARGET, as, localAdmin, false)} -} - -type TrafficRemarkExtended struct { - DSCP uint8 -} - -func (e *TrafficRemarkExtended) Serialize() ([]byte, error) { - buf := make([]byte, 8) - buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL) - buf[1] = byte(EC_SUBTYPE_FLOWSPEC_TRAFFIC_REMARK) - buf[7] = byte(e.DSCP) - return buf, nil -} - -func (e *TrafficRemarkExtended) String() string { - return fmt.Sprintf("remark: %d", e.DSCP) -} - -func (e *TrafficRemarkExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Value uint8 `json:"value"` - }{t, s, e.DSCP}) -} - -func (e *TrafficRemarkExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL, EC_SUBTYPE_FLOWSPEC_TRAFFIC_REMARK -} - -func NewTrafficRemarkExtended(dscp uint8) *TrafficRemarkExtended { - return &TrafficRemarkExtended{ - DSCP: dscp, - } -} - -func parseFlowSpecExtended(data []byte) (ExtendedCommunityInterface, error) { - typ := ExtendedCommunityAttrType(data[0]) - if typ != EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL && typ != EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2 && typ != EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3 { - return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("ext comm type is not EC_TYPE_FLOWSPEC: %d", data[0])) - } - subType := ExtendedCommunityAttrSubType(data[1]) - switch subType { - case EC_SUBTYPE_FLOWSPEC_TRAFFIC_RATE: - asn := binary.BigEndian.Uint16(data[2:4]) - bits := binary.BigEndian.Uint32(data[4:8]) - rate := math.Float32frombits(bits) - return NewTrafficRateExtended(asn, rate), nil - case EC_SUBTYPE_FLOWSPEC_TRAFFIC_ACTION: - terminal := data[7]&0x1 == 1 - sample := (data[7]>>1)&0x1 == 1 - return NewTrafficActionExtended(terminal, sample), nil - case EC_SUBTYPE_FLOWSPEC_REDIRECT: - // RFC7674 - switch typ { - case EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL: - as := binary.BigEndian.Uint16(data[2:4]) - localAdmin := binary.BigEndian.Uint32(data[4:8]) - return NewRedirectTwoOctetAsSpecificExtended(as, localAdmin), nil - case EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2: - ipv4 := net.IP(data[2:6]).String() - localAdmin := binary.BigEndian.Uint16(data[6:8]) - return NewRedirectIPv4AddressSpecificExtended(ipv4, localAdmin), nil - case EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3: - as := binary.BigEndian.Uint32(data[2:6]) - localAdmin := binary.BigEndian.Uint16(data[6:8]) - return NewRedirectFourOctetAsSpecificExtended(as, localAdmin), nil - } - case EC_SUBTYPE_FLOWSPEC_TRAFFIC_REMARK: - dscp := data[7] - return NewTrafficRemarkExtended(dscp), nil - case EC_SUBTYPE_FLOWSPEC_REDIRECT_IP6: - ipv6 := net.IP(data[2:18]).String() - localAdmin := binary.BigEndian.Uint16(data[18:20]) - return NewRedirectIPv6AddressSpecificExtended(ipv6, localAdmin), nil - } - return &UnknownExtended{ - Type: ExtendedCommunityAttrType(data[0]), - Value: data[1:8], - }, nil -} - -func parseIP6FlowSpecExtended(data []byte) (ExtendedCommunityInterface, error) { - typ := ExtendedCommunityAttrType(data[0]) - if typ != EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL && typ != EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2 && typ != EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3 { - return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("ext comm type is not EC_TYPE_FLOWSPEC: %d", data[0])) - } - subType := ExtendedCommunityAttrSubType(data[1]) - switch subType { - case EC_SUBTYPE_FLOWSPEC_REDIRECT_IP6: - // RFC7674 - switch typ { - case EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL: - ipv6 := net.IP(data[2:18]).String() - localAdmin := binary.BigEndian.Uint16(data[18:20]) - return NewRedirectIPv6AddressSpecificExtended(ipv6, localAdmin), nil - } - } - return &UnknownExtended{ - Type: ExtendedCommunityAttrType(data[0]), - Value: data[1:20], - }, nil -} - -type UnknownExtended struct { - Type ExtendedCommunityAttrType - Value []byte -} - -func (e *UnknownExtended) Serialize() ([]byte, error) { - if len(e.Value) != 7 { - return nil, fmt.Errorf("invalid value length for unknown extended community: %d", len(e.Value)) - } - buf := make([]byte, 8) - buf[0] = uint8(e.Type) - copy(buf[1:], e.Value) - return buf, nil -} - -func (e *UnknownExtended) String() string { - buf := make([]byte, 8) - copy(buf[1:], e.Value) - return fmt.Sprintf("%d", binary.BigEndian.Uint64(buf)) -} - -func (e *UnknownExtended) MarshalJSON() ([]byte, error) { - t, s := e.GetTypes() - return json.Marshal(struct { - Type ExtendedCommunityAttrType `json:"type"` - Subtype ExtendedCommunityAttrSubType `json:"subtype"` - Value []byte `json:"value"` - }{ - Type: t, - Subtype: s, - Value: e.Value, - }) -} - -func (e *UnknownExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) { - var subType ExtendedCommunityAttrSubType - if len(e.Value) > 0 { - // Use the first byte of value as the sub type - subType = ExtendedCommunityAttrSubType(e.Value[0]) - } - return e.Type, subType -} - -func NewUnknownExtended(typ ExtendedCommunityAttrType, value []byte) *UnknownExtended { - v := make([]byte, 7) - copy(v, value) - return &UnknownExtended{ - Type: typ, - Value: v, - } -} - -type PathAttributeExtendedCommunities struct { - PathAttribute - Value []ExtendedCommunityInterface -} - -func ParseExtended(data []byte) (ExtendedCommunityInterface, error) { - if len(data) < 8 { - return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all extended community bytes are available") - } - attrType := ExtendedCommunityAttrType(data[0]) - subtype := ExtendedCommunityAttrSubType(data[1]) - transitive := false - switch attrType { - case EC_TYPE_TRANSITIVE_TWO_OCTET_AS_SPECIFIC: - transitive = true - fallthrough - case EC_TYPE_NON_TRANSITIVE_TWO_OCTET_AS_SPECIFIC: - as := binary.BigEndian.Uint16(data[2:4]) - localAdmin := binary.BigEndian.Uint32(data[4:8]) - return NewTwoOctetAsSpecificExtended(subtype, as, localAdmin, transitive), nil - case EC_TYPE_TRANSITIVE_IP4_SPECIFIC: - transitive = true - fallthrough - case EC_TYPE_NON_TRANSITIVE_IP4_SPECIFIC: - ipv4 := net.IP(data[2:6]).String() - localAdmin := binary.BigEndian.Uint16(data[6:8]) - return NewIPv4AddressSpecificExtended(subtype, ipv4, localAdmin, transitive), nil - case EC_TYPE_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC: - transitive = true - fallthrough - case EC_TYPE_NON_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC: - as := binary.BigEndian.Uint32(data[2:6]) - localAdmin := binary.BigEndian.Uint16(data[6:8]) - return NewFourOctetAsSpecificExtended(subtype, as, localAdmin, transitive), nil - case EC_TYPE_TRANSITIVE_OPAQUE: - transitive = true - fallthrough - case EC_TYPE_NON_TRANSITIVE_OPAQUE: - return parseOpaqueExtended(data) - case EC_TYPE_EVPN: - return parseEvpnExtended(data) - case EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL, EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2, EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3: - return parseFlowSpecExtended(data) - default: - return &UnknownExtended{ - Type: ExtendedCommunityAttrType(data[0]), - Value: data[1:8], - }, nil - } -} - -func (p *PathAttributeExtendedCommunities) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - if p.Length%8 != 0 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - return NewMessageError(eCode, eSubCode, nil, "extendedcommunities length isn't correct") - } - for len(value) >= 8 { - e, err := ParseExtended(value) - if err != nil { - return err - } - p.Value = append(p.Value, e) - value = value[8:] - } - return nil -} - -func (p *PathAttributeExtendedCommunities) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 0) - for _, p := range p.Value { - ebuf, err := p.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, ebuf...) - } - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeExtendedCommunities) String() string { - buf := bytes.NewBuffer(make([]byte, 0, 32)) - for idx, v := range p.Value { - buf.WriteString("[") - buf.WriteString(v.String()) - buf.WriteString("]") - if idx < len(p.Value)-1 { - buf.WriteString(", ") - } - } - return fmt.Sprintf("{Extcomms: %s}", buf.String()) -} - -func (p *PathAttributeExtendedCommunities) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value []ExtendedCommunityInterface `json:"value"` - }{ - Type: p.GetType(), - Value: p.Value, - }) -} - -func NewPathAttributeExtendedCommunities(value []ExtendedCommunityInterface) *PathAttributeExtendedCommunities { - l := len(value) * 8 - t := BGP_ATTR_TYPE_EXTENDED_COMMUNITIES - return &PathAttributeExtendedCommunities{ - PathAttribute: PathAttribute{ - Flags: getPathAttrFlags(t, l), - Type: t, - Length: uint16(l), - }, - Value: value, - } -} - -type PathAttributeAs4Path struct { - PathAttribute - Value []*As4PathParam -} - -func (p *PathAttributeAs4Path) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST) - isAs4, err := validateAsPathValueBytes(value) - if err != nil { - return err - } - - if !isAs4 { - return NewMessageError(eCode, eSubCode, nil, "AS4 PATH param is malformed") - } - - for len(value) > 0 { - tuple := &As4PathParam{} - tuple.DecodeFromBytes(value) - p.Value = append(p.Value, tuple) - if len(value) < tuple.Len() { - return NewMessageError(eCode, eSubCode, nil, "AS4 PATH param is malformed") - } - value = value[tuple.Len():] - } - return nil -} - -func (p *PathAttributeAs4Path) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 0) - for _, v := range p.Value { - vbuf, err := v.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, vbuf...) - } - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeAs4Path) String() string { - params := make([]string, 0, len(p.Value)) - for _, param := range p.Value { - params = append(params, param.String()) - } - return strings.Join(params, " ") -} - -func (p *PathAttributeAs4Path) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value []*As4PathParam `json:"as_paths"` - }{ - Type: p.GetType(), - Value: p.Value, - }) -} - -func NewPathAttributeAs4Path(value []*As4PathParam) *PathAttributeAs4Path { - var l int - for _, v := range value { - l += v.Len() - } - t := BGP_ATTR_TYPE_AS4_PATH - return &PathAttributeAs4Path{ - PathAttribute: PathAttribute{ - Flags: getPathAttrFlags(t, l), - Type: t, - Length: uint16(l), - }, - Value: value, - } -} - -type PathAttributeAs4Aggregator struct { - PathAttribute - Value PathAttributeAggregatorParam -} - -func (p *PathAttributeAs4Aggregator) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - if p.Length != 8 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST) - return NewMessageError(eCode, eSubCode, nil, "AS4 Aggregator length is incorrect") - } - p.Value.AS = binary.BigEndian.Uint32(value[0:4]) - p.Value.Address = value[4:] - return nil -} - -func (p *PathAttributeAs4Aggregator) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 8) - binary.BigEndian.PutUint32(buf[0:], p.Value.AS) - copy(buf[4:], p.Value.Address.To4()) - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeAs4Aggregator) String() string { - return fmt.Sprintf("{As4Aggregator: {AS: %d, Address: %s}}", p.Value.AS, p.Value.Address) -} - -func (p *PathAttributeAs4Aggregator) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - AS uint32 `json:"as"` - Address string `json:"address"` - }{ - Type: p.GetType(), - AS: p.Value.AS, - Address: p.Value.Address.String(), - }) -} - -func NewPathAttributeAs4Aggregator(as uint32, address string) *PathAttributeAs4Aggregator { - t := BGP_ATTR_TYPE_AS4_AGGREGATOR - return &PathAttributeAs4Aggregator{ - PathAttribute: PathAttribute{ - Flags: PathAttrFlags[t], - Type: t, - Length: 8, - }, - Value: PathAttributeAggregatorParam{ - AS: as, - Address: net.ParseIP(address).To4(), - }, - } -} - -type TunnelEncapSubTLVInterface interface { - Len() int - DecodeFromBytes([]byte) error - Serialize() ([]byte, error) - String() string - MarshalJSON() ([]byte, error) -} - -type TunnelEncapSubTLV struct { - Type EncapSubTLVType - Length uint16 -} - -func (t *TunnelEncapSubTLV) Len() int { - if t.Type >= 0x80 { - return 3 + int(t.Length) - } - return 2 + int(t.Length) -} - -func (t *TunnelEncapSubTLV) DecodeFromBytes(data []byte) (value []byte, err error) { - t.Type = EncapSubTLVType(data[0]) - if t.Type >= 0x80 { - t.Length = binary.BigEndian.Uint16(data[1:3]) - data = data[3:] - } else { - t.Length = uint16(data[1]) - data = data[2:] - } - if len(data) < int(t.Length) { - return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all TunnelEncapSubTLV bytes available") - } - return data, nil -} - -func (t *TunnelEncapSubTLV) Serialize(value []byte) (buf []byte, err error) { - t.Length = uint16(len(value)) - if t.Type >= 0x80 { - buf = append(make([]byte, 3), value...) - binary.BigEndian.PutUint16(buf[1:3], t.Length) - } else { - buf = append(make([]byte, 2), value...) - buf[1] = uint8(t.Length) - } - buf[0] = uint8(t.Type) - return buf, nil -} - -type TunnelEncapSubTLVUnknown struct { - TunnelEncapSubTLV - Value []byte -} - -func (t *TunnelEncapSubTLVUnknown) DecodeFromBytes(data []byte) error { - value, err := t.TunnelEncapSubTLV.DecodeFromBytes(data) - if err != nil { - return err - } - t.Value = value - return nil -} - -func (t *TunnelEncapSubTLVUnknown) Serialize() ([]byte, error) { - return t.TunnelEncapSubTLV.Serialize(t.Value) -} - -func (t *TunnelEncapSubTLVUnknown) String() string { - return fmt.Sprintf("{Type: %d, Value: %x}", t.Type, t.Value) -} - -func (t *TunnelEncapSubTLVUnknown) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type EncapSubTLVType `json:"type"` - Value []byte `json:"value"` - }{ - Type: t.Type, - Value: t.Value, - }) -} - -func NewTunnelEncapSubTLVUnknown(typ EncapSubTLVType, value []byte) *TunnelEncapSubTLVUnknown { - return &TunnelEncapSubTLVUnknown{ - TunnelEncapSubTLV: TunnelEncapSubTLV{ - Type: typ, - }, - Value: value, - } -} - -type TunnelEncapSubTLVEncapsulation struct { - TunnelEncapSubTLV - Key uint32 // this represent both SessionID for L2TPv3 case and GRE-key for GRE case (RFC5512 4.) - Cookie []byte -} - -func (t *TunnelEncapSubTLVEncapsulation) DecodeFromBytes(data []byte) error { - value, err := t.TunnelEncapSubTLV.DecodeFromBytes(data) - if err != nil { - return err - } - if t.Length < 4 { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all TunnelEncapSubTLVEncapsulation bytes available") - } - t.Key = binary.BigEndian.Uint32(value[0:4]) - t.Cookie = value[4:] - return nil -} - -func (t *TunnelEncapSubTLVEncapsulation) Serialize() ([]byte, error) { - buf := make([]byte, 4) - binary.BigEndian.PutUint32(buf, t.Key) - buf = append(buf, t.Cookie...) - return t.TunnelEncapSubTLV.Serialize(buf) -} - -func (t *TunnelEncapSubTLVEncapsulation) String() string { - return fmt.Sprintf("{Key: %d, Cookie: %x}", t.Key, t.Cookie) -} - -func (t *TunnelEncapSubTLVEncapsulation) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type EncapSubTLVType `json:"type"` - Key uint32 `json:"key"` - Cookie []byte `json:"cookie"` - }{ - Type: t.Type, - Key: t.Key, - Cookie: t.Cookie, - }) -} - -func NewTunnelEncapSubTLVEncapsulation(key uint32, cookie []byte) *TunnelEncapSubTLVEncapsulation { - return &TunnelEncapSubTLVEncapsulation{ - TunnelEncapSubTLV: TunnelEncapSubTLV{ - Type: ENCAP_SUBTLV_TYPE_ENCAPSULATION, - }, - Key: key, - Cookie: cookie, - } -} - -type TunnelEncapSubTLVProtocol struct { - TunnelEncapSubTLV - Protocol uint16 -} - -func (t *TunnelEncapSubTLVProtocol) DecodeFromBytes(data []byte) error { - value, err := t.TunnelEncapSubTLV.DecodeFromBytes(data) - if err != nil { - return err - } - if t.Length < 2 { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all TunnelEncapSubTLVProtocol bytes available") - } - t.Protocol = binary.BigEndian.Uint16(value[0:2]) - return nil -} - -func (t *TunnelEncapSubTLVProtocol) Serialize() ([]byte, error) { - buf := make([]byte, 2) - binary.BigEndian.PutUint16(buf, t.Protocol) - return t.TunnelEncapSubTLV.Serialize(buf) -} - -func (t *TunnelEncapSubTLVProtocol) String() string { - return fmt.Sprintf("{Protocol: %d}", t.Protocol) -} - -func (t *TunnelEncapSubTLVProtocol) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type EncapSubTLVType `json:"type"` - Protocol uint16 `json:"protocol"` - }{ - Type: t.Type, - Protocol: t.Protocol, - }) -} - -func NewTunnelEncapSubTLVProtocol(protocol uint16) *TunnelEncapSubTLVProtocol { - return &TunnelEncapSubTLVProtocol{ - TunnelEncapSubTLV: TunnelEncapSubTLV{ - Type: ENCAP_SUBTLV_TYPE_PROTOCOL, - }, - Protocol: protocol, - } -} - -type TunnelEncapSubTLVColor struct { - TunnelEncapSubTLV - Color uint32 -} - -func (t *TunnelEncapSubTLVColor) DecodeFromBytes(data []byte) error { - value, err := t.TunnelEncapSubTLV.DecodeFromBytes(data) - if err != nil { - return err - } - if t.Length != 8 { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Invalid TunnelEncapSubTLVColor length") - } - t.Color = binary.BigEndian.Uint32(value[4:8]) - return nil -} - -func (t *TunnelEncapSubTLVColor) Serialize() ([]byte, error) { - buf := make([]byte, 8) - buf[0] = byte(EC_TYPE_TRANSITIVE_OPAQUE) - buf[1] = byte(EC_SUBTYPE_COLOR) - binary.BigEndian.PutUint32(buf[4:8], t.Color) - return t.TunnelEncapSubTLV.Serialize(buf) -} - -func (t *TunnelEncapSubTLVColor) String() string { - return fmt.Sprintf("{Color: %d}", t.Color) -} - -func (t *TunnelEncapSubTLVColor) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type EncapSubTLVType `json:"type"` - Color uint32 `json:"color"` - }{ - Type: t.Type, - Color: t.Color, - }) -} - -func NewTunnelEncapSubTLVColor(color uint32) *TunnelEncapSubTLVColor { - return &TunnelEncapSubTLVColor{ - TunnelEncapSubTLV: TunnelEncapSubTLV{ - Type: ENCAP_SUBTLV_TYPE_COLOR, - }, - Color: color, - } -} - -type TunnelEncapTLV struct { - Type TunnelType - Length uint16 - Value []TunnelEncapSubTLVInterface -} - -func (t *TunnelEncapTLV) Len() int { - var l int - for _, v := range t.Value { - l += v.Len() - } - return 4 + l // Type(2) + Length(2) + Value(variable) -} - -func (t *TunnelEncapTLV) DecodeFromBytes(data []byte) error { - t.Type = TunnelType(binary.BigEndian.Uint16(data[0:2])) - t.Length = binary.BigEndian.Uint16(data[2:4]) - data = data[4:] - if len(data) < int(t.Length) { - return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Not all TunnelEncapTLV bytes available")) - } - value := data[:t.Length] - for len(value) > 2 { - subType := EncapSubTLVType(value[0]) - var subTlv TunnelEncapSubTLVInterface - switch subType { - case ENCAP_SUBTLV_TYPE_ENCAPSULATION: - subTlv = &TunnelEncapSubTLVEncapsulation{} - case ENCAP_SUBTLV_TYPE_PROTOCOL: - subTlv = &TunnelEncapSubTLVProtocol{} - case ENCAP_SUBTLV_TYPE_COLOR: - subTlv = &TunnelEncapSubTLVColor{} - default: - subTlv = &TunnelEncapSubTLVUnknown{ - TunnelEncapSubTLV: TunnelEncapSubTLV{ - Type: subType, - }, - } - } - err := subTlv.DecodeFromBytes(value) - if err != nil { - return err - } - t.Value = append(t.Value, subTlv) - value = value[subTlv.Len():] - } - return nil -} - -func (p *TunnelEncapTLV) Serialize() ([]byte, error) { - buf := make([]byte, 4) - for _, t := range p.Value { - tBuf, err := t.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, tBuf...) - } - binary.BigEndian.PutUint16(buf, uint16(p.Type)) - binary.BigEndian.PutUint16(buf[2:], uint16(len(buf)-4)) - return buf, nil -} - -func (p *TunnelEncapTLV) String() string { - tlvList := make([]string, len(p.Value)) - for i, v := range p.Value { - tlvList[i] = v.String() - } - return fmt.Sprintf("{%s: %s}", p.Type, strings.Join(tlvList, ", ")) -} - -func (p *TunnelEncapTLV) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type TunnelType `json:"type"` - Value []TunnelEncapSubTLVInterface `json:"value"` - }{ - Type: p.Type, - Value: p.Value, - }) -} - -func NewTunnelEncapTLV(typ TunnelType, value []TunnelEncapSubTLVInterface) *TunnelEncapTLV { - return &TunnelEncapTLV{ - Type: typ, - Value: value, - } -} - -type PathAttributeTunnelEncap struct { - PathAttribute - Value []*TunnelEncapTLV -} - -func (p *PathAttributeTunnelEncap) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - for len(value) > 4 { - tlv := &TunnelEncapTLV{} - err = tlv.DecodeFromBytes(value) - if err != nil { - return err - } - p.Value = append(p.Value, tlv) - value = value[4+tlv.Length:] - } - return nil -} - -func (p *PathAttributeTunnelEncap) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 0) - for _, t := range p.Value { - bbuf, err := t.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, bbuf...) - } - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeTunnelEncap) String() string { - tlvList := make([]string, len(p.Value)) - for i, v := range p.Value { - tlvList[i] = v.String() - } - return fmt.Sprintf("{TunnelEncap: %s}", strings.Join(tlvList, ", ")) -} - -func (p *PathAttributeTunnelEncap) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value []*TunnelEncapTLV `json:"value"` - }{ - Type: p.Type, - Value: p.Value, - }) -} - -func NewPathAttributeTunnelEncap(value []*TunnelEncapTLV) *PathAttributeTunnelEncap { - var l int - for _, v := range value { - l += v.Len() - } - t := BGP_ATTR_TYPE_TUNNEL_ENCAP - return &PathAttributeTunnelEncap{ - PathAttribute: PathAttribute{ - Flags: getPathAttrFlags(t, l), - Type: t, - Length: uint16(l), - }, - Value: value, - } -} - -type PmsiTunnelIDInterface interface { - Len() int - Serialize() ([]byte, error) - String() string -} - -type DefaultPmsiTunnelID struct { - Value []byte -} - -func (i *DefaultPmsiTunnelID) Len() int { - return len(i.Value) -} - -func (i *DefaultPmsiTunnelID) Serialize() ([]byte, error) { - return i.Value, nil -} - -func (i *DefaultPmsiTunnelID) String() string { - return string(i.Value) -} - -func NewDefaultPmsiTunnelID(value []byte) *DefaultPmsiTunnelID { - return &DefaultPmsiTunnelID{ - Value: value, - } -} - -type IngressReplTunnelID struct { - Value net.IP -} - -func (i *IngressReplTunnelID) Len() int { - return len(i.Value) -} - -func (i *IngressReplTunnelID) Serialize() ([]byte, error) { - if i.Value.To4() != nil { - return []byte(i.Value.To4()), nil - } - return []byte(i.Value), nil -} - -func (i *IngressReplTunnelID) String() string { - return i.Value.String() -} - -func NewIngressReplTunnelID(value string) *IngressReplTunnelID { - ip := net.ParseIP(value) - if ip == nil { - return nil - } - return &IngressReplTunnelID{ - Value: ip, - } -} - -type PathAttributePmsiTunnel struct { - PathAttribute - IsLeafInfoRequired bool - TunnelType PmsiTunnelType - Label uint32 - TunnelID PmsiTunnelIDInterface -} - -func (p *PathAttributePmsiTunnel) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - if p.Length < 5 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST) - return NewMessageError(eCode, eSubCode, nil, "PMSI Tunnel length is incorrect") - } - - if (value[0] & 0x01) > 0 { - p.IsLeafInfoRequired = true - } - p.TunnelType = PmsiTunnelType(value[1]) - if p.Label, err = labelDecode(value[2:5]); err != nil { - return err - } - - switch p.TunnelType { - case PMSI_TUNNEL_TYPE_INGRESS_REPL: - p.TunnelID = &IngressReplTunnelID{net.IP(value[5:])} - default: - p.TunnelID = &DefaultPmsiTunnelID{value[5:]} - } - return nil -} - -func (p *PathAttributePmsiTunnel) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 2) - if p.IsLeafInfoRequired { - buf[0] = 0x01 - } - buf[1] = byte(p.TunnelType) - tbuf, err := labelSerialize(p.Label) - if err != nil { - return nil, err - } - buf = append(buf, tbuf...) - tbuf, err = p.TunnelID.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, tbuf...) - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributePmsiTunnel) String() string { - buf := bytes.NewBuffer(make([]byte, 0, 32)) - buf.WriteString(fmt.Sprintf("{Pmsi: type: %s,", p.TunnelType)) - if p.IsLeafInfoRequired { - buf.WriteString(" leaf-info-required,") - } - buf.WriteString(fmt.Sprintf(" label: %d, tunnel-id: %s}", p.Label, p.TunnelID)) - return buf.String() -} - -func (p *PathAttributePmsiTunnel) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - IsLeafInfoRequired bool `json:"is-leaf-info-required"` - TunnelType uint8 `json:"tunnel-type"` - Label uint32 `json:"label"` - TunnelID string `json:"tunnel-id"` - }{ - Type: p.Type, - IsLeafInfoRequired: p.IsLeafInfoRequired, - TunnelType: uint8(p.TunnelType), - Label: p.Label, - TunnelID: p.TunnelID.String(), - }) -} - -func NewPathAttributePmsiTunnel(typ PmsiTunnelType, isLeafInfoRequired bool, label uint32, id PmsiTunnelIDInterface) *PathAttributePmsiTunnel { - // Flags(1) + TunnelType(1) + Label(3) + TunnelID(variable) - l := 5 + id.Len() - t := BGP_ATTR_TYPE_PMSI_TUNNEL - return &PathAttributePmsiTunnel{ - PathAttribute: PathAttribute{ - Flags: getPathAttrFlags(t, l), - Type: t, - Length: uint16(l), - }, - IsLeafInfoRequired: isLeafInfoRequired, - TunnelType: typ, - Label: label, - TunnelID: id, - } -} - -func ParsePmsiTunnel(args []string) (*PathAttributePmsiTunnel, error) { - // Format: - // "<type>" ["leaf-info-required"] "<label>" "<tunnel-id>" - if len(args) < 3 { - return nil, fmt.Errorf("invalid pmsi tunnel arguments: %s", args) - } - - pmsi := NewPathAttributePmsiTunnel(0, false, 0, nil) - - switch args[0] { - case "ingress-repl": - pmsi.TunnelType = PMSI_TUNNEL_TYPE_INGRESS_REPL - default: - typ, err := strconv.ParseUint(args[0], 10, 8) - if err != nil { - return nil, fmt.Errorf("invalid pmsi tunnel type: %s", args[0]) - } - pmsi.TunnelType = PmsiTunnelType(typ) - } - - indx := 1 - if args[indx] == "leaf-info-required" { - pmsi.IsLeafInfoRequired = true - indx++ - } - - label, err := strconv.ParseUint(args[indx], 10, 32) - if err != nil { - return nil, fmt.Errorf("invalid pmsi tunnel label: %s", args[indx]) - } - pmsi.Label = uint32(label) - indx++ - - switch pmsi.TunnelType { - case PMSI_TUNNEL_TYPE_INGRESS_REPL: - ip := net.ParseIP(args[indx]) - if ip == nil { - return nil, fmt.Errorf("invalid pmsi tunnel identifier: %s", args[indx]) - } - pmsi.TunnelID = &IngressReplTunnelID{Value: ip} - default: - pmsi.TunnelID = &DefaultPmsiTunnelID{Value: []byte(args[indx])} - } - - return pmsi, nil -} - -type PathAttributeIP6ExtendedCommunities struct { - PathAttribute - Value []ExtendedCommunityInterface -} - -func ParseIP6Extended(data []byte) (ExtendedCommunityInterface, error) { - if len(data) < 8 { - return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all extended community bytes are available") - } - attrType := ExtendedCommunityAttrType(data[0]) - subtype := ExtendedCommunityAttrSubType(data[1]) - transitive := false - switch attrType { - case EC_TYPE_TRANSITIVE_IP6_SPECIFIC: - transitive = true - fallthrough - case EC_TYPE_NON_TRANSITIVE_IP6_SPECIFIC: - ipv6 := net.IP(data[2:18]).String() - localAdmin := binary.BigEndian.Uint16(data[18:20]) - return NewIPv6AddressSpecificExtended(subtype, ipv6, localAdmin, transitive), nil - case EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL: - return parseIP6FlowSpecExtended(data) - default: - return &UnknownExtended{ - Type: ExtendedCommunityAttrType(data[0]), - Value: data[1:8], - }, nil - } -} - -func (p *PathAttributeIP6ExtendedCommunities) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data) - if err != nil { - return err - } - if p.Length%20 != 0 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - return NewMessageError(eCode, eSubCode, nil, "extendedcommunities length isn't correct") - } - for len(value) >= 20 { - e, err := ParseIP6Extended(value) - if err != nil { - return err - } - p.Value = append(p.Value, e) - value = value[20:] - } - return nil -} - -func (p *PathAttributeIP6ExtendedCommunities) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 0) - for _, p := range p.Value { - ebuf, err := p.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, ebuf...) - } - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeIP6ExtendedCommunities) String() string { - var buf []string - for _, v := range p.Value { - buf = append(buf, fmt.Sprintf("[%s]", v.String())) - } - return fmt.Sprintf("{Extcomms: %s}", strings.Join(buf, ",")) -} - -func (p *PathAttributeIP6ExtendedCommunities) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value []ExtendedCommunityInterface `json:"value"` - }{ - Type: p.GetType(), - Value: p.Value, - }) -} - -func NewPathAttributeIP6ExtendedCommunities(value []ExtendedCommunityInterface) *PathAttributeIP6ExtendedCommunities { - l := len(value) * 20 - t := BGP_ATTR_TYPE_IP6_EXTENDED_COMMUNITIES - return &PathAttributeIP6ExtendedCommunities{ - PathAttribute: PathAttribute{ - Flags: getPathAttrFlags(t, l), - Type: t, - Length: uint16(l), - }, - Value: value, - } -} - -type AigpTLVType uint8 - -const ( - AIGP_TLV_UNKNOWN AigpTLVType = iota - AIGP_TLV_IGP_METRIC -) - -type AigpTLVInterface interface { - Serialize() ([]byte, error) - String() string - MarshalJSON() ([]byte, error) - Type() AigpTLVType - Len() int -} - -type AigpTLVDefault struct { - typ AigpTLVType - Value []byte -} - -func (t *AigpTLVDefault) Serialize() ([]byte, error) { - buf := make([]byte, 3+len(t.Value)) - buf[0] = uint8(t.Type()) - binary.BigEndian.PutUint16(buf[1:], uint16(3+len(t.Value))) - copy(buf[3:], t.Value) - return buf, nil -} - -func (t *AigpTLVDefault) String() string { - return fmt.Sprintf("{Type: %d, Value: %v}", t.Type(), t.Value) -} - -func (t *AigpTLVDefault) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type AigpTLVType `json:"type"` - Value []byte `json:"value"` - }{ - Type: t.Type(), - Value: t.Value, - }) -} - -func (t *AigpTLVDefault) Type() AigpTLVType { - return t.typ -} - -func (t *AigpTLVDefault) Len() int { - return 3 + len(t.Value) // Type(1) + Length(2) + Value(variable) -} - -func NewAigpTLVDefault(typ AigpTLVType, value []byte) *AigpTLVDefault { - return &AigpTLVDefault{ - typ: typ, - Value: value, - } -} - -type AigpTLVIgpMetric struct { - Metric uint64 -} - -func (t *AigpTLVIgpMetric) Serialize() ([]byte, error) { - buf := make([]byte, 11) - buf[0] = uint8(AIGP_TLV_IGP_METRIC) - binary.BigEndian.PutUint16(buf[1:], uint16(11)) - binary.BigEndian.PutUint64(buf[3:], t.Metric) - return buf, nil -} - -func (t *AigpTLVIgpMetric) String() string { - return fmt.Sprintf("{Metric: %d}", t.Metric) -} - -func (t *AigpTLVIgpMetric) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type AigpTLVType `json:"type"` - Metric uint64 `json:"metric"` - }{ - Type: AIGP_TLV_IGP_METRIC, - Metric: t.Metric, - }) -} - -func NewAigpTLVIgpMetric(metric uint64) *AigpTLVIgpMetric { - return &AigpTLVIgpMetric{ - Metric: metric, - } -} - -func (t *AigpTLVIgpMetric) Type() AigpTLVType { - return AIGP_TLV_IGP_METRIC -} - -func (t *AigpTLVIgpMetric) Len() int { - return 11 -} - -type PathAttributeAigp struct { - PathAttribute - Values []AigpTLVInterface -} - -func (p *PathAttributeAigp) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data, options...) - if err != nil { - return err - } - for len(value) > 3 { - typ := value[0] - length := binary.BigEndian.Uint16(value[1:3]) - if len(value) < int(length) { - break - } - v := value[3:length] - switch AigpTLVType(typ) { - case AIGP_TLV_IGP_METRIC: - if len(v) < 8 { - break - } - metric := binary.BigEndian.Uint64(v) - p.Values = append(p.Values, NewAigpTLVIgpMetric(metric)) - default: - p.Values = append(p.Values, NewAigpTLVDefault(AigpTLVType(typ), v)) - } - value = value[length:] - } - if len(value) != 0 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST) - return NewMessageError(eCode, eSubCode, nil, "Aigp length is incorrect") - } - return nil -} - -func (p *PathAttributeAigp) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 0) - for _, t := range p.Values { - bbuf, err := t.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, bbuf...) - } - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeAigp) String() string { - buf := bytes.NewBuffer(make([]byte, 0, 32)) - buf.WriteString("{Aigp: [") - for _, v := range p.Values { - buf.WriteString(v.String()) - } - buf.WriteString("]}") - return buf.String() -} - -func (p *PathAttributeAigp) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value []AigpTLVInterface `json:"value"` - }{ - Type: p.GetType(), - Value: p.Values, - }) -} - -func NewPathAttributeAigp(values []AigpTLVInterface) *PathAttributeAigp { - var l int - for _, v := range values { - l += v.Len() - } - t := BGP_ATTR_TYPE_AIGP - return &PathAttributeAigp{ - PathAttribute: PathAttribute{ - Flags: getPathAttrFlags(t, l), - Type: t, - Length: uint16(l), - }, - Values: values, - } -} - -type LargeCommunity struct { - ASN uint32 - LocalData1 uint32 - LocalData2 uint32 -} - -func (c *LargeCommunity) Serialize() ([]byte, error) { - buf := make([]byte, 12) - binary.BigEndian.PutUint32(buf, c.ASN) - binary.BigEndian.PutUint32(buf[4:], c.LocalData1) - binary.BigEndian.PutUint32(buf[8:], c.LocalData2) - return buf, nil -} - -func (c *LargeCommunity) String() string { - return fmt.Sprintf("%d:%d:%d", c.ASN, c.LocalData1, c.LocalData2) -} - -func NewLargeCommunity(asn, data1, data2 uint32) *LargeCommunity { - return &LargeCommunity{ - ASN: asn, - LocalData1: data1, - LocalData2: data2, - } -} - -func ParseLargeCommunity(value string) (*LargeCommunity, error) { - elems := strings.Split(value, ":") - if len(elems) != 3 { - return nil, fmt.Errorf("invalid large community format") - } - v := make([]uint32, 0, 3) - for _, elem := range elems { - e, err := strconv.ParseUint(elem, 10, 32) - if err != nil { - return nil, fmt.Errorf("invalid large community format") - } - v = append(v, uint32(e)) - } - return NewLargeCommunity(v[0], v[1], v[2]), nil -} - -type PathAttributeLargeCommunities struct { - PathAttribute - Values []*LargeCommunity -} - -func (p *PathAttributeLargeCommunities) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data) - if err != nil { - return err - } - if p.Length%12 != 0 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - return NewMessageError(eCode, eSubCode, nil, "large communities length isn't correct") - } - p.Values = make([]*LargeCommunity, 0, p.Length/12) - for len(value) >= 12 { - asn := binary.BigEndian.Uint32(value[:4]) - data1 := binary.BigEndian.Uint32(value[4:8]) - data2 := binary.BigEndian.Uint32(value[8:12]) - p.Values = append(p.Values, NewLargeCommunity(asn, data1, data2)) - value = value[12:] - } - return nil -} - -func (p *PathAttributeLargeCommunities) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 0, len(p.Values)*12) - for _, t := range p.Values { - bbuf, err := t.Serialize() - if err != nil { - return nil, err - } - buf = append(buf, bbuf...) - } - return p.PathAttribute.Serialize(buf, options...) -} - -func (p *PathAttributeLargeCommunities) String() string { - buf := bytes.NewBuffer(make([]byte, 0, 32)) - buf.WriteString("{LargeCommunity: [ ") - ss := []string{} - for _, v := range p.Values { - ss = append(ss, v.String()) - } - buf.WriteString(strings.Join(ss, ", ")) - buf.WriteString("]}") - return buf.String() -} - -func (p *PathAttributeLargeCommunities) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Type BGPAttrType `json:"type"` - Value []*LargeCommunity `json:"value"` - }{ - Type: p.GetType(), - Value: p.Values, - }) -} - -func NewPathAttributeLargeCommunities(values []*LargeCommunity) *PathAttributeLargeCommunities { - l := len(values) * 12 - t := BGP_ATTR_TYPE_LARGE_COMMUNITY - return &PathAttributeLargeCommunities{ - PathAttribute: PathAttribute{ - Flags: getPathAttrFlags(t, l), - Type: t, - Length: uint16(l), - }, - Values: values, - } -} - -type PathAttributeUnknown struct { - PathAttribute - Value []byte -} - -func (p *PathAttributeUnknown) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - value, err := p.PathAttribute.DecodeFromBytes(data) - if err != nil { - return err - } - p.Value = value - return nil -} - -func (p *PathAttributeUnknown) Serialize(options ...*MarshallingOption) ([]byte, error) { - return p.PathAttribute.Serialize(p.Value, options...) -} - -func (p *PathAttributeUnknown) String() string { - return fmt.Sprintf("{Flags: %s, Type: %s, Value: %s}", p.Flags, p.Type, p.Value) -} - -func (p *PathAttributeUnknown) MarshalJSON() ([]byte, error) { - return json.Marshal(struct { - Flags BGPAttrFlag `json:"flags"` - Type BGPAttrType `json:"type"` - Value []byte `json:"value"` - }{ - Flags: p.GetFlags(), - Type: p.GetType(), - Value: p.Value, - }) -} - -func NewPathAttributeUnknown(flags BGPAttrFlag, typ BGPAttrType, value []byte) *PathAttributeUnknown { - l := len(value) - if l > 255 { - flags |= BGP_ATTR_FLAG_EXTENDED_LENGTH - } - return &PathAttributeUnknown{ - PathAttribute: PathAttribute{ - Flags: flags, - Type: typ, - Length: uint16(l), - }, - Value: value, - } -} - -func GetPathAttribute(data []byte) (PathAttributeInterface, error) { - if len(data) < 2 { - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR) - return nil, NewMessageError(eCode, eSubCode, data, "attribute type length is short") - } - switch BGPAttrType(data[1]) { - case BGP_ATTR_TYPE_ORIGIN: - return &PathAttributeOrigin{}, nil - case BGP_ATTR_TYPE_AS_PATH: - return &PathAttributeAsPath{}, nil - case BGP_ATTR_TYPE_NEXT_HOP: - return &PathAttributeNextHop{}, nil - case BGP_ATTR_TYPE_MULTI_EXIT_DISC: - return &PathAttributeMultiExitDisc{}, nil - case BGP_ATTR_TYPE_LOCAL_PREF: - return &PathAttributeLocalPref{}, nil - case BGP_ATTR_TYPE_ATOMIC_AGGREGATE: - return &PathAttributeAtomicAggregate{}, nil - case BGP_ATTR_TYPE_AGGREGATOR: - return &PathAttributeAggregator{}, nil - case BGP_ATTR_TYPE_COMMUNITIES: - return &PathAttributeCommunities{}, nil - case BGP_ATTR_TYPE_ORIGINATOR_ID: - return &PathAttributeOriginatorId{}, nil - case BGP_ATTR_TYPE_CLUSTER_LIST: - return &PathAttributeClusterList{}, nil - case BGP_ATTR_TYPE_MP_REACH_NLRI: - return &PathAttributeMpReachNLRI{}, nil - case BGP_ATTR_TYPE_MP_UNREACH_NLRI: - return &PathAttributeMpUnreachNLRI{}, nil - case BGP_ATTR_TYPE_EXTENDED_COMMUNITIES: - return &PathAttributeExtendedCommunities{}, nil - case BGP_ATTR_TYPE_AS4_PATH: - return &PathAttributeAs4Path{}, nil - case BGP_ATTR_TYPE_AS4_AGGREGATOR: - return &PathAttributeAs4Aggregator{}, nil - case BGP_ATTR_TYPE_TUNNEL_ENCAP: - return &PathAttributeTunnelEncap{}, nil - case BGP_ATTR_TYPE_PMSI_TUNNEL: - return &PathAttributePmsiTunnel{}, nil - case BGP_ATTR_TYPE_IP6_EXTENDED_COMMUNITIES: - return &PathAttributeIP6ExtendedCommunities{}, nil - case BGP_ATTR_TYPE_AIGP: - return &PathAttributeAigp{}, nil - case BGP_ATTR_TYPE_LARGE_COMMUNITY: - return &PathAttributeLargeCommunities{}, nil - } - return &PathAttributeUnknown{}, nil -} - -type BGPUpdate struct { - WithdrawnRoutesLen uint16 - WithdrawnRoutes []*IPAddrPrefix - TotalPathAttributeLen uint16 - PathAttributes []PathAttributeInterface - NLRI []*IPAddrPrefix -} - -func (msg *BGPUpdate) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - var strongestError error - - // cache error codes - eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR) - eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST) - - // check withdrawn route length - if len(data) < 2 { - return NewMessageError(eCode, eSubCode, nil, "message length isn't enough for withdrawn route length") - } - - msg.WithdrawnRoutesLen = binary.BigEndian.Uint16(data[0:2]) - data = data[2:] - - // check withdrawn route - if len(data) < int(msg.WithdrawnRoutesLen) { - return NewMessageError(eCode, eSubCode, nil, "withdrawn route length exceeds message length") - } - - addpathLen := 0 - if IsAddPathEnabled(true, RF_IPv4_UC, options) { - addpathLen = 4 - } - - msg.WithdrawnRoutes = make([]*IPAddrPrefix, 0, msg.WithdrawnRoutesLen) - for routelen := msg.WithdrawnRoutesLen; routelen > 0; { - w := &IPAddrPrefix{} - err := w.DecodeFromBytes(data, options...) - if err != nil { - return err - } - routelen -= uint16(w.Len(options...) + addpathLen) - if len(data) < w.Len(options...)+addpathLen { - return NewMessageError(eCode, eSubCode, nil, "Withdrawn route length is short") - } - data = data[w.Len(options...)+addpathLen:] - msg.WithdrawnRoutes = append(msg.WithdrawnRoutes, w) - } - - // check path total attribute length - if len(data) < 2 { - return NewMessageError(eCode, eSubCode, nil, "message length isn't enough for path total attribute length") - } - - msg.TotalPathAttributeLen = binary.BigEndian.Uint16(data[0:2]) - data = data[2:] - - // check path attribute - if len(data) < int(msg.TotalPathAttributeLen) { - return NewMessageError(eCode, eSubCode, nil, "path total attribute length exceeds message length") - } - - msg.PathAttributes = []PathAttributeInterface{} - for pathlen := msg.TotalPathAttributeLen; pathlen > 0; { - var e error - if pathlen < 3 { - e = NewMessageErrorWithErrorHandling( - eCode, BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR, data, ERROR_HANDLING_TREAT_AS_WITHDRAW, nil, "insufficient data to decode") - if e.(*MessageError).Stronger(strongestError) { - strongestError = e - } - data = data[pathlen:] - break - } - p, err := GetPathAttribute(data) - if err != nil { - return err - } - - err = p.DecodeFromBytes(data, options...) - if err != nil { - e = err.(*MessageError) - if e.(*MessageError).SubTypeCode == BGP_ERROR_SUB_ATTRIBUTE_FLAGS_ERROR { - e.(*MessageError).ErrorHandling = ERROR_HANDLING_TREAT_AS_WITHDRAW - } else { - e.(*MessageError).ErrorHandling = getErrorHandlingFromPathAttribute(p.GetType()) - e.(*MessageError).ErrorAttribute = &p - } - if e.(*MessageError).Stronger(strongestError) { - strongestError = e - } - } - pathlen -= uint16(p.Len(options...)) - if len(data) < p.Len(options...) { - e = NewMessageErrorWithErrorHandling( - eCode, BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR, data, ERROR_HANDLING_TREAT_AS_WITHDRAW, nil, "attribute length is short") - if e.(*MessageError).Stronger(strongestError) { - strongestError = e - } - } - data = data[p.Len(options...):] - if e == nil || e.(*MessageError).ErrorHandling != ERROR_HANDLING_ATTRIBUTE_DISCARD { - msg.PathAttributes = append(msg.PathAttributes, p) - } - } - - msg.NLRI = make([]*IPAddrPrefix, 0) - for restlen := len(data); restlen > 0; { - n := &IPAddrPrefix{} - err := n.DecodeFromBytes(data, options...) - if err != nil { - return err - } - restlen -= n.Len(options...) + addpathLen - if len(data) < n.Len(options...)+addpathLen { - return NewMessageError(eCode, BGP_ERROR_SUB_INVALID_NETWORK_FIELD, nil, "NLRI length is short") - } - if n.Len(options...) > 32 { - return NewMessageError(eCode, BGP_ERROR_SUB_INVALID_NETWORK_FIELD, nil, "NLRI length is too long") - } - data = data[n.Len(options...)+addpathLen:] - msg.NLRI = append(msg.NLRI, n) - } - - return strongestError -} - -func (msg *BGPUpdate) Serialize(options ...*MarshallingOption) ([]byte, error) { - wbuf := make([]byte, 2) - for _, w := range msg.WithdrawnRoutes { - onewbuf, err := w.Serialize(options...) - if err != nil { - return nil, err - } - wbuf = append(wbuf, onewbuf...) - } - msg.WithdrawnRoutesLen = uint16(len(wbuf) - 2) - binary.BigEndian.PutUint16(wbuf, msg.WithdrawnRoutesLen) - - pbuf := make([]byte, 2) - for _, p := range msg.PathAttributes { - onepbuf, err := p.Serialize(options...) - if err != nil { - return nil, err - } - pbuf = append(pbuf, onepbuf...) - } - msg.TotalPathAttributeLen = uint16(len(pbuf) - 2) - binary.BigEndian.PutUint16(pbuf, msg.TotalPathAttributeLen) - - buf := append(wbuf, pbuf...) - for _, n := range msg.NLRI { - nbuf, err := n.Serialize(options...) - if err != nil { - return nil, err - } - buf = append(buf, nbuf...) - } - return buf, nil -} - -func (msg *BGPUpdate) IsEndOfRib() (bool, RouteFamily) { - if len(msg.WithdrawnRoutes) == 0 && len(msg.NLRI) == 0 { - if len(msg.PathAttributes) == 0 { - return true, RF_IPv4_UC - } else if len(msg.PathAttributes) == 1 && msg.PathAttributes[0].GetType() == BGP_ATTR_TYPE_MP_UNREACH_NLRI { - unreach := msg.PathAttributes[0].(*PathAttributeMpUnreachNLRI) - if len(unreach.Value) == 0 { - return true, AfiSafiToRouteFamily(unreach.AFI, unreach.SAFI) - } - } - } - return false, RouteFamily(0) -} - -func TreatAsWithdraw(msg *BGPUpdate) *BGPUpdate { - withdraw := &BGPUpdate{ - WithdrawnRoutesLen: 0, - WithdrawnRoutes: []*IPAddrPrefix{}, - TotalPathAttributeLen: 0, - PathAttributes: make([]PathAttributeInterface, 0, len(msg.PathAttributes)), - NLRI: []*IPAddrPrefix{}, - } - withdraw.WithdrawnRoutes = append(msg.WithdrawnRoutes, msg.NLRI...) - var unreach []AddrPrefixInterface - - for _, p := range msg.PathAttributes { - switch nlri := p.(type) { - case *PathAttributeMpReachNLRI: - unreach = append(unreach, nlri.Value...) - case *PathAttributeMpUnreachNLRI: - unreach = append(unreach, nlri.Value...) - } - } - if len(unreach) != 0 { - withdraw.PathAttributes = append(withdraw.PathAttributes, NewPathAttributeMpUnreachNLRI(unreach)) - } - return withdraw -} - -func NewBGPUpdateMessage(withdrawnRoutes []*IPAddrPrefix, pathattrs []PathAttributeInterface, nlri []*IPAddrPrefix) *BGPMessage { - return &BGPMessage{ - Header: BGPHeader{Type: BGP_MSG_UPDATE}, - Body: &BGPUpdate{0, withdrawnRoutes, 0, pathattrs, nlri}, - } -} - -func NewEndOfRib(family RouteFamily) *BGPMessage { - if family == RF_IPv4_UC { - return NewBGPUpdateMessage(nil, nil, nil) - } else { - afi, safi := RouteFamilyToAfiSafi(family) - t := BGP_ATTR_TYPE_MP_UNREACH_NLRI - unreach := &PathAttributeMpUnreachNLRI{ - PathAttribute: PathAttribute{ - Flags: PathAttrFlags[t], - Type: t, - }, - AFI: afi, - SAFI: safi, - } - return NewBGPUpdateMessage(nil, []PathAttributeInterface{unreach}, nil) - } -} - -type BGPNotification struct { - ErrorCode uint8 - ErrorSubcode uint8 - Data []byte -} - -func (msg *BGPNotification) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - if len(data) < 2 { - return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "Not all Notificaiton bytes available") - } - msg.ErrorCode = data[0] - msg.ErrorSubcode = data[1] - if len(data) > 2 { - msg.Data = data[2:] - } - return nil -} - -func (msg *BGPNotification) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 2) - buf[0] = msg.ErrorCode - buf[1] = msg.ErrorSubcode - buf = append(buf, msg.Data...) - return buf, nil -} - -func NewBGPNotificationMessage(errcode uint8, errsubcode uint8, data []byte) *BGPMessage { - return &BGPMessage{ - Header: BGPHeader{Type: BGP_MSG_NOTIFICATION}, - Body: &BGPNotification{errcode, errsubcode, data}, - } -} - -type BGPKeepAlive struct { -} - -func (msg *BGPKeepAlive) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - return nil -} - -func (msg *BGPKeepAlive) Serialize(options ...*MarshallingOption) ([]byte, error) { - return nil, nil -} - -func NewBGPKeepAliveMessage() *BGPMessage { - return &BGPMessage{ - Header: BGPHeader{Len: 19, Type: BGP_MSG_KEEPALIVE}, - Body: &BGPKeepAlive{}, - } -} - -type BGPRouteRefresh struct { - AFI uint16 - Demarcation uint8 - SAFI uint8 -} - -func (msg *BGPRouteRefresh) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - if len(data) < 4 { - return NewMessageError(BGP_ERROR_ROUTE_REFRESH_MESSAGE_ERROR, BGP_ERROR_SUB_INVALID_MESSAGE_LENGTH, nil, "Not all RouteRefresh bytes available") - } - msg.AFI = binary.BigEndian.Uint16(data[0:2]) - msg.Demarcation = data[2] - msg.SAFI = data[3] - return nil -} - -func (msg *BGPRouteRefresh) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 4) - binary.BigEndian.PutUint16(buf[0:2], msg.AFI) - buf[2] = msg.Demarcation - buf[3] = msg.SAFI - return buf, nil -} - -func NewBGPRouteRefreshMessage(afi uint16, demarcation uint8, safi uint8) *BGPMessage { - return &BGPMessage{ - Header: BGPHeader{Type: BGP_MSG_ROUTE_REFRESH}, - Body: &BGPRouteRefresh{afi, demarcation, safi}, - } -} - -type BGPBody interface { - DecodeFromBytes([]byte, ...*MarshallingOption) error - Serialize(...*MarshallingOption) ([]byte, error) -} - -const ( - BGP_HEADER_LENGTH = 19 - BGP_MAX_MESSAGE_LENGTH = 4096 -) - -type BGPHeader struct { - Marker []byte - Len uint16 - Type uint8 -} - -func (msg *BGPHeader) DecodeFromBytes(data []byte, options ...*MarshallingOption) error { - // minimum BGP message length - if uint16(len(data)) < BGP_HEADER_LENGTH { - return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "not all BGP message header") - } - - msg.Len = binary.BigEndian.Uint16(data[16:18]) - if int(msg.Len) < BGP_HEADER_LENGTH { - return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "unknown message type") - } - - msg.Type = data[18] - return nil -} - -func (msg *BGPHeader) Serialize(options ...*MarshallingOption) ([]byte, error) { - buf := make([]byte, 19) - for i := range buf[:16] { - buf[i] = 0xff - } - binary.BigEndian.PutUint16(buf[16:18], msg.Len) - buf[18] = msg.Type - return buf, nil -} - -type BGPMessage struct { - Header BGPHeader - Body BGPBody -} - -func parseBody(h *BGPHeader, data []byte, options ...*MarshallingOption) (*BGPMessage, error) { - if len(data) < int(h.Len)-BGP_HEADER_LENGTH { - return nil, NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "Not all BGP message bytes available") - } - msg := &BGPMessage{Header: *h} - - switch msg.Header.Type { - case BGP_MSG_OPEN: - msg.Body = &BGPOpen{} - case BGP_MSG_UPDATE: - msg.Body = &BGPUpdate{} - case BGP_MSG_NOTIFICATION: - msg.Body = &BGPNotification{} - case BGP_MSG_KEEPALIVE: - msg.Body = &BGPKeepAlive{} - case BGP_MSG_ROUTE_REFRESH: - msg.Body = &BGPRouteRefresh{} - default: - return nil, NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_TYPE, nil, "unknown message type") - } - err := msg.Body.DecodeFromBytes(data, options...) - return msg, err -} - -func ParseBGPMessage(data []byte, options ...*MarshallingOption) (*BGPMessage, error) { - h := &BGPHeader{} - err := h.DecodeFromBytes(data, options...) - if err != nil { - return nil, err - } - - if int(h.Len) > len(data) { - return nil, NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "unknown message type") - } - - return parseBody(h, data[19:h.Len], options...) -} - -func ParseBGPBody(h *BGPHeader, data []byte, options ...*MarshallingOption) (*BGPMessage, error) { - return parseBody(h, data, options...) -} - -func (msg *BGPMessage) Serialize(options ...*MarshallingOption) ([]byte, error) { - b, err := msg.Body.Serialize(options...) - if err != nil { - return nil, err - } - if msg.Header.Len == 0 { - if 19+len(b) > BGP_MAX_MESSAGE_LENGTH { - return nil, NewMessageError(0, 0, nil, fmt.Sprintf("too long message length %d", 19+len(b))) - } - msg.Header.Len = 19 + uint16(len(b)) - } - h, err := msg.Header.Serialize(options...) - if err != nil { - return nil, err - } - return append(h, b...), nil -} - -type ErrorHandling int - -const ( - ERROR_HANDLING_NONE ErrorHandling = iota - ERROR_HANDLING_ATTRIBUTE_DISCARD - ERROR_HANDLING_TREAT_AS_WITHDRAW - ERROR_HANDLING_AFISAFI_DISABLE - ERROR_HANDLING_SESSION_RESET -) - -func getErrorHandlingFromPathAttribute(t BGPAttrType) ErrorHandling { - switch t { - case BGP_ATTR_TYPE_ORIGIN: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_AS_PATH: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_AS4_PATH: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_NEXT_HOP: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_MULTI_EXIT_DISC: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_LOCAL_PREF: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_ATOMIC_AGGREGATE: - return ERROR_HANDLING_ATTRIBUTE_DISCARD - case BGP_ATTR_TYPE_AGGREGATOR: - return ERROR_HANDLING_ATTRIBUTE_DISCARD - case BGP_ATTR_TYPE_AS4_AGGREGATOR: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_COMMUNITIES: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_ORIGINATOR_ID: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_CLUSTER_LIST: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_MP_REACH_NLRI: - return ERROR_HANDLING_AFISAFI_DISABLE - case BGP_ATTR_TYPE_MP_UNREACH_NLRI: - return ERROR_HANDLING_AFISAFI_DISABLE - case BGP_ATTR_TYPE_EXTENDED_COMMUNITIES: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_IP6_EXTENDED_COMMUNITIES: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_PMSI_TUNNEL: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_LARGE_COMMUNITY: - return ERROR_HANDLING_TREAT_AS_WITHDRAW - case BGP_ATTR_TYPE_TUNNEL_ENCAP: - return ERROR_HANDLING_ATTRIBUTE_DISCARD - case BGP_ATTR_TYPE_AIGP: - return ERROR_HANDLING_ATTRIBUTE_DISCARD - default: - return ERROR_HANDLING_ATTRIBUTE_DISCARD - } -} - -type MessageError struct { - TypeCode uint8 - SubTypeCode uint8 - Data []byte - Message string - ErrorHandling ErrorHandling - ErrorAttribute *PathAttributeInterface -} - -func NewMessageError(typeCode, subTypeCode uint8, data []byte, msg string) error { - return &MessageError{ - TypeCode: typeCode, - SubTypeCode: subTypeCode, - Data: data, - ErrorHandling: ERROR_HANDLING_SESSION_RESET, - ErrorAttribute: nil, - Message: msg, - } -} - -func NewMessageErrorWithErrorHandling(typeCode, subTypeCode uint8, data []byte, errorHandling ErrorHandling, errorAttribute *PathAttributeInterface, msg string) error { - return &MessageError{ - TypeCode: typeCode, - SubTypeCode: subTypeCode, - Data: data, - ErrorHandling: errorHandling, - ErrorAttribute: errorAttribute, - Message: msg, - } -} - -func (e *MessageError) Error() string { - return e.Message -} - -func (e *MessageError) Stronger(err error) bool { - if err == nil { - return true - } - if msgErr, ok := err.(*MessageError); ok { - return e.ErrorHandling > msgErr.ErrorHandling - } - return false -} - -func (e *TwoOctetAsSpecificExtended) Flat() map[string]string { - if e.SubType == EC_SUBTYPE_ROUTE_TARGET { - return map[string]string{"routeTarget": e.String()} - } - return map[string]string{} -} - -func (e *ColorExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *EncapExtended) Flat() map[string]string { - return map[string]string{"encaspulation": e.TunnelType.String()} -} - -func (e *DefaultGatewayExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *ValidationExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *OpaqueExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *IPv4AddressSpecificExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *IPv6AddressSpecificExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *FourOctetAsSpecificExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *ESILabelExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *ESImportRouteTarget) Flat() map[string]string { - return map[string]string{} -} - -func (e *MacMobilityExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *RouterMacExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *TrafficRateExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *TrafficRemarkExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *RedirectIPv4AddressSpecificExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *RedirectIPv6AddressSpecificExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *RedirectFourOctetAsSpecificExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *UnknownExtended) Flat() map[string]string { - return map[string]string{} -} - -func (e *TrafficActionExtended) Flat() map[string]string { - return map[string]string{} -} - -func (p *PathAttributeExtendedCommunities) Flat() map[string]string { - flat := map[string]string{} - for _, ec := range p.Value { - FlatUpdate(flat, ec.Flat()) - } - return flat -} - -func (p *PathAttribute) Flat() map[string]string { - return map[string]string{} -} - -func (l *LabeledVPNIPAddrPrefix) Flat() map[string]string { - prefixLen := l.IPAddrPrefixDefault.Length - uint8(8*(l.Labels.Len()+l.RD.Len())) - return map[string]string{ - "Prefix": l.IPAddrPrefixDefault.Prefix.String(), - "PrefixLen": fmt.Sprintf("%d", prefixLen), - "NLRI": l.String(), - "Label": l.Labels.String(), - } -} - -func (p *IPAddrPrefixDefault) Flat() map[string]string { - l := strings.Split(p.String(), "/") - if len(l) == 2 { - return map[string]string{ - "Prefix": l[0], - "PrefixLen": l[1], - } - } - return map[string]string{} -} - -func (l *EVPNNLRI) Flat() map[string]string { - return map[string]string{} -} -func (l *RouteTargetMembershipNLRI) Flat() map[string]string { - return map[string]string{} -} -func (l *FlowSpecIPv4Unicast) Flat() map[string]string { - return map[string]string{} -} -func (l *FlowSpecIPv4VPN) Flat() map[string]string { - return map[string]string{} -} -func (l *FlowSpecIPv6Unicast) Flat() map[string]string { - return map[string]string{} -} -func (l *FlowSpecIPv6VPN) Flat() map[string]string { - return map[string]string{} -} -func (l *FlowSpecL2VPN) Flat() map[string]string { - return map[string]string{} -} -func (l *OpaqueNLRI) Flat() map[string]string { - return map[string]string{} -} - -// Update a Flat representation by adding elements of the second -// one. If two elements use same keys, values are separated with -// ';'. In this case, it returns an error but the update has been -// realized. -func FlatUpdate(f1, f2 map[string]string) error { - conflict := false - for k2, v2 := range f2 { - if v1, ok := f1[k2]; ok { - f1[k2] = v1 + ";" + v2 - conflict = true - } else { - f1[k2] = v2 - } - } - if conflict { - return fmt.Errorf("Keys conflict") - } else { - return nil - } -} |