Pull request 2634: AGDNS-3863-gopacket-dhcp-vol.23

Updates AdguardTeam#4923.

Squashed commit of the following:

commit 305d3ba
Merge: c7512c8 9e153fb
Author: Eugene Burkov <E.Burkov@AdGuard.COM>
Date:   Tue Apr 21 19:30:31 2026 +0300

    Merge branch 'master' into AGDNS-3863-gopacket-dhcp-vol.23

commit c7512c8
Author: Eugene Burkov <E.Burkov@AdGuard.COM>
Date:   Tue Apr 21 19:11:39 2026 +0300

    dhcpsvc: fix doc

commit f0fe3b6
Author: Eugene Burkov <E.Burkov@AdGuard.COM>
Date:   Tue Apr 21 15:10:16 2026 +0300

    dhcpsvc: imp docs

commit 8eeea47
Author: Eugene Burkov <E.Burkov@AdGuard.COM>
Date:   Tue Apr 21 14:53:56 2026 +0300

    dhcpsvc: imp code, docs

commit 96cf3b3
Author: Eugene Burkov <E.Burkov@AdGuard.COM>
Date:   Mon Apr 20 15:30:58 2026 +0300

    dhcpsvc: add dhcpv6 handle, imp code

commit e94cb9e
Author: Eugene Burkov <E.Burkov@AdGuard.COM>
Date:   Wed Apr 15 15:56:38 2026 +0300

    dhcpsvc: add ipv6 consts

Author: EugeneOne1

internal/dhcpsvc/config_test.go

@@ -140,15 +140,15 @@ func TestIPv6Config_Validate(t *testing.T) {
 			RangeStart:    testIPv4Conf.GatewayIP,
 			LeaseDuration: 1 * time.Hour,
 		},
