Murzaby/Adguardhome
1
0
Fork 0
mirror of https://github.com/AdguardTeam/AdGuardHome.git synced 2026-08-04 15:28:58 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 12

Merge remote-tracking branch 'origin/master' into AGDNS-4189-imp-code
Some checks failed
build / test (macOS-latest) (push) Has been cancelled
Details
build / test (ubuntu-latest) (push) Has been cancelled
Details
build / test (windows-latest) (push) Has been cancelled
Details
lint / go-lint (push) Has been cancelled
Details
lint / eslint (push) Has been cancelled
Details
build / build-release (push) Has been cancelled
Details
build / notify (push) Has been cancelled
Details
lint / notify (push) Has been cancelled
Details

Browse source
This commit is contained in:
Dimitry Kolyshev 2026-07-13 10:40:33 +07:00
commit 269d3e5c3b
24 changed files with 599 additions and 202 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.github/workflows/build.yml vendored
View file

@ -6,7 +6,7 @@
# See https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#permissions.
'permissions': {}
'env':
'GO_VERSION': '1.26.4'
'GO_VERSION': '1.26.5'
'NODE_VERSION': '20'
'on':
'push':

2
.twosky.json
View file

@ -52,7 +52,7 @@
"project_id": "hostlists-registry",
"base_locale": "en",
"localizable_files": [
"client/src/__locales-services/services.json"
"client/src/__locales-services/en.json"
],
"languages": {
"ar": "العربية",

7
CHANGELOG.md
View file

@ -22,7 +22,7 @@ NOTE: Add new changes BELOW THIS COMMENT.
- The H2C connection establishment via HTTP/1.1 request upgrade is no longer supported. See [RFC 9113][rfc9113].
- Go version has been updated to prevent the possibility of exploiting the Go vulnerabilities fixed in [1.26.4][go-1.26.4].
- Go version has been updated to prevent the possibility of exploiting the Go vulnerabilities fixed in [1.26.5][go-1.26.5].
- The size of rulelists is limited. This is necessary to prevent a user's machine from becoming overloaded if the filter source misbehaves.
@ -30,8 +30,6 @@ NOTE: Add new changes BELOW THIS COMMENT.
- Improved updater logging to give users more insight into the problem with version updating ([#8410]).
[#8410]: https://github.com/AdguardTeam/AdGuardHome/issues/8410
### Changed
- The interval of filter updates can now be set to any number of ours between 0 and 365 days in the configuration file.
@ -50,7 +48,8 @@ NOTE: Add new changes BELOW THIS COMMENT.
[#7955]: https://github.com/AdguardTeam/AdGuardHome/issues/7955
[#8276]: https://github.com/AdguardTeam/AdGuardHome/issues/8276
[go-1.26.4]: https://groups.google.com/g/golang-announce/c/tKs3rmcBcKw
[#8410]: https://github.com/AdguardTeam/AdGuardHome/issues/8410
[go-1.26.5]: https://groups.google.com/g/golang-announce/c/OrmQE_Yp5Sc
[rfc9113]: https://datatracker.ietf.org/doc/html/rfc9113
<!--

2
Makefile
View file

@ -25,7 +25,7 @@ DIST_DIR = dist
GOAMD64 = v1
GOPROXY = https://proxy.golang.org|direct
GOTELEMETRY = off
GOTOOLCHAIN = go1.26.4
GOTOOLCHAIN = go1.26.5
GPG_KEY = devteam@adguard.com
GPG_KEY_PASSPHRASE = not-a-real-password
NPM = npm

6
bamboo-specs/release.yaml
View file

@ -11,7 +11,7 @@
'cacheBuster': '0'
'channel': 'edge'
'dockerFrontend': 'adguard/home-js-builder:4.0'
'dockerGo': 'adguard/go-builder:1.26.4--1'
'dockerGo': 'adguard/go-builder:1.26.5--1'
'stages':
- 'Build frontend':
@ -280,7 +280,7 @@
'variables':
'channel': 'beta'
'dockerFrontend': 'adguard/home-js-builder:4.0'
'dockerGo': 'adguard/go-builder:1.26.4--1'
'dockerGo': 'adguard/go-builder:1.26.5--1'
# release-vX.Y.Z branches are the branches from which the actual final
# release is built.
- '^release-v[0-9]+\.[0-9]+\.[0-9]+':
@ -296,4 +296,4 @@
'variables':
'channel': 'release'
'dockerFrontend': 'adguard/home-js-builder:4.0'
'dockerGo': 'adguard/go-builder:1.26.4--1'
'dockerGo': 'adguard/go-builder:1.26.5--1'

4
bamboo-specs/test.yaml
View file

@ -10,7 +10,7 @@
'cacheBuster': '0'
'channel': 'development'
'dockerFrontend': 'adguard/home-js-builder:4.0'
'dockerGo': 'adguard/go-builder:1.26.4--1'
'dockerGo': 'adguard/go-builder:1.26.5--1'
'stages':
- 'Tests':
@ -255,5 +255,5 @@
# may need to build a few of these.
'variables':
'dockerFrontend': 'adguard/home-js-builder:4.0'
'dockerGo': 'adguard/go-builder:1.26.4--1'
'dockerGo': 'adguard/go-builder:1.26.5--1'
'channel': 'candidate'

2
docker/ci.Dockerfile
View file

@ -28,7 +28,7 @@
# needed. Keep it in sync with bamboo-specs/bamboo.yaml.
# NOTE: Keep in sync with bamboo-specs/bamboo.yaml.
ARG BASE_IMAGE=adguard/go-builder:1.26.4--1
ARG BASE_IMAGE=adguard/go-builder:1.26.5--1
# The dependencies stage is needed to install packages and tool dependencies.
# This is also where binaries like osslsigncode, which may be required for tests

2
go.mod
View file

@ -1,6 +1,6 @@
module github.com/AdguardTeam/AdGuardHome
go 1.26.4
go 1.26.5
require (
github.com/AdguardTeam/dnscrypt v0.0.2

7
internal/dhcpsvc/dhcpsvc_test.go
View file

@ -300,9 +300,16 @@ func newTestPacket(
// assertLeases asserts that the leases returned by srv are equal to orig if
// wantChanged is false and not equal if wantChanged is true. The assertion is
// performed 10 times during half of [testTimeout].
//
// TODO(e.burkov): Replace the lease storage with interface and test properly.
func assertLeases(tb testing.TB, orig []*dhcpsvc.Lease, srv dhcpsvc.Interface, wantChanged bool) {
tb.Helper()
// TODO(e.burkov): The tests using this helper are taking too long to fit
// into CI timeout. Given that the tests are passed locally, skip them for
// now and resolve the TODO above as soon as possible.
tb.SkipNow()
cond := func() (ok bool) {
got := srv.Leases()

150
internal/dhcpsvc/handle.go
View file

@ -1,150 +0,0 @@
package dhcpsvc
import (
"context"
"log/slog"
"net/netip"
"slices"
"github.com/AdguardTeam/golibs/logutil/slogutil"
"github.com/gopacket/gopacket"
"github.com/gopacket/gopacket/layers"
)
// serveEther4 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.
func (srv *DHCPServer) serveEther4(ctx context.Context, iface *dhcpInterfaceV4, nd NetworkDevice) {
defer slogutil.RecoverAndLog(ctx, srv.logger)
src := gopacket.NewPacketSource(nd, nd.LinkType())
for pkt := range src.Packets() {
fd := newFrameData4(ctx, srv.logger, pkt, nd)
if fd == nil {
continue
}
err := srv.serveV4(ctx, iface, pkt, fd)
if err != nil {
srv.logger.ErrorContext(ctx, "serving", slogutil.KeyError, err)
}
}
}
// 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.
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 newFrameData4(
ctx context.Context,
logger *slog.Logger,
pkt gopacket.Packet,
dev NetworkDevice,
) (fd *frameData4) {
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.LayerTypeIPv4).(*layers.IPv4)
if !ok {
actual := pkt.Layers()
logger.DebugContext(ctx, "skipping non-ipv4 packet", "layers", actual)
return nil
}
addr, ok := netip.AddrFromSlice(ipLayer.DstIP)
if !ok || !slices.Contains(addrs, addr) {
addr = addrs[0]
}
return &frameData4{
ether: etherLayer,
ip: ipLayer,
device: dev,
localAddr: addr,
}
}
// 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,
duidData: duid.Encode(),
device: dev,
localAddr: addr,
}
}

24
internal/dhcpsvc/handler4.go
View file

@ -12,6 +12,30 @@ import (
"github.com/gopacket/gopacket/layers"
)
// serveEther4 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.
func (srv *DHCPServer) serveEther4(ctx context.Context, iface *dhcpInterfaceV4, nd NetworkDevice) {
defer slogutil.RecoverAndLog(ctx, srv.logger)
src := gopacket.NewPacketSource(nd, nd.LinkType())
for pkt := range src.Packets() {
fd, err := newFrameData4(pkt, nd)
if err != nil {
srv.logger.DebugContext(ctx, "parsing frame data", slogutil.KeyError, err)
continue
}
err = srv.serveV4(ctx, iface, pkt, fd)
if err != nil {
srv.logger.ErrorContext(ctx, "serving", slogutil.KeyError, err)
}
}
}
// 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(

40
internal/dhcpsvc/handler4_test.go
View file

@ -226,10 +226,11 @@ func TestDHCPServer_ServeEther4_requestSelecting(t *testing.T) {
t.Parallel()
testCases := []struct {
discover gopacket.Packet
request gopacket.Packet
name string
wantOpts layers.DHCPOptions
discover gopacket.Packet
request gopacket.Packet
name string
wantOpts layers.DHCPOptions
wantChange bool
}{{
discover: newDHCPDISCOVER(t, testHWUnknown),
request: newDHCPREQUEST(t, &dhcpRequestConfig{
@ -246,6 +247,7 @@ func TestDHCPServer_ServeEther4_requestSelecting(t *testing.T) {
newOptServerID(t, testIfaceAddrV4),
newOptLeaseTime(t, testLeaseTTL),
},
wantChange: true,
}, {
discover: newDHCPDISCOVER(t, testHWStatic),
request: newDHCPREQUEST(t, &dhcpRequestConfig{
@ -256,8 +258,9 @@ func TestDHCPServer_ServeEther4_requestSelecting(t *testing.T) {
clientHWAddr: testHWStatic,
flags: dhcpsvc.FlagsBroadcast,
}),
name: "wrong_server_id",
wantOpts: nil,
name: "wrong_server_id",
wantOpts: nil,
wantChange: false,
}, {
discover: nil,
request: newDHCPREQUEST(t, &dhcpRequestConfig{
@ -273,6 +276,7 @@ func TestDHCPServer_ServeEther4_requestSelecting(t *testing.T) {
newOptMessageType(t, layers.DHCPMsgTypeNak),
newOptServerID(t, testIfaceAddrV4),
},
wantChange: false,
}, {
discover: newDHCPDISCOVER(t, testHWStatic),
request: newDHCPREQUEST(t, &dhcpRequestConfig{
@ -288,6 +292,7 @@ func TestDHCPServer_ServeEther4_requestSelecting(t *testing.T) {
newOptMessageType(t, layers.DHCPMsgTypeNak),
newOptServerID(t, testIfaceAddrV4),
},
wantChange: false,
}, {
discover: newDHCPDISCOVER(t, testHWStatic),
request: newDHCPREQUEST(t, &dhcpRequestConfig{
@ -299,8 +304,9 @@ func TestDHCPServer_ServeEther4_requestSelecting(t *testing.T) {
clientIP: testIPv4Static,
flags: dhcpsvc.FlagsBroadcast,
}),
name: "nonzero_ciaddr",
wantOpts: nil,
name: "nonzero_ciaddr",
wantOpts: nil,
wantChange: false,
}}
for _, tc := range testCases {
@ -310,13 +316,14 @@ func TestDHCPServer_ServeEther4_requestSelecting(t *testing.T) {
t.Parallel()
ndMgr, dev, inCh, outCh := newTestNetworkDeviceAndManager(t, testIfaceAddrV4)
startTestDHCPServer(t, &dhcpsvc.Config{
srv := newTestDHCPServer(t, &dhcpsvc.Config{
Logger: slogutil.NewDiscardLogger(),
Interfaces: testIPv4InterfacesConf,
NetworkDeviceManager: ndMgr,
DBFilePath: dbFilePath,
Enabled: true,
})
servicetest.RequireRun(t, srv, testTimeout)
if tc.discover != nil {
testutil.RequireSend(t, inCh, tc.discover, testTimeout)
@ -325,6 +332,8 @@ func TestDHCPServer_ServeEther4_requestSelecting(t *testing.T) {
require.True(t, ok)
}
leases := srv.Leases()
if tc.wantOpts == nil {
dev.onWritePacketData = unexpectedWritePacketData
}
@ -332,6 +341,7 @@ func TestDHCPServer_ServeEther4_requestSelecting(t *testing.T) {
testutil.RequireSend(t, inCh, tc.request, testTimeout)
assertValidResponse4(t, dhcpv4FromPacket(t, tc.request), outCh, tc.wantOpts)
assertLeases(t, leases, srv, tc.wantChange)
})
}
}
@ -418,16 +428,20 @@ func TestDHCPServer_ServeEther4_requestInitReboot(t *testing.T) {
dev.onWritePacketData = unexpectedWritePacketData
}
startTestDHCPServer(t, &dhcpsvc.Config{
srv := newTestDHCPServer(t, &dhcpsvc.Config{
Interfaces: testIPv4InterfacesConf,
NetworkDeviceManager: ndMgr,
DBFilePath: dbFilePath,
Enabled: true,
})
servicetest.RequireRun(t, srv, testTimeout)
leases := srv.Leases()
testutil.RequireSend(t, inCh, tc.req, testTimeout)
assertValidResponse4(t, dhcpv4FromPacket(t, tc.req), outCh, tc.wantOpts)
assertLeases(t, leases, srv, false)
})
}
}
@ -499,16 +513,20 @@ func TestDHCPServer_ServeEther4_requestRenewSuccess(t *testing.T) {
t.Parallel()
ndMgr, inCh, outCh := newTestNetworkDeviceManager(t, testIfaceAddrV4)
startTestDHCPServer(t, &dhcpsvc.Config{
srv := newTestDHCPServer(t, &dhcpsvc.Config{
Interfaces: testIPv4InterfacesConf,
NetworkDeviceManager: ndMgr,
DBFilePath: dbFilePath,
Enabled: true,
})
servicetest.RequireRun(t, srv, testTimeout)
leases := srv.Leases()
testutil.RequireSend(t, inCh, tc.req, testTimeout)
assertValidResponse4(t, dhcpv4FromPacket(t, tc.req), outCh, tc.wantOpts)
assertLeases(t, leases, srv, false)
})
}
}

67
internal/dhcpsvc/handler6.go
View file

@ -11,6 +11,31 @@ import (
"github.com/gopacket/gopacket/layers"
)
// 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.
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, err := newFrameData6(pkt, nd, srvDUID)
if err != nil {
srv.logger.DebugContext(ctx, "parsing frame data", slogutil.KeyError, err)
continue
}
err = srv.serveV6(ctx, iface, pkt, fd)
if err != nil {
srv.logger.ErrorContext(ctx, "serving", slogutil.KeyError, err)
}
}
}
// serveV6 handles the ethernet packet of IPv6 type. iface and pkt must not be
// nil. iface and fd must be valid. pkt must be an IPv6 packet.
//
@ -124,8 +149,6 @@ func (iface *dhcpInterfaceV6) handleSolicit(
// handleRequest handles messages of type REQUEST. req must not be nil and must
// be a valid DHCPv6 message of type REQUEST. fd must be valid.
//
// TODO(e.burkov): Implement. This is a stub for now.
func (iface *dhcpInterfaceV6) handleRequest(
ctx context.Context,
fd *frameData6,
@ -139,7 +162,45 @@ func (iface *dhcpInterfaceV6) handleRequest(
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 {
// In practice, the DHCPv6 REQUEST with no IA_NA options is not useful,
// since the standard explicitly defines the INFORMATION-REQUEST message
// type for that purpose. However, there are no requirements which
// invalidate such messages, so the server must respond.
resp.Options = iface.newRequestRespOpts(fd, req, cliID, layers.DHCPv6Option{})
return respond6(fd, resp)
}
reqIP, hasReqIP := iana.requestedAddr()
if hasReqIP && !iface.subnetPrefix.Contains(reqIP) {
respIANA := newIANAWithStatus(iana.ID, layers.DHCPv6StatusCodeNotOnLink)
resp.Options = iface.newRequestRespOpts(fd, req, cliID, respIANA)
return respond6(fd, resp)
}
var ianaOpt layers.DHCPv6Option
lease, err := iface.leaseForRequest(ctx, req, fd.ether.SrcMAC)
if err != nil {
ianaOpt = newIANAWithStatus(iana.ID, layers.DHCPv6StatusCodeNoAddrsAvail)
} else {
ianaOpt = iface.iaNAFromLease(lease, iana.ID)
}
resp.Options = iface.newRequestRespOpts(fd, req, cliID, ianaOpt)
return respond6(fd, resp)
}
// handleConfirm handles messages of type CONFIRM. req must not be nil and must

149
internal/dhcpsvc/handler6_test.go
View file

@ -9,6 +9,7 @@ import (
"github.com/AdguardTeam/AdGuardHome/internal/dhcpsvc"
"github.com/AdguardTeam/golibs/errors"
"github.com/AdguardTeam/golibs/testutil"
"github.com/AdguardTeam/golibs/testutil/servicetest"
"github.com/gopacket/gopacket"
"github.com/gopacket/gopacket/layers"
"github.com/stretchr/testify/assert"
@ -167,6 +168,126 @@ func TestDHCPServer_ServeEther6_solicit(t *testing.T) {
}
}
// TODO(e.burkov): Add tests for REQUEST causing errors. This would require a
// custom implementation of the address checker at least.
func TestDHCPServer_ServeEther6_request(t *testing.T) {
t.Parallel()
notOnLinkAddr := netip.MustParseAddr(testAnotherRangeStartV6Str)
testCases := []struct {
name string
in gopacket.Packet
solicit gopacket.Packet
wantOpts layers.DHCPv6Options
wantChange bool
}{{
name: "success",
in: newDHCPv6REQUEST(t, testHWUnknown, testIPv6Unknown),
solicit: nil,
wantOpts: layers.DHCPv6Options{
newOptServerDUID(t, testIfaceHWAddr),
newOptClientDUID(t, testHWUnknown),
newOptIANA(t, testIAID, testIPv6Conf.RangeStart),
newOptPreference(t, 0),
newOptSolMaxRT(t, dhcpsvc.DefaultSolMaxRT),
},
wantChange: true,
}, {
name: "not_on_link",
in: newDHCPv6REQUEST(t, testHWUnknown, notOnLinkAddr),
solicit: nil,
wantOpts: layers.DHCPv6Options{
newOptServerDUID(t, testIfaceHWAddr),
newOptClientDUID(t, testHWUnknown),
newOptIANAStatus(t, testIAID, layers.DHCPv6StatusCodeNotOnLink),
newOptPreference(t, 0),
newOptSolMaxRT(t, dhcpsvc.DefaultSolMaxRT),
},
wantChange: false,
}, {
name: "existing_static",
in: newDHCPv6REQUEST(t, testHWStatic, testIPv6Static),
solicit: nil,
wantOpts: layers.DHCPv6Options{
newOptServerDUID(t, testIfaceHWAddr),
newOptClientDUID(t, testHWStatic),
newOptIANA(t, testIAID, testIPv6Static),
newOptPreference(t, 0),
newOptSolMaxRT(t, dhcpsvc.DefaultSolMaxRT),
},
wantChange: false,
}, {
name: "no_iana",
in: newDHCPv6REQUEST(t, testHWUnknown, netip.Addr{}),
solicit: nil,
wantOpts: layers.DHCPv6Options{
newOptServerDUID(t, testIfaceHWAddr),
newOptClientDUID(t, testHWUnknown),
newOptPreference(t, 0),
newOptSolMaxRT(t, dhcpsvc.DefaultSolMaxRT),
},
wantChange: false,
}, {
name: "preceding_solicit",
in: newDHCPv6REQUEST(t, testHWUnknown, testIPv6Unknown),
solicit: newDHCPv6SOLICIT(t, testHWUnknown, testIPv6Unknown, false),
wantOpts: layers.DHCPv6Options{
newOptServerDUID(t, testIfaceHWAddr),
newOptClientDUID(t, testHWUnknown),
newOptIANA(t, testIAID, testIPv6Conf.RangeStart),
newOptPreference(t, 0),
newOptSolMaxRT(t, dhcpsvc.DefaultSolMaxRT),
},
wantChange: true,
}, {
name: "preceding_solicit_rapid_commit",
in: newDHCPv6REQUEST(t, testHWUnknown, testIPv6Unknown),
solicit: newDHCPv6SOLICIT(t, testHWUnknown, testIPv6Unknown, true),
wantOpts: layers.DHCPv6Options{
newOptServerDUID(t, testIfaceHWAddr),
newOptClientDUID(t, testHWUnknown),
newOptIANA(t, testIAID, testIPv6Conf.RangeStart),
newOptPreference(t, 0),
newOptSolMaxRT(t, dhcpsvc.DefaultSolMaxRT),
},
wantChange: false,
}}
for _, tc := range testCases {
dbFilePath := newTempDB(t)
req := testutil.RequireTypeAssert[*layers.DHCPv6](t, tc.in.Layer(layers.LayerTypeDHCPv6))
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ndMgr, inCh, outCh := newTestNetworkDeviceManager(t, testIfaceAddrV6)
srv := newTestDHCPServer(t, &dhcpsvc.Config{
Interfaces: testIPv6InterfacesConf,
NetworkDeviceManager: ndMgr,
Logger: testLogger,
DBFilePath: dbFilePath,
Enabled: true,
})
servicetest.RequireRun(t, srv, testTimeout)
if tc.solicit != nil {
testutil.RequireSend(t, inCh, tc.solicit, testTimeout)
_, ok := testutil.RequireReceive(t, outCh, testTimeout)
require.True(t, ok)
}
leases := srv.Leases()
testutil.RequireSend(t, inCh, tc.in, testTimeout)
assertValidResponse6(t, req, outCh, tc.wantOpts)
assertLeases(t, leases, srv, tc.wantChange)
})
}
}
// newDHCPv6SOLICIT creates a new DHCPv6 SOLICIT packet for testing.
func newDHCPv6SOLICIT(
tb testing.TB,
@ -205,6 +326,34 @@ func newDHCPv6SOLICIT(
return newTestPacket(tb, layers.LinkTypeEthernet, eth, ip, udp, dhcp)
}
// newDHCPv6REQUEST creates a new DHCPv6 REQUEST packet for testing.
func newDHCPv6REQUEST(tb testing.TB, mac net.HardwareAddr, reqIP netip.Addr) (pkt gopacket.Packet) {
tb.Helper()
eth := newEthernetLayer(tb, mac, testIfaceHWAddr, layers.EthernetTypeIPv6)
ip, udp := newIPv6UDPLayer(tb, netip.AddrPort{}, netip.AddrPort{})
dhcp := &layers.DHCPv6{
MsgType: layers.DHCPv6MsgTypeRequest,
HopCount: 0,
// Don't specify link and peer addresses, as they are intended for relay
// messages.
LinkAddr: nil,
PeerAddr: nil,
TransactionID: testTransactionID,
Options: layers.DHCPv6Options{
newOptClientDUID(tb, mac),
newOptServerDUID(tb, testIfaceHWAddr),
},
}
if reqIP.IsValid() && reqIP.Is6() {
dhcp.Options = append(dhcp.Options, newOptIANA(tb, testIAID, reqIP))
}
return newTestPacket(tb, layers.LinkTypeEthernet, eth, ip, udp, dhcp)
}
// newIPv6UDPLayer creates IPv6 and UDP layers for testing. Invalid src is
// replaced with an unspecified address and client DHCPv6 port, invalid dst is
// replaced with the broadcast address and server DHCPv6 port.

8
internal/dhcpsvc/interface.go
View file

@ -79,7 +79,7 @@ func (iface *netInterface) reset() {
}
// addLease inserts the given lease into iface. It returns an error if the
// lease can't be inserted.
// lease can't be inserted. l must not be nil. iface.indexMu must be locked.
func (iface *netInterface) addLease(l *Lease) (err error) {
mk := macToKey(l.HWAddr)
_, found := iface.leases[mk]
@ -96,7 +96,8 @@ func (iface *netInterface) addLease(l *Lease) (err error) {
}
// updateLease replaces an existing lease within iface with the given one. It
// returns an error if there is no lease with such hardware address.
// returns an error if there is no lease with such hardware address. l must not
// be nil. iface.indexMu must be locked.
func (iface *netInterface) updateLease(l *Lease) (prev *Lease, err error) {
mk := macToKey(l.HWAddr)
prev, found := iface.leases[mk]
@ -110,7 +111,8 @@ func (iface *netInterface) updateLease(l *Lease) (prev *Lease, err error) {
}
// removeLease removes an existing lease from iface. It returns an error if
// there is no lease equal to l. l must not be nil.
// there is no lease equal to l. l must not be nil. iface.indexMu must be
// locked.
func (iface *netInterface) removeLease(l *Lease) (err error) {
mk := macToKey(l.HWAddr)
_, found := iface.leases[mk]

8
internal/dhcpsvc/leaseindex.go
View file

@ -167,19 +167,13 @@ func (idx *leaseIndex) update(
return err
}
err = idx.dbStore(ctx, logger)
if err != nil {
// Don't wrap the error since it's informative enough as is.
return err
}
delete(idx.byAddr, prev.IP)
delete(idx.byName, strings.ToLower(prev.Hostname))
idx.byAddr[l.IP] = l
idx.byName[loweredName] = l
return nil
return idx.dbStore(ctx, logger)
}
// rangeLeases calls f for each lease in idx in an unspecified order until f

105
internal/dhcpsvc/networkdevice.go
View file

@ -2,11 +2,14 @@ package dhcpsvc
import (
"context"
"fmt"
"io"
"net"
"net/netip"
"slices"
"github.com/AdguardTeam/golibs/errors"
"github.com/AdguardTeam/golibs/netutil"
"github.com/AdguardTeam/golibs/validate"
"github.com/gopacket/gopacket"
"github.com/gopacket/gopacket/layers"
@ -169,3 +172,105 @@ type frameData6 struct {
// It must not be nil.
duidData []byte
}
// 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. pkt and dev must not be nil.
func newFrameData4(pkt gopacket.Packet, dev NetworkDevice) (fd *frameData4, err error) {
addrs := dev.Addresses()
if len(addrs) == 0 {
return nil, fmt.Errorf("addresses of network device: %w", errors.ErrEmptyValue)
}
ether, err := ethernetFromPacket(pkt, layers.EthernetTypeIPv4)
if err != nil {
return nil, fmt.Errorf("extracting ethernet layer: %w", err)
}
ipLayer, ok := pkt.Layer(layers.LayerTypeIPv4).(*layers.IPv4)
if !ok {
return nil, fmt.Errorf("extracting ipv4 layer: %w", errors.ErrNoValue)
}
addr, ok := netip.AddrFromSlice(ipLayer.DstIP)
if !ok || !slices.Contains(addrs, addr) {
addr = addrs[0]
}
return &frameData4{
ether: ether,
ip: ipLayer,
device: dev,
localAddr: addr,
}, nil
}
// 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. pkt, dev, and duid must not be nil.
func newFrameData6(
pkt gopacket.Packet,
dev NetworkDevice,
duid *layers.DHCPv6DUID,
) (fd *frameData6, err error) {
addrs := dev.Addresses()
if len(addrs) == 0 {
return nil, fmt.Errorf("addresses of network device: %w", errors.ErrEmptyValue)
}
ether, err := ethernetFromPacket(pkt, layers.EthernetTypeIPv6)
if err != nil {
return nil, fmt.Errorf("extracting ethernet layer: %w", err)
}
ipLayer, ok := pkt.Layer(layers.LayerTypeIPv6).(*layers.IPv6)
if !ok {
return nil, fmt.Errorf("extracting ipv6 layer: %w", errors.ErrNoValue)
}
addr, ok := netip.AddrFromSlice(ipLayer.DstIP)
if !ok || !slices.Contains(addrs, addr) {
addr = addrs[0]
}
return &frameData6{
ether: ether,
ip: ipLayer,
duid: duid,
duidData: duid.Encode(),
device: dev,
localAddr: addr,
}, nil
}
// ethernetFromPacket extracts the Ethernet layer from the given packet and
// validates its contents. pkt must not be nil, expType is the expected type of
// the Ethernet layer.
func ethernetFromPacket(
pkt gopacket.Packet,
expType layers.EthernetType,
) (ether *layers.Ethernet, err error) {
ether, ok := pkt.Layer(layers.LayerTypeEthernet).(*layers.Ethernet)
if !ok {
return nil, errors.ErrNoValue
}
var errs []error
err = netutil.ValidateMAC(ether.SrcMAC)
if err != nil {
errs = append(errs, fmt.Errorf("source mac: %w", err))
}
err = netutil.ValidateMAC(ether.DstMAC)
if err != nil {
errs = append(errs, fmt.Errorf("destination mac: %w", err))
}
err = validate.Equal("type", ether.EthernetType, expType)
if err != nil {
errs = append(errs, fmt.Errorf("ethernet type: %w", err))
}
return ether, errors.Join(errs...)
}

11
internal/dhcpsvc/options6.go
View file

@ -119,6 +119,17 @@ func (opt IANAOption) Encode() (iaOpt layers.DHCPv6Option) {
return layers.NewDHCPv6Option(layers.DHCPv6OptIANA, data)
}
// requestedAddr returns the first requested address within iana, if any.
func (opt IANAOption) requestedAddr() (addr netip.Addr, ok bool) {
if len(opt.Nested) == 0 {
return netip.Addr{}, false
}
addr = opt.Nested[0].Addr
return addr, addr.IsValid()
}
// iaAddrDataLen is the minimum length of an IA Address option data field, which
// is encoded [iaAddrOption], in bytes, excluding any nested options. It
// consists of the IPv6 address (16 bytes) and the preferred and valid lifetimes

40
internal/dhcpsvc/options6_test.go
View file

@ -34,6 +34,46 @@ func newOptIANA(tb testing.TB, iaid uint32, reqIP netip.Addr) (opt layers.DHCPv6
return iana.Encode()
}
// newOptIANAStatus creates a DHCPv6 IA_NA (3) option carrying only a nested
// Status Code option.
func newOptIANAStatus(
tb testing.TB,
iaid uint32,
status layers.DHCPv6StatusCode,
) (opt layers.DHCPv6Option) {
tb.Helper()
const (
// statusOptLen is the length of the nested status code option:
// code (2) + length (2) + status (2) = 6 bytes.
statusOptLen = 6
// iaNAMinLen is the minimum length of the IA_NA option:
// IAID (4) + T1 (4) + T2 (4) = 12 bytes.
iaNAMinLen = 12
// iaNAStatusLen is the length of the IA_NA option with a nested status
// code option.
iaNAStatusLen = iaNAMinLen + statusOptLen
)
data := make([]byte, 0, iaNAStatusLen)
data = binary.BigEndian.AppendUint32(data, iaid)
// T1 and T2 are set to zero.
data = binary.BigEndian.AppendUint32(data, 0)
data = binary.BigEndian.AppendUint32(data, 0)
// Nested Status Code option.
data = binary.BigEndian.AppendUint16(data, uint16(layers.DHCPv6OptStatusCode))
// The length of the Status Code option data is 2 bytes.
data = binary.BigEndian.AppendUint16(data, 2)
data = binary.BigEndian.AppendUint16(data, uint16(status))
return layers.NewDHCPv6Option(layers.DHCPv6OptIANA, data)
}
// newOptPreference creates a DHCPv6 Preference (7) option with the specified
// preference value.
func newOptPreference(tb testing.TB, pref uint8) (opt layers.DHCPv6Option) {

26
internal/dhcpsvc/testdata/TestDHCPServer_ServeEther6_request/leases.json vendored Normal file
View file

@ -0,0 +1,26 @@
{
"leases": [
{
"expires": "2025-01-01T10:01:01Z",
"ip": "2001:db8::66",
"hostname": "dynamic6",
"mac": "02:03:04:05:06:07",
"static": false
},
{
"expires": "2025-01-01T01:01:00Z",
"ip": "2001:db8::67",
"hostname": "expired6",
"mac": "03:04:05:06:07:08",
"static": false
},
{
"expires": "",
"ip": "2001:db8::65",
"hostname": "static6",
"mac": "01:02:03:04:05:06",
"static": true
}
],
"version": 1
}

2
internal/dhcpsvc/v4.go
View file

@ -157,6 +157,8 @@ type dhcpInterfaceV4 struct {
clock timeutil.Clock
// addrChecker checks addresses for availability.
//
// TODO(e.burkov): Move to [netInterface].
addrChecker addressChecker
// gateway is the IP address of the network gateway.

129
internal/dhcpsvc/v6.go
View file

@ -134,10 +134,14 @@ type dhcpInterfaceV6 struct {
common *netInterface
// clock is used to get the current time.
//
// TODO(e.burkov): Move to [netInterface].
clock timeutil.Clock
// addrChecker checks if an address is available for leasing in current
// network.
//
// TODO(e.burkov): Move to [netInterface].
addrChecker addressChecker
// subnetPrefix is the network prefix of the interface's IPv6 subnet. It is
@ -431,7 +435,7 @@ func (iface *dhcpInterfaceV6) allocateForSolicit(
l := iface.common.logger
key := macToKey(mac)
for _, reqOpt := range req.Options {
for i, reqOpt := range req.Options {
if reqOpt.Code != layers.DHCPv6OptIANA {
continue
}
@ -440,7 +444,7 @@ func (iface *dhcpInterfaceV6) allocateForSolicit(
err := iana.UnmarshalBinary(reqOpt.Data)
if err != nil {
// TODO(e.burkov): Recheck the logic on malformed IA_NA options.
l.DebugContext(ctx, "malformed ia_na in solicit", slogutil.KeyError, err)
l.DebugContext(ctx, "malformed ia_na", "idx", i, slogutil.KeyError, err)
continue
}
@ -467,8 +471,41 @@ func (iface *dhcpInterfaceV6) allocateForSolicit(
return nil, 0
}
// firstIANA returns the first valid IA_NA option in req. It returns false if
// there is no such option. req must not be nil.
//
// TODO(e.burkov): Support handling several IA_NA options at a time when the
// database will migrate, see the BUG at [Lease]'s documentation.
func (iface *dhcpInterfaceV6) firstIANA(
ctx context.Context,
req *layers.DHCPv6,
) (iana *IANAOption, ok bool) {
l := iface.common.logger
for i, reqOpt := range req.Options {
if reqOpt.Code != layers.DHCPv6OptIANA {
continue
}
iana = &IANAOption{}
err := iana.UnmarshalBinary(reqOpt.Data)
if err != nil {
l.DebugContext(ctx, "malformed ia_na", "idx", i, slogutil.KeyError, err)
continue
}
return iana, true
}
return nil, false
}
// newSolicitRespOpts returns the common option list for Advertise and
// rapid-commit Reply responses to a Solicit request. cliID must not be nil.
// rapid-commit Reply responses to a Solicit request. Zero iaid creates an
// option with Status Code NoAddrsAvail. rapidCommit defines whether the
// response should include the Rapid Commit option. fd, req, cliID, and lease
// must not be nil.
func (iface *dhcpInterfaceV6) newSolicitRespOpts(
fd *frameData6,
req *layers.DHCPv6,
@ -477,10 +514,8 @@ func (iface *dhcpInterfaceV6) newSolicitRespOpts(
lease *Lease,
rapidCommit bool,
) (opts layers.DHCPv6Options) {
cliIDData := cliID.Encode()
opts = append(opts, layers.NewDHCPv6Option(layers.DHCPv6OptServerID, fd.duidData))
opts = append(opts, layers.NewDHCPv6Option(layers.DHCPv6OptClientID, cliIDData))
opts = append(opts, layers.NewDHCPv6Option(layers.DHCPv6OptClientID, cliID.Encode()))
// For Solicit without IA_NA options, respond with safe Advertise with no
// IA_NA options and Status Code NoAddrsAvail.
@ -504,6 +539,34 @@ func (iface *dhcpInterfaceV6) newSolicitRespOpts(
return iface.appendRequestedOptions(opts, req)
}
// newRequestRespOpts returns the common option list for Reply responses to a
// Request message. fd, req, and cliID must not be nil. iana must be a valid
// IA_NA option.
//
// TODO(e.burkov): Keep the Reply option set aligned with the current Advertise
// response shape until the wider DHCPv6 implementation is completed.
func (iface *dhcpInterfaceV6) newRequestRespOpts(
fd *frameData6,
req *layers.DHCPv6,
cliID *layers.DHCPv6DUID,
iana layers.DHCPv6Option,
) (opts layers.DHCPv6Options) {
opts = append(opts, layers.NewDHCPv6Option(layers.DHCPv6OptServerID, fd.duidData))
opts = append(opts, layers.NewDHCPv6Option(layers.DHCPv6OptClientID, cliID.Encode()))
if iana.Code != 0 {
opts = append(opts, iana)
}
// The server preference value MUST default to 0 unless otherwise configured
// by the server administrator.
//
// See RFC 9915 Section 18.3.9.
opts = append(opts, newPreferenceOption(0))
opts = append(opts, newSOLMaxRTOption(DefaultSolMaxRT))
return iface.appendRequestedOptions(opts, req)
}
// iaNAFromLease returns an IA_NA option with a single IA Address sub-option
// corresponding to lease and with the given iaid. The T1 and T2 values are set
// according to iface.t1 and iface.t2. If lease is nil, it returns an IA_NA
@ -525,6 +588,39 @@ func (iface *dhcpInterfaceV6) iaNAFromLease(lease *Lease, iaid uint32) (iana lay
}.Encode()
}
// leaseForRequest returns the committed lease for req. It reuses an already
// reserved lease for the client when possible, or allocates and commits the new
// address. iface.common.indexMu must be locked.
//
// TODO(e.burkov): Support committing several leases at a time when the
// database will migrate, see the BUG at [Lease]'s documentation.
func (iface *dhcpInterfaceV6) leaseForRequest(
ctx context.Context,
req *layers.DHCPv6,
mac net.HardwareAddr,
) (lease *Lease, err error) {
key := macToKey(mac)
l := iface.common.logger
lease, ok := iface.common.leases[key]
if !ok {
lease, err = iface.common.allocateLease(ctx, mac, iface.addrChecker, iface.clock)
if err != nil {
return nil, fmt.Errorf("allocating lease for mac %s: %w", mac, err)
}
}
err = iface.commit(ctx, req, lease)
if err != nil {
l.WarnContext(ctx, "committing lease", slogutil.KeyError, err)
// Don't wrap the error, because it's informative enough as is.
return nil, err
}
return lease, nil
}
// commit updates the lease allocated previously via a SOLICIT, or during
// handling the Rapid Commit option, assigning a hostname according to req. It
// deallocates the lease if the one fails to be committed. lease must be
@ -538,15 +634,25 @@ func (iface *dhcpInterfaceV6) commit(
req *layers.DHCPv6,
lease *Lease,
) (err error) {
if hostname := clientFQDN6(req); hostname != "" {
l := iface.common.logger
// Don't change the hostname if it is already set.
if !netutil.IsValidHostname(lease.Hostname) {
hostname := clientFQDN6(req)
if !netutil.IsValidHostname(hostname) {
hostname = aghnet.GenerateHostname(lease.IP)
}
lease.Hostname = hostname
} else {
lease.Hostname = aghnet.GenerateHostname(lease.IP)
l.DebugContext(ctx, "updated lease hostname", "hostname", hostname, "ip", lease.IP)
}
// TODO(e.burkov): Add the Lease.isExpired. method.
if lease.Expiry.Before(iface.clock.Now()) {
if exp := lease.Expiry; !exp.IsZero() && exp.Before(iface.clock.Now()) {
lease.updateExpiry(iface.clock, iface.common.leaseTTL)
l.DebugContext(ctx, "updated lease expiry", "expires", lease.Expiry, "ip", lease.IP)
}
err = iface.common.index.update(ctx, iface.common.logger, lease, iface.common)
@ -554,8 +660,7 @@ func (iface *dhcpInterfaceV6) commit(
rmErr := iface.common.removeLease(lease)
err = errors.WithDeferred(err, rmErr)
return fmt.Errorf("committing rapid lease for ip %s: %w", lease.IP, err)
return fmt.Errorf("committing lease for ip %s: %w", lease.IP, err)
}
return nil

3
scripts/README.md
View file

@ -202,6 +202,9 @@ Optional environment:
- `go run ./scripts/translations summary`: show the current locales summary.
> [!NOTE]
> The following script may produce false positives because JavaScript uses template literals like `servicesgroup.${group.id}.name`, so the actual key won't be found by substring search.
- `go run ./scripts/translations unused`: show the list of unused strings.
- `go run ./scripts/translations auto-add`: add locales with additions to the git and restore locales with deletions.

5
scripts/translations/main.go
View file

@ -60,8 +60,9 @@ type languages map[langCode]string
// textlabel is a text label of localization.
type textLabel string
// locales is a map, where key is text label and value is translation.
type locales map[textLabel]string
// locales is a map, where key is a text label and the value is either a string
// or an object.
type locales map[textLabel]any
func main() {
ctx := context.Background()