2023-03-01 10:27:24 +00:00
|
|
|
package home
|
|
|
|
|
|
|
|
import (
|
2023-12-28 14:26:17 +00:00
|
|
|
"encoding"
|
2023-03-01 10:27:24 +00:00
|
|
|
"fmt"
|
2024-01-17 10:24:21 +00:00
|
|
|
"net"
|
|
|
|
"net/netip"
|
2024-02-08 17:39:18 +00:00
|
|
|
"slices"
|
2024-01-17 10:24:21 +00:00
|
|
|
"strings"
|
2023-04-06 12:12:50 +01:00
|
|
|
"time"
|
2023-03-01 10:27:24 +00:00
|
|
|
|
2024-01-17 10:24:21 +00:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/dnsforward"
|
2023-03-15 11:31:07 +00:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/filtering"
|
2023-04-06 12:12:50 +01:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/filtering/safesearch"
|
2023-03-01 10:27:24 +00:00
|
|
|
"github.com/AdguardTeam/dnsproxy/proxy"
|
2024-01-17 10:24:21 +00:00
|
|
|
"github.com/AdguardTeam/golibs/errors"
|
|
|
|
"github.com/AdguardTeam/golibs/log"
|
2023-05-25 15:45:55 +01:00
|
|
|
"github.com/AdguardTeam/golibs/stringutil"
|
2023-12-28 14:26:17 +00:00
|
|
|
"github.com/google/uuid"
|
2023-03-01 10:27:24 +00:00
|
|
|
)
|
|
|
|
|
2023-12-28 14:26:17 +00:00
|
|
|
// UID is the type for the unique IDs of persistent clients.
|
|
|
|
type UID uuid.UUID
|
|
|
|
|
|
|
|
// NewUID returns a new persistent client UID. Any error returned is an error
|
|
|
|
// from the cryptographic randomness reader.
|
|
|
|
func NewUID() (uid UID, err error) {
|
|
|
|
uuidv7, err := uuid.NewV7()
|
|
|
|
|
|
|
|
return UID(uuidv7), err
|
|
|
|
}
|
|
|
|
|
|
|
|
// type check
|
|
|
|
var _ encoding.TextMarshaler = UID{}
|
|
|
|
|
|
|
|
// MarshalText implements the [encoding.TextMarshaler] for UID.
|
|
|
|
func (uid UID) MarshalText() ([]byte, error) {
|
|
|
|
return uuid.UUID(uid).MarshalText()
|
|
|
|
}
|
|
|
|
|
|
|
|
// type check
|
|
|
|
var _ encoding.TextUnmarshaler = (*UID)(nil)
|
|
|
|
|
|
|
|
// UnmarshalText implements the [encoding.TextUnmarshaler] interface for UID.
|
|
|
|
func (uid *UID) UnmarshalText(data []byte) error {
|
|
|
|
return (*uuid.UUID)(uid).UnmarshalText(data)
|
|
|
|
}
|
|
|
|
|
|
|
|
// persistentClient contains information about persistent clients.
|
|
|
|
type persistentClient struct {
|
2023-11-17 12:51:51 +00:00
|
|
|
// upstreamConfig is the custom upstream configuration for this client. If
|
|
|
|
// it's nil, it has not been initialized yet. If it's non-nil and empty,
|
|
|
|
// there are no valid upstreams. If it's non-nil and non-empty, these
|
|
|
|
// upstream must be used.
|
|
|
|
upstreamConfig *proxy.CustomUpstreamConfig
|
2023-03-01 10:27:24 +00:00
|
|
|
|
2023-11-24 12:20:32 +00:00
|
|
|
// TODO(d.kolyshev): Make safeSearchConf a pointer.
|
2023-03-15 11:31:07 +00:00
|
|
|
safeSearchConf filtering.SafeSearchConfig
|
|
|
|
SafeSearch filtering.SafeSearch
|
|
|
|
|
2023-06-27 16:03:07 +01:00
|
|
|
// BlockedServices is the configuration of blocked services of a client.
|
|
|
|
BlockedServices *filtering.BlockedServices
|
|
|
|
|
2023-03-01 10:27:24 +00:00
|
|
|
Name string
|
|
|
|
|
2023-06-27 16:03:07 +01:00
|
|
|
Tags []string
|
|
|
|
Upstreams []string
|
2023-03-01 10:27:24 +00:00
|
|
|
|
2024-01-17 10:24:21 +00:00
|
|
|
IPs []netip.Addr
|
|
|
|
// TODO(s.chzhen): Use netutil.Prefix.
|
|
|
|
Subnets []netip.Prefix
|
|
|
|
MACs []net.HardwareAddr
|
|
|
|
ClientIDs []string
|
|
|
|
|
2023-12-28 14:26:17 +00:00
|
|
|
// UID is the unique identifier of the persistent client.
|
|
|
|
UID UID
|
|
|
|
|
2023-11-17 12:51:51 +00:00
|
|
|
UpstreamsCacheSize uint32
|
|
|
|
UpstreamsCacheEnabled bool
|
|
|
|
|
2023-03-01 10:27:24 +00:00
|
|
|
UseOwnSettings bool
|
|
|
|
FilteringEnabled bool
|
|
|
|
SafeBrowsingEnabled bool
|
|
|
|
ParentalEnabled bool
|
|
|
|
UseOwnBlockedServices bool
|
2023-04-07 11:17:40 +01:00
|
|
|
IgnoreQueryLog bool
|
|
|
|
IgnoreStatistics bool
|
2023-03-01 10:27:24 +00:00
|
|
|
}
|
|
|
|
|
2024-01-17 10:24:21 +00:00
|
|
|
// setTags sets the tags if they are known, otherwise logs an unknown tag.
|
|
|
|
func (c *persistentClient) setTags(tags []string, known *stringutil.Set) {
|
|
|
|
for _, t := range tags {
|
|
|
|
if !known.Has(t) {
|
|
|
|
log.Info("skipping unknown tag %q", t)
|
|
|
|
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
c.Tags = append(c.Tags, t)
|
|
|
|
}
|
|
|
|
|
|
|
|
slices.Sort(c.Tags)
|
|
|
|
}
|
|
|
|
|
|
|
|
// setIDs parses a list of strings into typed fields and returns an error if
|
|
|
|
// there is one.
|
|
|
|
func (c *persistentClient) setIDs(ids []string) (err error) {
|
|
|
|
for _, id := range ids {
|
|
|
|
err = c.setID(id)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
slices.SortFunc(c.IPs, netip.Addr.Compare)
|
|
|
|
|
|
|
|
// TODO(s.chzhen): Use netip.PrefixCompare in Go 1.23.
|
|
|
|
slices.SortFunc(c.Subnets, subnetCompare)
|
|
|
|
slices.SortFunc(c.MACs, slices.Compare[net.HardwareAddr])
|
|
|
|
slices.Sort(c.ClientIDs)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// subnetCompare is a comparison function for the two subnets. It returns -1 if
|
|
|
|
// x sorts before y, 1 if x sorts after y, and 0 if their relative sorting
|
|
|
|
// position is the same.
|
|
|
|
func subnetCompare(x, y netip.Prefix) (cmp int) {
|
|
|
|
if x == y {
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
xAddr, xBits := x.Addr(), x.Bits()
|
|
|
|
yAddr, yBits := y.Addr(), y.Bits()
|
|
|
|
if xBits == yBits {
|
|
|
|
return xAddr.Compare(yAddr)
|
|
|
|
}
|
|
|
|
|
|
|
|
if xBits > yBits {
|
|
|
|
return -1
|
|
|
|
} else {
|
|
|
|
return 1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// setID parses id into typed field if there is no error.
|
|
|
|
func (c *persistentClient) setID(id string) (err error) {
|
|
|
|
if id == "" {
|
|
|
|
return errors.Error("clientid is empty")
|
|
|
|
}
|
|
|
|
|
|
|
|
var ip netip.Addr
|
|
|
|
if ip, err = netip.ParseAddr(id); err == nil {
|
|
|
|
c.IPs = append(c.IPs, ip)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var subnet netip.Prefix
|
|
|
|
if subnet, err = netip.ParsePrefix(id); err == nil {
|
|
|
|
c.Subnets = append(c.Subnets, subnet)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var mac net.HardwareAddr
|
|
|
|
if mac, err = net.ParseMAC(id); err == nil {
|
|
|
|
c.MACs = append(c.MACs, mac)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
err = dnsforward.ValidateClientID(id)
|
|
|
|
if err != nil {
|
|
|
|
// Don't wrap the error, because it's informative enough as is.
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
c.ClientIDs = append(c.ClientIDs, strings.ToLower(id))
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// ids returns a list of client ids containing at least one element.
|
|
|
|
func (c *persistentClient) ids() (ids []string) {
|
|
|
|
ids = make([]string, 0, c.idsLen())
|
|
|
|
|
|
|
|
for _, ip := range c.IPs {
|
|
|
|
ids = append(ids, ip.String())
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, subnet := range c.Subnets {
|
|
|
|
ids = append(ids, subnet.String())
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, mac := range c.MACs {
|
|
|
|
ids = append(ids, mac.String())
|
|
|
|
}
|
|
|
|
|
|
|
|
return append(ids, c.ClientIDs...)
|
|
|
|
}
|
|
|
|
|
|
|
|
// idsLen returns a length of client ids.
|
|
|
|
func (c *persistentClient) idsLen() (n int) {
|
|
|
|
return len(c.IPs) + len(c.Subnets) + len(c.MACs) + len(c.ClientIDs)
|
|
|
|
}
|
|
|
|
|
|
|
|
// equalIDs returns true if the ids of the current and previous clients are the
|
|
|
|
// same.
|
|
|
|
func (c *persistentClient) equalIDs(prev *persistentClient) (equal bool) {
|
|
|
|
return slices.Equal(c.IPs, prev.IPs) &&
|
|
|
|
slices.Equal(c.Subnets, prev.Subnets) &&
|
|
|
|
slices.EqualFunc(c.MACs, prev.MACs, slices.Equal[net.HardwareAddr]) &&
|
|
|
|
slices.Equal(c.ClientIDs, prev.ClientIDs)
|
|
|
|
}
|
|
|
|
|
|
|
|
// shallowClone returns a deep copy of the client, except upstreamConfig,
|
2023-05-25 15:45:55 +01:00
|
|
|
// safeSearchConf, SafeSearch fields, because it's difficult to copy them.
|
2024-01-17 10:24:21 +00:00
|
|
|
func (c *persistentClient) shallowClone() (clone *persistentClient) {
|
|
|
|
clone = &persistentClient{}
|
|
|
|
*clone = *c
|
2023-05-25 15:45:55 +01:00
|
|
|
|
2023-06-27 16:03:07 +01:00
|
|
|
clone.BlockedServices = c.BlockedServices.Clone()
|
2024-01-17 10:24:21 +00:00
|
|
|
clone.Tags = slices.Clone(c.Tags)
|
|
|
|
clone.Upstreams = slices.Clone(c.Upstreams)
|
|
|
|
|
|
|
|
clone.IPs = slices.Clone(c.IPs)
|
|
|
|
clone.Subnets = slices.Clone(c.Subnets)
|
|
|
|
clone.MACs = slices.Clone(c.MACs)
|
|
|
|
clone.ClientIDs = slices.Clone(c.ClientIDs)
|
2023-05-25 15:45:55 +01:00
|
|
|
|
2024-01-17 10:24:21 +00:00
|
|
|
return clone
|
2023-05-25 15:45:55 +01:00
|
|
|
}
|
|
|
|
|
2023-03-01 10:27:24 +00:00
|
|
|
// closeUpstreams closes the client-specific upstream config of c if any.
|
2023-12-28 14:26:17 +00:00
|
|
|
func (c *persistentClient) closeUpstreams() (err error) {
|
2023-03-01 10:27:24 +00:00
|
|
|
if c.upstreamConfig != nil {
|
2023-11-17 12:51:51 +00:00
|
|
|
if err = c.upstreamConfig.Close(); err != nil {
|
2023-03-01 10:27:24 +00:00
|
|
|
return fmt.Errorf("closing upstreams of client %q: %w", c.Name, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2023-04-06 12:12:50 +01:00
|
|
|
// setSafeSearch initializes and sets the safe search filter for this client.
|
2023-12-28 14:26:17 +00:00
|
|
|
func (c *persistentClient) setSafeSearch(
|
2023-04-06 12:12:50 +01:00
|
|
|
conf filtering.SafeSearchConfig,
|
|
|
|
cacheSize uint,
|
|
|
|
cacheTTL time.Duration,
|
|
|
|
) (err error) {
|
|
|
|
ss, err := safesearch.NewDefault(conf, fmt.Sprintf("client %q", c.Name), cacheSize, cacheTTL)
|
|
|
|
if err != nil {
|
|
|
|
// Don't wrap the error, because it's informative enough as is.
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
c.SafeSearch = ss
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|