func showRPKITable(args []string) error {
family, err := checkAddressFamily(bgp.RouteFamily(0))
if err != nil {
exitWithError(err)
}
arg := &api.GetRoaRequest{
Family: uint32(family),
}
rsp, err := client.GetRoa(context.Background(), arg)
if err != nil {
fmt.Println(err)
return err
}
var format string
afi, _ := bgp.RouteFamilyToAfiSafi(family)
if afi == bgp.AFI_IP {
format = "%-18s %-6s %-10s %s\n"
} else {
format = "%-42s %-6s %-10s %s\n"
}
fmt.Printf(format, "Network", "Maxlen", "AS", "Server")
for _, r := range rsp.Roas {
if len(args) > 0 && args[0] != r.Conf.Address {
continue
}
server := net.JoinHostPort(r.Conf.Address, r.Conf.RemotePort)
fmt.Printf(format, fmt.Sprintf("%s/%d", r.Prefix, r.Prefixlen), fmt.Sprint(r.Maxlen), fmt.Sprint(r.As), server)
}
return nil
}
func showRPKITable(args []string) error {
family, err := checkAddressFamily(bgp.RouteFamily(0))
if err != nil {
exitWithError(err)
}
roas, err := client.GetROA(family)
if err != nil {
exitWithError(err)
}
var format string
afi, _ := bgp.RouteFamilyToAfiSafi(family)
if afi == bgp.AFI_IP {
format = "%-18s %-6s %-10s %s\n"
} else {
format = "%-42s %-6s %-10s %s\n"
}
fmt.Printf(format, "Network", "Maxlen", "AS", "Server")
for _, r := range roas {
host, _, _ := net.SplitHostPort(r.Src)
if len(args) > 0 && args[0] != host {
continue
}
fmt.Printf(format, r.Prefix.String(), fmt.Sprint(r.MaxLen), fmt.Sprint(r.AS), r.Src)
}
return nil
}
func (u *Rib) DecodeFromBytes(data []byte) error {
if len(data) < 4 {
return fmt.Errorf("Not all RibIpv4Unicast message bytes available")
}
u.SequenceNumber = binary.BigEndian.Uint32(data[:4])
data = data[4:]
afi, safi := bgp.RouteFamilyToAfiSafi(u.RouteFamily)
if afi == 0 && safi == 0 {
afi = binary.BigEndian.Uint16(data[:2])
safi = data[2]
data = data[3:]
}
prefix, err := bgp.NewPrefixFromRouteFamily(afi, safi)
if err != nil {
return err
}
err = prefix.DecodeFromBytes(data)
if err != nil {
return err
}
u.Prefix = prefix
data = data[prefix.Len():]
entryNum := binary.BigEndian.Uint16(data[:2])
data = data[2:]
u.Entries = make([]*RibEntry, 0, entryNum)
for i := 0; i < int(entryNum); i++ {
e := &RibEntry{}
data, err = e.DecodeFromBytes(data)
if err != nil {
return err
}
u.Entries = append(u.Entries, e)
}
return nil
}
func getNLRI(family bgp.RouteFamily, buf []byte) (bgp.AddrPrefixInterface, error) {
afi, safi := bgp.RouteFamilyToAfiSafi(bgp.RouteFamily(family))
nlri, err := bgp.NewPrefixFromRouteFamily(afi, safi)
if err != nil {
return nil, err
}
if err := nlri.DecodeFromBytes(buf); err != nil {
return nil, err
}
return nlri, nil
}
func NewEOR(family bgp.RouteFamily) *Path {
afi, safi := bgp.RouteFamilyToAfiSafi(family)
nlri, _ := bgp.NewPrefixFromRouteFamily(afi, safi)
return &Path{
info: &originInfo{
nlri: nlri,
eor: true,
},
filtered: make(map[string]PolicyDirection),
}
}
func ApiStruct2Path(p *gobgpapi.Path) ([]*Path, error) {
nlris := make([]bgp.AddrPrefixInterface, 0, 1)
if len(p.Nlri) == 0 {
return nil, fmt.Errorf("path doesn't have nlri")
}
afi, safi := bgp.RouteFamilyToAfiSafi(bgp.RouteFamily(p.Family))
nlri, err := bgp.NewPrefixFromRouteFamily(afi, safi)
if err != nil {
return nil, err
}
if err := nlri.DecodeFromBytes(p.Nlri); err != nil {
return nil, err
}
nlris = append(nlris, nlri)
pattr := make([]bgp.PathAttributeInterface, 0, len(p.Pattrs))
for _, attr := range p.Pattrs {
p, err := bgp.GetPathAttribute(attr)
if err != nil {
return nil, err
}
err = p.DecodeFromBytes(attr)
if err != nil {
return nil, err
}
pattr = append(pattr, p)
}
paths := make([]*Path, 0, len(nlris))
for _, nlri := range nlris {
paths = append(paths, &Path{
Nlri: nlri,
PathAttrs: pattr,
Age: p.Age,
Best: p.Best,
IsWithdraw: p.IsWithdraw,
Validation: p.Validation,
SourceId: p.SourceId,
NeighborIp: p.NeighborIp,
Filtered: p.Filtered,
Stale: p.Stale,
})
}
return paths, nil
}
func extractNexthop(rf bgp.RouteFamily, args []string) ([]string, string, error) {
afi, _ := bgp.RouteFamilyToAfiSafi(rf)
nexthop := "0.0.0.0"
if afi == bgp.AFI_IP6 {
nexthop = "::"
}
for idx, arg := range args {
if arg == "nexthop" && len(args) > (idx+1) {
if net.ParseIP(args[idx+1]) == nil {
return nil, "", fmt.Errorf("invalid nexthop address")
}
nexthop = args[idx+1]
args = append(args[:idx], args[idx+2:]...)
break
}
}
return args, nexthop, nil
}
func (cli *GoBGPClient) GetROA(family bgp.RouteFamily) ([]*table.ROA, error) {
rsp, err := cli.cli.GetRoa(context.Background(), &api.GetRoaRequest{
Family: uint32(family),
})
if err != nil {
return nil, err
}
roas := make([]*table.ROA, 0, len(rsp.Roas))
for _, r := range rsp.Roas {
ip := net.ParseIP(r.Prefix)
if ip.To4() != nil {
ip = ip.To4()
}
afi, _ := bgp.RouteFamilyToAfiSafi(family)
roa := table.NewROA(int(afi), []byte(ip), uint8(r.Prefixlen), uint8(r.Maxlen), r.As, net.JoinHostPort(r.Conf.Address, r.Conf.RemotePort))
roas = append(roas, roa)
}
return roas, nil
}
