ben/gocast
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a8fd79c0e1eb1f253112bc6c46ae0f38de7f18e5
gocast/vendor/github.com/osrg/gobgp/pkg/packet/bgp/bgp.go
Mayuresh Gaitonde a8fd79c0e1 Add app source, add vendoring and module support
2019-10-16 15:57:55 -07:00

9678 lines
265 KiB
Go
Raw Blame History

// 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: 48,
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 {
if id == nil {
return nil
}
// 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)
}
var tunnelType PmsiTunnelType
var isLeafInfoRequired bool
switch args[0] {
case "ingress-repl":
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])
}
tunnelType = PmsiTunnelType(typ)
}
indx := 1
if args[indx] == "leaf-info-required" {
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])
}
indx++
var id PmsiTunnelIDInterface
switch 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])
}
id = &IngressReplTunnelID{Value: ip}
default:
id = &DefaultPmsiTunnelID{Value: []byte(args[indx])}
}
return NewPathAttributePmsiTunnel(tunnelType, isLeafInfoRequired, uint32(label), id), 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
}
}
Reference in New Issue View Git Blame Copy Permalink