badguardhome/dhcpd/check_other_dhcp.go

package dhcpd

import (
	"bytes"
	"crypto/rand"
	"encoding/binary"
	"fmt"
	"math"
	"net"
	"os"
	"time"

	"github.com/AdguardTeam/golibs/log"
	"github.com/krolaw/dhcp4"
	"golang.org/x/net/ipv4"
)

// CheckIfOtherDHCPServersPresent sends a DHCP request to the specified network interface,
// and waits for a response for a period defined by defaultDiscoverTime
func CheckIfOtherDHCPServersPresent(ifaceName string) (bool, error) {
	iface, err := net.InterfaceByName(ifaceName)
	if err != nil {
		return false, wrapErrPrint(err, "Couldn't find interface by name %s", ifaceName)
	}

	// get ipv4 address of an interface
	ifaceIPNet := getIfaceIPv4(iface)
	if ifaceIPNet == nil {
		return false, fmt.Errorf("Couldn't find IPv4 address of interface %s %+v", ifaceName, iface)
	}

	srcIP := ifaceIPNet.IP
	src := net.JoinHostPort(srcIP.String(), "68")
	dst := "255.255.255.255:67"

	// form a DHCP request packet, try to emulate existing client as much as possible
	xID := make([]byte, 4)
	n, err := rand.Read(xID)
	if n != 4 && err == nil {
		err = fmt.Errorf("Generated less than 4 bytes")
	}
	if err != nil {
		return false, wrapErrPrint(err, "Couldn't generate random bytes")
	}
	hostname, err := os.Hostname()
	if err != nil {
		return false, wrapErrPrint(err, "Couldn't get hostname")
	}
	requestList := []byte{
		byte(dhcp4.OptionSubnetMask),
		byte(dhcp4.OptionClasslessRouteFormat),
		byte(dhcp4.OptionRouter),
		byte(dhcp4.OptionDomainNameServer),
		byte(dhcp4.OptionDomainName),
		byte(dhcp4.OptionDomainSearch),
		252, // private/proxy autodiscovery
		95,  // LDAP
		byte(dhcp4.OptionNetBIOSOverTCPIPNameServer),
		byte(dhcp4.OptionNetBIOSOverTCPIPNodeType),
	}
	maxUDPsizeRaw := make([]byte, 2)
	binary.BigEndian.PutUint16(maxUDPsizeRaw, 1500)
	leaseTimeRaw := make([]byte, 4)
	leaseTime := uint32(math.RoundToEven((time.Hour * 24 * 90).Seconds()))
	binary.BigEndian.PutUint32(leaseTimeRaw, leaseTime)
	options := []dhcp4.Option{
		{Code: dhcp4.OptionParameterRequestList, Value: requestList},
		{Code: dhcp4.OptionMaximumDHCPMessageSize, Value: maxUDPsizeRaw},
		{Code: dhcp4.OptionClientIdentifier, Value: append([]byte{0x01}, iface.HardwareAddr...)},
		{Code: dhcp4.OptionIPAddressLeaseTime, Value: leaseTimeRaw},
		{Code: dhcp4.OptionHostName, Value: []byte(hostname)},
	}
	packet := dhcp4.RequestPacket(dhcp4.Discover, iface.HardwareAddr, nil, xID, false, options)

	// resolve 0.0.0.0:68
	udpAddr, err := net.ResolveUDPAddr("udp4", src)
	if err != nil {
		return false, wrapErrPrint(err, "Couldn't resolve UDP address %s", src)
	}
	// spew.Dump(udpAddr, err)

	if !udpAddr.IP.To4().Equal(srcIP) {
		return false, wrapErrPrint(err, "Resolved UDP address is not %s", src)
	}

	// resolve 255.255.255.255:67
	dstAddr, err := net.ResolveUDPAddr("udp4", dst)
	if err != nil {
		return false, wrapErrPrint(err, "Couldn't resolve UDP address %s", dst)
	}

	// bind to 0.0.0.0:68
	log.Tracef("Listening to udp4 %+v", udpAddr)
	c, err := newBroadcastPacketConn(net.IPv4(0, 0, 0, 0), 68, ifaceName)
	if c != nil {
		defer c.Close()
	}
	// spew.Dump(c, err)
	// spew.Printf("net.ListenUDP returned %v, %v\n", c, err)
	if err != nil {
		return false, wrapErrPrint(err, "Couldn't listen on :68")
	}

	// send to 255.255.255.255:67
	cm := ipv4.ControlMessage{}
	_, err = c.WriteTo(packet, &cm, dstAddr)
	// spew.Dump(n, err)
	if err != nil {
		return false, wrapErrPrint(err, "Couldn't send a packet to %s", dst)
	}

	for {
		// wait for answer
		log.Tracef("Waiting %v for an answer", defaultDiscoverTime)
		// TODO: replicate dhclient's behaviour of retrying several times with progressively bigger timeouts
		b := make([]byte, 1500)
		_ = c.SetReadDeadline(time.Now().Add(defaultDiscoverTime))
		n, _, _, err = c.ReadFrom(b)
		if isTimeout(err) {
			// timed out -- no DHCP servers
			return false, nil
		}
		if err != nil {
			return false, wrapErrPrint(err, "Couldn't receive packet")
		}
		// spew.Dump(n, fromAddr, err, b)

		log.Tracef("Received packet (%v bytes)", n)

		if n < 240 {
			// packet too small for dhcp
			continue
		}

		response := dhcp4.Packet(b[:n])
		if response.OpCode() != dhcp4.BootReply ||
			response.HType() != 1 /*Ethernet*/ ||
			response.HLen() > 16 ||
			!bytes.Equal(response.CHAddr(), iface.HardwareAddr) ||
			!bytes.Equal(response.XId(), xID) {
			continue
		}

		parsedOptions := response.ParseOptions()
		if t := parsedOptions[dhcp4.OptionDHCPMessageType]; len(t) != 1 {
			continue //packet without DHCP message type
		}

		log.Tracef("The packet is from an active DHCP server")
		// that's a DHCP server there
		return true, nil
	}
}