Merge branch 'master' into ADG-12585-fix-dns64

Author: EugeneOne1

internal/aghnet/dhcp_windows.go

@@ -12,7 +12,7 @@ import (
 func checkOtherDHCP(
 	_ context.Context,
 	_ *slog.Logger,
-	ifaceName string,
+	_ string,
 ) (ok4, ok6 bool, err4, err6 error) {
 	return false,
 		false,

internal/aghnet/hostscontainer_test.go

@@ -64,10 +64,10 @@ func TestNewHostsContainer(t *testing.T) {
 				return nil
 			}
 
-			var eventsCalledCounter uint32
+			var eventsCalledCounter atomic.Uint32
 			eventsCh := make(chan struct{})
 			onEvents := func() (e <-chan struct{}) {
-				assert.Equal(t, uint32(1), atomic.AddUint32(&eventsCalledCounter, 1))
+				assert.Equal(t, uint32(1), eventsCalledCounter.Add(1))
 
 				return eventsCh
 			}
@@ -95,7 +95,7 @@ func TestNewHostsContainer(t *testing.T) {
 			assert.NotNil(t, <-hc.Upd())
 
 			eventsCh <- struct{}{}
-			assert.Equal(t, uint32(1), atomic.LoadUint32(&eventsCalledCounter))
+			assert.Equal(t, uint32(1), eventsCalledCounter.Load())
 		})
 	}
 

internal/aghnet/interfaces_linux.go

