From 10c388ce6577a8941418ea19f74af173738ea509 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Thu, 29 Oct 2026 20:09:08 +0100 Subject: [PATCH] =?UTF-8?q?f-42:=20l3vni:=20route=20par=20d=C3=A9faut=20du?= =?UTF-8?q?=20netns,=20export=20de=20la=20passerelle=20en=20type=205=20#42?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GnomeZworc --- internal/frr/client_test.go | 2 ++ internal/frr/config.go | 18 ++++++++++++++ internal/frr/config_test.go | 9 +++++++ internal/frr/teardown.go | 6 +++-- internal/frr/teardown_test.go | 11 ++++++++ internal/l3vni/host.go | 5 ++++ internal/l3vni/l3.go | 6 ++++- internal/l3vni/l3_test.go | 9 +++++-- internal/l3vni/route.go | 41 ++++++++++++++++++++++++++++++ internal/l3vni/route_test.go | 47 +++++++++++++++++++++++++++++++++++ internal/netif/route_linux.go | 18 ++++++++++++++ internal/netif/route_other.go | 4 +++ 12 files changed, 171 insertions(+), 5 deletions(-) diff --git a/internal/frr/client_test.go b/internal/frr/client_test.go index 0f9ec9e..13dc3a6 100644 --- a/internal/frr/client_test.go +++ b/internal/frr/client_test.go @@ -124,6 +124,8 @@ func TestWithdrawVRFRunsEachStepInOrderThenSaves(t *testing.T) { {"configure terminal", "no router bgp 64600 vrf vrf-a1b2"}, {"configure terminal", "no route-map EXPORT-a1b2"}, {"configure terminal", "no ip prefix-list PL-a1b2"}, + {"configure terminal", "no ip prefix-list PL-a1b2-default"}, + {"configure terminal", "no ip prefix-list PL-a1b2-transit"}, {"write memory"}, {"show running-config"}, } diff --git a/internal/frr/config.go b/internal/frr/config.go index 34e3210..9d1bd1d 100644 --- a/internal/frr/config.go +++ b/internal/frr/config.go @@ -20,6 +20,7 @@ type VRF struct { L3VNI uint32 VTEP net.IP Supernet *net.IPNet + Transit net.IP } func (b Base) validate() error { @@ -94,6 +95,14 @@ func (v VRF) prefixList() string { return "PL-" + v.ID } +func (v VRF) defaultPrefixList() string { + return "PL-" + v.ID + "-default" +} + +func (v VRF) transitPrefixList() string { + return "PL-" + v.ID + "-transit" +} + func (v VRF) routeMap() string { return "EXPORT-" + v.ID } @@ -125,15 +134,24 @@ func (v VRF) validate() error { if v.Supernet == nil || v.Supernet.IP.To4() == nil { return fmt.Errorf("frr: supernet %v is not an IPv4 prefix", v.Supernet) } + if v.Transit.To4() == nil { + return fmt.Errorf("frr: transit %v is not an IPv4 address", v.Transit) + } return nil } func (v VRF) commands() []string { return []string{ fmt.Sprintf("ip prefix-list %s seq 10 permit %s le 32", v.prefixList(), v.Supernet), + fmt.Sprintf("ip prefix-list %s seq 10 permit 0.0.0.0/0", v.defaultPrefixList()), + fmt.Sprintf("ip prefix-list %s seq 10 permit %s/32", v.transitPrefixList(), v.Transit.To4()), fmt.Sprintf("route-map %s permit 10", v.routeMap()), fmt.Sprintf("match ip address prefix-list %s", v.prefixList()), "exit", + fmt.Sprintf("route-map %s permit 15", v.routeMap()), + fmt.Sprintf("match ip address prefix-list %s", v.defaultPrefixList()), + fmt.Sprintf("match ip next-hop prefix-list %s", v.transitPrefixList()), + "exit", fmt.Sprintf("route-map %s deny 20", v.routeMap()), "exit", fmt.Sprintf("vrf %s", v.Name()), diff --git a/internal/frr/config_test.go b/internal/frr/config_test.go index 766554a..9ce27d9 100644 --- a/internal/frr/config_test.go +++ b/internal/frr/config_test.go @@ -23,6 +23,7 @@ func labVRF(t *testing.T) VRF { L3VNI: 4001, VTEP: net.ParseIP("192.168.14.11"), Supernet: mustCIDR(t, "10.10.0.0/16"), + Transit: net.ParseIP("169.254.0.2"), } } @@ -55,9 +56,15 @@ func TestBaseCommands(t *testing.T) { func TestVRFCommands(t *testing.T) { want := []string{ "ip prefix-list PL-a1b2 seq 10 permit 10.10.0.0/16 le 32", + "ip prefix-list PL-a1b2-default seq 10 permit 0.0.0.0/0", + "ip prefix-list PL-a1b2-transit seq 10 permit 169.254.0.2/32", "route-map EXPORT-a1b2 permit 10", "match ip address prefix-list PL-a1b2", "exit", + "route-map EXPORT-a1b2 permit 15", + "match ip address prefix-list PL-a1b2-default", + "match ip next-hop prefix-list PL-a1b2-transit", + "exit", "route-map EXPORT-a1b2 deny 20", "exit", "vrf vrf-a1b2", @@ -124,6 +131,8 @@ func TestVRFValidateRejects(t *testing.T) { "vtep IPv6": {func(v *VRF) { v.VTEP = net.ParseIP("fd00::1") }, "vtep fd00::1 is not an IPv4 address"}, "supernet absent": {func(v *VRF) { v.Supernet = nil }, "supernet is not an IPv4 prefix"}, "supernet IPv6": {func(v *VRF) { v.Supernet = mustCIDR(t, "fd00::/48") }, "supernet fd00::/48 is not an IPv4 prefix"}, + "transit absent": {func(v *VRF) { v.Transit = nil }, "transit is not an IPv4 address"}, + "transit IPv6": {func(v *VRF) { v.Transit = net.ParseIP("fd00::2") }, "transit fd00::2 is not an IPv4 address"}, } for name, c := range cases { v := labVRF(t) diff --git a/internal/frr/teardown.go b/internal/frr/teardown.go index fcbc407..dcb43c8 100644 --- a/internal/frr/teardown.go +++ b/internal/frr/teardown.go @@ -25,8 +25,10 @@ func routingTeardown(v VRF, running string) []step { if hasPrefix(lines, "route-map "+v.routeMap()+" ") { steps = append(steps, step{"no route-map " + v.routeMap()}) } - if hasPrefix(lines, "ip prefix-list "+v.prefixList()+" ") { - steps = append(steps, step{"no ip prefix-list " + v.prefixList()}) + for _, list := range []string{v.prefixList(), v.defaultPrefixList(), v.transitPrefixList()} { + if hasPrefix(lines, "ip prefix-list "+list+" ") { + steps = append(steps, step{"no ip prefix-list " + list}) + } } return steps } diff --git a/internal/frr/teardown_test.go b/internal/frr/teardown_test.go index 210c943..91ca84b 100644 --- a/internal/frr/teardown_test.go +++ b/internal/frr/teardown_test.go @@ -51,12 +51,19 @@ router bgp 64600 vrf vrf-a1b2c exit ! ip prefix-list PL-a1b2 seq 10 permit 10.10.0.0/16 le 32 +ip prefix-list PL-a1b2-default seq 10 permit 0.0.0.0/0 +ip prefix-list PL-a1b2-transit seq 10 permit 169.254.0.2/32 ip prefix-list PL-a1b2c seq 10 permit 10.20.0.0/16 le 32 ! route-map EXPORT-a1b2 permit 10 match ip address prefix-list PL-a1b2 exit ! +route-map EXPORT-a1b2 permit 15 + match ip address prefix-list PL-a1b2-default + match ip next-hop prefix-list PL-a1b2-transit +exit +! route-map EXPORT-a1b2 deny 20 exit ! @@ -91,6 +98,8 @@ func TestRoutingTeardownFollowsTheOrderFRRRequires(t *testing.T) { {"no router bgp 64600 vrf vrf-a1b2"}, {"no route-map EXPORT-a1b2"}, {"no ip prefix-list PL-a1b2"}, + {"no ip prefix-list PL-a1b2-default"}, + {"no ip prefix-list PL-a1b2-transit"}, } if got := routingTeardown(labVRF(t), fullRunning); !reflect.DeepEqual(got, want) { t.Errorf("démontage :\n%q\nattendu :\n%q", got, want) @@ -104,6 +113,8 @@ func TestRoutingTeardownTakesTheASNOfTheInstanceFromFRR(t *testing.T) { {"no router bgp 64600 vrf vrf-a1b2"}, {"no route-map EXPORT-a1b2"}, {"no ip prefix-list PL-a1b2"}, + {"no ip prefix-list PL-a1b2-default"}, + {"no ip prefix-list PL-a1b2-transit"}, } for _, asn := range []uint32{0, 64601} { v := labVRF(t) diff --git a/internal/l3vni/host.go b/internal/l3vni/host.go index 24a6c98..a97c547 100644 --- a/internal/l3vni/host.go +++ b/internal/l3vni/host.go @@ -23,6 +23,7 @@ type host interface { DeleteLink(name string) error TableRouteVia(table uint32, dst *net.IPNet, gw net.IP, iface string) error TableRouteDel(table uint32, dst *net.IPNet) error + TableRouteDelVia(table uint32, dst *net.IPNet, gw net.IP, iface string) error TableUnreachableDefault(table uint32) error TableUnreachableDefaultDel(table uint32) error ApplyVRF(v frr.VRF) error @@ -89,6 +90,10 @@ func (system) TableRouteDel(table uint32, dst *net.IPNet) error { return netif.RouteDelIfExists(int(table), dst) } +func (system) TableRouteDelVia(table uint32, dst *net.IPNet, gw net.IP, iface string) error { + return netif.RouteDelViaIfExists(int(table), dst, gw, iface) +} + func (system) TableUnreachableDefault(table uint32) error { return netif.RouteReplaceUnreachableDefault(int(table), UnreachableMetric) } diff --git a/internal/l3vni/l3.go b/internal/l3vni/l3.go index ad22ac2..03b5658 100644 --- a/internal/l3vni/l3.go +++ b/internal/l3vni/l3.go @@ -19,6 +19,7 @@ const UnreachableMetric = 4278198272 var ( transitHost = &net.IPNet{IP: net.IPv4(169, 254, 0, 1).To4(), Mask: net.CIDRMask(30, 32)} transitNetns = &net.IPNet{IP: net.IPv4(169, 254, 0, 2).To4(), Mask: net.CIDRMask(30, 32)} + defaultRoute = &net.IPNet{IP: net.IPv4zero.To4(), Mask: net.CIDRMask(0, 32)} ) type l3VPC struct { @@ -104,8 +105,11 @@ func createL3(h host, cfg *configuration.Config, v l3VPC) error { {"route " + v.supernet.String() + " in " + v.netns, func() error { return h.RouteVia(v.netns, v.supernet, transitHost.IP, v.vethNetns()) }}, + {"default route in " + v.netns, func() error { + return h.RouteVia(v.netns, defaultRoute, transitHost.IP, v.vethNetns()) + }}, {"frr " + v.vrf(), func() error { - return h.ApplyVRF(frr.VRF{ASN: asn, ID: v.id, L3VNI: v.vni, VTEP: vtep, Supernet: v.supernet}) + return h.ApplyVRF(frr.VRF{ASN: asn, ID: v.id, L3VNI: v.vni, VTEP: vtep, Supernet: v.supernet, Transit: transitNetns.IP}) }}, } for _, s := range steps { diff --git a/internal/l3vni/l3_test.go b/internal/l3vni/l3_test.go index 7855f27..75cb17a 100644 --- a/internal/l3vni/l3_test.go +++ b/internal/l3vni/l3_test.go @@ -83,6 +83,10 @@ func (f *fakeHost) TableRouteDel(table uint32, dst *net.IPNet) error { return f.record(fmt.Sprintf("table %d del %s", table, dst)) } +func (f *fakeHost) TableRouteDelVia(table uint32, dst *net.IPNet, gw net.IP, iface string) error { + return f.record(fmt.Sprintf("table %d del %s via %s dev %s", table, dst, gw, iface)) +} + func (f *fakeHost) TableUnreachableDefault(table uint32) error { return f.record(fmt.Sprintf("table %d unreachable default", table)) } @@ -92,7 +96,7 @@ func (f *fakeHost) TableUnreachableDefaultDel(table uint32) error { } func (f *fakeHost) ApplyVRF(v frr.VRF) error { - return f.record(fmt.Sprintf("frr apply asn=%d id=%s vni=%d vtep=%s supernet=%s", v.ASN, v.ID, v.L3VNI, v.VTEP, v.Supernet)) + return f.record(fmt.Sprintf("frr apply asn=%d id=%s vni=%d vtep=%s supernet=%s transit=%s", v.ASN, v.ID, v.L3VNI, v.VTEP, v.Supernet, v.Transit)) } func (f *fakeHost) WithdrawVRF(v frr.VRF) error { @@ -145,7 +149,8 @@ func TestCreateL3FollowsTheLabRecipe(t *testing.T) { "up [vp-s7] l3-s7-i", "sysctl [vp-s7] net.ipv4.ip_forward=1", "route [vp-s7] 10.241.0.0/16 via 169.254.0.1 dev l3-s7-i", - "frr apply asn=64600 id=s7 vni=2700 vtep=192.168.14.11 supernet=10.241.0.0/16", + "route [vp-s7] 0.0.0.0/0 via 169.254.0.1 dev l3-s7-i", + "frr apply asn=64600 id=s7 vni=2700 vtep=192.168.14.11 supernet=10.241.0.0/16 transit=169.254.0.2", } if !reflect.DeepEqual(f.calls, want) { t.Errorf("appels :\n%s\nattendu :\n%s", strings.Join(f.calls, "\n"), strings.Join(want, "\n")) diff --git a/internal/l3vni/route.go b/internal/l3vni/route.go index 333abf6..767ec31 100644 --- a/internal/l3vni/route.go +++ b/internal/l3vni/route.go @@ -16,6 +16,14 @@ func WithdrawRoute(db *badger.DB, vpcName string, dst *net.IPNet) error { return withdrawRoute(newSystem(), db, vpcName, dst) } +func ExportDefault(db *badger.DB, vpcName string) error { + return exportDefault(newSystem(), db, vpcName) +} + +func WithdrawDefault(db *badger.DB, vpcName string) error { + return withdrawDefault(newSystem(), db, vpcName) +} + func loadRouted(db *badger.DB, vpcName string) (l3VPC, bool, error) { parts := strings.SplitN(vpcName, "-", 2) if len(parts) != 2 { @@ -48,3 +56,36 @@ func withdrawRoute(h host, db *badger.DB, vpcName string, dst *net.IPNet) error } return nil } + +func loadRequired(db *badger.DB, vpcName string) (l3VPC, error) { + v, ok, err := loadRouted(db, vpcName) + if err != nil { + return l3VPC{}, err + } + if !ok { + return l3VPC{}, fmt.Errorf("vpc %q has no l3vni", vpcName) + } + return v, nil +} + +func exportDefault(h host, db *badger.DB, vpcName string) error { + v, err := loadRequired(db, vpcName) + if err != nil { + return err + } + if err := h.TableRouteVia(v.vni, defaultRoute, transitNetns.IP, v.vethHost()); err != nil { + return fmt.Errorf("export default in %s: %w", v.vrf(), err) + } + return nil +} + +func withdrawDefault(h host, db *badger.DB, vpcName string) error { + v, err := loadRequired(db, vpcName) + if err != nil { + return err + } + if err := h.TableRouteDelVia(v.vni, defaultRoute, transitNetns.IP, v.vethHost()); err != nil { + return fmt.Errorf("withdraw default from %s: %w", v.vrf(), err) + } + return nil +} diff --git a/internal/l3vni/route_test.go b/internal/l3vni/route_test.go index 0377f68..b592bc6 100644 --- a/internal/l3vni/route_test.go +++ b/internal/l3vni/route_test.go @@ -87,3 +87,50 @@ func TestRouteErrorsArePropagated(t *testing.T) { t.Error("nom de VPC sans tiret accepté") } } + +func TestExportDefaultInstallsTheDefaultRouteInTheVRFTowardsTheNetns(t *testing.T) { + f := &fakeHost{} + if err := exportDefault(f, routedDB(t), "vp-s7"); err != nil { + t.Fatal(err) + } + want := []string{"table 2700 route 0.0.0.0/0 via 169.254.0.2 dev l3-s7-o"} + if !reflect.DeepEqual(f.calls, want) { + t.Errorf("appels %q, attendu %q", f.calls, want) + } +} + +func TestWithdrawDefaultNamesTheGatewaySoTheUnreachableDefaultStays(t *testing.T) { + f := &fakeHost{} + if err := withdrawDefault(f, routedDB(t), "vp-s7"); err != nil { + t.Fatal(err) + } + want := []string{"table 2700 del 0.0.0.0/0 via 169.254.0.2 dev l3-s7-o"} + if !reflect.DeepEqual(f.calls, want) { + t.Errorf("appels %q, attendu %q", f.calls, want) + } +} + +func TestDefaultRouteRefusesAVPCWithoutL3VNI(t *testing.T) { + db := routedDB(t) + for label, run := range map[string]func(host, *badger.DB, string) error{ + "export": exportDefault, + "withdraw": withdrawDefault, + } { + f := &fakeHost{} + err := run(f, db, "vp-flat") + if err == nil || !strings.Contains(err.Error(), `vpc "vp-flat" has no l3vni`) || len(f.calls) != 0 { + t.Errorf("%s : erreur %v, appels %q", label, err, f.calls) + } + } +} + +func TestDefaultRouteErrorsArePropagated(t *testing.T) { + db := routedDB(t) + f := &fakeHost{fail: map[string]error{"table ": errors.New("network unreachable")}} + if err := exportDefault(f, db, "vp-s7"); err == nil || !strings.Contains(err.Error(), "export default in vrf-s7: network unreachable") { + t.Errorf("export : %v", err) + } + if err := withdrawDefault(f, db, "vp-s7"); err == nil || !strings.Contains(err.Error(), "withdraw default from vrf-s7: network unreachable") { + t.Errorf("withdraw : %v", err) + } +} diff --git a/internal/netif/route_linux.go b/internal/netif/route_linux.go index 1001a53..75ef3df 100644 --- a/internal/netif/route_linux.go +++ b/internal/netif/route_linux.go @@ -51,6 +51,24 @@ func TableRoutesVia(table int, iface string) ([]*net.IPNet, error) { return dsts, nil } +func RouteDelViaIfExists(table int, dst *net.IPNet, gw net.IP, iface string) error { + link, err := netlink.LinkByName(iface) + if err != nil { + return err + } + err = netlink.RouteDel(&netlink.Route{ + LinkIndex: link.Attrs().Index, + Dst: dst, + Gw: gw, + Table: table, + Type: unix.RTN_UNICAST, + }) + if err != nil && !errors.Is(err, syscall.ESRCH) { + return err + } + return nil +} + func unreachableDefault(table, metric int) *netlink.Route { return &netlink.Route{ Dst: defaultIPv4, diff --git a/internal/netif/route_other.go b/internal/netif/route_other.go index 9b7a12b..2ea9883 100644 --- a/internal/netif/route_other.go +++ b/internal/netif/route_other.go @@ -30,3 +30,7 @@ func RouteDelUnreachableDefaultIfExists(_, _ int) error { func HasUnreachableDefault(_, _ int) (bool, error) { return false, errors.New("route listing is only implemented on linux") } + +func RouteDelViaIfExists(_ int, _ *net.IPNet, _ net.IP, _ string) error { + return errors.New("not supported on this platform") +}