mirror of
https://github.com/osrg/gobgp.git
synced 2024-05-11 05:55:10 +00:00
table: fix UpdatePathAttrs2ByteAs and UpdatePathAttrs4ByteAs
This commit is contained in:
ISHIDA Wataru
committed by
FUJITA Tomonori
FUJITA Tomonori
parent
3184c7691c
commit
fdaa6da2cd
+128
-55
@@ -17,6 +17,7 @@ package table
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
log "github.com/Sirupsen/logrus"
|
||||
"github.com/osrg/gobgp/packet"
|
||||
"hash/fnv"
|
||||
)
|
||||
@@ -25,10 +26,10 @@ func UpdatePathAttrs2ByteAs(msg *bgp.BGPUpdate) error {
|
||||
var asAttr *bgp.PathAttributeAsPath
|
||||
idx := 0
|
||||
for i, attr := range msg.PathAttributes {
|
||||
switch attr.(type) {
|
||||
case *bgp.PathAttributeAsPath:
|
||||
asAttr = attr.(*bgp.PathAttributeAsPath)
|
||||
if a, ok := attr.(*bgp.PathAttributeAsPath); ok {
|
||||
asAttr = a
|
||||
idx = i
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
@@ -36,89 +37,161 @@ func UpdatePathAttrs2ByteAs(msg *bgp.BGPUpdate) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
msg.PathAttributes = cloneAttrSlice(msg.PathAttributes)
|
||||
asAttr = msg.PathAttributes[idx].(*bgp.PathAttributeAsPath)
|
||||
as4pathParam := make([]*bgp.As4PathParam, 0)
|
||||
newASparams := make([]bgp.AsPathParamInterface, len(asAttr.Value))
|
||||
for i, param := range asAttr.Value {
|
||||
asParam := param.(*bgp.As4PathParam)
|
||||
|
||||
newAs := make([]uint32, 0)
|
||||
oldAs := make([]uint16, len(asParam.AS))
|
||||
for j := 0; j < len(asParam.AS); j++ {
|
||||
if asParam.AS[j] > (1<<16)-1 {
|
||||
oldAs[j] = bgp.AS_TRANS
|
||||
newAs = append(newAs, asParam.AS[j])
|
||||
as4Params := make([]*bgp.As4PathParam, 0, len(asAttr.Value))
|
||||
as2Params := make([]bgp.AsPathParamInterface, 0, len(asAttr.Value))
|
||||
mkAs4 := false
|
||||
for _, param := range asAttr.Value {
|
||||
as4Param := param.(*bgp.As4PathParam)
|
||||
as2Path := make([]uint16, 0, len(as4Param.AS))
|
||||
for _, as := range as4Param.AS {
|
||||
if as > (1<<16)-1 {
|
||||
mkAs4 = true
|
||||
as2Path = append(as2Path, bgp.AS_TRANS)
|
||||
} else {
|
||||
oldAs[j] = uint16(asParam.AS[j])
|
||||
as2Path = append(as2Path, uint16(as))
|
||||
}
|
||||
}
|
||||
as2Params = append(as2Params, bgp.NewAsPathParam(as4Param.Type, as2Path))
|
||||
|
||||
newASparams[i] = bgp.NewAsPathParam(asParam.Type, oldAs)
|
||||
if len(newAs) > 0 {
|
||||
as4pathParam = append(as4pathParam, bgp.NewAs4PathParam(asParam.Type, newAs))
|
||||
// RFC 6793 4.2.2 Generating Updates
|
||||
//
|
||||
// Whenever the AS path information contains the AS_CONFED_SEQUENCE or
|
||||
// AS_CONFED_SET path segment, the NEW BGP speaker MUST exclude such
|
||||
// path segments from the AS4_PATH attribute being constructed.
|
||||
if as4Param.Type != bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SEQ && as4Param.Type != bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SET {
|
||||
as4Params = append(as4Params, as4Param)
|
||||
}
|
||||
}
|
||||
msg.PathAttributes[idx] = bgp.NewPathAttributeAsPath(newASparams)
|
||||
if len(as4pathParam) > 0 {
|
||||
msg.PathAttributes = append(msg.PathAttributes, bgp.NewPathAttributeAs4Path(as4pathParam))
|
||||
msg.PathAttributes[idx] = bgp.NewPathAttributeAsPath(as2Params)
|
||||
if mkAs4 {
|
||||
msg.PathAttributes = append(msg.PathAttributes, bgp.NewPathAttributeAs4Path(as4Params))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func UpdatePathAttrs4ByteAs(msg *bgp.BGPUpdate) error {
|
||||
newPathAttrs := make([]bgp.PathAttributeInterface, 0)
|
||||
var asAttr *bgp.PathAttributeAsPath
|
||||
var as4Attr *bgp.PathAttributeAs4Path
|
||||
|
||||
for _, attr := range msg.PathAttributes {
|
||||
asAttrPos := 0
|
||||
as4AttrPos := 0
|
||||
for i, attr := range msg.PathAttributes {
|
||||
switch attr.(type) {
|
||||
case *bgp.PathAttributeAsPath:
|
||||
asAttr = attr.(*bgp.PathAttributeAsPath)
|
||||
newPathAttrs = append(newPathAttrs, attr)
|
||||
for j, param := range asAttr.Value {
|
||||
as2Param, ok := param.(*bgp.AsPathParam)
|
||||
if ok {
|
||||
asPath := make([]uint32, 0, len(as2Param.AS))
|
||||
for _, as := range as2Param.AS {
|
||||
asPath = append(asPath, uint32(as))
|
||||
}
|
||||
as4Param := bgp.NewAs4PathParam(as2Param.Type, asPath)
|
||||
asAttr.Value[j] = as4Param
|
||||
}
|
||||
}
|
||||
asAttrPos = i
|
||||
msg.PathAttributes[i] = asAttr
|
||||
case *bgp.PathAttributeAs4Path:
|
||||
as4AttrPos = i
|
||||
as4Attr = attr.(*bgp.PathAttributeAs4Path)
|
||||
default:
|
||||
newPathAttrs = append(newPathAttrs, attr)
|
||||
}
|
||||
}
|
||||
|
||||
if asAttr == nil {
|
||||
if as4Attr != nil {
|
||||
msg.PathAttributes = append(msg.PathAttributes[:as4AttrPos], msg.PathAttributes[as4AttrPos+1:]...)
|
||||
}
|
||||
|
||||
if asAttr == nil || as4Attr == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
AS := make([]uint32, 0)
|
||||
asLen := 0
|
||||
asConfedLen := 0
|
||||
asParams := make([]*bgp.As4PathParam, 0, len(asAttr.Value))
|
||||
for _, param := range asAttr.Value {
|
||||
asLen += param.ASLen()
|
||||
p := param.(*bgp.As4PathParam)
|
||||
switch p.Type {
|
||||
case bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SET:
|
||||
asConfedLen += 1
|
||||
case bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SEQ:
|
||||
asConfedLen += len(p.AS)
|
||||
}
|
||||
asParams = append(asParams, p)
|
||||
}
|
||||
|
||||
as4Len := 0
|
||||
as4Params := make([]*bgp.As4PathParam, 0, len(as4Attr.Value))
|
||||
if as4Attr != nil {
|
||||
for _, p := range as4Attr.Value {
|
||||
AS = append(AS, p.AS...)
|
||||
}
|
||||
msg.PathAttributes = newPathAttrs
|
||||
}
|
||||
|
||||
transIdx := 0
|
||||
for i, param := range asAttr.Value {
|
||||
asParam, y := param.(*bgp.AsPathParam)
|
||||
if !y {
|
||||
continue
|
||||
}
|
||||
|
||||
newAS := make([]uint32, len(asParam.AS))
|
||||
for j := 0; j < len(asParam.AS); j++ {
|
||||
if asParam.AS[j] == bgp.AS_TRANS {
|
||||
if transIdx == len(AS) {
|
||||
//return error
|
||||
// RFC 6793 6. Error Handling
|
||||
//
|
||||
// the path segment types AS_CONFED_SEQUENCE and AS_CONFED_SET [RFC5065]
|
||||
// MUST NOT be carried in the AS4_PATH attribute of an UPDATE message.
|
||||
// A NEW BGP speaker that receives these path segment types in the AS4_PATH
|
||||
// attribute of an UPDATE message from an OLD BGP speaker MUST discard
|
||||
// these path segments, adjust the relevant attribute fields accordingly,
|
||||
// and continue processing the UPDATE message.
|
||||
// This case SHOULD be logged locally for analysis.
|
||||
switch p.Type {
|
||||
case bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SEQ, bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SET:
|
||||
typ := "CONFED_SEQ"
|
||||
if p.Type == bgp.BGP_ASPATH_ATTR_TYPE_CONFED_SET {
|
||||
typ = "CONFED_SET"
|
||||
}
|
||||
newAS[j] = AS[transIdx]
|
||||
transIdx++
|
||||
} else {
|
||||
newAS[j] = uint32(asParam.AS[j])
|
||||
log.Warnf("AS4_PATH contains %s segment %s. ignore", typ, p.String())
|
||||
continue
|
||||
}
|
||||
as4Len += p.ASLen()
|
||||
as4Params = append(as4Params, p)
|
||||
}
|
||||
asAttr.Value[i] = bgp.NewAs4PathParam(asParam.Type, newAS)
|
||||
}
|
||||
if len(AS) != transIdx {
|
||||
//return error
|
||||
|
||||
if asLen+asConfedLen < as4Len {
|
||||
log.Warnf("AS4_PATH is longer than AS_PATH. ignore AS4_PATH")
|
||||
return nil
|
||||
}
|
||||
|
||||
keepNum := asLen + asConfedLen - as4Len
|
||||
|
||||
newParams := make([]*bgp.As4PathParam, 0, len(asAttr.Value))
|
||||
for _, param := range asParams {
|
||||
if keepNum-param.ASLen() >= 0 {
|
||||
newParams = append(newParams, param)
|
||||
keepNum -= param.ASLen()
|
||||
} else {
|
||||
// only SEQ param reaches here
|
||||
param.AS = param.AS[:keepNum]
|
||||
newParams = append(newParams, param)
|
||||
keepNum = 0
|
||||
}
|
||||
|
||||
if keepNum <= 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
for _, param := range as4Params {
|
||||
lastParam := newParams[len(newParams)-1]
|
||||
if param.Type == lastParam.Type && param.Type == bgp.BGP_ASPATH_ATTR_TYPE_SEQ {
|
||||
if len(lastParam.AS)+len(param.AS) > 255 {
|
||||
lastParam.AS = append(lastParam.AS, param.AS[:255-len(lastParam.AS)]...)
|
||||
param.AS = param.AS[255-len(lastParam.AS):]
|
||||
newParams = append(newParams, param)
|
||||
} else {
|
||||
lastParam.AS = append(lastParam.AS, param.AS...)
|
||||
}
|
||||
} else {
|
||||
newParams = append(newParams, param)
|
||||
}
|
||||
}
|
||||
|
||||
newIntfParams := make([]bgp.AsPathParamInterface, 0, len(asAttr.Value))
|
||||
for _, p := range newParams {
|
||||
newIntfParams = append(newIntfParams, p)
|
||||
}
|
||||
|
||||
msg.PathAttributes[asAttrPos] = bgp.NewPathAttributeAsPath(newIntfParams)
|
||||
return nil
|
||||
}
|
||||
|
||||
|
||||
+292
-69
@@ -18,87 +18,310 @@ package table
|
||||
import (
|
||||
"github.com/osrg/gobgp/packet"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func updateMsg1(as []uint16) *bgp.BGPMessage {
|
||||
origin := bgp.NewPathAttributeOrigin(0)
|
||||
aspathParam := []bgp.AsPathParamInterface{bgp.NewAsPathParam(2, as)}
|
||||
aspath := bgp.NewPathAttributeAsPath(aspathParam)
|
||||
nexthop := bgp.NewPathAttributeNextHop("192.168.50.1")
|
||||
med := bgp.NewPathAttributeMultiExitDisc(0)
|
||||
|
||||
pathAttributes := []bgp.PathAttributeInterface{
|
||||
origin,
|
||||
aspath,
|
||||
nexthop,
|
||||
med,
|
||||
}
|
||||
|
||||
nlri := []*bgp.IPAddrPrefix{bgp.NewIPAddrPrefix(24, "10.10.10.0")}
|
||||
return bgp.NewBGPUpdateMessage(nil, pathAttributes, nlri)
|
||||
// before:
|
||||
// as-path : 65000, 4000, 400000, 300000, 40001
|
||||
// expected result:
|
||||
// as-path : 65000, 4000, 23456, 23456, 40001
|
||||
// as4-path : 65000, 4000, 400000, 300000, 40001
|
||||
func TestAsPathAs2Trans1(t *testing.T) {
|
||||
as := []uint32{65000, 4000, 400000, 300000, 40001}
|
||||
params := []bgp.AsPathParamInterface{bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as)}
|
||||
aspath := bgp.NewPathAttributeAsPath(params)
|
||||
msg := bgp.NewBGPUpdateMessage(nil, []bgp.PathAttributeInterface{aspath}, nil).Body.(*bgp.BGPUpdate)
|
||||
UpdatePathAttrs2ByteAs(msg)
|
||||
assert.Equal(t, len(msg.PathAttributes), 2)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.AsPathParam).AS), 5)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.AsPathParam).AS[0], uint16(65000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.AsPathParam).AS[1], uint16(4000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.AsPathParam).AS[2], uint16(bgp.AS_TRANS))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.AsPathParam).AS[3], uint16(bgp.AS_TRANS))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.AsPathParam).AS[4], uint16(40001))
|
||||
assert.Equal(t, len(msg.PathAttributes[1].(*bgp.PathAttributeAs4Path).Value), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[1].(*bgp.PathAttributeAs4Path).Value[0].AS), 5)
|
||||
assert.Equal(t, msg.PathAttributes[1].(*bgp.PathAttributeAs4Path).Value[0].AS[0], uint32(65000))
|
||||
assert.Equal(t, msg.PathAttributes[1].(*bgp.PathAttributeAs4Path).Value[0].AS[1], uint32(4000))
|
||||
assert.Equal(t, msg.PathAttributes[1].(*bgp.PathAttributeAs4Path).Value[0].AS[2], uint32(400000))
|
||||
assert.Equal(t, msg.PathAttributes[1].(*bgp.PathAttributeAs4Path).Value[0].AS[3], uint32(300000))
|
||||
assert.Equal(t, msg.PathAttributes[1].(*bgp.PathAttributeAs4Path).Value[0].AS[4], uint32(40001))
|
||||
}
|
||||
|
||||
func TestAsPathAsTrans(t *testing.T) {
|
||||
// before:
|
||||
// as-path : 65000, 4000, 40000, 30000, 40001
|
||||
// expected result:
|
||||
// as-path : 65000, 4000, 40000, 30000, 40001
|
||||
func TestAsPathAs2Trans2(t *testing.T) {
|
||||
as := []uint32{65000, 4000, 40000, 30000, 40001}
|
||||
params := []bgp.AsPathParamInterface{bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as)}
|
||||
aspath := bgp.NewPathAttributeAsPath(params)
|
||||
msg := bgp.NewBGPUpdateMessage(nil, []bgp.PathAttributeInterface{aspath}, nil).Body.(*bgp.BGPUpdate)
|
||||
UpdatePathAttrs2ByteAs(msg)
|
||||
assert.Equal(t, len(msg.PathAttributes), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.AsPathParam).AS), 5)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.AsPathParam).AS[0], uint16(65000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.AsPathParam).AS[1], uint16(4000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.AsPathParam).AS[2], uint16(40000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.AsPathParam).AS[3], uint16(30000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.AsPathParam).AS[4], uint16(40001))
|
||||
}
|
||||
|
||||
// before:
|
||||
// as-path : 65000, 4000, 23456, 23456, 40001
|
||||
// as4-path : 400000, 300000, 40001
|
||||
// expected result:
|
||||
// as-path : 65000, 4000, 400000, 300000, 40001
|
||||
func TestAsPathAs4Trans1(t *testing.T) {
|
||||
as := []uint16{65000, 4000, bgp.AS_TRANS, bgp.AS_TRANS, 40001}
|
||||
m := updateMsg1(as).Body.(*bgp.BGPUpdate)
|
||||
params := []bgp.AsPathParamInterface{bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as)}
|
||||
aspath := bgp.NewPathAttributeAsPath(params)
|
||||
|
||||
m.PathAttributes = append(m.PathAttributes, m.PathAttributes[3])
|
||||
as4 := []uint32{400000, 300000}
|
||||
aspathParam := []*bgp.As4PathParam{bgp.NewAs4PathParam(2, as4)}
|
||||
m.PathAttributes[3] = bgp.NewPathAttributeAs4Path(aspathParam)
|
||||
assert.Equal(t, len(m.PathAttributes), 5)
|
||||
|
||||
UpdatePathAttrs4ByteAs(m)
|
||||
assert.Equal(t, len(m.PathAttributes), 4)
|
||||
|
||||
assert.Equal(t, reflect.TypeOf(m.PathAttributes[0]).String(), "*bgp.PathAttributeOrigin")
|
||||
assert.Equal(t, reflect.TypeOf(m.PathAttributes[1]).String(), "*bgp.PathAttributeAsPath")
|
||||
assert.Equal(t, reflect.TypeOf(m.PathAttributes[2]).String(), "*bgp.PathAttributeNextHop")
|
||||
assert.Equal(t, reflect.TypeOf(m.PathAttributes[3]).String(), "*bgp.PathAttributeMultiExitDisc")
|
||||
|
||||
newAS := []uint32{65000, 4000, 400000, 300000, 40001}
|
||||
asAttr := m.PathAttributes[1].(*bgp.PathAttributeAsPath)
|
||||
assert.Equal(t, len(asAttr.Value), 1)
|
||||
for _, param := range asAttr.Value {
|
||||
asParam := param.(*bgp.As4PathParam)
|
||||
for i, v := range asParam.AS {
|
||||
assert.Equal(t, v, newAS[i])
|
||||
}
|
||||
}
|
||||
UpdatePathAttrs2ByteAs(m)
|
||||
assert.Equal(t, len(m.PathAttributes), 5)
|
||||
attr := m.PathAttributes[1].(*bgp.PathAttributeAsPath)
|
||||
assert.Equal(t, len(attr.Value), 1)
|
||||
assert.Equal(t, attr.Value[0].(*bgp.AsPathParam).AS, as)
|
||||
attr2 := m.PathAttributes[4].(*bgp.PathAttributeAs4Path)
|
||||
assert.Equal(t, len(attr2.Value), 1)
|
||||
assert.Equal(t, attr2.Value[0].AS, as4)
|
||||
as4 := []uint32{400000, 300000, 40001}
|
||||
param4s := []*bgp.As4PathParam{bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as4)}
|
||||
as4path := bgp.NewPathAttributeAs4Path(param4s)
|
||||
msg := bgp.NewBGPUpdateMessage(nil, []bgp.PathAttributeInterface{aspath, as4path}, nil).Body.(*bgp.BGPUpdate)
|
||||
UpdatePathAttrs4ByteAs(msg)
|
||||
assert.Equal(t, len(msg.PathAttributes), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS), 5)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[0], uint32(65000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[1], uint32(4000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[2], uint32(400000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[3], uint32(300000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[4], uint32(40001))
|
||||
}
|
||||
|
||||
func TestAs4PathUnchanged(t *testing.T) {
|
||||
as4 := []uint32{65000, 4000, 500000, 400010}
|
||||
m := updateMsg1([]uint16{}).Body.(*bgp.BGPUpdate)
|
||||
aspathParam := []bgp.AsPathParamInterface{bgp.NewAs4PathParam(2, as4)}
|
||||
m.PathAttributes[1] = bgp.NewPathAttributeAsPath(aspathParam)
|
||||
UpdatePathAttrs4ByteAs(m)
|
||||
assert.Equal(t, len(m.PathAttributes), 4)
|
||||
// before:
|
||||
// as-path : 65000, 4000, {10, 20, 30}, 23456, 23456, 40001
|
||||
// as4-path : 400000, 300000, 40001
|
||||
// expected result:
|
||||
// as-path : 65000, 4000, {10, 20, 30}, 400000, 300000, 40001
|
||||
func TestAsPathAs4Trans2(t *testing.T) {
|
||||
as1 := []uint16{65000, 4000}
|
||||
param1 := bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as1)
|
||||
as2 := []uint16{10, 20, 30}
|
||||
param2 := bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SET, as2)
|
||||
as3 := []uint16{bgp.AS_TRANS, bgp.AS_TRANS, 40001}
|
||||
param3 := bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as3)
|
||||
params := []bgp.AsPathParamInterface{param1, param2, param3}
|
||||
aspath := bgp.NewPathAttributeAsPath(params)
|
||||
|
||||
assert.Equal(t, reflect.TypeOf(m.PathAttributes[0]).String(), "*bgp.PathAttributeOrigin")
|
||||
assert.Equal(t, reflect.TypeOf(m.PathAttributes[1]).String(), "*bgp.PathAttributeAsPath")
|
||||
assert.Equal(t, reflect.TypeOf(m.PathAttributes[2]).String(), "*bgp.PathAttributeNextHop")
|
||||
assert.Equal(t, reflect.TypeOf(m.PathAttributes[3]).String(), "*bgp.PathAttributeMultiExitDisc")
|
||||
as4 := []uint32{400000, 300000, 40001}
|
||||
param4s := []*bgp.As4PathParam{bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as4)}
|
||||
as4path := bgp.NewPathAttributeAs4Path(param4s)
|
||||
msg := bgp.NewBGPUpdateMessage(nil, []bgp.PathAttributeInterface{aspath, as4path}, nil).Body.(*bgp.BGPUpdate)
|
||||
UpdatePathAttrs4ByteAs(msg)
|
||||
assert.Equal(t, len(msg.PathAttributes), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value), 3)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS), 2)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[0], uint32(65000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[1], uint32(4000))
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[1].(*bgp.As4PathParam).AS), 3)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[1].(*bgp.As4PathParam).AS[0], uint32(10))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[1].(*bgp.As4PathParam).AS[1], uint32(20))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[1].(*bgp.As4PathParam).AS[2], uint32(30))
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[2].(*bgp.As4PathParam).AS), 3)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[2].(*bgp.As4PathParam).AS[0], uint32(400000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[2].(*bgp.As4PathParam).AS[1], uint32(300000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[2].(*bgp.As4PathParam).AS[2], uint32(40001))
|
||||
}
|
||||
|
||||
asAttr := m.PathAttributes[1].(*bgp.PathAttributeAsPath)
|
||||
assert.Equal(t, len(asAttr.Value), 1)
|
||||
for _, param := range asAttr.Value {
|
||||
asParam := param.(*bgp.As4PathParam)
|
||||
for i, v := range asParam.AS {
|
||||
assert.Equal(t, v, as4[i])
|
||||
}
|
||||
}
|
||||
// before:
|
||||
// as-path : 65000, 4000, {10, 20, 30}, 23456, 23456, 40001
|
||||
// as4-path : 3000, 400000, 300000, 40001
|
||||
// expected result:
|
||||
// as-path : 65000, 4000, 3000, 400000, 300000, 40001
|
||||
func TestAsPathAs4Trans3(t *testing.T) {
|
||||
as1 := []uint16{65000, 4000}
|
||||
param1 := bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as1)
|
||||
as2 := []uint16{10, 20, 30}
|
||||
param2 := bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SET, as2)
|
||||
as3 := []uint16{bgp.AS_TRANS, bgp.AS_TRANS, 40001}
|
||||
param3 := bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as3)
|
||||
params := []bgp.AsPathParamInterface{param1, param2, param3}
|
||||
aspath := bgp.NewPathAttributeAsPath(params)
|
||||
|
||||
as4 := []uint32{3000, 400000, 300000, 40001}
|
||||
param4s := []*bgp.As4PathParam{bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as4)}
|
||||
as4path := bgp.NewPathAttributeAs4Path(param4s)
|
||||
msg := bgp.NewBGPUpdateMessage(nil, []bgp.PathAttributeInterface{aspath, as4path}, nil).Body.(*bgp.BGPUpdate)
|
||||
UpdatePathAttrs4ByteAs(msg)
|
||||
assert.Equal(t, len(msg.PathAttributes), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS), 6)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[0], uint32(65000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[1], uint32(4000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[2], uint32(3000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[3], uint32(400000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[4], uint32(300000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[5], uint32(40001))
|
||||
}
|
||||
|
||||
// before:
|
||||
// as-path : 65000, 4000, 23456, 23456, 40001
|
||||
// as4-path : 400000, 300000, 40001, {10, 20, 30}
|
||||
// expected result:
|
||||
// as-path : 65000, 400000, 300000, 40001, {10, 20, 30}
|
||||
func TestAsPathAs4Trans4(t *testing.T) {
|
||||
as := []uint16{65000, 4000, bgp.AS_TRANS, bgp.AS_TRANS, 40001}
|
||||
params := []bgp.AsPathParamInterface{bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as)}
|
||||
aspath := bgp.NewPathAttributeAsPath(params)
|
||||
|
||||
as4 := []uint32{400000, 300000, 40001}
|
||||
as4param1 := bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as4)
|
||||
as5 := []uint32{10, 20, 30}
|
||||
as4param2 := bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SET, as5)
|
||||
param4s := []*bgp.As4PathParam{as4param1, as4param2}
|
||||
as4path := bgp.NewPathAttributeAs4Path(param4s)
|
||||
msg := bgp.NewBGPUpdateMessage(nil, []bgp.PathAttributeInterface{aspath, as4path}, nil).Body.(*bgp.BGPUpdate)
|
||||
UpdatePathAttrs4ByteAs(msg)
|
||||
assert.Equal(t, len(msg.PathAttributes), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value), 2)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS), 4)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[0], uint32(65000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[1], uint32(400000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[2], uint32(300000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[3], uint32(40001))
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[1].(*bgp.As4PathParam).AS), 3)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[1].(*bgp.As4PathParam).AS[0], uint32(10))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[1].(*bgp.As4PathParam).AS[1], uint32(20))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[1].(*bgp.As4PathParam).AS[2], uint32(30))
|
||||
}
|
||||
|
||||
// before:
|
||||
// as-path : 65000, 4000, 23456, 23456, 40001
|
||||
// as4-path : {10, 20, 30} 400000, 300000, 40001
|
||||
// expected result:
|
||||
// as-path : 65000, {10, 20, 30}, 400000, 300000, 40001
|
||||
func TestAsPathAs4Trans5(t *testing.T) {
|
||||
as := []uint16{65000, 4000, bgp.AS_TRANS, bgp.AS_TRANS, 40001}
|
||||
params := []bgp.AsPathParamInterface{bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as)}
|
||||
aspath := bgp.NewPathAttributeAsPath(params)
|
||||
|
||||
as4 := []uint32{400000, 300000, 40001}
|
||||
as4param1 := bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as4)
|
||||
as5 := []uint32{10, 20, 30}
|
||||
as4param2 := bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SET, as5)
|
||||
param4s := []*bgp.As4PathParam{as4param2, as4param1}
|
||||
as4path := bgp.NewPathAttributeAs4Path(param4s)
|
||||
msg := bgp.NewBGPUpdateMessage(nil, []bgp.PathAttributeInterface{aspath, as4path}, nil).Body.(*bgp.BGPUpdate)
|
||||
UpdatePathAttrs4ByteAs(msg)
|
||||
assert.Equal(t, len(msg.PathAttributes), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value), 3)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS), 1)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[0], uint32(65000))
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[1].(*bgp.As4PathParam).AS), 3)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[1].(*bgp.As4PathParam).AS[0], uint32(10))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[1].(*bgp.As4PathParam).AS[1], uint32(20))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[1].(*bgp.As4PathParam).AS[2], uint32(30))
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[2].(*bgp.As4PathParam).AS), 3)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[2].(*bgp.As4PathParam).AS[0], uint32(400000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[2].(*bgp.As4PathParam).AS[1], uint32(300000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[2].(*bgp.As4PathParam).AS[2], uint32(40001))
|
||||
}
|
||||
|
||||
// before:
|
||||
// as-path : 65000, 4000, 23456, 23456, 40001
|
||||
// as4-path : 100000, 65000, 4000, 400000, 300000, 40001
|
||||
// expected result:
|
||||
// as-path : 65000, 4000, 23456, 23456, 40001
|
||||
func TestAsPathAs4TransInvalid1(t *testing.T) {
|
||||
as := []uint16{65000, 4000, bgp.AS_TRANS, bgp.AS_TRANS, 40001}
|
||||
params := []bgp.AsPathParamInterface{bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as)}
|
||||
aspath := bgp.NewPathAttributeAsPath(params)
|
||||
|
||||
as4 := []uint32{100000, 65000, 4000, 400000, 300000, 40001}
|
||||
as4param1 := bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as4)
|
||||
param4s := []*bgp.As4PathParam{as4param1}
|
||||
as4path := bgp.NewPathAttributeAs4Path(param4s)
|
||||
msg := bgp.NewBGPUpdateMessage(nil, []bgp.PathAttributeInterface{aspath, as4path}, nil).Body.(*bgp.BGPUpdate)
|
||||
UpdatePathAttrs4ByteAs(msg)
|
||||
assert.Equal(t, len(msg.PathAttributes), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS), 5)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[0], uint32(65000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[1], uint32(4000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[2], uint32(bgp.AS_TRANS))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[3], uint32(bgp.AS_TRANS))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[4], uint32(40001))
|
||||
}
|
||||
|
||||
// before:
|
||||
// as-path : 65000, 4000, 23456, 23456, 40001
|
||||
// as4-path : 300000, 40001
|
||||
// expected result:
|
||||
// as-path : 65000, 4000, 23456, 300000, 40001
|
||||
func TestAsPathAs4TransInvalid2(t *testing.T) {
|
||||
as := []uint16{65000, 4000, bgp.AS_TRANS, bgp.AS_TRANS, 40001}
|
||||
params := []bgp.AsPathParamInterface{bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as)}
|
||||
aspath := bgp.NewPathAttributeAsPath(params)
|
||||
|
||||
as4 := []uint32{300000, 40001}
|
||||
as4param1 := bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as4)
|
||||
param4s := []*bgp.As4PathParam{as4param1}
|
||||
as4path := bgp.NewPathAttributeAs4Path(param4s)
|
||||
msg := bgp.NewBGPUpdateMessage(nil, []bgp.PathAttributeInterface{aspath, as4path}, nil).Body.(*bgp.BGPUpdate)
|
||||
UpdatePathAttrs4ByteAs(msg)
|
||||
assert.Equal(t, len(msg.PathAttributes), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS), 5)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[0], uint32(65000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[1], uint32(4000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[2], uint32(bgp.AS_TRANS))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[3], uint32(300000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[4], uint32(40001))
|
||||
}
|
||||
|
||||
// before:
|
||||
// as-path : 65000, 4000, 23456, 23456, 40001
|
||||
// as4-path : nil
|
||||
// expected result:
|
||||
// as-path : 65000, 4000, 23456, 23456, 40001
|
||||
func TestAsPathAs4TransInvalid3(t *testing.T) {
|
||||
as := []uint16{65000, 4000, bgp.AS_TRANS, bgp.AS_TRANS, 40001}
|
||||
params := []bgp.AsPathParamInterface{bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as)}
|
||||
aspath := bgp.NewPathAttributeAsPath(params)
|
||||
|
||||
msg := bgp.NewBGPUpdateMessage(nil, []bgp.PathAttributeInterface{aspath}, nil).Body.(*bgp.BGPUpdate)
|
||||
UpdatePathAttrs4ByteAs(msg)
|
||||
assert.Equal(t, len(msg.PathAttributes), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS), 5)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[0], uint32(65000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[1], uint32(4000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[2], uint32(bgp.AS_TRANS))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[3], uint32(bgp.AS_TRANS))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[4], uint32(40001))
|
||||
}
|
||||
|
||||
// before:
|
||||
// as-path : 65000, 4000, 23456, 23456, 40001
|
||||
// as4-path : empty
|
||||
// expected result:
|
||||
// as-path : 65000, 4000, 23456, 23456, 40001
|
||||
func TestAsPathAs4TransInvalid4(t *testing.T) {
|
||||
as := []uint16{65000, 4000, bgp.AS_TRANS, bgp.AS_TRANS, 40001}
|
||||
params := []bgp.AsPathParamInterface{bgp.NewAsPathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as)}
|
||||
aspath := bgp.NewPathAttributeAsPath(params)
|
||||
|
||||
as4 := []uint32{}
|
||||
as4param1 := bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, as4)
|
||||
param4s := []*bgp.As4PathParam{as4param1}
|
||||
as4path := bgp.NewPathAttributeAs4Path(param4s)
|
||||
msg := bgp.NewBGPUpdateMessage(nil, []bgp.PathAttributeInterface{aspath, as4path}, nil).Body.(*bgp.BGPUpdate)
|
||||
UpdatePathAttrs4ByteAs(msg)
|
||||
assert.Equal(t, len(msg.PathAttributes), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value), 1)
|
||||
assert.Equal(t, len(msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS), 5)
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[0], uint32(65000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[1], uint32(4000))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[2], uint32(bgp.AS_TRANS))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[3], uint32(bgp.AS_TRANS))
|
||||
assert.Equal(t, msg.PathAttributes[0].(*bgp.PathAttributeAsPath).Value[0].(*bgp.As4PathParam).AS[4], uint32(40001))
|
||||
}
|
||||
|
||||
func TestBMP(t *testing.T) {
|
||||
|
||||
Reference in New Issue
Block a user