Fix GARP sending 0.0.0.0 due to incorrect IPv4 byte extraction

net.ParseIP() returns 16-byte IPv4-mapped IPv6 format where IPv4 bytes
are at the END, not beginning. [4]byte(garp.IP) took wrong bytes.

Fixed by calling To4() before, forcing validated creation via
NewGARP(). Interface prevents bypassing extracting the correct IPv4 address.

Signed-off-by: Patryk Diak <[email protected]>

Author: kyrtapz

go-controller/pkg/kubevirt/pod.go

@@ -528,11 +528,10 @@ func (r *DefaultGatewayReconciler) ReconcileIPv4AfterLiveMigration(liveMigration
 
 	lrpMAC := util.IPAddrToHWAddr(lrpJoinAddress)
 	for _, subnet := range r.netInfo.Subnets() {
-		gwIP := r.netInfo.GetNodeGatewayIP(subnet.CIDR).IP.To4()
-		if gwIP == nil {
-			continue
+		garp, err := util.NewGARP(r.netInfo.GetNodeGatewayIP(subnet.CIDR).IP, &lrpMAC)
+		if err != nil {
+			return fmt.Errorf("failed to create GARP for gateway IP %s: %w", r.netInfo.GetNodeGatewayIP(subnet.CIDR).IP, err)
 		}
-		garp := util.GARP{IP: gwIP, MAC: &lrpMAC}
 		if err := util.BroadcastGARP(r.interfaceName, garp); err != nil {
 			return err
 		}

go-controller/pkg/node/linkmanager/link_network_manager.go

@@ -196,8 +196,13 @@ func (c *Controller) syncLink(link netlink.Link) error {
 		// For IPv4, use arping to try to update other hosts ARP caches, in case this IP was
 		// previously active on another node
 		if addressWanted.IP.To4() != nil {
-			if err = util.BroadcastGARP(linkName, util.GARP{IP: addressWanted.IP}); err != nil {
-				klog.Errorf("Failed to send a GARP for IP %s over interface %s: %v", addressWanted.IP.String(),
+			garp, err := util.NewGARP(addressWanted.IP, nil)
+			if err != nil {
+				klog.Errorf("Link manager: failed to create GARP for IP %s: %v", addressWanted.IP.String(), err)
+				continue
+			}
+			if err = util.BroadcastGARP(linkName, garp); err != nil {
+				klog.Errorf("Link manager: failed to send GARP for IP %s over interface %s: %v", addressWanted.IP.String(),
 					linkName, err)
 			}
 		}

go-controller/pkg/util/arp.go

@@ -6,29 +6,69 @@ import (
 	"net/netip"
 
 	"github.com/mdlayher/arp"
+
+	"k8s.io/klog/v2"
 )
 
-type GARP struct {
-	// IP to advertise the MAC address
-	IP net.IP
-	// MAC to advertise (optional), default: link mac address
-	MAC *net.HardwareAddr
+// GARP represents a gratuitous ARP request for an IPv4 address.
+type GARP interface {
+	// IP returns the IPv4 address as a net.IP
+	IP() net.IP
+	// IPv4 returns the raw 4-byte IPv4 address
+	IPv4() [net.IPv4len]byte
+	// MAC returns the MAC address to advertise (nil means use interface MAC)
+	MAC() *net.HardwareAddr
+}
+
+// garp is the private implementation of GARP
+type garp struct {
+	ip  [4]byte
+	mac *net.HardwareAddr
+}
+
+// NewGARP creates a new GARP with validation that the IP is IPv4.
+// Returns error if the IP is not a valid IPv4 address.
+// mac can be nil to use the interface's MAC address.
+func NewGARP(ip net.IP, mac *net.HardwareAddr) (GARP, error) {
+	ip4 := ip.To4()
+	if ip4 == nil {
+		return nil, fmt.Errorf("GARP only supports IPv4 addresses, got %s (len=%d bytes)", ip.String(), len(ip))
+	}
+	return &garp{
+		ip:  [4]byte(ip4),
+		mac: mac,
+	}, nil
+}
+
+// IP returns the IPv4 address as a net.IP
+func (g *garp) IP() net.IP {
+	return net.IP(g.ip[:])
+}
+
+// IPv4 returns the raw 4-byte IPv4 address
+func (g *garp) IPv4() [4]byte {
+	return g.ip
+}
+
+// MAC returns the MAC address to advertise
+func (g *garp) MAC() *net.HardwareAddr {
+	return g.mac
 }
 
 // BroadcastGARP send a pair of GARPs with "request" and "reply" operations
 // since some system response to request and others to reply.
 // If "garp.MAC" is not passed the link form "interfaceName" mac will be
 // advertise
 func BroadcastGARP(interfaceName string, garp GARP) error {
-	srcIP := netip.AddrFrom4([4]byte(garp.IP))
-
 	iface, err := net.InterfaceByName(interfaceName)
 	if err != nil {
 		return fmt.Errorf("failed finding interface %s: %v", interfaceName, err)
 	}
 
-	if garp.MAC == nil {
-		garp.MAC = &iface.HardwareAddr
+	srcIP := netip.AddrFrom4(garp.IPv4())
+	mac := garp.MAC()
+	if mac == nil {
+		mac = &iface.HardwareAddr
 	}
 
 	c, err := arp.Dial(iface)
@@ -50,7 +90,7 @@ func BroadcastGARP(interfaceName string, garp GARP) error {
 	for _, op := range []arp.Operation{arp.OperationRequest, arp.OperationReply} {
 		// At at GARP the source and target IP should be the same and point to the
 		// the IP we want to reconcile -> https://wiki.wireshark.org/Gratuitous_ARP
-		p, err := arp.NewPacket(op, *garp.MAC /* srcHw */, srcIP, net.HardwareAddr{0, 0, 0, 0, 0, 0}, srcIP)
+		p, err := arp.NewPacket(op, *mac /* srcHw */, srcIP, net.HardwareAddr{0, 0, 0, 0, 0, 0}, srcIP)
 		if err != nil {
 			return fmt.Errorf("failed creating %q GARP %+v: %w", op, garp, err)
 		}
@@ -60,5 +100,6 @@ func BroadcastGARP(interfaceName string, garp GARP) error {
 		}
 	}
 
+	klog.Infof("BroadcastGARP: completed GARP broadcast for IP %s on interface %s with MAC: %s", garp.IP().String(), interfaceName, mac.String())
 	return nil
 }