create initial windows dhcp client

Author: QxBytes

cni/network/network.go

@@ -131,8 +131,9 @@ func NewPlugin(name string,
 	}
 
 	nl := netlink.NewNetlink()
+	plc := platform.NewExecClient(logger)
 	// Setup network manager.
-	nm, err := network.NewNetworkManager(nl, platform.NewExecClient(logger), &netio.NetIO{}, network.NewNamespaceClient(), iptables.NewClient(), dhcp.New(logger))
+	nm, err := network.NewNetworkManager(nl, plc, &netio.NetIO{}, network.NewNamespaceClient(), iptables.NewClient(), dhcp.New(logger, plc))
 	if err != nil {
 		return nil, err
 	}
@@ -1526,7 +1527,7 @@ func (plugin *NetPlugin) validateArgs(args *cniSkel.CmdArgs, nwCfg *cni.NetworkC
 	if !allowedInput.MatchString(args.ContainerID) || !allowedInput.MatchString(args.IfName) {
 		return errors.New("invalid args value")
 	}
-	if !allowedInput.MatchString(nwCfg.Bridge) {
+	if !allowedInput.MatchString(nwCfg.Bridge) || !allowedInput.MatchString(nwCfg.Master) {
 		return errors.New("invalid network config value")
 	}
 

dhcp/dhcp.go

@@ -47,13 +47,19 @@ var (
 	DefaultTimeout     = 3 * time.Second
 )
 
+type ExecClient interface {
+	ExecuteCommand(ctx context.Context, command string, args ...string) (string, error)
+}
+
 type DHCP struct {
-	logger *zap.Logger
+	logger     *zap.Logger
+	execClient ExecClient
 }
 
-func New(logger *zap.Logger) *DHCP {
+func New(logger *zap.Logger, plc ExecClient) *DHCP {
 	return &DHCP{
-		logger: logger,
+		logger:     logger,
+		execClient: plc,
 	}
 }
 

dhcp/dhcp_windows.go

@@ -2,9 +2,170 @@ package dhcp
 
 import (
 	"context"
+	"golang.org/x/sys/windows"
 	"net"
+	"regexp"
+	"time"
+
+	"github.com/pkg/errors"
+	"go.uber.org/zap"
+)
+
+const (
+	dummyIPAddressStr      = "169.254.128.10"
+	dummySubnetMask        = "255.255.128.0"
+	addIPAddressTimeout    = 10 * time.Second
+	deleteIPAddressTimeout = 2 * time.Second
+
+	socketTimeout = 1000
 )
 
-func (c *DHCP) DiscoverRequest(_ context.Context, _ net.HardwareAddr, _ string) error {
+var (
+	dummyIPAddress = net.IPv4(169, 254, 128, 10)
+	// matches if the string fully consists of zero or more alphanumeric, dots, dashes, parentheses, spaces, or underscores
+	allowedInput = regexp.MustCompile(`^[a-zA-Z0-9._\-\(\) ]*$`)
+)
+
+type Socket struct {
+	fd       windows.Handle
+	destAddr windows.SockaddrInet4
+}
+
+func NewSocket(destAddr windows.SockaddrInet4) (*Socket, error) {
+	// Create a raw socket using windows.WSASocket
+	fd, err := windows.WSASocket(windows.AF_INET, windows.SOCK_RAW, windows.IPPROTO_UDP, nil, 0, windows.WSA_FLAG_OVERLAPPED)
+	ret := &Socket{
+		fd:       fd,
+		destAddr: destAddr,
+	}
+	if err != nil {
+		return ret, errors.Wrap(err, "error creating socket")
+	}
+	defer windows.Closesocket(fd)
+
+	// Set IP_HDRINCL to indicate that we are including our own IP header
+	err = windows.SetsockoptInt(fd, windows.IPPROTO_IP, windows.IP_HDRINCL, 1)
+	if err != nil {
+		return ret, errors.Wrap(err, "error setting IP_HDRINCL")
+	}
+	// Set the SO_BROADCAST option or else we get an error saying that we access a socket in a way forbidden by its access perms
+	err = windows.SetsockoptInt(windows.Handle(fd), windows.SOL_SOCKET, windows.SO_BROADCAST, 1)
+	if err != nil {
+		return ret, errors.Wrap(err, "error setting SO_BROADCAST")
+	}
+	// Set timeout
+	if err = windows.SetsockoptInt(windows.Handle(fd), windows.SOL_SOCKET, windows.SO_RCVTIMEO, socketTimeout); err != nil {
+		return ret, errors.Wrap(err, "error setting receive timeout")
+	}
+	return ret, nil
+}
+
+func (s *Socket) Write(packetBytes []byte) (int, error) {
+	err := windows.Sendto(s.fd, packetBytes, 0, &s.destAddr)
+	if err != nil {
+		return 0, errors.Wrap(err, "failed windows send to")
+	}
+	return len(packetBytes), nil
+}
+func (s *Socket) Read(p []byte) (n int, err error) {
+	n, _, innerErr := windows.Recvfrom(s.fd, p, 0)
+	if innerErr != nil {
+		return 0, errors.Wrap(err, "failed windows recv from")
+	}
+	return n, nil
+}
+
+func (s *Socket) Close() error {
+	// do not attempt to close invalid fd (happens on socket creation failure)
+	if s.fd == windows.InvalidHandle {
+		return nil
+	}
+	// Ensure the file descriptor is closed when done
+	if err := windows.Close(s.fd); err != nil {
+		return errors.Wrap(err, "error closing dhcp windows socket")
+	}
+	return nil
+}
+
+// issues a dhcp discover request on an interface by assigning an ip to that interface
+// then, sends a packet with that interface's dummy ip, and then unassigns the dummy ip
+func (c *DHCP) DiscoverRequest(ctx context.Context, macAddress net.HardwareAddr, ifName string) error {
+	// validate interface name
+	if !allowedInput.MatchString(ifName) {
+		return errors.New("invalid dhcp discover request interface name")
+	}
+	// delete dummy ip off the interface if it already exists
+	ret, err := c.execClient.ExecuteCommand(ctx, "netsh", "interface", "ipv4", "delete", "address", ifName, dummyIPAddressStr)
+	if err != nil {
+		c.logger.Info("Could not remove dummy ip", zap.String("output", ret), zap.Error(err))
+	}
+	time.Sleep(deleteIPAddressTimeout)
+
+	// create dummy ip so we can direct the packet to the correct interface
+	ret, err = c.execClient.ExecuteCommand(ctx, "netsh", "interface", "ipv4", "add", "address", ifName, dummyIPAddressStr, dummySubnetMask)
+	if err != nil {
+		return errors.Wrap(err, "failed to add dummy ip to interface: "+ret)
+	}
+	// ensure we always remove the dummy ip we added from the interface
+	defer func() {
+		ret, err := c.execClient.ExecuteCommand(ctx, "netsh", "interface", "ipv4", "delete", "address", ifName, dummyIPAddressStr)
+		if err != nil {
+			c.logger.Info("Could not remove dummy ip on leaving function", zap.String("output", ret), zap.Error(err))
+		}
+	}()
+	// it takes time for the address to be assigned
+	time.Sleep(addIPAddressTimeout)
+
+	// now begin the dhcp request
+	txid, err := GenerateTransactionID()
+	if err != nil {
+		return errors.Wrap(err, "failed to generate transaction id")
+	}
+
+	// Prepare an IP and UDP header
+	raddr := &net.UDPAddr{IP: net.IPv4bcast, Port: dhcpServerPort}
+	laddr := &net.UDPAddr{IP: dummyIPAddress, Port: dhcpClientPort}
+
+	dhcpDiscover, err := buildDHCPDiscover(macAddress, txid)
+	if err != nil {
+		return errors.Wrap(err, "failed to build dhcp discover")
+	}
+
+	// Fill out the headers, add payload, and construct the full packet
+	bytesToSend, err := MakeRawUDPPacket(dhcpDiscover, *raddr, *laddr)
+	if err != nil {
+		return errors.Wrap(err, "failed to make raw udp packet")
+	}
+
+	destAddr := windows.SockaddrInet4{
+		Addr: [4]byte{255, 255, 255, 255}, // Destination IP
+		Port: 67,                          // Destination Port
+	}
+	// create new socket for writing and reading
+	sock, err := NewSocket(destAddr)
+	defer func() {
+		// always clean up the socket, even if we fail while setting options
+		closeErr := sock.Close()
+		if closeErr != nil {
+			c.logger.Error("Error closing dhcp socket:", zap.Error(closeErr))
+		}
+	}()
+	if err != nil {
+		return errors.Wrap(err, "failed to create socket")
+	}
+
+	_, err = sock.Write(bytesToSend)
+	if err != nil {
+		return errors.Wrap(err, "failed to write to dhcp socket")
+	}
+
+	c.logger.Info("DHCP Discover packet was sent successfully", zap.Any("transactionID", txid))
+
+	// Wait for DHCP response (Offer)
+	err = c.receiveDHCPResponse(ctx, sock, txid)
+	if err != nil {
+		return errors.Wrap(err, "failed to read from dhcp socket")
+	}
+
 	return nil
 }

network/endpoint_windows.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"net"
 	"strings"
+	"time"
 
 	"github.com/Azure/azure-container-networking/cns"
 	"github.com/Azure/azure-container-networking/netio"
@@ -141,6 +142,21 @@ func (nw *network) getEndpointWithVFDevice(plc platform.ExecClient, epInfo *Endp
 	return ep, nil
 }
 
+func (nw *network) sendDHCPDiscoverOnSecondary(client dhcpClient, mac net.HardwareAddr, ifName string) error {
+	// issue dhcp discover packet to ensure mapping created for dns via wireserver to work
+	// we do not use the response for anything
+	numSecs := 15 // we need to wait for the address to be assigned
+	timeout := time.Duration(numSecs) * time.Second
+	ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(timeout))
+	defer cancel()
+	logger.Info("Sending DHCP packet", zap.Any("macAddress", mac), zap.String("ifName", ifName))
+	err := client.DiscoverRequest(ctx, mac, ifName)
+	if err != nil {
+		return errors.Wrapf(err, "failed to issue dhcp discover packet to create mapping in host")
+	}
+	return nil
+}
+
 // newEndpointImpl creates a new endpoint in the network.
 func (nw *network) newEndpointImpl(
 	cli apipaClient,
@@ -150,12 +166,18 @@ func (nw *network) newEndpointImpl(
 	_ EndpointClient,
 	_ NamespaceClientInterface,
 	_ ipTablesClient,
-	_ dhcpClient,
+	dhcpc dhcpClient,
 	epInfo *EndpointInfo,
 ) (*endpoint, error) {
 	if epInfo.NICType == cns.BackendNIC {
 		return nw.getEndpointWithVFDevice(plc, epInfo)
 	}
+	if epInfo.NICType == cns.DelegatedVMNIC {
+		// use master interface name, interface name, or adapter name?
+		if err := nw.sendDHCPDiscoverOnSecondary(dhcpc, epInfo.MacAddress, epInfo.MasterIfName); err != nil {
+			return nil, err
+		}
+	}
 
 	if useHnsV2, err := UseHnsV2(epInfo.NetNsPath); useHnsV2 {
 		if err != nil {