plugins: set MAC addresses based on IP

This will give deterministic MAC addresses for all interfaces CNI
creates and manages the IP for:
* bridge: container veth and host bridge
* macvlan: container veth
* ptp: container veth and host veth

diff --git a/ip/link.go b/ip/link.go
index 1b78567..6d9d1cc 100644 (file)
--- a/ip/link.go
+++ b/ip/link.go
@@ -21,6 +21,7 @@ import (
        "os"
 
        "github.com/containernetworking/cni/pkg/ns"
+       "github.com/containernetworking/cni/pkg/utils/hwaddr"
        "github.com/vishvananda/netlink"
 )
 
@@ -151,3 +152,19 @@ func DelLinkByNameAddr(ifName string, family int) (*net.IPNet, error) {
 
        return addrs[0].IPNet, nil
 }
+
+func SetHWAddrByIP(link netlink.Link, ip4 net.IP, ip6 net.IP) error {
+       if ip4 != nil {
+               hwAddr, err := hwaddr.GenerateHardwareAddr4(ip4, hwaddr.PrivateMACPrefix)
+               if err != nil {
+                       return fmt.Errorf("failed to generate hardware addr: %v", err)
+               }
+               if err = netlink.LinkSetHardwareAddr(link, hwAddr); err != nil {
+                       return fmt.Errorf("failed to add hardware addr to %q: %v", link.Attrs().Name, err)
+               }
+       }
+
+       // TODO: IPv6
+
+       return nil
+}

diff --git a/ipam/ipam.go b/ipam/ipam.go
index 62bf15d..d9fbff7 100644 (file)
--- a/ipam/ipam.go
+++ b/ipam/ipam.go
@@ -21,16 +21,10 @@ import (
        "github.com/containernetworking/cni/pkg/invoke"
        "github.com/containernetworking/cni/pkg/ip"
        "github.com/containernetworking/cni/pkg/types"
-       "github.com/containernetworking/cni/pkg/utils/hwaddr"
 
        "github.com/vishvananda/netlink"
 )
 
-const (
-       // veth link dev type
-       vethLinkType = "veth"
-)
-
 func ExecAdd(plugin string, netconf []byte) (*types.Result, error) {
        return invoke.DelegateAdd(plugin, netconf)
 }
@@ -51,17 +45,6 @@ func ConfigureIface(ifName string, res *types.Result) error {
                return fmt.Errorf("failed to set %q UP: %v", ifName, err)
        }
 
