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

pkg/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
+}

pkg/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 {

pkg/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
+	ipByteLen := len(ip)
-	sections := strings.Split(ip.String(), ".")
+	return (net.HardwareAddr)(
-	for _, s := range sections {
+		append(
-		i, _ := strconv.Atoi(s)
+			prefix,
-		mac += fmt.Sprintf(":%02x", i)
+			ip[ipByteLen-ipRelevantByteLen:ipByteLen]...),
-	}
+	), nil
-
-	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
 }

pkg/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{}))
 		})
 	})

plugins/main/bridge/bridge.go

@@ -247,7 +247,19 @@ func cmdAdd(args *skel.CmdArgs) error {
 			// TODO: IPV6
 		}
 
-		return ipam.ConfigureIface(args.IfName, result)
+		if err := ipam.ConfigureIface(args.IfName, result); err != nil {
+			return err
+		}
+
+		contVethLink, err := netlink.LinkByName(args.IfName)
+		if err != nil {
+			return fmt.Errorf("failed to lookup %q: %v", args.IfName, err)
+		}
+		if err := ip.SetHWAddrByIP(contVethLink, result.IP4.IP.IP, nil /* TODO IPv6 */); err != nil {
+			return err
+		}
+
+		return nil
 	}); err != nil {
 		return err
 	}
@@ -262,6 +274,10 @@ func cmdAdd(args *skel.CmdArgs) error {
 			return err
 		}
 
+		if err := ip.SetHWAddrByIP(br, gwn.IP, nil /* TODO IPv6 */); err != nil {
+			return err
+		}
+
 		if err := ip.EnableIP4Forward(); err != nil {
 			return fmt.Errorf("failed to enable forwarding: %v", err)
 		}

plugins/main/macvlan/macvlan.go

@@ -149,6 +149,14 @@ func cmdAdd(args *skel.CmdArgs) error {
 	}
 
 	err = netns.Do(func(_ ns.NetNS) error {
+		contVethLink, err := netlink.LinkByName(args.IfName)
+		if err != nil {
+			return fmt.Errorf("failed to lookup %q: %v", args.IfName, err)
+		}
+		if err := ip.SetHWAddrByIP(contVethLink, result.IP4.IP.IP, nil /* TODO IPv6 */); err != nil {
+			return err
+		}
+
 		return ipam.ConfigureIface(args.IfName, result)
 	})
 	if err != nil {

plugins/main/ptp/ptp.go

@@ -64,6 +64,10 @@ func setupContainerVeth(netns, ifName string, mtu int, pr *types.Result) (string
 			return err
 		}
 
+		if err := ip.SetHWAddrByIP(hostVeth, pr.IP4.IP.IP, nil /* TODO IPv6 */); err != nil {
+			return fmt.Errorf("failed to set hardware addr by IP: %v", err)
+		}
+
 		if err = ipam.ConfigureIface(ifName, pr); err != nil {
 			return err
 		}
@@ -73,6 +77,10 @@ func setupContainerVeth(netns, ifName string, mtu int, pr *types.Result) (string
 			return fmt.Errorf("failed to look up %q: %v", ifName, err)
 		}
 
+		if err := ip.SetHWAddrByIP(contVeth, pr.IP4.IP.IP, nil /* TODO IPv6 */); err != nil {
+			return fmt.Errorf("failed to set hardware addr by IP: %v", err)
+		}
+
 		// Delete the route that was automatically added
 		route := netlink.Route{
 			LinkIndex: contVeth.Attrs().Index,