all: sync with master

internal/client/persistent.go

@@ -12,6 +12,7 @@ import (
 	"github.com/AdguardTeam/AdGuardHome/internal/filtering"
 	"github.com/AdguardTeam/AdGuardHome/internal/filtering/safesearch"
 	"github.com/AdguardTeam/dnsproxy/proxy"
+	"github.com/AdguardTeam/dnsproxy/upstream"
 	"github.com/AdguardTeam/golibs/container"
 	"github.com/AdguardTeam/golibs/errors"
 	"github.com/AdguardTeam/golibs/log"
@@ -64,53 +65,107 @@ type Persistent struct {
 	// upstream must be used.
 	UpstreamConfig *proxy.CustomUpstreamConfig
 
+	// SafeSearch handles search engine hosts rewrites.
 	SafeSearch filtering.SafeSearch
 
-	// BlockedServices is the configuration of blocked services of a client.
+	// BlockedServices is the configuration of blocked services of a client.  It
+	// must not be nil after initialization.
 	BlockedServices *filtering.BlockedServices
 
+	// Name of the persistent client.  Must not be empty.
 	Name string
 
-	Tags      []string
+	// Tags is a list of client tags that categorize the client.
+	Tags []string
+
+	// Upstreams is a list of custom upstream DNS servers for the client.
 	Upstreams []string
 
+	// IPs is a list of IP addresses that identify the client.  The client must
+	// have at least one ID (IP, subnet, MAC, or ClientID).
 	IPs []netip.Addr
+
+	// Subnets identifying the client.  The client must have at least one ID
+	// (IP, subnet, MAC, or ClientID).
+	//
 	// TODO(s.chzhen):  Use netutil.Prefix.
-	Subnets   []netip.Prefix
-	MACs      []net.HardwareAddr
+	Subnets []netip.Prefix
+
+	// MACs identifying the client.  The client must have at least one ID (IP,
+	// subnet, MAC, or ClientID).
+	MACs []net.HardwareAddr
+
+	// ClientIDs identifying the client.  The client must have at least one ID
+	// (IP, subnet, MAC, or ClientID).
 	ClientIDs []string
 
 	// UID is the unique identifier of the persistent client.
 	UID UID
 
-	UpstreamsCacheSize    uint32
+	// UpstreamsCacheSize is the cache size for custom upstreams.
+	UpstreamsCacheSize uint32
+
+	// UpstreamsCacheEnabled specifies whether custom upstreams are used.
 	UpstreamsCacheEnabled bool
 
-	UseOwnSettings        bool
-	FilteringEnabled      bool
-	SafeBrowsingEnabled   bool
-	ParentalEnabled       bool
-	UseOwnBlockedServices bool
-	IgnoreQueryLog        bool
-	IgnoreStatistics      bool
+	// UseOwnSettings specifies whether custom filtering settings are used.
+	UseOwnSettings bool
 
+	// FilteringEnabled specifies whether filtering is enabled.
+	FilteringEnabled bool
+
+	// SafeBrowsingEnabled specifies whether safe browsing is enabled.
+	SafeBrowsingEnabled bool
+
+	// ParentalEnabled specifies whether parental control is enabled.
+	ParentalEnabled bool
+
+	// UseOwnBlockedServices specifies whether custom services are blocked.
+	UseOwnBlockedServices bool
+
+	// IgnoreQueryLog specifies whether the client requests are logged.
+	IgnoreQueryLog bool
+
+	// IgnoreStatistics  specifies whether the client requests are counted.
+	IgnoreStatistics bool
+
+	// SafeSearchConf is the safe search filtering configuration.
+	//
 	// TODO(d.kolyshev): Make SafeSearchConf a pointer.
 	SafeSearchConf filtering.SafeSearchConfig
 }
 
-// SetTags sets the tags if they are known, otherwise logs an unknown tag.
-func (c *Persistent) SetTags(tags []string, known *container.MapSet[string]) {
-	for _, t := range tags {
-		if !known.Has(t) {
-			log.Info("skipping unknown tag %q", t)
-
-			continue
-		}
-
-		c.Tags = append(c.Tags, t)
+// validate returns an error if persistent client information contains errors.
+func (c *Persistent) validate(allTags *container.MapSet[string]) (err error) {
+	switch {
+	case c.Name == "":
+		return errors.Error("empty name")
+	case c.IDsLen() == 0:
+		return errors.Error("id required")
+	case c.UID == UID{}:
+		return errors.Error("uid required")
 	}
 
+	conf, err := proxy.ParseUpstreamsConfig(c.Upstreams, &upstream.Options{})
+	if err != nil {
+		return fmt.Errorf("invalid upstream servers: %w", err)
+	}
+
+	err = conf.Close()
+	if err != nil {
+		log.Error("client: closing upstream config: %s", err)
+	}
+
+	for _, t := range c.Tags {
+		if !allTags.Has(t) {
+			return fmt.Errorf("invalid tag: %q", t)
+		}
+	}
+
+	// TODO(s.chzhen):  Move to the constructor.
 	slices.Sort(c.Tags)
+
+	return nil
 }
 
 // SetIDs parses a list of strings into typed fields and returns an error if