From 4d394e6f2162f797c409073cb52e1e0de93a9d5e Mon Sep 17 00:00:00 2001
From: Stanislav Chzhen <s.chzhen@adguard.com>
Date: Thu, 29 Aug 2024 20:40:38 +0300
Subject: [PATCH] all: client storage runtime sources
---
internal/client/storage.go | 229 ++++++++++++++--
internal/client/storage_test.go | 25 +-
internal/home/clients.go | 349 ++-----------------------
internal/home/clients_internal_test.go | 97 +++++--
internal/home/clientshttp.go | 5 +-
internal/home/dns.go | 4 +-
internal/home/dns_internal_test.go | 3 +-
internal/home/home.go | 2 +-
8 files changed, 335 insertions(+), 379 deletions(-)
diff --git a/internal/client/storage.go b/internal/client/storage.go
index 23bb6ca8..8684fc28 100644
--- a/internal/client/storage.go
+++ b/internal/client/storage.go
@@ -1,23 +1,62 @@
package client
import (
+ "cmp"
"fmt"
"net"
"net/netip"
"slices"
"sync"
+ "time"
+ "github.com/AdguardTeam/AdGuardHome/internal/aghnet"
+ "github.com/AdguardTeam/AdGuardHome/internal/arpdb"
+ "github.com/AdguardTeam/AdGuardHome/internal/dhcpsvc"
+ "github.com/AdguardTeam/AdGuardHome/internal/whois"
"github.com/AdguardTeam/golibs/container"
"github.com/AdguardTeam/golibs/errors"
+ "github.com/AdguardTeam/golibs/hostsfile"
"github.com/AdguardTeam/golibs/log"
)
+// DHCP is an interface for accessing DHCP lease data the [Storage] needs.
+type DHCP interface {
+ // Leases returns all the DHCP leases.
+ Leases() (leases []*dhcpsvc.Lease)
+
+ // HostByIP returns the hostname of the DHCP client with the given IP
+ // address. The address will be netip.Addr{} if there is no such client,
+ // due to an assumption that a DHCP client must always have a hostname.
+ HostByIP(ip netip.Addr) (host string)
+
+ // MACByIP returns the MAC address for the given IP address leased. It
+ // returns nil if there is no such client, due to an assumption that a DHCP
+ // client must always have a MAC address.
+ MACByIP(ip netip.Addr) (mac net.HardwareAddr)
+}
+
+type emptyDHCP struct{}
+
+// type check
+var _ DHCP = emptyDHCP{}
+
+func (emptyDHCP) Leases() (_ []*dhcpsvc.Lease) { return nil }
+
+func (emptyDHCP) HostByIP(_ netip.Addr) (_ string) { return "" }
+
+func (emptyDHCP) MACByIP(_ netip.Addr) (_ net.HardwareAddr) { return nil }
+
// Config is the client storage configuration structure.
-//
-// TODO(s.chzhen): Expand.
type Config struct {
+ DHCP DHCP
+ EtcHosts *aghnet.HostsContainer
+ ARPDB arpdb.Interface
+
// AllowedTags is a list of all allowed client tags.
AllowedTags []string
+
+ InitialClients []*Persistent
+ ARPClientsUpdatePeriod time.Duration
}
// Storage contains information about persistent and runtime clients.
@@ -33,18 +72,156 @@ type Storage struct {
// runtimeIndex contains information about runtime clients.
runtimeIndex *RuntimeIndex
+
+ dhcp DHCP
+ etcHosts *aghnet.HostsContainer
+ arpDB arpdb.Interface
+ arpClientsUpdatePeriod time.Duration
}
// NewStorage returns initialized client storage. conf must not be nil.
-func NewStorage(conf *Config) (s *Storage) {
+func NewStorage(conf *Config) (s *Storage, err error) {
allowedTags := container.NewMapSet(conf.AllowedTags...)
-
- return &Storage{
- allowedTags: allowedTags,
- mu: &sync.Mutex{},
- index: newIndex(),
- runtimeIndex: NewRuntimeIndex(),
+ s = &Storage{
+ allowedTags: allowedTags,
+ mu: &sync.Mutex{},
+ index: newIndex(),
+ runtimeIndex: NewRuntimeIndex(),
+ dhcp: cmp.Or(conf.DHCP, DHCP(emptyDHCP{})),
+ etcHosts: conf.EtcHosts,
+ arpDB: conf.ARPDB,
+ arpClientsUpdatePeriod: conf.ARPClientsUpdatePeriod,
}
+
+ for i, p := range conf.InitialClients {
+ err = s.Add(p)
+ if err != nil {
+ return nil, fmt.Errorf("adding client %q at index %d: %w", p.Name, i, err)
+ }
+ }
+
+ return s, nil
+}
+
+// Start starts the goroutines for updating the runtime client information.
+func (s *Storage) Start() {
+ go s.periodicARPUpdate()
+ go s.handleHostsUpdates()
+}
+
+// periodicARPUpdate periodically reloads runtime clients from ARP. It is
+// intended to be used as a goroutine.
+func (s *Storage) periodicARPUpdate() {
+ defer log.OnPanic("storage")
+
+ for {
+ s.ReloadARP()
+ time.Sleep(s.arpClientsUpdatePeriod)
+ }
+}
+
+// ReloadARP reloads runtime clients from ARP, if configured.
+func (s *Storage) ReloadARP() {
+ if s.arpDB != nil {
+ s.addFromSystemARP()
+ }
+}
+
+// addFromSystemARP adds the IP-hostname pairings from the output of the arp -a
+// command.
+func (s *Storage) addFromSystemARP() {
+ if err := s.arpDB.Refresh(); err != nil {
+ s.arpDB = arpdb.Empty{}
+ log.Error("refreshing arp container: %s", err)
+
+ return
+ }
+
+ ns := s.arpDB.Neighbors()
+ if len(ns) == 0 {
+ log.Debug("refreshing arp container: the update is empty")
+
+ return
+ }
+
+ var rcs []*Runtime
+ for _, n := range ns {
+ rc := NewRuntime(n.IP)
+ rc.SetInfo(SourceARP, []string{n.Name})
+
+ rcs = append(rcs, rc)
+ }
+
+ added, removed := s.BatchUpdateBySource(SourceARP, rcs)
+ log.Debug("storage: added %d, removed %d client aliases from arp neighborhood", added, removed)
+}
+
+// handleHostsUpdates receives the updates from the hosts container and adds
+// them to the clients storage. It is intended to be used as a goroutine.
+func (s *Storage) handleHostsUpdates() {
+ defer log.OnPanic("storage")
+
+ for upd := range s.etcHosts.Upd() {
+ s.addFromHostsFile(upd)
+ }
+}
+
+// addFromHostsFile fills the client-hostname pairing index from the system's
+// hosts files.
+func (s *Storage) addFromHostsFile(hosts *hostsfile.DefaultStorage) {
+ var rcs []*Runtime
+ hosts.RangeNames(func(addr netip.Addr, names []string) (cont bool) {
+ // Only the first name of the first record is considered a canonical
+ // hostname for the IP address.
+ //
+ // TODO(e.burkov): Consider using all the names from all the records.
+ rc := NewRuntime(addr)
+ rc.SetInfo(SourceHostsFile, []string{names[0]})
+
+ rcs = append(rcs, rc)
+
+ return true
+ })
+
+ added, removed := s.BatchUpdateBySource(SourceHostsFile, rcs)
+ log.Debug("storage: added %d, removed %d client aliases from system hosts file", added, removed)
+}
+
+// type check
+var _ AddressUpdater = (*Storage)(nil)
+
+// UpdateAddress implements the [AddressUpdater] interface for *Storage
+func (s *Storage) UpdateAddress(ip netip.Addr, host string, info *whois.Info) {
+ // Common fast path optimization.
+ if host == "" && info == nil {
+ return
+ }
+
+ if host != "" {
+ rc := NewRuntime(ip)
+ rc.SetInfo(SourceRDNS, []string{host})
+ s.UpdateRuntime(rc)
+ }
+
+ if info != nil {
+ s.setWHOISInfo(ip, info)
+ }
+}
+
+// setWHOISInfo sets the WHOIS information for a runtime client.
+func (s *Storage) setWHOISInfo(ip netip.Addr, wi *whois.Info) {
+ _, ok := s.Find(ip.String())
+ if ok {
+ log.Debug("storage: client for %s is already created, ignore whois info", ip)
+
+ return
+ }
+
+ rc := NewRuntime(ip)
+ rc.SetWHOIS(wi)
+ s.UpdateRuntime(rc)
+
+ log.Debug("storage: set whois info for runtime client with ip %s: %+v", ip, wi)
}
// Add stores persistent client information or returns an error.
@@ -103,6 +280,16 @@ func (s *Storage) Find(id string) (p *Persistent, ok bool) {
return p.ShallowClone(), ok
}
+ ip, err := netip.ParseAddr(id)
+ if err != nil {
+ return nil, false
+ }
+
+ foundMAC := s.dhcp.MACByIP(ip)
+ if foundMAC != nil {
+ return s.FindByMAC(foundMAC)
+ }
+
return nil, false
}
@@ -130,11 +317,9 @@ func (s *Storage) FindLoose(ip netip.Addr, id string) (p *Persistent, ok bool) {
return nil, false
}
-// FindByMAC finds persistent client by MAC and returns its shallow copy.
+// FindByMAC finds persistent client by MAC and returns its shallow copy. s.mu
+// is expected to be locked.
func (s *Storage) FindByMAC(mac net.HardwareAddr) (p *Persistent, ok bool) {
- s.mu.Lock()
- defer s.mu.Unlock()
-
p, ok = s.index.findByMAC(mac)
if ok {
return p.ShallowClone(), ok
@@ -226,13 +411,25 @@ func (s *Storage) CloseUpstreams() (err error) {
// ClientRuntime returns a copy of the saved runtime client by ip. If no such
// client exists, returns nil.
-//
-// TODO(s.chzhen): Use it.
func (s *Storage) ClientRuntime(ip netip.Addr) (rc *Runtime) {
s.mu.Lock()
defer s.mu.Unlock()
- return s.runtimeIndex.Client(ip)
+ rc = s.runtimeIndex.Client(ip)
+ if rc != nil {
+ return rc
+ }
+
+ host := s.dhcp.HostByIP(ip)
+ if host == "" {
+ return nil
+ }
+
+ rc = NewRuntime(ip)
+ rc.SetInfo(SourceDHCP, []string{host})
+ s.UpdateRuntime(rc)
+
+ return rc
}
// UpdateRuntime updates the stored runtime client with information from rc. If
diff --git a/internal/client/storage_test.go b/internal/client/storage_test.go
index 5ac02747..34a35636 100644
--- a/internal/client/storage_test.go
+++ b/internal/client/storage_test.go
@@ -17,9 +17,10 @@ import (
func newStorage(tb testing.TB, m []*client.Persistent) (s *client.Storage) {
tb.Helper()
- s = client.NewStorage(&client.Config{
+ s, err := client.NewStorage(&client.Config{
AllowedTags: nil,
})
+ require.NoError(tb, err)
for _, c := range m {
c.UID = client.MustNewUID()
@@ -73,10 +74,12 @@ func TestStorage_Add(t *testing.T) {
UID: existingClientUID,
}
- s := client.NewStorage(&client.Config{
+ s, err := client.NewStorage(&client.Config{
AllowedTags: []string{allowedTag},
})
- err := s.Add(existingClient)
+ require.NoError(t, err)
+
+ err = s.Add(existingClient)
require.NoError(t, err)
testCases := []struct {
@@ -164,10 +167,12 @@ func TestStorage_RemoveByName(t *testing.T) {
UID: client.MustNewUID(),
}
- s := client.NewStorage(&client.Config{
+ s, err := client.NewStorage(&client.Config{
AllowedTags: nil,
})
- err := s.Add(existingClient)
+ require.NoError(t, err)
+
+ err = s.Add(existingClient)
require.NoError(t, err)
testCases := []struct {
@@ -191,9 +196,11 @@ func TestStorage_RemoveByName(t *testing.T) {
}
t.Run("duplicate_remove", func(t *testing.T) {
- s = client.NewStorage(&client.Config{
+ s, err = client.NewStorage(&client.Config{
AllowedTags: nil,
})
+ require.NoError(t, err)
+
err = s.Add(existingClient)
require.NoError(t, err)
@@ -651,9 +658,10 @@ func TestStorage_UpdateRuntime(t *testing.T) {
}
updated.SetWHOIS(info)
- s := client.NewStorage(&client.Config{
+ s, err := client.NewStorage(&client.Config{
AllowedTags: nil,
})
+ require.NoError(t, err)
t.Run("add_arp_client", func(t *testing.T) {
added := client.NewRuntime(ip)
@@ -739,9 +747,10 @@ func TestStorage_BatchUpdateBySource(t *testing.T) {
newRuntimeClient(cliUpdatedIP5, defSrc, cliUpdatedHost5),
}
- s := client.NewStorage(&client.Config{
+ s, err := client.NewStorage(&client.Config{
AllowedTags: nil,
})
+ require.NoError(t, err)
t.Run("populate_storage_with_first_clients", func(t *testing.T) {
added, removed := s.BatchUpdateBySource(defSrc, firstClients)
diff --git a/internal/home/clients.go b/internal/home/clients.go
index 819564bc..0952991c 100644
--- a/internal/home/clients.go
+++ b/internal/home/clients.go
@@ -2,7 +2,6 @@ package home
import (
"fmt"
- "net"
"net/netip"
"slices"
"sync"
@@ -11,7 +10,6 @@ import (
"github.com/AdguardTeam/AdGuardHome/internal/aghnet"
"github.com/AdguardTeam/AdGuardHome/internal/arpdb"
"github.com/AdguardTeam/AdGuardHome/internal/client"
- "github.com/AdguardTeam/AdGuardHome/internal/dhcpsvc"
"github.com/AdguardTeam/AdGuardHome/internal/dnsforward"
"github.com/AdguardTeam/AdGuardHome/internal/filtering"
"github.com/AdguardTeam/AdGuardHome/internal/querylog"
@@ -20,47 +18,21 @@ import (
"github.com/AdguardTeam/dnsproxy/proxy"
"github.com/AdguardTeam/dnsproxy/upstream"
"github.com/AdguardTeam/golibs/errors"
- "github.com/AdguardTeam/golibs/hostsfile"
- "github.com/AdguardTeam/golibs/log"
"github.com/AdguardTeam/golibs/stringutil"
)
-// DHCP is an interface for accessing DHCP lease data the [clientsContainer]
-// needs.
-type DHCP interface {
- // Leases returns all the DHCP leases.
- Leases() (leases []*dhcpsvc.Lease)
-
- // HostByIP returns the hostname of the DHCP client with the given IP
- // address. The address will be netip.Addr{} if there is no such client,
- // due to an assumption that a DHCP client must always have a hostname.
- HostByIP(ip netip.Addr) (host string)
-
- // MACByIP returns the MAC address for the given IP address leased. It
- // returns nil if there is no such client, due to an assumption that a DHCP
- // client must always have a MAC address.
- MACByIP(ip netip.Addr) (mac net.HardwareAddr)
-}
-
// clientsContainer is the storage of all runtime and persistent clients.
type clientsContainer struct {
// storage stores information about persistent clients.
storage *client.Storage
// dhcp is the DHCP service implementation.
- dhcp DHCP
+ dhcp client.DHCP
// clientChecker checks if a client is blocked by the current access
// settings.
clientChecker BlockedClientChecker
- // etcHosts contains list of rewrite rules taken from the operating system's
- // hosts database.
- etcHosts *aghnet.HostsContainer
-
- // arpDB stores the neighbors retrieved from ARP.
- arpDB arpdb.Interface
-
// lock protects all fields.
//
// TODO(a.garipov): Use a pointer and describe which fields are protected in
@@ -92,7 +64,7 @@ type BlockedClientChecker interface {
// Note: this function must be called only once
func (clients *clientsContainer) Init(
objects []*clientObject,
- dhcpServer DHCP,
+ dhcpServer client.DHCP,
etcHosts *aghnet.HostsContainer,
arpDB arpdb.Interface,
filteringConf *filtering.Config,
@@ -102,49 +74,35 @@ func (clients *clientsContainer) Init(
return errors.Error("clients container already initialized")
}
- clients.storage = client.NewStorage(&client.Config{
- AllowedTags: clientTags,
- })
-
// TODO(e.burkov): Use [dhcpsvc] implementation when it's ready.
clients.dhcp = dhcpServer
- clients.etcHosts = etcHosts
- clients.arpDB = arpDB
- err = clients.addFromConfig(objects, filteringConf)
+ confClients := make([]*client.Persistent, 0, len(objects))
+ for i, o := range objects {
+ var p *client.Persistent
+ p, err = o.toPersistent(filteringConf)
+ if err != nil {
+ return fmt.Errorf("init persistent client at index %d: %w", i, err)
+ }
+
+ confClients = append(confClients, p)
+ }
+
+ clients.storage, err = client.NewStorage(&client.Config{
+ AllowedTags: clientTags,
+ InitialClients: confClients,
+ DHCP: dhcpServer,
+ EtcHosts: etcHosts,
+ ARPDB: arpDB,
+ ARPClientsUpdatePeriod: arpClientsUpdatePeriod,
+ })
if err != nil {
- // Don't wrap the error, because it's informative enough as is.
- return err
- }
-
- clients.safeSearchCacheSize = filteringConf.SafeSearchCacheSize
- clients.safeSearchCacheTTL = time.Minute * time.Duration(filteringConf.CacheTime)
-
- if clients.testing {
- return nil
- }
-
- // The clients.etcHosts may be nil even if config.Clients.Sources.HostsFile
- // is true, because of the deprecated option --no-etc-hosts.
- //
- // TODO(e.burkov): The option should probably be returned, since hosts file
- // currently used not only for clients' information enrichment, but also in
- // the filtering module and upstream addresses resolution.
- if config.Clients.Sources.HostsFile && clients.etcHosts != nil {
- go clients.handleHostsUpdates()
+ return fmt.Errorf("init client storage: %w", err)
}
return nil
}
-// handleHostsUpdates receives the updates from the hosts container and adds
-// them to the clients container. It is intended to be used as a goroutine.
-func (clients *clientsContainer) handleHostsUpdates() {
- for upd := range clients.etcHosts.Upd() {
- clients.addFromHostsFile(upd)
- }
-}
-
// webHandlersRegistered prevents a [clientsContainer] from registering its web
// handlers more than once.
//
@@ -162,14 +120,7 @@ func (clients *clientsContainer) Start() {
clients.registerWebHandlers()
}
- go clients.periodicUpdate()
-}
-
-// reloadARP reloads runtime clients from ARP, if configured.
-func (clients *clientsContainer) reloadARP() {
- if clients.arpDB != nil {
- clients.addFromSystemARP()
- }
+ clients.storage.Start()
}
// clientObject is the YAML representation of a persistent client.
@@ -270,28 +221,6 @@ func (o *clientObject) toPersistent(
return cli, nil
}
-// addFromConfig initializes the clients container with objects from the
-// configuration file.
-func (clients *clientsContainer) addFromConfig(
- objects []*clientObject,
- filteringConf *filtering.Config,
-) (err error) {
- for i, o := range objects {
- var cli *client.Persistent
- cli, err = o.toPersistent(filteringConf)
- if err != nil {
- return fmt.Errorf("clients: init persistent client at index %d: %w", i, err)
- }
-
- err = clients.storage.Add(cli)
- if err != nil {
- return fmt.Errorf("adding client %q at index %d: %w", cli.Name, i, err)
- }
- }
-
- return nil
-}
-
// forConfig returns all currently known persistent clients as objects for the
// configuration file.
func (clients *clientsContainer) forConfig() (objs []*clientObject) {
@@ -332,39 +261,6 @@ func (clients *clientsContainer) forConfig() (objs []*clientObject) {
// arpClientsUpdatePeriod defines how often ARP clients are updated.
const arpClientsUpdatePeriod = 10 * time.Minute
-func (clients *clientsContainer) periodicUpdate() {
- defer log.OnPanic("clients container")
-
- for {
- clients.reloadARP()
- time.Sleep(arpClientsUpdatePeriod)
- }
-}
-
-// clientSource checks if client with this IP address already exists and returns
-// the source which updated it last. It returns [client.SourceNone] if the
-// client doesn't exist. Note that it is only used in tests.
-func (clients *clientsContainer) clientSource(ip netip.Addr) (src client.Source) {
- clients.lock.Lock()
- defer clients.lock.Unlock()
-
- _, ok := clients.findLocked(ip.String())
- if ok {
- return client.SourcePersistent
- }
-
- rc := clients.storage.ClientRuntime(ip)
- if rc != nil {
- src, _ = rc.Info()
- }
-
- if src < client.SourceDHCP && clients.dhcp.HostByIP(ip) != "" {
- src = client.SourceDHCP
- }
-
- return src
-}
-
// findMultiple is a wrapper around [clientsContainer.find] to make it a valid
// client finder for the query log. c is never nil; if no information about the
// client is found, it returns an artificial client record by only setting the
@@ -410,7 +306,7 @@ func (clients *clientsContainer) clientOrArtificial(
}, false
}
- rc := clients.findRuntimeClient(ip)
+ rc := clients.storage.ClientRuntime(ip)
if rc != nil {
_, host := rc.Info()
@@ -425,19 +321,6 @@ func (clients *clientsContainer) clientOrArtificial(
}, true
}
-// find returns a shallow copy of the client if there is one found.
-func (clients *clientsContainer) find(id string) (c *client.Persistent, ok bool) {
- clients.lock.Lock()
- defer clients.lock.Unlock()
-
- c, ok = clients.findLocked(id)
- if !ok {
- return nil, false
- }
-
- return c, true
-}
-
// shouldCountClient is a wrapper around [clientsContainer.find] to make it a
// valid client information finder for the statistics. If no information about
// the client is found, it returns true.
@@ -446,7 +329,7 @@ func (clients *clientsContainer) shouldCountClient(ids []string) (y bool) {
defer clients.lock.Unlock()
for _, id := range ids {
- client, ok := clients.findLocked(id)
+ client, ok := clients.storage.Find(id)
if ok {
return !client.IgnoreStatistics
}
@@ -468,7 +351,7 @@ func (clients *clientsContainer) UpstreamConfigByID(
clients.lock.Lock()
defer clients.lock.Unlock()
- c, ok := clients.findLocked(id)
+ c, ok := clients.storage.Find(id)
if !ok {
return nil, nil
} else if c.UpstreamConfig != nil {
@@ -506,191 +389,13 @@ func (clients *clientsContainer) UpstreamConfigByID(
return conf, nil
}
-// findLocked searches for a client by its ID. clients.lock is expected to be
-// locked.
-func (clients *clientsContainer) findLocked(id string) (c *client.Persistent, ok bool) {
- c, ok = clients.storage.Find(id)
- if ok {
- return c, true
- }
-
- ip, err := netip.ParseAddr(id)
- if err != nil {
- return nil, false
- }
-
- // TODO(e.burkov): Iterate through clients.list only once.
- return clients.findDHCP(ip)
-}
-
-// findDHCP searches for a client by its MAC, if the DHCP server is active and
-// there is such client. clients.lock is expected to be locked.
-func (clients *clientsContainer) findDHCP(ip netip.Addr) (c *client.Persistent, ok bool) {
- foundMAC := clients.dhcp.MACByIP(ip)
- if foundMAC == nil {
- return nil, false
- }
-
- return clients.storage.FindByMAC(foundMAC)
-}
-
-// findRuntimeClient finds a runtime client by their IP.
-func (clients *clientsContainer) findRuntimeClient(ip netip.Addr) (rc *client.Runtime) {
- rc = clients.storage.ClientRuntime(ip)
- host := clients.dhcp.HostByIP(ip)
-
- if host != "" {
- if rc == nil {
- rc = client.NewRuntime(ip)
- }
-
- rc.SetInfo(client.SourceDHCP, []string{host})
-
- return rc
- }
-
- return rc
-}
-
-// setWHOISInfo sets the WHOIS information for a client. clients.lock is
-// expected to be locked.
-func (clients *clientsContainer) setWHOISInfo(ip netip.Addr, wi *whois.Info) {
- _, ok := clients.findLocked(ip.String())
- if ok {
- log.Debug("clients: client for %s is already created, ignore whois info", ip)
-
- return
- }
-
- rc := client.NewRuntime(ip)
- rc.SetWHOIS(wi)
- clients.storage.UpdateRuntime(rc)
-
- log.Debug("clients: set whois info for runtime client with ip %s: %+v", ip, wi)
-}
-
-// addHost adds a new IP-hostname pairing. The priorities of the sources are
-// taken into account. ok is true if the pairing was added.
-//
-// TODO(a.garipov): Only used in internal tests. Consider removing.
-func (clients *clientsContainer) addHost(
- ip netip.Addr,
- host string,
- src client.Source,
-) (ok bool) {
- clients.lock.Lock()
- defer clients.lock.Unlock()
-
- return clients.addHostLocked(ip, host, src)
-}
-
// type check
var _ client.AddressUpdater = (*clientsContainer)(nil)
// UpdateAddress implements the [client.AddressUpdater] interface for
// *clientsContainer
func (clients *clientsContainer) UpdateAddress(ip netip.Addr, host string, info *whois.Info) {
- // Common fast path optimization.
- if host == "" && info == nil {
- return
- }
-
- clients.lock.Lock()
- defer clients.lock.Unlock()
-
- if host != "" {
- ok := clients.addHostLocked(ip, host, client.SourceRDNS)
- if !ok {
- log.Debug("clients: host for client %q already set with higher priority source", ip)
- }
- }
-
- if info != nil {
- clients.setWHOISInfo(ip, info)
- }
-}
-
-// addHostLocked adds a new IP-hostname pairing. clients.lock is expected to be
-// locked.
-func (clients *clientsContainer) addHostLocked(
- ip netip.Addr,
- host string,
- src client.Source,
-) (ok bool) {
- rc := client.NewRuntime(ip)
- rc.SetInfo(src, []string{host})
- if dhcpHost := clients.dhcp.HostByIP(ip); dhcpHost != "" {
- rc.SetInfo(client.SourceDHCP, []string{dhcpHost})
- }
-
- clients.storage.UpdateRuntime(rc)
-
- log.Debug(
- "clients: adding client info %s -> %q %q [%d]",
- ip,
- src,
- host,
- clients.storage.SizeRuntime(),
- )
-
- return true
-}
-
-// addFromHostsFile fills the client-hostname pairing index from the system's
-// hosts files.
-func (clients *clientsContainer) addFromHostsFile(hosts *hostsfile.DefaultStorage) {
- clients.lock.Lock()
- defer clients.lock.Unlock()
-
- var rcs []*client.Runtime
- hosts.RangeNames(func(addr netip.Addr, names []string) (cont bool) {
- // Only the first name of the first record is considered a canonical
- // hostname for the IP address.
- //
- // TODO(e.burkov): Consider using all the names from all the records.
- rc := client.NewRuntime(addr)
- rc.SetInfo(client.SourceHostsFile, []string{names[0]})
-
- rcs = append(rcs, rc)
-
- return true
- })
-
- added, removed := clients.storage.BatchUpdateBySource(client.SourceHostsFile, rcs)
- log.Debug("clients: added %d, removed %d client aliases from system hosts file", added, removed)
-}
-
-// addFromSystemARP adds the IP-hostname pairings from the output of the arp -a
-// command.
-func (clients *clientsContainer) addFromSystemARP() {
- if err := clients.arpDB.Refresh(); err != nil {
- log.Error("refreshing arp container: %s", err)
-
- clients.arpDB = arpdb.Empty{}
-
- return
- }
-
- ns := clients.arpDB.Neighbors()
- if len(ns) == 0 {
- log.Debug("refreshing arp container: the update is empty")
-
- return
- }
-
- clients.lock.Lock()
- defer clients.lock.Unlock()
-
- var rcs []*client.Runtime
- for _, n := range ns {
- rc := client.NewRuntime(n.IP)
- rc.SetInfo(client.SourceARP, []string{n.Name})
-
- rcs = append(rcs, rc)
- }
-
- added, removed := clients.storage.BatchUpdateBySource(client.SourceARP, rcs)
- log.Debug("clients: added %d, removed %d client aliases from arp neighborhood", added, removed)
+ clients.storage.UpdateAddress(ip, host, info)
}
// close gracefully closes all the client-specific upstream configurations of
diff --git a/internal/home/clients_internal_test.go b/internal/home/clients_internal_test.go
index f47676f0..1fd004c8 100644
--- a/internal/home/clients_internal_test.go
+++ b/internal/home/clients_internal_test.go
@@ -51,6 +51,47 @@ func newClientsContainer(t *testing.T) (c *clientsContainer) {
return c
}
+// addHost adds a new IP-hostname pairing.
+func (clients *clientsContainer) addHost(
+ ip netip.Addr,
+ host string,
+ src client.Source,
+) (ok bool) {
+ rc := client.NewRuntime(ip)
+ rc.SetInfo(src, []string{host})
+ clients.storage.UpdateRuntime(rc)
+
+ return true
+}
+
+// setWHOISInfo sets the WHOIS information for a client.
+func (clients *clientsContainer) setWHOISInfo(ip netip.Addr, wi *whois.Info) {
+ _, ok := clients.storage.Find(ip.String())
+ if ok {
+ return
+ }
+
+ rc := client.NewRuntime(ip)
+ rc.SetWHOIS(wi)
+ clients.storage.UpdateRuntime(rc)
+}
+
+// clientSource checks if client with this IP address already exists and returns
+// the highest priority client source.
+func (clients *clientsContainer) clientSource(ip netip.Addr) (src client.Source) {
+ _, ok := clients.storage.Find(ip.String())
+ if ok {
+ return client.SourcePersistent
+ }
+
+ rc := clients.storage.ClientRuntime(ip)
+ if rc != nil {
+ src, _ = rc.Info()
+ }
+
+ return src
+}
+
func TestClients(t *testing.T) {
clients := newClientsContainer(t)
@@ -84,22 +125,22 @@ func TestClients(t *testing.T) {
err = clients.storage.Add(c)
require.NoError(t, err)
- c, ok := clients.find(cli1)
+ c, ok := clients.storage.Find(cli1)
require.True(t, ok)
assert.Equal(t, "client1", c.Name)
- c, ok = clients.find("1:2:3::4")
+ c, ok = clients.storage.Find("1:2:3::4")
require.True(t, ok)
assert.Equal(t, "client1", c.Name)
- c, ok = clients.find(cli2)
+ c, ok = clients.storage.Find(cli2)
require.True(t, ok)
assert.Equal(t, "client2", c.Name)
- _, ok = clients.find(cliNone)
+ _, ok = clients.storage.Find(cliNone)
assert.False(t, ok)
assert.Equal(t, clients.clientSource(cli1IP), client.SourcePersistent)
@@ -150,7 +191,7 @@ func TestClients(t *testing.T) {
})
require.NoError(t, err)
- _, ok = clients.find(cliOld)
+ _, ok = clients.storage.Find(cliOld)
assert.False(t, ok)
assert.Equal(t, clients.clientSource(cliNewIP), client.SourcePersistent)
@@ -167,7 +208,7 @@ func TestClients(t *testing.T) {
})
require.NoError(t, err)
- c, ok := clients.find(cliNew)
+ c, ok := clients.storage.Find(cliNew)
require.True(t, ok)
assert.Equal(t, "client1-renamed", c.Name)
@@ -187,7 +228,7 @@ func TestClients(t *testing.T) {
ok := clients.storage.RemoveByName("client1-renamed")
require.True(t, ok)
- _, ok = clients.find("1.1.1.2")
+ _, ok = clients.storage.Find("1.1.1.2")
assert.False(t, ok)
})
@@ -277,13 +318,33 @@ func TestClientsWHOIS(t *testing.T) {
}
func TestClientsAddExisting(t *testing.T) {
- clients := newClientsContainer(t)
+ clients := &clientsContainer{
+ testing: true,
+ }
+
+ // First, init a DHCP server with a single static lease.
+ config := &dhcpd.ServerConfig{
+ Enabled: true,
+ DataDir: t.TempDir(),
+ Conf4: dhcpd.V4ServerConf{
+ Enabled: true,
+ GatewayIP: netip.MustParseAddr("1.2.3.1"),
+ SubnetMask: netip.MustParseAddr("255.255.255.0"),
+ RangeStart: netip.MustParseAddr("1.2.3.2"),
+ RangeEnd: netip.MustParseAddr("1.2.3.10"),
+ },
+ }
+
+ dhcpServer, err := dhcpd.Create(config)
+ require.NoError(t, err)
+
+ require.NoError(t, clients.Init(nil, dhcpServer, nil, nil, &filtering.Config{}))
t.Run("simple", func(t *testing.T) {
ip := netip.MustParseAddr("1.1.1.1")
// Add a client.
- err := clients.storage.Add(&client.Persistent{
+ err = clients.storage.Add(&client.Persistent{
Name: "client1",
UID: client.MustNewUID(),
IPs: []netip.Addr{ip, netip.MustParseAddr("1:2:3::4")},
@@ -306,24 +367,6 @@ func TestClientsAddExisting(t *testing.T) {
ip := netip.MustParseAddr("1.2.3.4")
- // First, init a DHCP server with a single static lease.
- config := &dhcpd.ServerConfig{
- Enabled: true,
- DataDir: t.TempDir(),
- Conf4: dhcpd.V4ServerConf{
- Enabled: true,
- GatewayIP: netip.MustParseAddr("1.2.3.1"),
- SubnetMask: netip.MustParseAddr("255.255.255.0"),
- RangeStart: netip.MustParseAddr("1.2.3.2"),
- RangeEnd: netip.MustParseAddr("1.2.3.10"),
- },
- }
-
- dhcpServer, err := dhcpd.Create(config)
- require.NoError(t, err)
-
- clients.dhcp = dhcpServer
-
err = dhcpServer.AddStaticLease(&dhcpsvc.Lease{
HWAddr: net.HardwareAddr{0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA},
IP: ip,
diff --git a/internal/home/clientshttp.go b/internal/home/clientshttp.go
index eba22ddb..7766ba57 100644
--- a/internal/home/clientshttp.go
+++ b/internal/home/clientshttp.go
@@ -117,6 +117,7 @@ func (clients *clientsContainer) handleGetClients(w http.ResponseWriter, r *http
return true
})
+ // TODO(s.chzhen): Remove.
for _, l := range clients.dhcp.Leases() {
cj := runtimeClientJSON{
Name: l.Hostname,
@@ -430,7 +431,7 @@ func (clients *clientsContainer) handleFindClient(w http.ResponseWriter, r *http
}
ip, _ := netip.ParseAddr(idStr)
- c, ok := clients.find(idStr)
+ c, ok := clients.storage.Find(idStr)
var cj *clientJSON
if !ok {
cj = clients.findRuntime(ip, idStr)
@@ -452,7 +453,7 @@ func (clients *clientsContainer) handleFindClient(w http.ResponseWriter, r *http
// /etc/hosts tables, DHCP leases, or blocklists. cj is guaranteed to be
// non-nil.
func (clients *clientsContainer) findRuntime(ip netip.Addr, idStr string) (cj *clientJSON) {
- rc := clients.findRuntimeClient(ip)
+ rc := clients.storage.ClientRuntime(ip)
if rc == nil {
// It is still possible that the IP used to be in the runtime clients
// list, but then the server was reloaded. So, check the DNS server's
diff --git a/internal/home/dns.go b/internal/home/dns.go
index ed1f1675..44c8f93f 100644
--- a/internal/home/dns.go
+++ b/internal/home/dns.go
@@ -412,9 +412,9 @@ func applyAdditionalFiltering(clientIP netip.Addr, clientID string, setts *filte
setts.ClientIP = clientIP
- c, ok := Context.clients.find(clientID)
+ c, ok := Context.clients.storage.Find(clientID)
if !ok {
- c, ok = Context.clients.find(clientIP.String())
+ c, ok = Context.clients.storage.Find(clientIP.String())
if !ok {
log.Debug("%s: no clients with ip %s and clientid %q", pref, clientIP, clientID)
diff --git a/internal/home/dns_internal_test.go b/internal/home/dns_internal_test.go
index 4adaec81..ca112e59 100644
--- a/internal/home/dns_internal_test.go
+++ b/internal/home/dns_internal_test.go
@@ -18,9 +18,10 @@ var testIPv4 = netip.AddrFrom4([4]byte{1, 2, 3, 4})
func newStorage(tb testing.TB, clients []*client.Persistent) (s *client.Storage) {
tb.Helper()
- s = client.NewStorage(&client.Config{
+ s, err := client.NewStorage(&client.Config{
AllowedTags: nil,
})
+ require.NoError(tb, err)
for _, p := range clients {
p.UID = client.MustNewUID()
diff --git a/internal/home/home.go b/internal/home/home.go
index 8c343dbc..69a67223 100644
--- a/internal/home/home.go
+++ b/internal/home/home.go
@@ -119,7 +119,7 @@ func Main(clientBuildFS fs.FS) {
log.Info("Received signal %q", sig)
switch sig {
case syscall.SIGHUP:
- Context.clients.reloadARP()
+ Context.clients.storage.ReloadARP()
Context.tls.reload()
default:
cleanup(context.Background())