-		wantErrMsg: "range start " + testGatewayIPv4Str + " should be a valid ipv6",
+		wantErrMsg: "range start " + testGatewayIPv4Str + " must be a valid ipv6",
 	}, {
 		name: "bad_lease_duration",
 		conf: &dhcpsvc.IPv6Config{
 			Enabled:       true,
 			RangeStart:    netip.MustParseAddr(testRangeStartV6Str),
 			LeaseDuration: 0,
 		},
-		wantErrMsg: "lease duration 0s must be positive",
+		wantErrMsg: "lease duration: not positive: 0s",
 	}, {
 		name: "valid",
 		conf: &dhcpsvc.IPv6Config{

internal/dhcpsvc/db.go

@@ -34,6 +34,8 @@ type dataLeases struct {
 }
 
 // dbLease is the structure of stored lease.
+//
+// TODO(e.burkov):  Migrate to add DUID and IAID fields for DHCPv6 leases.
 type dbLease struct {
 	Expiry   string     `json:"expires"`
 	IP       netip.Addr `json:"ip"`

internal/dhcpsvc/dhcpsvc_test.go

@@ -109,6 +109,9 @@ const (
 	testAnotherRangeStartV6Str = "2001:db9::1"
 )
 
+// testHWIface is the test MAC address of a test network interface.
+var testHWIface = net.HardwareAddr{0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA}
+
 var (
 	// testIPv4Conf is a common valid IPv4 part of the interface configuration
 	// for tests.

internal/dhcpsvc/handle.go

@@ -21,7 +21,7 @@ func (srv *DHCPServer) serveEther4(ctx context.Context, iface *dhcpInterfaceV4,
 	src := gopacket.NewPacketSource(nd, nd.LinkType())
 
 	for pkt := range src.Packets() {
-		fd := newFrameData(ctx, srv.logger, pkt, nd)
+		fd := newFrameData4(ctx, srv.logger, pkt, nd)
 		if fd == nil {
 			continue
 		}
@@ -33,15 +33,40 @@ func (srv *DHCPServer) serveEther4(ctx context.Context, iface *dhcpInterfaceV4,
 	}
 }
 
-// newFrameData creates a new frameData with layers extracted from pkt.  It
+// serveEther6 handles the incoming ethernet packets and dispatches them to the
+// appropriate handler.  It's used to run in a separate goroutine as it blocks
+// until packets channel is closed.  iface and nd must not be nil.  nd must have
+// at least a single address returned by its Addresses method.
+//
+//lint:ignore U1000 TODO(e.burkov): Use.
+func (srv *DHCPServer) serveEther6(ctx context.Context, iface *dhcpInterfaceV6, nd NetworkDevice) {
+	defer slogutil.RecoverAndLog(ctx, srv.logger)
+
+	src := gopacket.NewPacketSource(nd, nd.LinkType())
+	srvDUID := newServerDUID(nd.HardwareAddr())
+
+	for pkt := range src.Packets() {
+		fd := newFrameData6(ctx, srv.logger, pkt, nd, srvDUID)
+		if fd == nil {
+			continue
+		}
+
+		err := srv.serveV6(ctx, iface, pkt, fd)
+		if err != nil {
+			srv.logger.ErrorContext(ctx, "serving", slogutil.KeyError, err)
+		}
+	}
+}
+
+// newFrameData4 creates a new [frameData4] with layers extracted from pkt.  It
 // returns nil if the packet is not an Ethernet or IPv4 packet, or if the
 // network device has no addresses.  logger, pkt, and dev must not be nil.
-func newFrameData(
+func newFrameData4(
 	ctx context.Context,
 	logger *slog.Logger,
 	pkt gopacket.Packet,
 	dev NetworkDevice,
-) (fd *frameData) {
+) (fd *frameData4) {
 	addrs := dev.Addresses()
 	if len(addrs) == 0 {
 		logger.ErrorContext(ctx, "no addresses for network device")
@@ -70,12 +95,57 @@ func newFrameData(
 		addr = addrs[0]
 	}
 
-	return &frameData{
+	return &frameData4{
 		ether:     etherLayer,
 		ip:        ipLayer,
 		device:    dev,
 		localAddr: addr,
 	}
 }
 
-// TODO(e.burkov):  Add DHCPServer.serveEther6.
+// newFrameData6 creates a new [frameData6] with layers extracted from pkt.  It
+// returns nil if the packet is not an Ethernet or IPv6 packet, or if the
+// network device has no addresses.  logger, pkt, and dev must not be nil.
+func newFrameData6(
+	ctx context.Context,
+	logger *slog.Logger,
+	pkt gopacket.Packet,
+	dev NetworkDevice,
+	duid *layers.DHCPv6DUID,
+) (fd *frameData6) {
+	addrs := dev.Addresses()
+	if len(addrs) == 0 {
+		logger.ErrorContext(ctx, "no addresses for network device")
+
+		return nil
+	}
+
+	etherLayer, ok := pkt.Layer(layers.LayerTypeEthernet).(*layers.Ethernet)
+	if !ok {
+		actual := pkt.Layers()
+		logger.DebugContext(ctx, "skipping non-ethernet packet", "layers", actual)
+
+		return nil
+	}
+
+	ipLayer, ok := pkt.Layer(layers.LayerTypeIPv6).(*layers.IPv6)
+	if !ok {
+		actual := pkt.Layers()
+		logger.DebugContext(ctx, "skipping non-ipv6 packet", "layers", actual)
+
+		return nil
+	}
+
+	addr, ok := netip.AddrFromSlice(ipLayer.DstIP)
+	if !ok || !slices.Contains(addrs, addr) {
+		addr = addrs[0]
+	}
+
+	return &frameData6{
+		ether:     etherLayer,
+		ip:        ipLayer,
+		duid:      duid,
+		device:    dev,
+		localAddr: addr,
+	}
+}

internal/dhcpsvc/handler4.go

@@ -12,13 +12,13 @@ import (
 	"github.com/google/gopacket/layers"
 )
 
-// serveV4 handles the ethernet packet of IPv4 type. iface and pkt must not be
-// nil.  iface and fd must not be nil.  pkt must be an IPv4 packet.
+// serveV4 handles the ethernet packet of IPv4 type.  iface must not be nil, fd
+// must be valid, pkt must be an IPv4 packet.
 func (srv *DHCPServer) serveV4(
 	ctx context.Context,
 	iface *dhcpInterfaceV4,
 	pkt gopacket.Packet,
-	fd *frameData,
+	fd *frameData4,
 ) (err error) {
 	defer func() { err = errors.Annotate(err, "serving dhcpv4: %w") }()
 
@@ -55,7 +55,7 @@ func (srv *DHCPServer) serveV4(
 // messages are handled by all interfaces concurrently, as those offer addresses
 // for the independent networks.  The DHCPREQUEST, DHCPRELEASE, and DHCPDECLINE
 // messages are handled by the appropriate interface according to the client's
-// choice.  req and fd must not be nil, typ should be one of:
+// choice.  req must not be nil, fd must be valid, typ should be one of:
 //   - [layers.DHCPMsgTypeDiscover]
 //   - [layers.DHCPMsgTypeRequest]
 //   - [layers.DHCPMsgTypeRelease]
@@ -64,7 +64,7 @@ func (iface *dhcpInterfaceV4) handleDHCPv4(
 	ctx context.Context,
 	typ layers.DHCPMsgType,
 	req *layers.DHCPv4,
-	fd *frameData,
+	fd *frameData4,
 ) (err error) {
 	switch typ {
 	case layers.DHCPMsgTypeDiscover:
@@ -84,11 +84,11 @@ func (iface *dhcpInterfaceV4) handleDHCPv4(
 }
 
 // handleDiscover handles messages of type DHCPDISCOVER.  req must be a
-// DHCPDISCOVER message, fd must not be nil.
+// DHCPDISCOVER message, fd must be valid.
 func (iface *dhcpInterfaceV4) handleDiscover(
 	ctx context.Context,
 	req *layers.DHCPv4,
-	fd *frameData,
+	fd *frameData4,
 ) {
 	l := iface.common.logger
 
@@ -125,15 +125,15 @@ func (iface *dhcpInterfaceV4) handleDiscover(
 }
 
 // handleRequest handles the DHCPv4 message of DHCPREQUEST type.  req must be a
-// DHCPREQUEST message.  req and fd must not be nil.
+// DHCPREQUEST message.  req must not be nil, fd must be valid.
 //
 // See https://datatracker.ietf.org/doc/html/rfc2131#section-4.3.2.
 //
 // TODO(e.burkov):  Remove allocated leases after client have chosen one.
 func (iface *dhcpInterfaceV4) handleRequest(
 	ctx context.Context,
 	req *layers.DHCPv4,
-	fd *frameData,
+	fd *frameData4,
 ) {
 	srvID, hasSrvID := serverID4(req)
 	reqIP, hasReqIP := requestedIPv4(req)
@@ -181,12 +181,12 @@ func (iface *dhcpInterfaceV4) handleRequest(
 }
 
 // handleSelecting handles messages of type DHCPREQUEST in SELECTING state.  req
-// must be a DHCPREQUEST message, reqIP must be a valid IPv4 address, fd must
-// not be nil.
+// must be a DHCPREQUEST message, reqIP must be a valid IPv4 address, fd must be
+// valid.
 func (iface *dhcpInterfaceV4) handleSelecting(
 	ctx context.Context,
 	req *layers.DHCPv4,
-	fd *frameData,
+	fd *frameData4,
 	reqIP netip.Addr,
 ) {
 	l := iface.common.logger
@@ -235,11 +235,11 @@ func (iface *dhcpInterfaceV4) handleSelecting(
 
 // handleInitReboot handles messages of type DHCPREQUEST in INIT-REBOOT state.
 // req must be a DHCPREQUEST message, reqIP must be a valid IPv4 address, fd
-// must not be nil.
+// must be valid.
 func (iface *dhcpInterfaceV4) handleInitReboot(
 	ctx context.Context,
 	req *layers.DHCPv4,
-	fd *frameData,
+	fd *frameData4,
 	reqIP netip.Addr,
 ) {
 	l := iface.common.logger
@@ -282,11 +282,11 @@ func (iface *dhcpInterfaceV4) handleInitReboot(
 
 // handleRenew handles messages of type DHCPREQUEST in RENEWING or REBINDING
 // state.  req must be a DHCPREQUEST message, ip should be a previously leased
-// address, fd must not be nil.
+// address, fd must be valid.
 func (iface *dhcpInterfaceV4) handleRenew(
 	ctx context.Context,
 	req *layers.DHCPv4,
-	fd *frameData,
+	fd *frameData4,
 	ip netip.Addr,
 ) {
 	l := iface.common.logger

internal/dhcpsvc/handler6.go

@@ -10,16 +10,21 @@ import (
 )
 
 // serveV6 handles the ethernet packet of IPv6 type. iface and pkt must not be
-// nil.  ctx must contain a [frameData] accessible with [frameDataFromContext].
+// nil.  iface and fd must be valid.  pkt must be an IPv6 packet.
 //
 //lint:ignore U1000 TODO(e.burkov): Use.
 func (srv *DHCPServer) serveV6(
 	ctx context.Context,
-	_ *dhcpInterfaceV6,
+	iface *dhcpInterfaceV6,
 	pkt gopacket.Packet,
+	fd *frameData6,
 ) (err error) {
 	defer func() { err = errors.Annotate(err, "serving dhcpv6: %w") }()
 
+	// TODO(e.burkov):  Use the iface and fd parameters.
+	_ = iface
+	_ = fd
+
 	msg, ok := pkt.Layer(layers.LayerTypeDHCPv6).(*layers.DHCPv6)
 	if !ok {
 		// TODO(e.burkov):  Consider adding some debug information about the

internal/dhcpsvc/interface.go

@@ -19,6 +19,8 @@ import (
 //
 // TODO(e.burkov):  Identify the client by the hardware address and the client
 // identifier from the DHCP messages.
+//
+// TODO(e.burkov):  Identify IPv6 clients with DUID.
 type macKey any
 
 // macToKey converts mac into macKey, which is used as the key for the lease

internal/dhcpsvc/lease.go

@@ -16,6 +16,8 @@ import (
 // [websvc].
 //
 // TODO(e.burkov):  Add validation method.
+//
+// TODO(e.burkov):  Migrate to add DUID and IAID fields for DHCPv6 leases.
 type Lease struct {
 	// IP is the IP address leased to the client.  It must not be empty.
 	IP netip.Addr

internal/dhcpsvc/networkdevice.go

@@ -3,6 +3,7 @@ package dhcpsvc
 import (
 	"context"
 	"io"
+	"net"
 	"net/netip"
 
 	"github.com/AdguardTeam/golibs/errors"
@@ -63,10 +64,18 @@ type NetworkDevice interface {
 	// No methods of a device should be called after Close.
 	io.Closer
 
-	// Addresses returns all IP addresses assigned to the device.
+	// Addresses returns all IP addresses assigned to the device.  It must
+	// return at least one valid address, unless the implementation documents
+	// the opposite.
 	Addresses() (ips []netip.Addr)
 
-	// LinkType returns the link type of the network interface.
+	// HardwareAddr returns the hardware (MAC) address of the device.  It must
+	// return a valid hardware address, unless the implementation documents the
+	// opposite.
+	HardwareAddr() (hw net.HardwareAddr)
+
+	// LinkType returns the link type of the network interface.  It must return
+	// a valid link type, unless the implementation documents the opposite.
 	LinkType() (lt layers.LinkType)
 
 	// WritePacketData writes a serialized packet to the network interface.
@@ -98,6 +107,12 @@ func (EmptyNetworkDevice) Addresses() (ips []netip.Addr) {
 	return nil
 }
 
+// HardwareAddr implements the [NetworkDevice] interface for
+// [EmptyNetworkDevice].  It always returns nil.
+func (EmptyNetworkDevice) HardwareAddr() (hw net.HardwareAddr) {
+	return nil
+}
+
 // LinkType implements the [NetworkDevice] interface for [EmptyNetworkDevice].
 // It always returns [layers.LinkTypeNull].
 func (EmptyNetworkDevice) LinkType() (lt layers.LinkType) {
@@ -110,11 +125,42 @@ func (EmptyNetworkDevice) WritePacketData(_ []byte) (err error) {
 	return nil
 }
 
-// frameData stores the Ethernet and IPv4 layers of the incoming packet, and
-// the network device that the packet was received from.
-type frameData struct {
-	ether     *layers.Ethernet
-	ip        *layers.IPv4
-	device    NetworkDevice
+// frameData4 stores the Ethernet and IPv4 layers of the incoming packet, as
+// well as the network device that the packet was received from and its address.
+type frameData4 struct {
+	// ether is the Ethernet layer of the incoming packet.  It must not be nil.
+	ether *layers.Ethernet
+
+	// ip is the IPv4 layer of the incoming packet.  It must not be nil.
+	ip *layers.IPv4
+
+	// device is the network device that the packet was received from.  It must
+	// not be nil.
+	device NetworkDevice
+
+	// localAddr is the local IP address that the packet was sent to.  It must
+	// be a valid IPv4 address assigned to the device.
+	localAddr netip.Addr
+}
+
+// frameData6 stores the Ethernet and IPv6 layers of the incoming packet, as
+// well as the network device that the packet was received from and its address.
+type frameData6 struct {
+	// ether is the Ethernet layer of the incoming packet.  It must not be nil.
+	ether *layers.Ethernet
+
+	// ip is the IPv6 layer of the incoming packet.  It must not be nil.
+	ip *layers.IPv6
+
+	// duid is the DHCPv6 DUID constructed of the network device hardware
+	// address.  It must not be nil.
+	duid *layers.DHCPv6DUID
+
+	// device is the network device that the packet was received from.  It must
+	// not be nil.
+	device NetworkDevice
+
+	// localAddr is the local IP address that the packet was sent to.  It must
+	// be a valid IPv6 address assigned to the device.
 	localAddr netip.Addr
 }