diff --git a/internal/fip/fip.go b/internal/fip/fip.go new file mode 100644 index 0000000..a17a33b --- /dev/null +++ b/internal/fip/fip.go @@ -0,0 +1,190 @@ +package fip + +import ( + "encoding/binary" + "fmt" + "net" + "strings" + + "git.g3e.fr/syonad/two/internal/netif" + "git.g3e.fr/syonad/two/internal/nft" + "git.g3e.fr/syonad/two/pkg/db/kv" + + "github.com/dgraph-io/badger/v4" +) + +const ( + publicBridge = "br-public" + mainTable = 254 + prefMain = 100 + prefOwn = 101 +) + +type Target struct { + VPC string + CIDR *net.IPNet + Private net.IP +} + +type floatingIP struct { + netns string + vpcCIDR *net.IPNet + iface string + mac net.HardwareAddr + public *net.IPNet + private net.IP + gateway net.IP + table int +} + +func Iface(public net.IP) (string, error) { + ip := public.To4() + if ip == nil { + return "", fmt.Errorf("public ip %v is not an IPv4 address", public) + } + return fmt.Sprintf("fip-%08x", binary.BigEndian.Uint32(ip)), nil +} + +func table(private net.IP) (int, error) { + ip := private.To4() + if ip == nil { + return 0, fmt.Errorf("private ip %v is not an IPv4 address", private) + } + t := int(binary.BigEndian.Uint32(ip)) + if t < 256 { + return 0, fmt.Errorf("private ip %v gives a reserved routing table %d", private, t) + } + return t, nil +} + +func Resolve(db *badger.DB, vmName, ifaceName string) (Target, error) { + prefix := "vm/" + vmName + "/nic/" + entries, err := kv.ListByPrefix(db, prefix) + if err != nil { + return Target{}, fmt.Errorf("vm %q: listing interfaces: %w", vmName, err) + } + for key, value := range entries { + nic, ok := strings.CutSuffix(strings.TrimPrefix(key, prefix), "/name") + if !ok || strings.Contains(nic, "/") || value != ifaceName { + continue + } + ip := net.ParseIP(entries[prefix+nic+"/ip"]).To4() + if ip == nil { + return Target{}, fmt.Errorf("vm %q: interface %q has no IPv4 address", vmName, ifaceName) + } + subnet := entries[prefix+nic+"/subnet"] + vpc, err := kv.GetFromDB(db, "subnet/"+subnet+"/vpc") + if err != nil { + return Target{}, fmt.Errorf("vm %q: interface %q: vpc of subnet %q: %w", vmName, ifaceName, subnet, err) + } + raw, err := kv.GetFromDB(db, "vpc/"+vpc+"/cidr") + if err != nil { + return Target{}, fmt.Errorf("vm %q: interface %q: cidr of vpc %q: %w", vmName, ifaceName, vpc, err) + } + _, cidr, err := net.ParseCIDR(raw) + if err != nil { + return Target{}, fmt.Errorf("vm %q: interface %q: invalid cidr %q of vpc %q", vmName, ifaceName, raw, vpc) + } + return Target{VPC: vpc, CIDR: cidr, Private: ip}, nil + } + return Target{}, fmt.Errorf("vm %q has no interface %q", vmName, ifaceName) +} + +func build(t Target, public *net.IPNet, gw net.IP) (floatingIP, error) { + iface, err := Iface(public.IP) + if err != nil { + return floatingIP{}, err + } + mac, err := netif.FloatingIPMAC(public.IP) + if err != nil { + return floatingIP{}, err + } + tbl, err := table(t.Private) + if err != nil { + return floatingIP{}, err + } + return floatingIP{netns: t.VPC, vpcCIDR: t.CIDR, iface: iface, mac: mac, public: public, private: t.Private, gateway: gw, table: tbl}, nil +} + +func Create(t Target, public *net.IPNet, gw net.IP) error { + f, err := build(t, public, gw) + if err != nil { + return err + } + return create(system{}, f) +} + +func Delete(t Target, public *net.IPNet) error { + f, err := build(t, public, nil) + if err != nil { + return err + } + return remove(system{}, f) +} + +type step struct { + what string + run func() error +} + +func runSteps(f floatingIP, steps []step) error { + for _, s := range steps { + if err := s.run(); err != nil { + return fmt.Errorf("floating ip %s of %s: %s: %w", f.public.IP, f.private, s.what, err) + } + } + return nil +} + +func (f floatingIP) host() *net.IPNet { + return &net.IPNet{IP: f.public.IP.To4(), Mask: net.CIDRMask(32, 32)} +} + +func (f floatingIP) segment() *net.IPNet { + return &net.IPNet{IP: f.public.IP.Mask(f.public.Mask), Mask: f.public.Mask} +} + +func sysctls(iface string) [][2]string { + return [][2]string{ + {"net.ipv4.conf." + iface + ".arp_ignore", "1"}, + {"net.ipv4.conf." + iface + ".arp_announce", "2"}, + {"net.ipv4.conf." + iface + ".arp_notify", "1"}, + } +} + +func create(h host, f floatingIP) error { + ns := f.netns + rules := nft.FloatingIP{Iface: f.iface, Public: f.public.IP.String(), Private: f.private.String()} + steps := []step{ + {"create " + f.iface, func() error { return h.CreateMacvlan(ns, f.iface, publicBridge, f.mac) }}, + {"local fdb entry " + f.mac.String(), func() error { return h.BridgeAddLocalMAC(ns, publicBridge, f.mac) }}, + } + for _, sc := range sysctls(f.iface) { + steps = append(steps, step{sc[0], func() error { return h.Sysctl(ns, sc[0], sc[1]) }}) + } + steps = append(steps, + step{"translation rules", func() error { return h.SetFloatingIP(ns, rules) }}, + step{"address " + f.host().String(), func() error { return h.AddrAdd(ns, f.iface, f.host()) }}, + step{"set up " + f.iface, func() error { return h.LinkUp(ns, f.iface) }}, + step{fmt.Sprintf("route %s of table %d", f.segment(), f.table), func() error { + return h.TableRouteDev(ns, f.table, f.segment(), f.iface) + }}, + step{fmt.Sprintf("default route of table %d via %s", f.table, f.gateway), func() error { + return h.TableDefaultVia(ns, f.table, f.gateway, f.iface) + }}, + step{"rule to the main table for " + f.vpcCIDR.String(), func() error { return h.RuleAdd(ns, f.private, f.vpcCIDR, mainTable, prefMain) }}, + step{fmt.Sprintf("rule to table %d", f.table), func() error { return h.RuleAdd(ns, f.private, nil, f.table, prefOwn) }}, + ) + return runSteps(f, steps) +} + +func remove(h host, f floatingIP) error { + ns := f.netns + return runSteps(f, []step{ + {fmt.Sprintf("rule to table %d", f.table), func() error { return h.RuleDel(ns, f.private, nil, f.table, prefOwn) }}, + {"rule to the main table for " + f.vpcCIDR.String(), func() error { return h.RuleDel(ns, f.private, f.vpcCIDR, mainTable, prefMain) }}, + {"translation rules", func() error { return h.DeleteFloatingIP(ns, f.iface) }}, + {"local fdb entry " + f.mac.String(), func() error { return h.BridgeDelLocalMAC(ns, publicBridge, f.mac) }}, + {"delete " + f.iface, func() error { return h.DeleteLink(ns, f.iface) }}, + }) +} diff --git a/internal/fip/fip_test.go b/internal/fip/fip_test.go new file mode 100644 index 0000000..9ca5709 --- /dev/null +++ b/internal/fip/fip_test.go @@ -0,0 +1,235 @@ +package fip + +import ( + "errors" + "fmt" + "net" + "reflect" + "strings" + "testing" + + "git.g3e.fr/syonad/two/internal/nft" + "git.g3e.fr/syonad/two/pkg/db/kv" + "github.com/dgraph-io/badger/v4" +) + +type fakeHost struct { + calls []string + fail map[string]error +} + +func (f *fakeHost) record(call string) error { + f.calls = append(f.calls, call) + for prefix, err := range f.fail { + if strings.HasPrefix(call, prefix) { + return err + } + } + return nil +} + +func (f *fakeHost) CreateMacvlan(ns, name, parent string, mac net.HardwareAddr) error { + return f.record(fmt.Sprintf("macvlan [%s] %s parent %s mac %s", ns, name, parent, mac)) +} + +func (f *fakeHost) BridgeAddLocalMAC(ns, bridge string, mac net.HardwareAddr) error { + return f.record(fmt.Sprintf("fdb add [%s] %s %s", ns, bridge, mac)) +} + +func (f *fakeHost) BridgeDelLocalMAC(ns, bridge string, mac net.HardwareAddr) error { + return f.record(fmt.Sprintf("fdb del [%s] %s %s", ns, bridge, mac)) +} + +func (f *fakeHost) Sysctl(ns, key, value string) error { + return f.record(fmt.Sprintf("sysctl [%s] %s=%s", ns, key, value)) +} + +func (f *fakeHost) SetFloatingIP(ns string, r nft.FloatingIP) error { + return f.record(fmt.Sprintf("nft set [%s] %s %s<->%s", ns, r.Iface, r.Public, r.Private)) +} + +func (f *fakeHost) DeleteFloatingIP(ns, iface string) error { + return f.record(fmt.Sprintf("nft del [%s] %s", ns, iface)) +} + +func (f *fakeHost) AddrAdd(ns, iface string, prefix *net.IPNet) error { + return f.record(fmt.Sprintf("addr [%s] %s %s", ns, iface, prefix)) +} + +func (f *fakeHost) LinkUp(ns, iface string) error { + return f.record(fmt.Sprintf("up [%s] %s", ns, iface)) +} + +func (f *fakeHost) TableRouteDev(ns string, table int, dst *net.IPNet, iface string) error { + return f.record(fmt.Sprintf("table %d [%s] %s dev %s", table, ns, dst, iface)) +} + +func (f *fakeHost) TableDefaultVia(ns string, table int, gw net.IP, iface string) error { + return f.record(fmt.Sprintf("table %d [%s] default via %s dev %s", table, ns, gw, iface)) +} + +func rule(src net.IP, dst *net.IPNet, table, priority int) string { + to := "all" + if dst != nil { + to = dst.String() + } + return fmt.Sprintf("%d from %s to %s lookup %d", priority, src, to, table) +} + +func (f *fakeHost) RuleAdd(ns string, src net.IP, dst *net.IPNet, table, priority int) error { + return f.record(fmt.Sprintf("rule add [%s] %s", ns, rule(src, dst, table, priority))) +} + +func (f *fakeHost) RuleDel(ns string, src net.IP, dst *net.IPNet, table, priority int) error { + return f.record(fmt.Sprintf("rule del [%s] %s", ns, rule(src, dst, table, priority))) +} + +func (f *fakeHost) DeleteLink(ns, name string) error { + return f.record(fmt.Sprintf("del [%s] %s", ns, name)) +} + +func labFloatingIP(t *testing.T) floatingIP { + t.Helper() + ip, public, err := net.ParseCIDR("240.0.0.47/24") + if err != nil { + t.Fatal(err) + } + public.IP = ip + _, cidr, _ := net.ParseCIDR("10.47.0.0/16") + f, err := build(Target{VPC: "vp-t47", CIDR: cidr, Private: net.ParseIP("10.47.1.10")}, public, net.ParseIP("240.0.0.1")) + if err != nil { + t.Fatal(err) + } + return f +} + +func TestBuildDerivesInterfaceMACAndTable(t *testing.T) { + f := labFloatingIP(t) + if f.iface != "fip-f000002f" || f.mac.String() != "02:05:f0:00:00:2f" || f.table != 0x0a2f010a { + t.Errorf("interface %s, MAC %s, table %d", f.iface, f.mac, f.table) + } +} + +func TestBuildRefusesAReservedTable(t *testing.T) { + _, public, _ := net.ParseCIDR("240.0.0.47/24") + if _, err := build(Target{VPC: "vp-t47", Private: net.ParseIP("0.0.0.254")}, public, nil); err == nil || !strings.Contains(err.Error(), "reserved routing table 254") { + t.Errorf("erreur %v", err) + } +} + +func TestCreateTranslatesBeforeRoutingThroughTheFloatingIP(t *testing.T) { + f := &fakeHost{} + if err := create(f, labFloatingIP(t)); err != nil { + t.Fatal(err) + } + want := []string{ + "macvlan [vp-t47] fip-f000002f parent br-public mac 02:05:f0:00:00:2f", + "fdb add [vp-t47] br-public 02:05:f0:00:00:2f", + "sysctl [vp-t47] net.ipv4.conf.fip-f000002f.arp_ignore=1", + "sysctl [vp-t47] net.ipv4.conf.fip-f000002f.arp_announce=2", + "sysctl [vp-t47] net.ipv4.conf.fip-f000002f.arp_notify=1", + "nft set [vp-t47] fip-f000002f 240.0.0.47<->10.47.1.10", + "addr [vp-t47] fip-f000002f 240.0.0.47/32", + "up [vp-t47] fip-f000002f", + "table 170852618 [vp-t47] 240.0.0.0/24 dev fip-f000002f", + "table 170852618 [vp-t47] default via 240.0.0.1 dev fip-f000002f", + "rule add [vp-t47] 100 from 10.47.1.10 to 10.47.0.0/16 lookup 254", + "rule add [vp-t47] 101 from 10.47.1.10 to all lookup 170852618", + } + if !reflect.DeepEqual(f.calls, want) { + t.Errorf("appels :\n%s\nattendu :\n%s", strings.Join(f.calls, "\n"), strings.Join(want, "\n")) + } +} + +func TestCreateRoutesNothingThroughTheFloatingIPWithoutTranslation(t *testing.T) { + f := &fakeHost{fail: map[string]error{"nft set ": errors.New("nft absent")}} + err := create(f, labFloatingIP(t)) + if err == nil || !strings.Contains(err.Error(), "floating ip 240.0.0.47 of 10.47.1.10: translation rules: nft absent") { + t.Fatalf("erreur %v", err) + } + for _, c := range f.calls { + if strings.HasPrefix(c, "rule ") || strings.HasPrefix(c, "table ") || strings.HasPrefix(c, "addr ") { + t.Errorf("étape exécutée sans traduction : %q", c) + } + } +} + +func TestRemoveDropsTheRulesFirstThenUndoesTheHost(t *testing.T) { + f := &fakeHost{} + if err := remove(f, labFloatingIP(t)); err != nil { + t.Fatal(err) + } + want := []string{ + "rule del [vp-t47] 101 from 10.47.1.10 to all lookup 170852618", + "rule del [vp-t47] 100 from 10.47.1.10 to 10.47.0.0/16 lookup 254", + "nft del [vp-t47] fip-f000002f", + "fdb del [vp-t47] br-public 02:05:f0:00:00:2f", + "del [vp-t47] fip-f000002f", + } + if !reflect.DeepEqual(f.calls, want) { + t.Errorf("appels :\n%s\nattendu :\n%s", strings.Join(f.calls, "\n"), strings.Join(want, "\n")) + } +} + +func TestRemoveStopsAtTheFirstFailure(t *testing.T) { + f := &fakeHost{fail: map[string]error{"rule del [vp-t47] 101": errors.New("netns absent")}} + if err := remove(f, labFloatingIP(t)); err == nil || len(f.calls) != 1 { + t.Errorf("erreur %v, appels %q", err, f.calls) + } +} + +func seedVM(t *testing.T) *badger.DB { + t.Helper() + db := kv.InitDB(kv.Config{Path: t.TempDir()}, false) + t.Cleanup(func() { db.Close() }) + for key, value := range map[string]string{ + "vpc/vp-t47/cidr": "10.47.0.0/16", + "subnet/sn-a/vpc": "vp-t47", + "subnet/sn-b/vpc": "vp-t47", + "vm/vm-1/nic/0/name": "nic-a1b2", + "vm/vm-1/nic/0/subnet": "sn-a", + "vm/vm-1/nic/0/ip": "10.47.1.10", + "vm/vm-1/nic/1/name": "nic-c3d4", + "vm/vm-1/nic/1/subnet": "sn-b", + "vm/vm-1/nic/1/ip": "10.47.2.10", + "vm/vm-10/nic/0/name": "nic-a1b2", + "vm/vm-10/nic/0/subnet": "sn-a", + "vm/vm-10/nic/0/ip": "10.47.1.99", + } { + kv.AddInDB(db, key, value) + } + return db +} + +func TestResolveFindsTheInterfaceByName(t *testing.T) { + got, err := Resolve(seedVM(t), "vm-1", "nic-c3d4") + if err != nil { + t.Fatal(err) + } + if got.VPC != "vp-t47" || got.CIDR.String() != "10.47.0.0/16" || got.Private.String() != "10.47.2.10" { + t.Errorf("cible %+v", got) + } +} + +func TestResolveIgnoresAVMWhoseNameExtendsTheOne(t *testing.T) { + got, err := Resolve(seedVM(t), "vm-1", "nic-a1b2") + if err != nil || got.Private.String() != "10.47.1.10" { + t.Errorf("cible %+v, erreur %v", got, err) + } +} + +func TestResolveRefusesAnUnknownInterface(t *testing.T) { + if _, err := Resolve(seedVM(t), "vm-1", "nic-zzzz"); err == nil || !strings.Contains(err.Error(), `vm "vm-1" has no interface "nic-zzzz"`) { + t.Errorf("erreur %v", err) + } +} + +func TestIfaceFitsTheKernelLimit(t *testing.T) { + name, err := Iface(net.ParseIP("255.255.255.255")) + if err != nil || name != "fip-ffffffff" || len(name) > 15 { + t.Errorf("%q (%d caractères), %v", name, len(name), err) + } + if _, err := Iface(net.ParseIP("2001:db8::1")); err == nil { + t.Error("IPv6 acceptée") + } +} diff --git a/internal/fip/host.go b/internal/fip/host.go new file mode 100644 index 0000000..7616c49 --- /dev/null +++ b/internal/fip/host.go @@ -0,0 +1,82 @@ +package fip + +import ( + "net" + + "git.g3e.fr/syonad/two/internal/netif" + "git.g3e.fr/syonad/two/internal/netns" + "git.g3e.fr/syonad/two/internal/nft" + "git.g3e.fr/syonad/two/internal/sysctl" +) + +type host interface { + CreateMacvlan(ns, name, parent string, mac net.HardwareAddr) error + BridgeAddLocalMAC(ns, bridge string, mac net.HardwareAddr) error + BridgeDelLocalMAC(ns, bridge string, mac net.HardwareAddr) error + Sysctl(ns, key, value string) error + SetFloatingIP(ns string, f nft.FloatingIP) error + DeleteFloatingIP(ns, iface string) error + AddrAdd(ns, iface string, prefix *net.IPNet) error + LinkUp(ns, iface string) error + TableRouteDev(ns string, table int, dst *net.IPNet, iface string) error + TableDefaultVia(ns string, table int, gw net.IP, iface string) error + RuleAdd(ns string, src net.IP, dst *net.IPNet, table, priority int) error + RuleDel(ns string, src net.IP, dst *net.IPNet, table, priority int) error + DeleteLink(ns, name string) error +} + +var defaultRoute = &net.IPNet{IP: net.IPv4zero.To4(), Mask: net.CIDRMask(0, 32)} + +type system struct{} + +func (system) CreateMacvlan(ns, name, parent string, mac net.HardwareAddr) error { + return netns.Call(ns, func() error { return netif.CreateMacvlan(name, parent, mac) }) +} + +func (system) BridgeAddLocalMAC(ns, bridge string, mac net.HardwareAddr) error { + return netns.Call(ns, func() error { return netif.BridgeAddLocalMAC(bridge, mac) }) +} + +func (system) BridgeDelLocalMAC(ns, bridge string, mac net.HardwareAddr) error { + return netns.Call(ns, func() error { return netif.BridgeDelLocalMACIfExists(bridge, mac) }) +} + +func (system) Sysctl(ns, key, value string) error { + return netns.Call(ns, func() error { return sysctl.Set(key, value) }) +} + +func (system) SetFloatingIP(ns string, f nft.FloatingIP) error { + return netns.Call(ns, func() error { return nft.SetFloatingIP(f) }) +} + +func (system) DeleteFloatingIP(ns, iface string) error { + return netns.Call(ns, func() error { return nft.DeleteFloatingIP(iface) }) +} + +func (system) AddrAdd(ns, iface string, prefix *net.IPNet) error { + return netns.Call(ns, func() error { return netif.AddrAddPrefix(iface, prefix) }) +} + +func (system) LinkUp(ns, iface string) error { + return netns.Call(ns, func() error { return netif.LinkSetUp(iface) }) +} + +func (system) TableRouteDev(ns string, table int, dst *net.IPNet, iface string) error { + return netns.Call(ns, func() error { return netif.RouteReplaceDev(table, dst, iface) }) +} + +func (system) TableDefaultVia(ns string, table int, gw net.IP, iface string) error { + return netns.Call(ns, func() error { return netif.RouteReplaceVia(table, defaultRoute, gw, iface) }) +} + +func (system) RuleAdd(ns string, src net.IP, dst *net.IPNet, table, priority int) error { + return netns.Call(ns, func() error { return netif.RuleAddFrom(src, dst, table, priority) }) +} + +func (system) RuleDel(ns string, src net.IP, dst *net.IPNet, table, priority int) error { + return netns.Call(ns, func() error { return netif.RuleDelFromIfExists(src, dst, table, priority) }) +} + +func (system) DeleteLink(ns, name string) error { + return netns.Call(ns, func() error { return netif.DeleteLinkIfExists(name) }) +} diff --git a/internal/netif/route_linux.go b/internal/netif/route_linux.go index 75ef3df..5b8e5da 100644 --- a/internal/netif/route_linux.go +++ b/internal/netif/route_linux.go @@ -51,6 +51,19 @@ func TableRoutesVia(table int, iface string) ([]*net.IPNet, error) { return dsts, nil } +func RouteReplaceDev(table int, dst *net.IPNet, iface string) error { + link, err := netlink.LinkByName(iface) + if err != nil { + return err + } + return netlink.RouteReplace(&netlink.Route{ + LinkIndex: link.Attrs().Index, + Dst: dst, + Table: table, + Scope: netlink.SCOPE_LINK, + }) +} + func RouteDelViaIfExists(table int, dst *net.IPNet, gw net.IP, iface string) error { link, err := netlink.LinkByName(iface) if err != nil { diff --git a/internal/netif/route_other.go b/internal/netif/route_other.go index 2ea9883..62d6f4f 100644 --- a/internal/netif/route_other.go +++ b/internal/netif/route_other.go @@ -34,3 +34,7 @@ func HasUnreachableDefault(_, _ int) (bool, error) { func RouteDelViaIfExists(_ int, _ *net.IPNet, _ net.IP, _ string) error { return errors.New("not supported on this platform") } + +func RouteReplaceDev(_ int, _ *net.IPNet, _ string) error { + return errors.New("not supported on this platform") +} diff --git a/internal/netif/rule_linux.go b/internal/netif/rule_linux.go index fcc2538..88f0b32 100644 --- a/internal/netif/rule_linux.go +++ b/internal/netif/rule_linux.go @@ -10,24 +10,22 @@ import ( "github.com/vishvananda/netlink" ) -func sourceRule(src net.IP, table, priority int, suppressDefault bool) *netlink.Rule { +func sourceRule(src net.IP, dst *net.IPNet, table, priority int) *netlink.Rule { r := netlink.NewRule() r.Family = netlink.FAMILY_V4 r.Src = &net.IPNet{IP: src.To4(), Mask: net.CIDRMask(32, 32)} + r.Dst = dst r.Table = table r.Priority = priority - if suppressDefault { - r.SuppressPrefixlen = 0 - } return r } -func RuleAddFrom(src net.IP, table, priority int, suppressDefault bool) error { - return netlink.RuleAdd(sourceRule(src, table, priority, suppressDefault)) +func RuleAddFrom(src net.IP, dst *net.IPNet, table, priority int) error { + return netlink.RuleAdd(sourceRule(src, dst, table, priority)) } -func RuleDelFromIfExists(src net.IP, table, priority int, suppressDefault bool) error { - if err := netlink.RuleDel(sourceRule(src, table, priority, suppressDefault)); err != nil && !errors.Is(err, syscall.ENOENT) { +func RuleDelFromIfExists(src net.IP, dst *net.IPNet, table, priority int) error { + if err := netlink.RuleDel(sourceRule(src, dst, table, priority)); err != nil && !errors.Is(err, syscall.ENOENT) { return err } return nil diff --git a/internal/netif/rule_linux_test.go b/internal/netif/rule_linux_test.go index 846c247..24f5a10 100644 --- a/internal/netif/rule_linux_test.go +++ b/internal/netif/rule_linux_test.go @@ -10,15 +10,13 @@ import ( ) func TestSourceRule(t *testing.T) { - r := sourceRule(net.ParseIP("10.46.1.10"), 170786058, 101, false) - if r.Family != netlink.FAMILY_V4 || r.Src.String() != "10.46.1.10/32" || r.Table != 170786058 || r.Priority != 101 { + r := sourceRule(net.ParseIP("10.46.1.10"), nil, 170786058, 101) + if r.Family != netlink.FAMILY_V4 || r.Src.String() != "10.46.1.10/32" || r.Dst != nil || r.Table != 170786058 || r.Priority != 101 { t.Errorf("règle %+v", r) } - if r.SuppressPrefixlen != -1 { - t.Errorf("suppress_prefixlength %d sans suppression demandée, -1 attendu", r.SuppressPrefixlen) - } - main := sourceRule(net.ParseIP("10.46.1.10"), 254, 100, true) - if main.SuppressPrefixlen != 0 || main.Table != 254 { - t.Errorf("règle de la table main %+v", main) + _, vpc, _ := net.ParseCIDR("10.46.0.0/16") + toVPC := sourceRule(net.ParseIP("10.46.1.10"), vpc, 254, 100) + if toVPC.Dst.String() != "10.46.0.0/16" || toVPC.Table != 254 || toVPC.SuppressPrefixlen != -1 { + t.Errorf("règle vers le VPC %+v", toVPC) } } diff --git a/internal/netif/rule_other.go b/internal/netif/rule_other.go index f3bb34b..5ee7949 100644 --- a/internal/netif/rule_other.go +++ b/internal/netif/rule_other.go @@ -7,10 +7,10 @@ import ( "net" ) -func RuleAddFrom(_ net.IP, _, _ int, _ bool) error { +func RuleAddFrom(_ net.IP, _ *net.IPNet, _, _ int) error { return errors.New("not supported on this platform") } -func RuleDelFromIfExists(_ net.IP, _, _ int, _ bool) error { +func RuleDelFromIfExists(_ net.IP, _ *net.IPNet, _, _ int) error { return errors.New("not supported on this platform") }