-       // only set hardware address to veth when using ipv4
-       if link.Type() == vethLinkType && res.IP4 != nil {
-               hwAddr, err := hwaddr.GenerateHardwareAddr4(res.IP4.IP.IP, hwaddr.PrivateMACPrefix)
-               if err != nil {
-                       return fmt.Errorf("failed to generate hardware addr: %v", err)
-               }
-               if err = netlink.LinkSetHardwareAddr(link, hwAddr); err != nil {
-                       return fmt.Errorf("failed to add hardware addr to %q: %v", ifName, err)
-               }
-       }
-
        // TODO(eyakubovich): IPv6
        addr := &netlink.Addr{IPNet: &res.IP4.IP, Label: ""}
        if err = netlink.AddrAdd(link, addr); err != nil {

diff --git a/utils/hwaddr/hwaddr.go b/utils/hwaddr/hwaddr.go
index f03b7ac..aaf3b8a 100644 (file)
--- a/utils/hwaddr/hwaddr.go
+++ b/utils/hwaddr/hwaddr.go
@@ -17,13 +17,16 @@ package hwaddr
 import (
        "fmt"
        "net"
-       "strconv"
-       "strings"
 )
 
 const (
+       ipRelevantByteLen      = 4
+       PrivateMACPrefixString = "0a:58"
+)
+
+var (
        // private mac prefix safe to use
-       PrivateMACPrefix = "0a:58"
+       PrivateMACPrefix = []byte{0x0a, 0x58}
 )
 
 type SupportIp4OnlyErr struct{ msg string }
@@ -39,7 +42,7 @@ type InvalidPrefixLengthErr struct{ msg string }
 func (e InvalidPrefixLengthErr) Error() string { return e.msg }
 
 // GenerateHardwareAddr4 generates 48 bit virtual mac addresses based on the IP4 input.
-func GenerateHardwareAddr4(ip net.IP, prefix string) (net.HardwareAddr, error) {
+func GenerateHardwareAddr4(ip net.IP, prefix []byte) (net.HardwareAddr, error) {
        switch {
 
        case ip.To4() == nil:
@@ -51,18 +54,10 @@ func GenerateHardwareAddr4(ip net.IP, prefix string) (net.HardwareAddr, error) {
                }
        }
 
-       mac := prefix
-       sections := strings.Split(ip.String(), ".")
-       for _, s := range sections {
-               i, _ := strconv.Atoi(s)
-               mac += fmt.Sprintf(":%02x", i)
-       }
-
-       hwAddr, err := net.ParseMAC(mac)
-       if err != nil {
-               return nil, MacParseErr{msg: fmt.Sprintf(
-                       "Failed to parse mac address %q generated based on IP %q due to: %v", mac, ip, err),
-               }
-       }
-       return hwAddr, nil
+       ipByteLen := len(ip)
+       return (net.HardwareAddr)(
+               append(
+                       prefix,
+                       ip[ipByteLen-ipRelevantByteLen:ipByteLen]...),
+       ), nil
 }

diff --git a/utils/hwaddr/hwaddr_test.go b/utils/hwaddr/hwaddr_test.go
index 8a201a2..51c4e49 100644 (file)
--- a/utils/hwaddr/hwaddr_test.go
+++ b/utils/hwaddr/hwaddr_test.go
@@ -28,26 +28,26 @@ var _ = Describe("Hwaddr", func() {
                It("generate hardware address based on ipv4 address", func() {
                        testCases := []struct {
                                ip          net.IP
-                               expectedMAC string
+                               expectedMAC net.HardwareAddr
                        }{
                                {
                                        ip:          net.ParseIP("10.0.0.2"),
-                                       expectedMAC: hwaddr.PrivateMACPrefix + ":0a:00:00:02",
+                                       expectedMAC: (net.HardwareAddr)(append(hwaddr.PrivateMACPrefix, 0x0a, 0x00, 0x00, 0x02)),
                                },
                                {
                                        ip:          net.ParseIP("10.250.0.244"),
-                                       expectedMAC: hwaddr.PrivateMACPrefix + ":0a:fa:00:f4",
+                                       expectedMAC: (net.HardwareAddr)(append(hwaddr.PrivateMACPrefix, 0x0a, 0xfa, 0x00, 0xf4)),
                                },
                                {
                                        ip:          net.ParseIP("172.17.0.2"),
-                                       expectedMAC: hwaddr.PrivateMACPrefix + ":ac:11:00:02",
+                                       expectedMAC: (net.HardwareAddr)(append(hwaddr.PrivateMACPrefix, 0xac, 0x11, 0x00, 0x02)),
                                },
                        }
 
                        for _, tc := range testCases {
                                mac, err := hwaddr.GenerateHardwareAddr4(tc.ip, hwaddr.PrivateMACPrefix)
                                Expect(err).NotTo(HaveOccurred())
-                               Expect(mac.String()).To(Equal(tc.expectedMAC))
+                               Expect(mac).To(Equal(tc.expectedMAC))
                        }
                })
 
@@ -63,7 +63,7 @@ var _ = Describe("Hwaddr", func() {
                })
 
                It("return error if prefix is invalid", func() {
-                       _, err := hwaddr.GenerateHardwareAddr4(net.ParseIP("10.0.0.2"), "")
+                       _, err := hwaddr.GenerateHardwareAddr4(net.ParseIP("10.0.0.2"), []byte{0x58})
                        Expect(err).To(BeAssignableToTypeOf(hwaddr.InvalidPrefixLengthErr{}))
                })
        })