func (p *Path) ToGlobal(vrf *Vrf) *Path {
nlri := p.GetNlri()
nh := p.GetNexthop()
switch rf := p.GetRouteFamily(); rf {
case bgp.RF_IPv4_UC:
n := nlri.(*bgp.IPAddrPrefix)
nlri = bgp.NewLabeledVPNIPAddrPrefix(n.Length, n.Prefix.String(), *bgp.NewMPLSLabelStack(0), vrf.Rd)
case bgp.RF_IPv6_UC:
n := nlri.(*bgp.IPv6AddrPrefix)
nlri = bgp.NewLabeledVPNIPv6AddrPrefix(n.Length, n.Prefix.String(), *bgp.NewMPLSLabelStack(0), vrf.Rd)
case bgp.RF_EVPN:
n := nlri.(*bgp.EVPNNLRI)
switch n.RouteType {
case bgp.EVPN_ROUTE_TYPE_MAC_IP_ADVERTISEMENT:
old := n.RouteTypeData.(*bgp.EVPNMacIPAdvertisementRoute)
new := &bgp.EVPNMacIPAdvertisementRoute{
RD: vrf.Rd,
ESI: old.ESI,
ETag: old.ETag,
MacAddressLength: old.MacAddressLength,
MacAddress: old.MacAddress,
IPAddressLength: old.IPAddressLength,
IPAddress: old.IPAddress,
Labels: old.Labels,
}
nlri = bgp.NewEVPNNLRI(n.RouteType, n.Length, new)
case bgp.EVPN_INCLUSIVE_MULTICAST_ETHERNET_TAG:
old := n.RouteTypeData.(*bgp.EVPNMulticastEthernetTagRoute)
new := &bgp.EVPNMulticastEthernetTagRoute{
RD: vrf.Rd,
ETag: old.ETag,
IPAddressLength: old.IPAddressLength,
IPAddress: old.IPAddress,
}
nlri = bgp.NewEVPNNLRI(n.RouteType, n.Length, new)
}
default:
return p
}
path := NewPath(p.OriginInfo().source, nlri, p.IsWithdraw, p.GetPathAttrs(), p.OriginInfo().timestamp, false)
path.SetExtCommunities(vrf.ExportRt, false)
path.delPathAttr(bgp.BGP_ATTR_TYPE_NEXT_HOP)
path.setPathAttr(bgp.NewPathAttributeMpReachNLRI(nh.String(), []bgp.AddrPrefixInterface{nlri}))
return path
}
func ParseEvpnMacAdvArgs(args []string) (bgp.AddrPrefixInterface, []string, error) {
if len(args) < 4 {
return nil, nil, fmt.Errorf("lack of number of args needs 4 but %d", len(args))
}
var nlri bgp.AddrPrefixInterface
var ip net.IP
iplen := 0
mac, err := net.ParseMAC(args[0])
if err != nil {
return nil, nil, fmt.Errorf("invalid mac: %s", args[0])
}
if args[1] != "0.0.0.0" && args[1] != "::" {
ip = net.ParseIP(args[1])
if ip == nil {
return nil, nil, fmt.Errorf("invalid ip prefix: %s", args[1])
}
iplen = net.IPv4len * 8
if ip.To4() == nil {
iplen = net.IPv6len * 8
}
}
eTag, err := strconv.Atoi(args[2])
if err != nil {
return nil, nil, fmt.Errorf("invalid eTag: %s. err: %s", args[2], err)
}
label, err := strconv.Atoi(args[3])
if err != nil {
return nil, nil, fmt.Errorf("invalid label: %s. err: %s", args[3], err)
}
var rd bgp.RouteDistinguisherInterface
if args[4] == "rd" && len(args) > 5 {
rd, err = bgp.ParseRouteDistinguisher(args[5])
if err != nil {
return nil, nil, err
}
}
macIpAdv := &bgp.EVPNMacIPAdvertisementRoute{
RD: rd,
ESI: bgp.EthernetSegmentIdentifier{
Type: bgp.ESI_ARBITRARY,
},
MacAddressLength: 48,
MacAddress: mac,
IPAddressLength: uint8(iplen),
IPAddress: ip,
Labels: []uint32{uint32(label)},
ETag: uint32(eTag),
}
nlri = bgp.NewEVPNNLRI(bgp.EVPN_ROUTE_TYPE_MAC_IP_ADVERTISEMENT, 0, macIpAdv)
extcomms := args[6:]
return nlri, extcomms, nil
}
func ParseEVPNIPPrefixArgs(args []string) (bgp.AddrPrefixInterface, []string, error) {
if len(args) < 6 {
return nil, nil, fmt.Errorf("lack of number of args needs 6 at least but got %d", len(args))
}
m := extractReserved(args, []string{"gw", "rd", "rt", "encap", "etag", "label"})
if len(m[""]) < 1 {
return nil, nil, fmt.Errorf("specify prefix")
}
ip, n, err := net.ParseCIDR(m[""][0])
if err != nil {
return nil, nil, err
}
ones, _ := n.Mask.Size()
var gw net.IP
if len(m["gw"]) > 0 {
gw = net.ParseIP(m["gw"][0])
}
if len(m["rd"]) < 1 {
return nil, nil, fmt.Errorf("specify RD")
}
rd, err := bgp.ParseRouteDistinguisher(m["rd"][0])
if err != nil {
return nil, nil, err
}
var etag uint32
if len(m["etag"]) > 0 {
e, err := strconv.Atoi(m["etag"][0])
if err != nil {
return nil, nil, err
}
etag = uint32(e)
}
var label uint32
if len(m["label"]) > 0 {
e, err := strconv.Atoi(m["label"][0])
if err != nil {
return nil, nil, err
}
label = uint32(e)
}
r := &bgp.EVPNIPPrefixRoute{
RD: rd,
ETag: etag,
IPPrefixLength: uint8(ones),
IPPrefix: ip,
GWIPAddress: gw,
Label: label,
}
return bgp.NewEVPNNLRI(bgp.EVPN_IP_PREFIX, 0, r), nil, nil
}
func ParseEvpnMulticastArgs(args []string) (bgp.AddrPrefixInterface, []string, error) {
if len(args) < 2 {
return nil, nil, fmt.Errorf("lack of number of args needs 2 but %d", len(args))
}
var nlri bgp.AddrPrefixInterface
var ip net.IP
iplen := 0
if args[0] != "0.0.0.0" && args[0] != "::" {
ip = net.ParseIP(args[0])
if ip == nil {
return nil, nil, fmt.Errorf("invalid ip prefix: %s", args[0])
}
iplen = net.IPv4len * 8
if ip.To4() == nil {
iplen = net.IPv6len * 8
}
}
eTag, err := strconv.Atoi(args[1])
if err != nil {
return nil, nil, fmt.Errorf("invalid eTag: %s. err: %s", args[1], err)
}
var rd bgp.RouteDistinguisherInterface
if args[2] == "rd" && len(args) > 3 {
rd, err = bgp.ParseRouteDistinguisher(args[3])
if err != nil {
return nil, nil, err
}
}
multicastEtag := &bgp.EVPNMulticastEthernetTagRoute{
RD: rd,
IPAddressLength: uint8(iplen),
IPAddress: ip,
ETag: uint32(eTag),
}
extcomms := args[4:]
nlri = bgp.NewEVPNNLRI(bgp.EVPN_INCLUSIVE_MULTICAST_ETHERNET_TAG, 0, multicastEtag)
return nlri, extcomms, nil
}