@@ -11,7 +11,7 @@ import (
 
 // listenPacketReusable announces on the local network address additionally
 // configuring the socket to have a reusable binding.
-func listenPacketReusable(ifaceName, network, address string) (c net.PacketConn, err error) {
+func listenPacketReusable(ifaceName, _, address string) (c net.PacketConn, err error) {
 	var port uint16
 	_, port, err = netutil.SplitHostPort(address)
 	if err != nil {

internal/dhcpsvc/dhcpsvc_test.go

@@ -393,27 +393,19 @@ func (db *testDatabase) Store(ctx context.Context, leases []*dhcpsvc.Lease) (err
 	return db.onStore(ctx, leases)
 }
 
-// newTestDatabase creates a new *testDatabase for testing.  If initial is not
-// nil, db.Load is set to return it.  By default, db.Store panics on any call.
-func newTestDatabase(tb testing.TB, initial []*dhcpsvc.Lease) (db *testDatabase) {
+// newTestDatabase creates a new *testDatabase for testing.  The Load method
+// returns [testLeases], and the Store method panics.
+func newTestDatabase(tb testing.TB) (db *testDatabase) {
 	tb.Helper()
 
-	db = &testDatabase{
-		onLoad: func(ctx context.Context) (_ []*dhcpsvc.Lease, _ error) {
-			panic(testutil.UnexpectedCall(ctx))
+	return &testDatabase{
+		onLoad: func(_ context.Context) (leases []*dhcpsvc.Lease, err error) {
+			return testLeases, nil
 		},
 		onStore: func(ctx context.Context, leases []*dhcpsvc.Lease) (_ error) {
 			panic(testutil.UnexpectedCall(ctx, leases))
 		},
 	}
-
-	if initial != nil {
-		db.onLoad = func(ctx context.Context) (leases []*dhcpsvc.Lease, err error) {
-			return initial, nil
-		}
-	}
-
-	return db
 }
 
 // newTestDHCPServer creates a new DHCPServer for testing.  It uses the default

internal/dhcpsvc/handler4_test.go

@@ -83,7 +83,7 @@ func TestDHCPServer_ServeEther4_discover(t *testing.T) {
 
 			ndMgr, inCh, outCh := newTestNetworkDeviceManager(t, testIfaceAddrV4)
 			startTestDHCPServer(t, &dhcpsvc.Config{
-				Database:             newTestDatabase(t, testLeases),
+				Database:             newTestDatabase(t),
 				Interfaces:           testIPv4InterfacesConf,
 				NetworkDeviceManager: ndMgr,
 				Enabled:              true,
@@ -105,7 +105,7 @@ func TestDHCPServer_ServeEther4_discoverExpired(t *testing.T) {
 	ndMgr, inCh, outCh := newTestNetworkDeviceManager(t, testIfaceAddrV4)
 
 	startTestDHCPServer(t, &dhcpsvc.Config{
-		Database:             newTestDatabase(t, testLeases),
+		Database:             newTestDatabase(t),
 		Interfaces:           testIPv4InterfacesConf,
 		NetworkDeviceManager: ndMgr,
 		Enabled:              true,
@@ -156,7 +156,7 @@ func TestDHCPServer_ServeEther4_release(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			db := newTestDatabase(t, testLeases)
+			db := newTestDatabase(t)
 
 			onStore := func(ctx context.Context, leases []*dhcpsvc.Lease) (err error) {
 				assert.NotContains(testutil.NewPanicT(t), leases, tc.want)
@@ -262,7 +262,7 @@ func TestDHCPServer_ServeEther4_requestSelecting(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			db := newTestDatabase(t, testLeases)
+			db := newTestDatabase(t)
 
 			onStore := func(ctx context.Context, leases []*dhcpsvc.Lease) (err error) {
 				assert.Contains(t, leases, tc.want)
@@ -311,7 +311,7 @@ func TestDHCPServer_ServeEther4_requestSelectingNoLease(t *testing.T) {
 		flags:        dhcpsvc.FlagsBroadcast,
 	})
 
-	db := newTestDatabase(t, testLeases)
+	db := newTestDatabase(t)
 
 	ndMgr, inCh, outCh := newTestNetworkDeviceManager(t, testIfaceAddrV4)
 	startTestDHCPServer(t, &dhcpsvc.Config{
@@ -413,7 +413,7 @@ func TestDHCPServer_ServeEther4_requestInitReboot(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			db := newTestDatabase(t, testLeases)
+			db := newTestDatabase(t)
 
 			onStore := func(ctx context.Context, leases []*dhcpsvc.Lease) (err error) {
 				assert.Contains(t, leases, tc.want)
@@ -513,7 +513,7 @@ func TestDHCPServer_ServeEther4_requestRenewSuccess(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			db := newTestDatabase(t, testLeases)
+			db := newTestDatabase(t)
 
 			onStore := func(ctx context.Context, leases []*dhcpsvc.Lease) (err error) {
 				assert.Contains(t, leases, tc.want)
@@ -586,7 +586,7 @@ func TestDHCPServer_ServeEther4_requestRenewFail(t *testing.T) {
 			}
 
 			startTestDHCPServer(t, &dhcpsvc.Config{
-				Database:             newTestDatabase(t, testLeases),
+				Database:             newTestDatabase(t),
 				Interfaces:           testIPv4InterfacesConf,
 				NetworkDeviceManager: ndMgr,
 				Enabled:              true,
@@ -641,7 +641,7 @@ func TestDHCPServer_ServeEther4_decline(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			db := newTestDatabase(t, testLeases)
+			db := newTestDatabase(t)
 
 			onStore := func(ctx context.Context, leases []*dhcpsvc.Lease) (err error) {
 				assert.Contains(t, leases, wantLease)

internal/dhcpsvc/handler6.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"net/netip"
 
 	"github.com/AdguardTeam/golibs/errors"
 	"github.com/AdguardTeam/golibs/logutil/slogutil"
@@ -274,24 +275,27 @@ func (iface *dhcpInterfaceV6) handleRenew(
 		// handler does.
 		//
 		// See RFC 9915 Section 18.3.4.
-		resp.Options = iface.newRenewRespOpts(fd, req, cliID, layers.DHCPv6Option{})
+		resp.Options = iface.newUpdateRespOpts(fd, req, cliID, layers.DHCPv6Option{})
 
 		return respond6(fd, resp)
 	}
 
-	ianaOpt := iface.ianaForRenew(ctx, req, iana, fd.ether.SrcMAC)
-	resp.Options = iface.newRenewRespOpts(fd, req, cliID, ianaOpt)
+	ianaOpt := iface.ianaForUpdate(ctx, req, iana, fd.ether.SrcMAC)
+	resp.Options = iface.newUpdateRespOpts(fd, req, cliID, ianaOpt)
 
 	return respond6(fd, resp)
 }
 
 // handleRebind handles messages of type REBIND.  req must not be nil and must
-// be a valid DHCPv6 message of type REBIND.  fd must be valid.
+// be a valid DHCPv6 message of type REBIND, fd must be valid.
 //
-// TODO(e.burkov):  Implement.  This is a stub for now.
+// TODO(e.burkov):  The current implementation rebinds only the first valid
+// IA_NA option.  It does not verify that the addresses in the IA match the
+// stored lease, since clients are identified by MAC address rather than
+// DUID+IAID.
 func (iface *dhcpInterfaceV6) handleRebind(
 	ctx context.Context,
-	_ *frameData6,
+	fd *frameData6,
 	req *layers.DHCPv6,
 ) (err error) {
 	cliID, err := clientIDNoServer(req.Options)
@@ -302,31 +306,54 @@ func (iface *dhcpInterfaceV6) handleRebind(
 	l := iface.common.logger
 	l.DebugContext(ctx, "handling message", "type", req.MsgType, "cli_id", cliID)
 
-	return nil
+	iface.common.indexMu.Lock()
+	defer iface.common.indexMu.Unlock()
+
+	resp := &layers.DHCPv6{
+		MsgType:       layers.DHCPv6MsgTypeReply,
+		TransactionID: req.TransactionID,
+	}
+
+	iana, ok := iface.firstIANA(ctx, req)
+	if !ok {
+		// With no IA_NA options and no requested addresses there's nothing to
+		// rebind.  Respond with no IA options similarly to how the Renew
+		// handler does.
+		//
+		// See RFC 9915 Section 18.3.5.
+		resp.Options = iface.newUpdateRespOpts(fd, req, cliID, layers.DHCPv6Option{})
+
+		return respond6(fd, resp)
+	}
+
+	ianaOpt := iface.ianaForUpdate(ctx, req, iana, fd.ether.SrcMAC)
+	resp.Options = iface.newUpdateRespOpts(fd, req, cliID, ianaOpt)
+
+	return respond6(fd, resp)
 }
 
 // handleInfo handles messages of type INFORMATION-REQUEST.  req must not be nil
 // and must be a valid DHCPv6 message of type INFORMATION-REQUEST.  fd must be
 // valid.
 //
-// TODO(e.burkov):  Implement.  This is a stub for now.
+// TODO(e.burkov):  The current implementation does not handle relay-forwarded
+// INFORMATION-REQUEST messages.
 func (iface *dhcpInterfaceV6) handleInfo(
 	ctx context.Context,
 	fd *frameData6,
 	req *layers.DHCPv6,
 ) (err error) {
-	if srvID, ok := findOption6(req.Options, layers.DHCPv6OptServerID); ok {
-		if !bytes.Equal(srvID, fd.duidData) {
-			return fmt.Errorf(
-				"dhcpv6: server id: got %v, want %v: %w",
-				srvID,
-				fd.duidData,
-				errors.ErrNotEqual,
-			)
-		}
+	srvID, ok := findOption6(req.Options, layers.DHCPv6OptServerID)
+	if ok && !bytes.Equal(srvID, fd.duidData) {
+		return fmt.Errorf(
+			"dhcpv6: server id: got %v, want %v: %w",
+			srvID,
+			fd.duidData,
+			errors.ErrNotEqual,
+		)
 	}
 
-	_, ok := findOption6(req.Options, layers.DHCPv6OptIANA)
+	_, ok = findOption6(req.Options, layers.DHCPv6OptIANA)
 	if ok {
 		return fmt.Errorf("dhcpv6: %s: ia option: %w", req.MsgType, errors.ErrUnexpectedValue)
 	}
@@ -339,13 +366,20 @@ func (iface *dhcpInterfaceV6) handleInfo(
 	l := iface.common.logger
 	l.DebugContext(ctx, "handling message", "type", req.MsgType)
 
-	return nil
+	resp := &layers.DHCPv6{
+		MsgType:       layers.DHCPv6MsgTypeReply,
+		TransactionID: req.TransactionID,
+		Options:       iface.newInfoRespOpts(fd, req),
+	}
+
+	return respond6(fd, resp)
 }
 
 // handleRelease handles messages of type RELEASE.  req must not be nil and must
 // be a valid DHCPv6 message of type RELEASE.  fd must be valid.
 //
-// TODO(e.burkov):  Implement.  This is a stub for now.
+// TODO(e.burkov):  Verify all IA_NA options instead of handling only the first
+// one.
 func (iface *dhcpInterfaceV6) handleRelease(
 	ctx context.Context,
 	fd *frameData6,
@@ -359,7 +393,43 @@ func (iface *dhcpInterfaceV6) handleRelease(
 	l := iface.common.logger
 	l.DebugContext(ctx, "handling message", "type", req.MsgType, "cli_id", cliID)
 
-	return nil
+	resp := &layers.DHCPv6{
+		MsgType:       layers.DHCPv6MsgTypeReply,
+		TransactionID: req.TransactionID,
+	}
+
+	iaid, ip := iface.ipForRelease(ctx, req)
+	if ip == (netip.Addr{}) {
+		resp.Options = iface.newUpdateRespOpts(fd, req, cliID, layers.DHCPv6Option{})
+
+		return respond6(fd, resp)
+	}
+
+	key := macToKey(fd.ether.SrcMAC)
+
+	iface.common.indexMu.Lock()
+	defer iface.common.indexMu.Unlock()
+
+	lease, hasLease := iface.common.leases[key]
+	if !hasLease || lease.IP != ip {
+		respIANA := newIANAWithStatus(iaid, layers.DHCPv6StatusCodeNoBinding)
+		resp.Options = iface.newUpdateRespOpts(fd, req, cliID, respIANA)
+
+		return respond6(fd, resp)
+	}
+
+	err = iface.common.index.remove(ctx, lease, iface.common)
+	if err != nil {
+		l.ErrorContext(ctx, "removing lease", slogutil.KeyError, err)
+
+		respIANA := newIANAWithStatus(iaid, layers.DHCPv6StatusCodeNoBinding)
+		resp.Options = iface.newUpdateRespOpts(fd, req, cliID, respIANA)
+	} else {
+		respIANA := &IANAOption{ID: iaid}
+		resp.Options = iface.newUpdateRespOpts(fd, req, cliID, respIANA.Encode())
+	}
+
+	return respond6(fd, resp)
 }
 
 // handleDecline handles messages of type DECLINE.  req must not be nil and must