all: sync with master; upd chlog

Updates #4557.

* commit 'e3624ec5880361b8afccd0ddac9dc31fd7ce4a07':
  all: fix abbreviation
  Update README.md

CHANGELOG.md

@@ -23,20 +23,6 @@ See also the [v0.107.30 GitHub milestone][ms-v0.107.30].
 NOTE: Add new changes BELOW THIS COMMENT.
 -->
 
-### Fixed
-
-- Unquoted IPv6 bind hosts with trailing colons erroneously considered
-  unspecified addresses are now properly validated ([#5752]).
-
-  **NOTE:** the Docker healthcheck script now also doesn't interpret the `""`
-  value as unspecified address.
-- Incorrect `Content-Type` header value in `POST /control/version.json` and `GET
-  /control/dhcp/interfaces` HTTP APIs ([#5716]).
-- Provided bootstrap servers are now used to resolve the hostnames of plain
-  UDP/TCP upstream servers.
-
-[#5716]: https://github.com/AdguardTeam/AdGuardHome/issues/5716
-
 <!--
 NOTE: Add new changes ABOVE THIS COMMENT.
 -->
@@ -50,7 +36,8 @@ See also the [v0.107.29 GitHub milestone][ms-v0.107.29].
 ### Added
 
 - The ability to exclude client activity from the query log or statistics by
-  editing client's settings on the respective page in the UI ([#1717], [#4299]).
+  editing client's settings on the Clients settings page in the UI  ([#1717],
+  [#4299]).
 
 ### Changed
 
@@ -69,7 +56,6 @@ See also the [v0.107.29 GitHub milestone][ms-v0.107.29].
 [#5712]: https://github.com/AdguardTeam/AdGuardHome/issues/5712
 [#5721]: https://github.com/AdguardTeam/AdGuardHome/issues/5721
 [#5725]: https://github.com/AdguardTeam/AdGuardHome/issues/5725
-[#5752]: https://github.com/AdguardTeam/AdGuardHome/issues/5752
 
 [ms-v0.107.29]: https://github.com/AdguardTeam/AdGuardHome/milestone/65?closed=1
 

Makefile

@@ -37,8 +37,6 @@ SIGN = 1
 VERSION = v0.0.0
 YARN = yarn
 
-NEXTAPI = 0
-
 # Macros for the build-release target.  If FRONTEND_PREBUILT is 0, the
 # default, the macro $(BUILD_RELEASE_DEPS_$(FRONTEND_PREBUILT)) expands
 # into BUILD_RELEASE_DEPS_0, and so both frontend and backend
@@ -66,7 +64,6 @@ ENV = env\
 	PATH="$${PWD}/bin:$$( "$(GO.MACRO)" env GOPATH )/bin:$${PATH}"\
 	RACE='$(RACE)'\
 	SIGN='$(SIGN)'\
-	NEXTAPI='$(NEXTAPI)'\
 	VERBOSE="$(VERBOSE.MACRO)"\
 	VERSION='$(VERSION)'\
 

docker/dns-bind.awk

@@ -7,10 +7,11 @@
         addrs[$2] = true
         prev_line = FNR
 
-        if ($2 == "0.0.0.0" || $2 == "'::'") {
-            # Drop all the other addresses.
+        if ($2 == "0.0.0.0" || $2 == "::") {
             delete addrs
-            addrs[""] = true
+            addrs["localhost"] = true
+
+            # Drop all the other addresses.
             prev_line = -1
         }
     }

docker/healthcheck.sh

@@ -61,11 +61,8 @@ then
     error_exit "no DNS bindings could be retrieved from $filename"
 fi
 
-first_dns="$( echo "$dns_hosts" | head -n 1 )"
-readonly first_dns
-
 # TODO(e.burkov):  Deal with 0 port.
-case "$first_dns"
+case "$( echo "$dns_hosts" | head -n 1 )"
 in
 (*':0')
     error_exit '0 in DNS port is not supported by healthcheck'
@@ -85,23 +82,8 @@ esac
 # See https://github.com/AdguardTeam/AdGuardHome/issues/5642.
 wget --no-check-certificate "$web_url" -O /dev/null -q || exit 1
 
-test_fqdn="healthcheck.adguardhome.test."
-readonly test_fqdn
-
-# The awk script currently returns only port prefixed with colon in case of
-# unspecified address.
-case "$first_dns"
-in
-(':'*)
-    nslookup -type=a "$test_fqdn" "127.0.0.1${first_dns}" > /dev/null ||\
-    nslookup -type=a "$test_fqdn" "[::1]${first_dns}" > /dev/null ||\
+echo "$dns_hosts" | while read -r host
+do
+    nslookup -type=a healthcheck.adguardhome.test. "$host" > /dev/null ||\
         error_exit "nslookup failed for $host"
-    ;;
-(*)
-    echo "$dns_hosts" | while read -r host
-    do
-        nslookup -type=a "$test_fqdn" "$host" > /dev/null ||\
-            error_exit "nslookup failed for $host"
-    done
-    ;;
-esac
+done

go.mod

@@ -3,7 +3,7 @@ module github.com/AdguardTeam/AdGuardHome
 go 1.19
 
 require (
-	github.com/AdguardTeam/dnsproxy v0.49.1
+	github.com/AdguardTeam/dnsproxy v0.48.3
 	github.com/AdguardTeam/golibs v0.13.2
 	github.com/AdguardTeam/urlfilter v0.16.1
 	github.com/NYTimes/gziphandler v1.1.1

go.sum

@@ -1,5 +1,5 @@
-github.com/AdguardTeam/dnsproxy v0.49.1 h1:JpStBK05uCgA3ldleaNLRmIwE9V7vRg7/kVJQSdnQYg=
-github.com/AdguardTeam/dnsproxy v0.49.1/go.mod h1:Y7g7jRTd/u7+KJ/QvnGI2PCE8vnisp6EsW47/Sz0DZw=
+github.com/AdguardTeam/dnsproxy v0.48.3 h1:h9xgDSmd1MqsPFNApyaPVXolmSTtzOWOcfWvPeDEP6s=
+github.com/AdguardTeam/dnsproxy v0.48.3/go.mod h1:Y7g7jRTd/u7+KJ/QvnGI2PCE8vnisp6EsW47/Sz0DZw=
 github.com/AdguardTeam/golibs v0.4.0/go.mod h1:skKsDKIBB7kkFflLJBpfGX+G8QFTx0WKUzB6TIgtUj4=
 github.com/AdguardTeam/golibs v0.10.4/go.mod h1:rSfQRGHIdgfxriDDNgNJ7HmE5zRoURq8R+VdR81Zuzw=
 github.com/AdguardTeam/golibs v0.13.2 h1:BPASsyQKmb+b8VnvsNOHp7bKfcZl9Z+Z2UhPjOiupSc=

internal/aghhttp/aghhttp.go

@@ -72,8 +72,8 @@ func WriteJSONResponse(w http.ResponseWriter, r *http.Request, resp any) (err er
 // WriteJSONResponseCode is like [WriteJSONResponse] but adds the ability to
 // redefine the status code.
 func WriteJSONResponseCode(w http.ResponseWriter, r *http.Request, code int, resp any) (err error) {
-	w.Header().Set(httphdr.ContentType, HdrValApplicationJSON)
 	w.WriteHeader(code)
+	w.Header().Set(httphdr.ContentType, HdrValApplicationJSON)
 	err = json.NewEncoder(w).Encode(resp)
 	if err != nil {
 		Error(r, w, http.StatusInternalServerError, "encoding resp: %s", err)

internal/aghos/service.go

@@ -1,6 +0,0 @@
-package aghos
-
-// PreCheckActionStart performs the service start action pre-check.
-func PreCheckActionStart() (err error) {
-	return preCheckActionStart()
-}

internal/aghos/service_darwin.go

@@ -1,32 +0,0 @@
-//go:build darwin
-
-package aghos
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/AdguardTeam/golibs/log"
-)
-
-// preCheckActionStart performs the service start action pre-check.  It warns
-// user that the service should be installed into Applications directory.
-func preCheckActionStart() (err error) {
-	exe, err := os.Executable()
-	if err != nil {
-		return fmt.Errorf("getting executable path: %v", err)
-	}
-
-	exe, err = filepath.EvalSymlinks(exe)
-	if err != nil {
-		return fmt.Errorf("evaluating executable symlinks: %v", err)
-	}
-
-	if !strings.HasPrefix(exe, "/Applications/") {
-		log.Info("warning: service must be started from within the /Applications directory")
-	}
-
-	return err
-}

internal/aghos/service_others.go

@@ -1,8 +0,0 @@
-//go:build !darwin
-
-package aghos
-
-// preCheckActionStart performs the service start action pre-check.
-func preCheckActionStart() (err error) {
-	return nil
-}

internal/aghtest/interface.go

@@ -1,12 +1,10 @@
 package aghtest
 
 import (
-	"context"
 	"io/fs"
 	"net"
 
 	"github.com/AdguardTeam/AdGuardHome/internal/aghos"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/agh"
 	"github.com/AdguardTeam/dnsproxy/upstream"
 	"github.com/miekg/dns"
 )
@@ -118,36 +116,6 @@ func (w *FSWatcher) Close() (err error) {
 	return w.OnClose()
 }
 
-// Package agh
-
-// type check
-var _ agh.ServiceWithConfig[struct{}] = (*ServiceWithConfig[struct{}])(nil)
-
-// ServiceWithConfig is a mock [agh.ServiceWithConfig] implementation for tests.
-type ServiceWithConfig[ConfigType any] struct {
-	OnStart    func() (err error)
-	OnShutdown func(ctx context.Context) (err error)
-	OnConfig   func() (c ConfigType)
-}
-
-// Start implements the [agh.ServiceWithConfig] interface for
-// *ServiceWithConfig.
-func (s *ServiceWithConfig[_]) Start() (err error) {
-	return s.OnStart()
-}
-
-// Shutdown implements the [agh.ServiceWithConfig] interface for
-// *ServiceWithConfig.
-func (s *ServiceWithConfig[_]) Shutdown(ctx context.Context) (err error) {
-	return s.OnShutdown(ctx)
-}
-
-// Config implements the [agh.ServiceWithConfig] interface for
-// *ServiceWithConfig.
-func (s *ServiceWithConfig[ConfigType]) Config() (c ConfigType) {
-	return s.OnConfig()
-}
-
 // Module dnsproxy
 
 // Package upstream

internal/dhcpd/http_unix.go

@@ -350,10 +350,8 @@ type netInterfaceJSON struct {
 	Addrs6       []netip.Addr `json:"ipv6_addresses"`
 }
 
-// handleDHCPInterfaces is the handler for the GET /control/dhcp/interfaces HTTP
-// API.
 func (s *server) handleDHCPInterfaces(w http.ResponseWriter, r *http.Request) {
-	resp := map[string]netInterfaceJSON{}
+	response := map[string]netInterfaceJSON{}
 
 	ifaces, err := net.Interfaces()
 	if err != nil {
@@ -426,11 +424,20 @@ func (s *server) handleDHCPInterfaces(w http.ResponseWriter, r *http.Request) {
 		}
 		if len(jsonIface.Addrs4)+len(jsonIface.Addrs6) != 0 {
 			jsonIface.GatewayIP = aghnet.GatewayIP(iface.Name)
-			resp[iface.Name] = jsonIface
+			response[iface.Name] = jsonIface
 		}
 	}
 
-	_ = aghhttp.WriteJSONResponse(w, r, resp)
+	err = json.NewEncoder(w).Encode(response)
+	if err != nil {
+		aghhttp.Error(
+			r,
+			w,
+			http.StatusInternalServerError,
+			"Failed to marshal json with available interfaces: %s",
+			err,
+		)
+	}
 }
 
 // dhcpSearchOtherResult contains information about other DHCP server for

internal/dnsforward/dnsforward_test.go

@@ -23,7 +23,6 @@ import (
 	"github.com/AdguardTeam/AdGuardHome/internal/aghtest"
 	"github.com/AdguardTeam/AdGuardHome/internal/dhcpd"
 	"github.com/AdguardTeam/AdGuardHome/internal/filtering"
-	"github.com/AdguardTeam/AdGuardHome/internal/filtering/hashprefix"
 	"github.com/AdguardTeam/AdGuardHome/internal/filtering/safesearch"
 	"github.com/AdguardTeam/dnsproxy/proxy"
 	"github.com/AdguardTeam/dnsproxy/upstream"
@@ -916,23 +915,13 @@ func TestBlockedByHosts(t *testing.T) {
 }
 
 func TestBlockedBySafeBrowsing(t *testing.T) {
-	const (
-		hostname  = "wmconvirus.narod.ru"
-		cacheTime = 10 * time.Minute
-		cacheSize = 10000
-	)
-
-	sbChecker := hashprefix.New(&hashprefix.Config{
-		CacheTime: cacheTime,
-		CacheSize: cacheSize,
-		Upstream:  aghtest.NewBlockUpstream(hostname, true),
-	})
+	const hostname = "wmconvirus.narod.ru"
 
+	sbUps := aghtest.NewBlockUpstream(hostname, true)
 	ans4, _ := (&aghtest.TestResolver{}).HostToIPs(hostname)
 
 	filterConf := &filtering.Config{
 		SafeBrowsingEnabled: true,
-		SafeBrowsingChecker: sbChecker,
 	}
 	forwardConf := ServerConfig{
 		UDPListenAddrs: []*net.UDPAddr{{}},
@@ -946,6 +935,7 @@ func TestBlockedBySafeBrowsing(t *testing.T) {
 		},
 	}
 	s := createTestServer(t, filterConf, forwardConf, nil)
+	s.dnsFilter.SetSafeBrowsingUpstream(sbUps)
 	startDeferStop(t, s)
 	addr := s.dnsProxy.Addr(proxy.ProtoUDP)
 

internal/dnsforward/http_test.go

@@ -205,8 +205,8 @@ func TestDNSForwardHTTP_handleSetConfig(t *testing.T) {
 		wantSet: `validating upstream servers: validating upstream "!!!": not an ip:port`,
 	}, {
 		name: "bootstraps_bad",
-		wantSet: `checking bootstrap a: invalid address: bootstrap a:53: ` +
-			`ParseAddr("a"): unable to parse IP`,
+		wantSet: `checking bootstrap a: invalid address: ` +
+			`Resolver a is not eligible to be a bootstrap DNS server`,
 	}, {
 		name:    "cache_bad_ttl",
 		wantSet: `cache_ttl_min must be less or equal than cache_ttl_max`,

internal/filtering/dnsrewrite.go

@@ -3,7 +3,6 @@ package filtering
 import (
 	"github.com/AdguardTeam/urlfilter/rules"
 	"github.com/miekg/dns"
-	"golang.org/x/exp/slices"
 )
 
 // DNSRewriteResult is the result of application of $dnsrewrite rules.
@@ -25,13 +24,7 @@ func (d *DNSFilter) processDNSRewrites(dnsr []*rules.NetworkRule) (res Result) {
 		Response: DNSRewriteResultResponse{},
 	}
 
-	slices.SortFunc(dnsr, rewriteSortsBefore)
-
-	for i, nr := range dnsr {
-		if i > 0 && containsWildcard(nr) {
-			break
-		}
-
+	for _, nr := range dnsr {
 		dr := nr.DNSRewrite
 		if dr.NewCNAME != "" {
 			// NewCNAME rules have a higher priority than other rules.
@@ -80,19 +73,3 @@ func (d *DNSFilter) processDNSRewrites(dnsr []*rules.NetworkRule) (res Result) {
 		Reason:           RewrittenRule,
 	}
 }
-
-func rewriteSortsBefore(a, b *rules.NetworkRule) (sortsBefore bool) {
-	return len(a.Shortcut) > len(b.Shortcut)
-}
-
-func containsWildcard(r *rules.NetworkRule) (ok bool) {
-	for _, c := range r.RuleText {
-		if c == '*' {
-			return true
-		} else if c == '^' {
-			break
-		}
-	}
-
-	return false
-}

internal/filtering/dnsrewrite_test.go

@@ -5,7 +5,6 @@ import (
 	"path"
 	"testing"
 
-	"github.com/AdguardTeam/urlfilter"
 	"github.com/miekg/dns"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -203,32 +202,3 @@ func TestDNSFilter_CheckHostRules_dnsrewrite(t *testing.T) {
 		assert.Equal(t, "new-ptr-with-dot.", ptr)
 	})
 }
-
-func TestDNSFilter_ProcessDNSRewrites(t *testing.T) {
-	const text = `
-|www.example.com^$dnsrewrite=127.0.0.1
-|*.example.com^$dnsrewrite=127.0.0.2
-`
-
-	host := "www.example.com"
-	rrtype := dns.TypeA
-
-	f, _ := newForTest(t, nil, []Filter{{ID: 0, Data: []byte(text)}})
-	setts := &Settings{
-		FilteringEnabled: true,
-	}
-
-	ufReq := &urlfilter.DNSRequest{
-		Hostname:         host,
-		SortedClientTags: setts.ClientTags,
-		ClientIP:         setts.ClientIP.String(),
-		ClientName:       setts.ClientName,
-		DNSType:          rrtype,
-	}
-
-	dres, matched := f.filteringEngine.MatchRequest(ufReq)
-	require.False(t, matched)
-
-	res := f.processDNSResultRewrites(dres, host)
-	assert.Len(t, res.Rules, 1)
-}

internal/filtering/filtering.go

@@ -18,6 +18,8 @@ import (
 
 	"github.com/AdguardTeam/AdGuardHome/internal/aghhttp"
 	"github.com/AdguardTeam/AdGuardHome/internal/aghnet"
+	"github.com/AdguardTeam/dnsproxy/upstream"
+	"github.com/AdguardTeam/golibs/cache"
 	"github.com/AdguardTeam/golibs/errors"
 	"github.com/AdguardTeam/golibs/log"
 	"github.com/AdguardTeam/golibs/mathutil"
@@ -73,12 +75,6 @@ type Resolver interface {
 
 // Config allows you to configure DNS filtering with New() or just change variables directly.
 type Config struct {
-	// SafeBrowsingChecker is the safe browsing hash-prefix checker.
-	SafeBrowsingChecker Checker `yaml:"-"`
-
-	// ParentControl is the parental control hash-prefix checker.
-	ParentalControlChecker Checker `yaml:"-"`
-
 	// enabled is used to be returned within Settings.
 	//
 	// It is of type uint32 to be accessed by atomic.
@@ -162,22 +158,8 @@ type hostChecker struct {
 	name  string
 }
 
-// Checker is used for safe browsing or parental control hash-prefix filtering.
-type Checker interface {
-	// Check returns true if request for the host should be blocked.
-	Check(host string) (block bool, err error)
-}
-
 // DNSFilter matches hostnames and DNS requests against filtering rules.
 type DNSFilter struct {
-	safeSearch SafeSearch
-
-	// safeBrowsingChecker is the safe browsing hash-prefix checker.
-	safeBrowsingChecker Checker
-
-	// parentalControl is the parental control hash-prefix checker.
-	parentalControlChecker Checker
-
 	rulesStorage    *filterlist.RuleStorage
 	filteringEngine *urlfilter.DNSEngine
 
@@ -186,6 +168,14 @@ type DNSFilter struct {
 
 	engineLock sync.RWMutex
 
+	parentalServer       string // access via methods
+	safeBrowsingServer   string // access via methods
+	parentalUpstream     upstream.Upstream
+	safeBrowsingUpstream upstream.Upstream
+
+	safebrowsingCache cache.Cache
+	parentalCache     cache.Cache
+
 	Config // for direct access by library users, even a = assignment
 	// confLock protects Config.
 	confLock sync.RWMutex
@@ -202,6 +192,7 @@ type DNSFilter struct {
 	// TODO(e.burkov):  Don't use regexp for such a simple text processing task.
 	filterTitleRegexp *regexp.Regexp
 
+	safeSearch   SafeSearch
 	hostCheckers []hostChecker
 }
 
@@ -949,12 +940,19 @@ func InitModule() {
 // be non-nil.
 func New(c *Config, blockFilters []Filter) (d *DNSFilter, err error) {
 	d = &DNSFilter{
-		refreshLock:            &sync.Mutex{},
-		filterTitleRegexp:      regexp.MustCompile(`^! Title: +(.*)$`),
-		safeBrowsingChecker:    c.SafeBrowsingChecker,
-		parentalControlChecker: c.ParentalControlChecker,
+		refreshLock:       &sync.Mutex{},
+		filterTitleRegexp: regexp.MustCompile(`^! Title: +(.*)$`),
 	}
 
+	d.safebrowsingCache = cache.New(cache.Config{
+		EnableLRU: true,
+		MaxSize:   c.SafeBrowsingCacheSize,
+	})
+	d.parentalCache = cache.New(cache.Config{
+		EnableLRU: true,
+		MaxSize:   c.ParentalCacheSize,
+	})
+
 	d.safeSearch = c.SafeSearch
 
 	d.hostCheckers = []hostChecker{{
@@ -979,6 +977,11 @@ func New(c *Config, blockFilters []Filter) (d *DNSFilter, err error) {
 
 	defer func() { err = errors.Annotate(err, "filtering: %w") }()
 
+	err = d.initSecurityServices()
+	if err != nil {
+		return nil, fmt.Errorf("initializing services: %s", err)
+	}
+
 	d.Config = *c
 	d.filtersMu = &sync.RWMutex{}
 
@@ -1035,69 +1038,3 @@ func (d *DNSFilter) Start() {
 	// So for now we just start this periodic task from here.
 	go d.periodicallyRefreshFilters()
 }
-
-// Safe browsing and parental control methods.
-
-// TODO(a.garipov): Unify with checkParental.
-func (d *DNSFilter) checkSafeBrowsing(
-	host string,
-	_ uint16,
-	setts *Settings,
-) (res Result, err error) {
-	if !setts.ProtectionEnabled || !setts.SafeBrowsingEnabled {
-		return Result{}, nil
-	}
-
-	if log.GetLevel() >= log.DEBUG {
-		timer := log.StartTimer()
-		defer timer.LogElapsed("safebrowsing lookup for %q", host)
-	}
-
-	res = Result{
-		Rules: []*ResultRule{{
-			Text:         "adguard-malware-shavar",
-			FilterListID: SafeBrowsingListID,
-		}},
-		Reason:     FilteredSafeBrowsing,
-		IsFiltered: true,
-	}
-
-	block, err := d.safeBrowsingChecker.Check(host)
-	if !block || err != nil {
-		return Result{}, err
-	}
-
-	return res, nil
-}
-
-// TODO(a.garipov): Unify with checkSafeBrowsing.
-func (d *DNSFilter) checkParental(
-	host string,
-	_ uint16,
-	setts *Settings,
-) (res Result, err error) {
-	if !setts.ProtectionEnabled || !setts.ParentalEnabled {
-		return Result{}, nil
-	}
-
-	if log.GetLevel() >= log.DEBUG {
-		timer := log.StartTimer()
-		defer timer.LogElapsed("parental lookup for %q", host)
-	}
-
-	res = Result{
-		Rules: []*ResultRule{{
-			Text:         "parental CATEGORY_BLACKLISTED",
-			FilterListID: ParentalListID,
-		}},
-		Reason:     FilteredParental,
-		IsFiltered: true,
-	}
-
-	block, err := d.parentalControlChecker.Check(host)
-	if !block || err != nil {
-		return Result{}, err
-	}
-
-	return res, nil
-}

internal/filtering/filtering_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/AdguardTeam/AdGuardHome/internal/aghtest"
-	"github.com/AdguardTeam/AdGuardHome/internal/filtering/hashprefix"
+	"github.com/AdguardTeam/golibs/cache"
 	"github.com/AdguardTeam/golibs/log"
 	"github.com/AdguardTeam/golibs/testutil"
 	"github.com/AdguardTeam/urlfilter/rules"
@@ -27,6 +27,17 @@ const (
 
 // Helpers.
 
+func purgeCaches(d *DNSFilter) {
+	for _, c := range []cache.Cache{
+		d.safebrowsingCache,
+		d.parentalCache,
+	} {
+		if c != nil {
+			c.Clear()
+		}
+	}
+}
+
 func newForTest(t testing.TB, c *Config, filters []Filter) (f *DNSFilter, setts *Settings) {
 	setts = &Settings{
 		ProtectionEnabled: true,
@@ -47,15 +58,9 @@ func newForTest(t testing.TB, c *Config, filters []Filter) (f *DNSFilter, setts
 	f, err := New(c, filters)
 	require.NoError(t, err)
 
-	return f, setts
-}
+	purgeCaches(f)
 
-func newChecker(host string) Checker {
-	return hashprefix.New(&hashprefix.Config{
-		CacheTime: 10,
-		CacheSize: 100000,
-		Upstream:  aghtest.NewBlockUpstream(host, true),
-	})
+	return f, setts
 }
 
 func (d *DNSFilter) checkMatch(t *testing.T, hostname string, setts *Settings) {
@@ -170,14 +175,10 @@ func TestSafeBrowsing(t *testing.T) {
 	aghtest.ReplaceLogWriter(t, logOutput)
 	aghtest.ReplaceLogLevel(t, log.DEBUG)
 
-	sbChecker := newChecker(sbBlocked)
-
-	d, setts := newForTest(t, &Config{
-		SafeBrowsingEnabled: true,
-		SafeBrowsingChecker: sbChecker,
-	}, nil)
+	d, setts := newForTest(t, &Config{SafeBrowsingEnabled: true}, nil)
 	t.Cleanup(d.Close)
 
+	d.SetSafeBrowsingUpstream(aghtest.NewBlockUpstream(sbBlocked, true))
 	d.checkMatch(t, sbBlocked, setts)
 
 	require.Contains(t, logOutput.String(), fmt.Sprintf("safebrowsing lookup for %q", sbBlocked))
@@ -187,17 +188,18 @@ func TestSafeBrowsing(t *testing.T) {
 	d.checkMatchEmpty(t, pcBlocked, setts)
 
 	// Cached result.
+	d.safeBrowsingServer = "127.0.0.1"
 	d.checkMatch(t, sbBlocked, setts)
 	d.checkMatchEmpty(t, pcBlocked, setts)
+	d.safeBrowsingServer = defaultSafebrowsingServer
 }
 
 func TestParallelSB(t *testing.T) {
-	d, setts := newForTest(t, &Config{
-		SafeBrowsingEnabled: true,
-		SafeBrowsingChecker: newChecker(sbBlocked),
-	}, nil)
+	d, setts := newForTest(t, &Config{SafeBrowsingEnabled: true}, nil)
 	t.Cleanup(d.Close)
 
+	d.SetSafeBrowsingUpstream(aghtest.NewBlockUpstream(sbBlocked, true))
+
 	t.Run("group", func(t *testing.T) {
 		for i := 0; i < 100; i++ {
 			t.Run(fmt.Sprintf("aaa%d", i), func(t *testing.T) {
@@ -218,12 +220,10 @@ func TestParentalControl(t *testing.T) {
 	aghtest.ReplaceLogWriter(t, logOutput)
 	aghtest.ReplaceLogLevel(t, log.DEBUG)
 
-	d, setts := newForTest(t, &Config{
-		ParentalEnabled:        true,
-		ParentalControlChecker: newChecker(pcBlocked),
-	}, nil)
+	d, setts := newForTest(t, &Config{ParentalEnabled: true}, nil)
 	t.Cleanup(d.Close)
 
+	d.SetParentalUpstream(aghtest.NewBlockUpstream(pcBlocked, true))
 	d.checkMatch(t, pcBlocked, setts)
 	require.Contains(t, logOutput.String(), fmt.Sprintf("parental lookup for %q", pcBlocked))
 
@@ -233,6 +233,7 @@ func TestParentalControl(t *testing.T) {
 	d.checkMatchEmpty(t, "api.jquery.com", setts)
 
 	// Test cached result.
+	d.parentalServer = "127.0.0.1"
 	d.checkMatch(t, pcBlocked, setts)
 	d.checkMatchEmpty(t, "yandex.ru", setts)
 }
@@ -592,10 +593,8 @@ func applyClientSettings(setts *Settings) {
 func TestClientSettings(t *testing.T) {
 	d, setts := newForTest(t,
 		&Config{
-			ParentalEnabled:        true,
-			SafeBrowsingEnabled:    false,
-			SafeBrowsingChecker:    newChecker(sbBlocked),
-			ParentalControlChecker: newChecker(pcBlocked),
+			ParentalEnabled:     true,
+			SafeBrowsingEnabled: false,
 		},
 		[]Filter{{
 			ID: 0, Data: []byte("||example.org^\n"),
@@ -603,6 +602,9 @@ func TestClientSettings(t *testing.T) {
 	)
 	t.Cleanup(d.Close)
 
+	d.SetParentalUpstream(aghtest.NewBlockUpstream(pcBlocked, true))
+	d.SetSafeBrowsingUpstream(aghtest.NewBlockUpstream(sbBlocked, true))
+
 	type testCase struct {
 		name       string
 		host       string
@@ -663,12 +665,11 @@ func TestClientSettings(t *testing.T) {
 // Benchmarks.
 
 func BenchmarkSafeBrowsing(b *testing.B) {
-	d, setts := newForTest(b, &Config{
-		SafeBrowsingEnabled: true,
-		SafeBrowsingChecker: newChecker(sbBlocked),
-	}, nil)
+	d, setts := newForTest(b, &Config{SafeBrowsingEnabled: true}, nil)
 	b.Cleanup(d.Close)
 
+	d.SetSafeBrowsingUpstream(aghtest.NewBlockUpstream(sbBlocked, true))
+
 	for n := 0; n < b.N; n++ {
 		res, err := d.CheckHost(sbBlocked, dns.TypeA, setts)
 		require.NoError(b, err)
@@ -678,12 +679,11 @@ func BenchmarkSafeBrowsing(b *testing.B) {
 }
 
 func BenchmarkSafeBrowsingParallel(b *testing.B) {
-	d, setts := newForTest(b, &Config{
-		SafeBrowsingEnabled: true,
-		SafeBrowsingChecker: newChecker(sbBlocked),
-	}, nil)
+	d, setts := newForTest(b, &Config{SafeBrowsingEnabled: true}, nil)
 	b.Cleanup(d.Close)
 
+	d.SetSafeBrowsingUpstream(aghtest.NewBlockUpstream(sbBlocked, true))
+
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
 			res, err := d.CheckHost(sbBlocked, dns.TypeA, setts)

internal/filtering/hashprefix/cache.go

@@ -1,130 +0,0 @@
-package hashprefix
-
-import (
-	"encoding/binary"
-	"time"
-
-	"github.com/AdguardTeam/golibs/log"
-)
-
-// expirySize is the size of expiry in cacheItem.
-const expirySize = 8
-
-// cacheItem represents an item that we will store in the cache.
-type cacheItem struct {
-	// expiry is the time when cacheItem will expire.
-	expiry time.Time
-
-	// hashes is the hashed hostnames.
-	hashes []hostnameHash
-}
-
-// toCacheItem decodes cacheItem from data.  data must be at least equal to
-// expiry size.
-func toCacheItem(data []byte) *cacheItem {
-	t := time.Unix(int64(binary.BigEndian.Uint64(data)), 0)
-
-	data = data[expirySize:]
-	hashes := make([]hostnameHash, len(data)/hashSize)
-
-	for i := 0; i < len(data); i += hashSize {
-		var hash hostnameHash
-		copy(hash[:], data[i:i+hashSize])
-		hashes = append(hashes, hash)
-	}
-
-	return &cacheItem{
-		expiry: t,
-		hashes: hashes,
-	}
-}
-
-// fromCacheItem encodes cacheItem into data.
-func fromCacheItem(item *cacheItem) (data []byte) {
-	data = make([]byte, len(item.hashes)*hashSize+expirySize)
-	expiry := item.expiry.Unix()
-	binary.BigEndian.PutUint64(data[:expirySize], uint64(expiry))
-
-	for _, v := range item.hashes {
-		// nolint:looppointer // The subsilce is used for a copy.
-		data = append(data, v[:]...)
-	}
-
-	return data
-}
-
-// findInCache finds hashes in the cache.  If nothing found returns list of
-// hashes, prefixes of which will be sent to upstream.
-func (c *Checker) findInCache(
-	hashes []hostnameHash,
-) (found, blocked bool, hashesToRequest []hostnameHash) {
-	now := time.Now()
-
-	i := 0
-	for _, hash := range hashes {
-		// nolint:looppointer // The subsilce is used for a safe cache lookup.
-		data := c.cache.Get(hash[:prefixLen])
-		if data == nil {
-			hashes[i] = hash
-			i++
-
-			continue
-		}
-
-		item := toCacheItem(data)
-		if now.After(item.expiry) {
-			hashes[i] = hash
-			i++
-
-			continue
-		}
-
-		if ok := findMatch(hashes, item.hashes); ok {
-			return true, true, nil
-		}
-	}
-
-	if i == 0 {
-		return true, false, nil
-	}
-
-	return false, false, hashes[:i]
-}
-
-// storeInCache caches hashes.
-func (c *Checker) storeInCache(hashesToRequest, respHashes []hostnameHash) {
-	hashToStore := make(map[prefix][]hostnameHash)
-
-	for _, hash := range respHashes {
-		var pref prefix
-		// nolint:looppointer // The subsilce is used for a copy.
-		copy(pref[:], hash[:])
-
-		hashToStore[pref] = append(hashToStore[pref], hash)
-	}
-
-	for pref, hash := range hashToStore {
-		// nolint:looppointer // The subsilce is used for a safe cache lookup.
-		c.setCache(pref[:], hash)
-	}
-
-	for _, hash := range hashesToRequest {
-		// nolint:looppointer // The subsilce is used for a safe cache lookup.
-		pref := hash[:prefixLen]
-		val := c.cache.Get(pref)
-		if val == nil {
-			c.setCache(pref, nil)
-		}
-	}
-}
-
-// setCache stores hash in cache.
-func (c *Checker) setCache(pref []byte, hashes []hostnameHash) {
-	item := &cacheItem{
-		expiry: time.Now().Add(c.cacheTime),
-		hashes: hashes,
-	}
-
-	c.cache.Set(pref, fromCacheItem(item))
-	log.Debug("%s: stored in cache: %v", c.svc, pref)
-}

internal/filtering/hashprefix/hashprefix.go

@@ -1,245 +0,0 @@
-// Package hashprefix used for safe browsing and parent control.
-package hashprefix
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/AdguardTeam/dnsproxy/upstream"
-	"github.com/AdguardTeam/golibs/cache"
-	"github.com/AdguardTeam/golibs/log"
-	"github.com/AdguardTeam/golibs/netutil"
-	"github.com/AdguardTeam/golibs/stringutil"
-	"github.com/miekg/dns"
-	"golang.org/x/exp/slices"
-	"golang.org/x/net/publicsuffix"
-)
-
-const (
-	// prefixLen is the length of the hash prefix of the filtered hostname.
-	prefixLen = 2
-
-	// hashSize is the size of hashed hostname.
-	hashSize = sha256.Size
-
-	// hexSize is the size of hexadecimal representation of hashed hostname.
-	hexSize = hashSize * 2
-)
-
-// prefix is the type of the SHA256 hash prefix used to match against the
-// domain-name database.
-type prefix [prefixLen]byte
-
-// hostnameHash is the hashed hostname.
-//
-// TODO(s.chzhen):  Split into prefix and suffix.
-type hostnameHash [hashSize]byte
-
-// findMatch returns true if one of the a hostnames matches one of the b.
-func findMatch(a, b []hostnameHash) (matched bool) {
-	for _, hash := range a {
-		if slices.Contains(b, hash) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// Config is the configuration structure for safe browsing and parental
-// control.
-type Config struct {
-	// Upstream is the upstream DNS server.
-	Upstream upstream.Upstream
-
-	// ServiceName is the name of the service.
-	ServiceName string
-
-	// TXTSuffix is the TXT suffix for DNS request.
-	TXTSuffix string
-
-	// CacheTime is the time period to store hash.
-	CacheTime time.Duration
-
-	// CacheSize is the maximum size of the cache.  If it's zero, cache size is
-	// unlimited.
-	CacheSize uint
-}
-
-type Checker struct {
-	// upstream is the upstream DNS server.
-	upstream upstream.Upstream
-
-	// cache stores hostname hashes.
-	cache cache.Cache
-
-	// svc is the name of the service.
-	svc string
-
-	// txtSuffix is the TXT suffix for DNS request.
-	txtSuffix string
-
-	// cacheTime is the time period to store hash.
-	cacheTime time.Duration
-}
-
-// New returns Checker.
-func New(conf *Config) (c *Checker) {
-	return &Checker{
-		upstream: conf.Upstream,
-		cache: cache.New(cache.Config{
-			EnableLRU: true,
-			MaxSize:   conf.CacheSize,
-		}),
-		svc:       conf.ServiceName,
-		txtSuffix: conf.TXTSuffix,
-		cacheTime: conf.CacheTime,
-	}
-}
-
-// Check returns true if request for the host should be blocked.
-func (c *Checker) Check(host string) (ok bool, err error) {
-	hashes := hostnameToHashes(host)
-
-	found, blocked, hashesToRequest := c.findInCache(hashes)
-	if found {
-		log.Debug("%s: found %q in cache, blocked: %t", c.svc, host, blocked)
-
-		return blocked, nil
-	}
-
-	question := c.getQuestion(hashesToRequest)
-
-	log.Debug("%s: checking %s: %s", c.svc, host, question)
-	req := (&dns.Msg{}).SetQuestion(question, dns.TypeTXT)
-
-	resp, err := c.upstream.Exchange(req)
-	if err != nil {
-		return false, fmt.Errorf("getting hashes: %w", err)
-	}
-
-	matched, receivedHashes := c.processAnswer(hashesToRequest, resp, host)
-
-	c.storeInCache(hashesToRequest, receivedHashes)
-
-	return matched, nil
-}
-
-// hostnameToHashes returns hashes that should be checked by the hash prefix
-// filter.
-func hostnameToHashes(host string) (hashes []hostnameHash) {
-	// subDomainNum defines how many labels should be hashed to match against a
-	// hash prefix filter.
-	const subDomainNum = 4
-
-	pubSuf, icann := publicsuffix.PublicSuffix(host)
-	if !icann {
-		// Check the full private domain space.
-		pubSuf = ""
-	}
-
-	nDots := 0
-	i := strings.LastIndexFunc(host, func(r rune) (ok bool) {
-		if r == '.' {
-			nDots++
-		}
-
-		return nDots == subDomainNum
-	})
-	if i != -1 {
-		host = host[i+1:]
-	}
-
-	sub := netutil.Subdomains(host)
-
-	for _, s := range sub {
-		if s == pubSuf {
-			break
-		}
-
-		sum := sha256.Sum256([]byte(s))
-		hashes = append(hashes, sum)
-	}
-
-	return hashes
-}
-
-// getQuestion combines hexadecimal encoded prefixes of hashed hostnames into
-// string.
-func (c *Checker) getQuestion(hashes []hostnameHash) (q string) {
-	b := &strings.Builder{}
-
-	for _, hash := range hashes {
-		// nolint:looppointer // The subsilce is used for safe hex encoding.
-		stringutil.WriteToBuilder(b, hex.EncodeToString(hash[:prefixLen]), ".")
-	}
-
-	stringutil.WriteToBuilder(b, c.txtSuffix)
-
-	return b.String()
-}
-
-// processAnswer returns true if DNS response matches the hash, and received
-// hashed hostnames from the upstream.
-func (c *Checker) processAnswer(
-	hashesToRequest []hostnameHash,
-	resp *dns.Msg,
-	host string,
-) (matched bool, receivedHashes []hostnameHash) {
-	txtCount := 0
-
-	for _, a := range resp.Answer {
-		txt, ok := a.(*dns.TXT)
-		if !ok {
-			continue
-		}
-
-		txtCount++
-
-		receivedHashes = c.appendHashesFromTXT(receivedHashes, txt, host)
-	}
-
-	log.Debug("%s: received answer for %s with %d TXT count", c.svc, host, txtCount)
-
-	matched = findMatch(hashesToRequest, receivedHashes)
-	if matched {
-		log.Debug("%s: matched %s", c.svc, host)
-
-		return true, receivedHashes
-	}
-
-	return false, receivedHashes
-}
-
-// appendHashesFromTXT appends received hashed hostnames.
-func (c *Checker) appendHashesFromTXT(
-	hashes []hostnameHash,
-	txt *dns.TXT,
-	host string,
-) (receivedHashes []hostnameHash) {
-	log.Debug("%s: received hashes for %s: %v", c.svc, host, txt.Txt)
-
-	for _, t := range txt.Txt {
-		if len(t) != hexSize {
-			log.Debug("%s: wrong hex size %d for %s %s", c.svc, len(t), host, t)
-
-			continue
-		}
-
-		buf, err := hex.DecodeString(t)
-		if err != nil {
-			log.Debug("%s: decoding hex string %s: %s", c.svc, t, err)
-
-			continue
-		}
-
-		var hash hostnameHash
-		copy(hash[:], buf)
-		hashes = append(hashes, hash)
-	}
-
-	return hashes
-}

internal/filtering/hashprefix/hashprefix_internal_test.go

@@ -1,248 +0,0 @@
-package hashprefix
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/aghtest"
-	"github.com/AdguardTeam/golibs/cache"
-	"github.com/miekg/dns"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"golang.org/x/exp/slices"
-)
-
-const (
-	cacheTime = 10 * time.Minute
-	cacheSize = 10000
-)
-
-func TestChcker_getQuestion(t *testing.T) {
-	const suf = "sb.dns.adguard.com."
-
-	// test hostnameToHashes()
-	hashes := hostnameToHashes("1.2.3.sub.host.com")
-	assert.Len(t, hashes, 3)
-
-	hash := sha256.Sum256([]byte("3.sub.host.com"))
-	hexPref1 := hex.EncodeToString(hash[:prefixLen])
-	assert.True(t, slices.Contains(hashes, hash))
-
-	hash = sha256.Sum256([]byte("sub.host.com"))
-	hexPref2 := hex.EncodeToString(hash[:prefixLen])
-	assert.True(t, slices.Contains(hashes, hash))
-
-	hash = sha256.Sum256([]byte("host.com"))
-	hexPref3 := hex.EncodeToString(hash[:prefixLen])
-	assert.True(t, slices.Contains(hashes, hash))
-
-	hash = sha256.Sum256([]byte("com"))
-	assert.False(t, slices.Contains(hashes, hash))
-
-	c := &Checker{
-		svc:       "SafeBrowsing",
-		txtSuffix: suf,
-	}
-
-	q := c.getQuestion(hashes)
-
-	assert.Contains(t, q, hexPref1)
-	assert.Contains(t, q, hexPref2)
-	assert.Contains(t, q, hexPref3)
-	assert.True(t, strings.HasSuffix(q, suf))
-}
-
-func TestHostnameToHashes(t *testing.T) {
-	testCases := []struct {
-		name    string
-		host    string
-		wantLen int
-	}{{
-		name:    "basic",
-		host:    "example.com",
-		wantLen: 1,
-	}, {
-		name:    "sub_basic",
-		host:    "www.example.com",
-		wantLen: 2,
-	}, {
-		name:    "private_domain",
-		host:    "foo.co.uk",
-		wantLen: 1,
-	}, {
-		name:    "sub_private_domain",
-		host:    "bar.foo.co.uk",
-		wantLen: 2,
-	}, {
-		name:    "private_domain_v2",
-		host:    "foo.blogspot.co.uk",
-		wantLen: 4,
-	}, {
-		name:    "sub_private_domain_v2",
-		host:    "bar.foo.blogspot.co.uk",
-		wantLen: 4,
-	}}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			hashes := hostnameToHashes(tc.host)
-			assert.Len(t, hashes, tc.wantLen)
-		})
-	}
-}
-
-func TestChecker_storeInCache(t *testing.T) {
-	c := &Checker{
-		svc:       "SafeBrowsing",
-		cacheTime: cacheTime,
-	}
-	conf := cache.Config{}
-	c.cache = cache.New(conf)
-
-	// store in cache hashes for "3.sub.host.com" and "host.com"
-	//  and empty data for hash-prefix for "sub.host.com"
-	hashes := []hostnameHash{}
-	hash := sha256.Sum256([]byte("sub.host.com"))
-	hashes = append(hashes, hash)
-	var hashesArray []hostnameHash
-	hash4 := sha256.Sum256([]byte("3.sub.host.com"))
-	hashesArray = append(hashesArray, hash4)
-	hash2 := sha256.Sum256([]byte("host.com"))
-	hashesArray = append(hashesArray, hash2)
-	c.storeInCache(hashes, hashesArray)
-
-	// match "3.sub.host.com" or "host.com" from cache
-	hashes = []hostnameHash{}
-	hash = sha256.Sum256([]byte("3.sub.host.com"))
-	hashes = append(hashes, hash)
-	hash = sha256.Sum256([]byte("sub.host.com"))
-	hashes = append(hashes, hash)
-	hash = sha256.Sum256([]byte("host.com"))
-	hashes = append(hashes, hash)
-	found, blocked, _ := c.findInCache(hashes)
-	assert.True(t, found)
-	assert.True(t, blocked)
-
-	// match "sub.host.com" from cache
-	hashes = []hostnameHash{}
-	hash = sha256.Sum256([]byte("sub.host.com"))
-	hashes = append(hashes, hash)
-	found, blocked, _ = c.findInCache(hashes)
-	assert.True(t, found)
-	assert.False(t, blocked)
-
-	// Match "sub.host.com" from cache.  Another hash for "host.example" is not
-	// in the cache, so get data for it from the server.
-	hashes = []hostnameHash{}
-	hash = sha256.Sum256([]byte("sub.host.com"))
-	hashes = append(hashes, hash)
-	hash = sha256.Sum256([]byte("host.example"))
-	hashes = append(hashes, hash)
-	found, _, hashesToRequest := c.findInCache(hashes)
-	assert.False(t, found)
-
-	hash = sha256.Sum256([]byte("sub.host.com"))
-	ok := slices.Contains(hashesToRequest, hash)
-	assert.False(t, ok)
-
-	hash = sha256.Sum256([]byte("host.example"))
-	ok = slices.Contains(hashesToRequest, hash)
-	assert.True(t, ok)
-
-	c = &Checker{
-		svc:       "SafeBrowsing",
-		cacheTime: cacheTime,
-	}
-	c.cache = cache.New(cache.Config{})
-
-	hashes = []hostnameHash{}
-	hash = sha256.Sum256([]byte("sub.host.com"))
-	hashes = append(hashes, hash)
-
-	c.cache.Set(hash[:prefixLen], make([]byte, expirySize+hashSize))
-	found, _, _ = c.findInCache(hashes)
-	assert.False(t, found)
-}
-
-func TestChecker_Check(t *testing.T) {
-	const hostname = "example.org"
-
-	testCases := []struct {
-		name      string
-		wantBlock bool
-	}{{
-		name:      "sb_no_block",
-		wantBlock: false,
-	}, {
-		name:      "sb_block",
-		wantBlock: true,
-	}, {
-		name:      "pc_no_block",
-		wantBlock: false,
-	}, {
-		name:      "pc_block",
-		wantBlock: true,
-	}}
-
-	for _, tc := range testCases {
-		c := New(&Config{
-			CacheTime: cacheTime,
-			CacheSize: cacheSize,
-		})
-
-		// Prepare the upstream.
-		ups := aghtest.NewBlockUpstream(hostname, tc.wantBlock)
-
-		var numReq int
-		onExchange := ups.OnExchange
-		ups.OnExchange = func(req *dns.Msg) (resp *dns.Msg, err error) {
-			numReq++
-
-			return onExchange(req)
-		}
-
-		c.upstream = ups
-
-		t.Run(tc.name, func(t *testing.T) {
-			// Firstly, check the request blocking.
-			hits := 0
-			res := false
-			res, err := c.Check(hostname)
-			require.NoError(t, err)
-
-			if tc.wantBlock {
-				assert.True(t, res)
-				hits++
-			} else {
-				require.False(t, res)
-			}
-
-			// Check the cache state, check the response is now cached.
-			assert.Equal(t, 1, c.cache.Stats().Count)
-			assert.Equal(t, hits, c.cache.Stats().Hit)
-
-			// There was one request to an upstream.
-			assert.Equal(t, 1, numReq)
-
-			// Now make the same request to check the cache was used.
-			res, err = c.Check(hostname)
-			require.NoError(t, err)
-
-			if tc.wantBlock {
-				assert.True(t, res)
-			} else {
-				require.False(t, res)
-			}
-
-			// Check the cache state, it should've been used.
-			assert.Equal(t, 1, c.cache.Stats().Count)
-			assert.Equal(t, hits+1, c.cache.Stats().Hit)
-
-			// Check that there were no additional requests.
-			assert.Equal(t, 1, numReq)
-		})
-	}
-}

internal/filtering/http.go

@@ -8,7 +8,6 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
-	"sync"
 	"time"
 
 	"github.com/AdguardTeam/AdGuardHome/internal/aghhttp"
@@ -459,80 +458,6 @@ func (d *DNSFilter) handleCheckHost(w http.ResponseWriter, r *http.Request) {
 	_ = aghhttp.WriteJSONResponse(w, r, resp)
 }
 
-// setProtectedBool sets the value of a boolean pointer under a lock.  l must
-// protect the value under ptr.
-//
-// TODO(e.burkov):  Make it generic?
-func setProtectedBool(mu *sync.RWMutex, ptr *bool, val bool) {
-	mu.Lock()
-	defer mu.Unlock()
-
-	*ptr = val
-}
-
-// protectedBool gets the value of a boolean pointer under a read lock.  l must
-// protect the value under ptr.
-//
-// TODO(e.burkov):  Make it generic?
-func protectedBool(mu *sync.RWMutex, ptr *bool) (val bool) {
-	mu.RLock()
-	defer mu.RUnlock()
-
-	return *ptr
-}
-
-// handleSafeBrowsingEnable is the handler for the POST
-// /control/safebrowsing/enable HTTP API.
-func (d *DNSFilter) handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
-	setProtectedBool(&d.confLock, &d.Config.SafeBrowsingEnabled, true)
-	d.Config.ConfigModified()
-}
-
-// handleSafeBrowsingDisable is the handler for the POST
-// /control/safebrowsing/disable HTTP API.
-func (d *DNSFilter) handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
-	setProtectedBool(&d.confLock, &d.Config.SafeBrowsingEnabled, false)
-	d.Config.ConfigModified()
-}
-
-// handleSafeBrowsingStatus is the handler for the GET
-// /control/safebrowsing/status HTTP API.
-func (d *DNSFilter) handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
-	resp := &struct {
-		Enabled bool `json:"enabled"`
-	}{
-		Enabled: protectedBool(&d.confLock, &d.Config.SafeBrowsingEnabled),
-	}
-
-	_ = aghhttp.WriteJSONResponse(w, r, resp)
-}
-
-// handleParentalEnable is the handler for the POST /control/parental/enable
-// HTTP API.
-func (d *DNSFilter) handleParentalEnable(w http.ResponseWriter, r *http.Request) {
-	setProtectedBool(&d.confLock, &d.Config.ParentalEnabled, true)
-	d.Config.ConfigModified()
-}
-
-// handleParentalDisable is the handler for the POST /control/parental/disable
-// HTTP API.
-func (d *DNSFilter) handleParentalDisable(w http.ResponseWriter, r *http.Request) {
-	setProtectedBool(&d.confLock, &d.Config.ParentalEnabled, false)
-	d.Config.ConfigModified()
-}
-
-// handleParentalStatus is the handler for the GET /control/parental/status
-// HTTP API.
-func (d *DNSFilter) handleParentalStatus(w http.ResponseWriter, r *http.Request) {
-	resp := &struct {
-		Enabled bool `json:"enabled"`
-	}{
-		Enabled: protectedBool(&d.confLock, &d.Config.ParentalEnabled),
-	}
-
-	_ = aghhttp.WriteJSONResponse(w, r, resp)
-}
-
 // RegisterFilteringHandlers - register handlers
 func (d *DNSFilter) RegisterFilteringHandlers() {
 	registerHTTP := d.HTTPRegister

internal/filtering/http_test.go

@@ -8,7 +8,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/AdguardTeam/golibs/testutil"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -137,171 +136,3 @@ func TestDNSFilter_handleFilteringSetURL(t *testing.T) {
 		})
 	}
 }
-
-func TestDNSFilter_handleSafeBrowsingStatus(t *testing.T) {
-	const (
-		testTimeout = time.Second
-		statusURL   = "/control/safebrowsing/status"
-	)
-
-	confModCh := make(chan struct{})
-	filtersDir := t.TempDir()
-
-	testCases := []struct {
-		name       string
-		url        string
-		enabled    bool
-		wantStatus assert.BoolAssertionFunc
-	}{{
-		name:       "enable_off",
-		url:        "/control/safebrowsing/enable",
-		enabled:    false,
-		wantStatus: assert.True,
-	}, {
-		name:       "enable_on",
-		url:        "/control/safebrowsing/enable",
-		enabled:    true,
-		wantStatus: assert.True,
-	}, {
-		name:       "disable_on",
-		url:        "/control/safebrowsing/disable",
-		enabled:    true,
-		wantStatus: assert.False,
-	}, {
-		name:       "disable_off",
-		url:        "/control/safebrowsing/disable",
-		enabled:    false,
-		wantStatus: assert.False,
-	}}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			handlers := make(map[string]http.Handler)
-
-			d, err := New(&Config{
-				ConfigModified: func() {
-					testutil.RequireSend(testutil.PanicT{}, confModCh, struct{}{}, testTimeout)
-				},
-				DataDir: filtersDir,
-				HTTPRegister: func(_, url string, handler http.HandlerFunc) {
-					handlers[url] = handler
-				},
-				SafeBrowsingEnabled: tc.enabled,
-			}, nil)
-			require.NoError(t, err)
-			t.Cleanup(d.Close)
-
-			d.RegisterFilteringHandlers()
-			require.NotEmpty(t, handlers)
-			require.Contains(t, handlers, statusURL)
-
-			r := httptest.NewRequest(http.MethodPost, tc.url, nil)
-			w := httptest.NewRecorder()
-
-			go handlers[tc.url].ServeHTTP(w, r)
-
-			testutil.RequireReceive(t, confModCh, testTimeout)
-
-			r = httptest.NewRequest(http.MethodGet, statusURL, nil)
-			w = httptest.NewRecorder()
-
-			handlers[statusURL].ServeHTTP(w, r)
-			require.Equal(t, http.StatusOK, w.Code)
-
-			status := struct {
-				Enabled bool `json:"enabled"`
-			}{
-				Enabled: false,
-			}
-
-			err = json.NewDecoder(w.Body).Decode(&status)
-			require.NoError(t, err)
-
-			tc.wantStatus(t, status.Enabled)
-		})
-	}
-}
-
-func TestDNSFilter_handleParentalStatus(t *testing.T) {
-	const (
-		testTimeout = time.Second
-		statusURL   = "/control/parental/status"
-	)
-
-	confModCh := make(chan struct{})
-	filtersDir := t.TempDir()
-
-	testCases := []struct {
-		name       string
-		url        string
-		enabled    bool
-		wantStatus assert.BoolAssertionFunc
-	}{{
-		name:       "enable_off",
-		url:        "/control/parental/enable",
-		enabled:    false,
-		wantStatus: assert.True,
-	}, {
-		name:       "enable_on",
-		url:        "/control/parental/enable",
-		enabled:    true,
-		wantStatus: assert.True,
-	}, {
-		name:       "disable_on",
-		url:        "/control/parental/disable",
-		enabled:    true,
-		wantStatus: assert.False,
-	}, {
-		name:       "disable_off",
-		url:        "/control/parental/disable",
-		enabled:    false,
-		wantStatus: assert.False,
-	}}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			handlers := make(map[string]http.Handler)
-
-			d, err := New(&Config{
-				ConfigModified: func() {
-					testutil.RequireSend(testutil.PanicT{}, confModCh, struct{}{}, testTimeout)
-				},
-				DataDir: filtersDir,
-				HTTPRegister: func(_, url string, handler http.HandlerFunc) {
-					handlers[url] = handler
-				},
-				ParentalEnabled: tc.enabled,
-			}, nil)
-			require.NoError(t, err)
-			t.Cleanup(d.Close)
-
-			d.RegisterFilteringHandlers()
-			require.NotEmpty(t, handlers)
-			require.Contains(t, handlers, statusURL)
-
-			r := httptest.NewRequest(http.MethodPost, tc.url, nil)
-			w := httptest.NewRecorder()
-
-			go handlers[tc.url].ServeHTTP(w, r)
-
-			testutil.RequireReceive(t, confModCh, testTimeout)
-
-			r = httptest.NewRequest(http.MethodGet, statusURL, nil)
-			w = httptest.NewRecorder()
-
-			handlers[statusURL].ServeHTTP(w, r)
-			require.Equal(t, http.StatusOK, w.Code)
-
-			status := struct {
-				Enabled bool `json:"enabled"`
-			}{
-				Enabled: false,
-			}
-
-			err = json.NewDecoder(w.Body).Decode(&status)
-			require.NoError(t, err)
-
-			tc.wantStatus(t, status.Enabled)
-		})
-	}
-}

internal/filtering/safebrowsing.go

@@ -0,0 +1,433 @@
+package filtering
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"net"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/AdguardTeam/AdGuardHome/internal/aghhttp"
+	"github.com/AdguardTeam/dnsproxy/upstream"
+	"github.com/AdguardTeam/golibs/cache"
+	"github.com/AdguardTeam/golibs/log"
+	"github.com/AdguardTeam/golibs/stringutil"
+	"github.com/miekg/dns"
+	"golang.org/x/exp/slices"
+	"golang.org/x/net/publicsuffix"
+)
+
+// Safe browsing and parental control methods.
+
+// TODO(a.garipov): Make configurable.
+const (
+	dnsTimeout                = 3 * time.Second
+	defaultSafebrowsingServer = `https://family.adguard-dns.com/dns-query`
+	defaultParentalServer     = `https://family.adguard-dns.com/dns-query`
+	sbTXTSuffix               = `sb.dns.adguard.com.`
+	pcTXTSuffix               = `pc.dns.adguard.com.`
+)
+
+// SetParentalUpstream sets the parental upstream for *DNSFilter.
+//
+// TODO(e.burkov): Remove this in v1 API to forbid the direct access.
+func (d *DNSFilter) SetParentalUpstream(u upstream.Upstream) {
+	d.parentalUpstream = u
+}
+
+// SetSafeBrowsingUpstream sets the safe browsing upstream for *DNSFilter.
+//
+// TODO(e.burkov): Remove this in v1 API to forbid the direct access.
+func (d *DNSFilter) SetSafeBrowsingUpstream(u upstream.Upstream) {
+	d.safeBrowsingUpstream = u
+}
+
+func (d *DNSFilter) initSecurityServices() error {
+	var err error
+	d.safeBrowsingServer = defaultSafebrowsingServer
+	d.parentalServer = defaultParentalServer
+	opts := &upstream.Options{
+		Timeout: dnsTimeout,
+		ServerIPAddrs: []net.IP{
+			{94, 140, 14, 15},
+			{94, 140, 15, 16},
+			net.ParseIP("2a10:50c0::bad1:ff"),
+			net.ParseIP("2a10:50c0::bad2:ff"),
+		},
+	}
+
+	parUps, err := upstream.AddressToUpstream(d.parentalServer, opts)
+	if err != nil {
+		return fmt.Errorf("converting parental server: %w", err)
+	}
+	d.SetParentalUpstream(parUps)
+
+	sbUps, err := upstream.AddressToUpstream(d.safeBrowsingServer, opts)
+	if err != nil {
+		return fmt.Errorf("converting safe browsing server: %w", err)
+	}
+	d.SetSafeBrowsingUpstream(sbUps)
+
+	return nil
+}
+
+/*
+expire byte[4]
+hash byte[32]
+...
+*/
+func (c *sbCtx) setCache(prefix, hashes []byte) {
+	d := make([]byte, 4+len(hashes))
+	expire := uint(time.Now().Unix()) + c.cacheTime*60
+	binary.BigEndian.PutUint32(d[:4], uint32(expire))
+	copy(d[4:], hashes)
+	c.cache.Set(prefix, d)
+	log.Debug("%s: stored in cache: %v", c.svc, prefix)
+}
+
+// findInHash returns 32-byte hash if it's found in hashToHost.
+func (c *sbCtx) findInHash(val []byte) (hash32 [32]byte, found bool) {
+	for i := 4; i < len(val); i += 32 {
+		hash := val[i : i+32]
+
+		copy(hash32[:], hash[0:32])
+
+		_, found = c.hashToHost[hash32]
+		if found {
+			return hash32, found
+		}
+	}
+
+	return [32]byte{}, false
+}
+
+func (c *sbCtx) getCached() int {
+	now := time.Now().Unix()
+	hashesToRequest := map[[32]byte]string{}
+	for k, v := range c.hashToHost {
+		// nolint:looppointer // The subsilce is used for a safe cache lookup.
+		val := c.cache.Get(k[0:2])
+		if val == nil || now >= int64(binary.BigEndian.Uint32(val)) {
+			hashesToRequest[k] = v
+			continue
+		}
+		if hash32, found := c.findInHash(val); found {
+			log.Debug("%s: found in cache: %s: blocked by %v", c.svc, c.host, hash32)
+			return 1
+		}
+	}
+
+	if len(hashesToRequest) == 0 {
+		log.Debug("%s: found in cache: %s: not blocked", c.svc, c.host)
+		return -1
+	}
+
+	c.hashToHost = hashesToRequest
+	return 0
+}
+
+type sbCtx struct {
+	host       string
+	svc        string
+	hashToHost map[[32]byte]string
+	cache      cache.Cache
+	cacheTime  uint
+}
+
+func hostnameToHashes(host string) map[[32]byte]string {
+	hashes := map[[32]byte]string{}
+	tld, icann := publicsuffix.PublicSuffix(host)
+	if !icann {
+		// private suffixes like cloudfront.net
+		tld = ""
+	}
+	curhost := host
+
+	nDots := 0
+	for i := len(curhost) - 1; i >= 0; i-- {
+		if curhost[i] == '.' {
+			nDots++
+			if nDots == 4 {
+				curhost = curhost[i+1:] // "xxx.a.b.c.d" -> "a.b.c.d"
+				break
+			}
+		}
+	}
+
+	for {
+		if curhost == "" {
+			// we've reached end of string
+			break
+		}
+		if tld != "" && curhost == tld {
+			// we've reached the TLD, don't hash it
+			break
+		}
+
+		sum := sha256.Sum256([]byte(curhost))
+		hashes[sum] = curhost
+
+		pos := strings.IndexByte(curhost, byte('.'))
+		if pos < 0 {
+			break
+		}
+		curhost = curhost[pos+1:]
+	}
+	return hashes
+}
+
+// convert hash array to string
+func (c *sbCtx) getQuestion() string {
+	b := &strings.Builder{}
+
+	for hash := range c.hashToHost {
+		// nolint:looppointer // The subsilce is used for safe hex encoding.
+		stringutil.WriteToBuilder(b, hex.EncodeToString(hash[0:2]), ".")
+	}
+
+	if c.svc == "SafeBrowsing" {
+		stringutil.WriteToBuilder(b, sbTXTSuffix)
+
+		return b.String()
+	}
+
+	stringutil.WriteToBuilder(b, pcTXTSuffix)
+
+	return b.String()
+}
+
+// Find the target hash in TXT response
+func (c *sbCtx) processTXT(resp *dns.Msg) (bool, [][]byte) {
+	matched := false
+	hashes := [][]byte{}
+	for _, a := range resp.Answer {
+		txt, ok := a.(*dns.TXT)
+		if !ok {
+			continue
+		}
+		log.Debug("%s: received hashes for %s: %v", c.svc, c.host, txt.Txt)
+
+		for _, t := range txt.Txt {
+			if len(t) != 32*2 {
+				continue
+			}
+			hash, err := hex.DecodeString(t)
+			if err != nil {
+				continue
+			}
+
+			hashes = append(hashes, hash)
+
+			if !matched {
+				var hash32 [32]byte
+				copy(hash32[:], hash)
+
+				var hashHost string
+				hashHost, ok = c.hashToHost[hash32]
+				if ok {
+					log.Debug("%s: matched %s by %s/%s", c.svc, c.host, hashHost, t)
+					matched = true
+				}
+			}
+		}
+	}
+
+	return matched, hashes
+}
+
+func (c *sbCtx) storeCache(hashes [][]byte) {
+	slices.SortFunc(hashes, func(a, b []byte) (sortsBefore bool) {
+		return bytes.Compare(a, b) == -1
+	})
+
+	var curData []byte
+	var prevPrefix []byte
+	for i, hash := range hashes {
+		// nolint:looppointer // The subsilce is used for a safe comparison.
+		if !bytes.Equal(hash[0:2], prevPrefix) {
+			if i != 0 {
+				c.setCache(prevPrefix, curData)
+				curData = nil
+			}
+			prevPrefix = hashes[i][0:2]
+		}
+		curData = append(curData, hash...)
+	}
+
+	if len(prevPrefix) != 0 {
+		c.setCache(prevPrefix, curData)
+	}
+
+	for hash := range c.hashToHost {
+		// nolint:looppointer // The subsilce is used for a safe cache lookup.
+		prefix := hash[0:2]
+		val := c.cache.Get(prefix)
+		if val == nil {
+			c.setCache(prefix, nil)
+		}
+	}
+}
+
+func check(c *sbCtx, r Result, u upstream.Upstream) (Result, error) {
+	c.hashToHost = hostnameToHashes(c.host)
+	switch c.getCached() {
+	case -1:
+		return Result{}, nil
+	case 1:
+		return r, nil
+	}
+
+	question := c.getQuestion()
+
+	log.Tracef("%s: checking %s: %s", c.svc, c.host, question)
+	req := (&dns.Msg{}).SetQuestion(question, dns.TypeTXT)
+
+	resp, err := u.Exchange(req)
+	if err != nil {
+		return Result{}, err
+	}
+
+	matched, receivedHashes := c.processTXT(resp)
+
+	c.storeCache(receivedHashes)
+	if matched {
+		return r, nil
+	}
+
+	return Result{}, nil
+}
+
+// TODO(a.garipov): Unify with checkParental.
+func (d *DNSFilter) checkSafeBrowsing(
+	host string,
+	_ uint16,
+	setts *Settings,
+) (res Result, err error) {
+	if !setts.ProtectionEnabled || !setts.SafeBrowsingEnabled {
+		return Result{}, nil
+	}
+
+	if log.GetLevel() >= log.DEBUG {
+		timer := log.StartTimer()
+		defer timer.LogElapsed("safebrowsing lookup for %q", host)
+	}
+
+	sctx := &sbCtx{
+		host:      host,
+		svc:       "SafeBrowsing",
+		cache:     d.safebrowsingCache,
+		cacheTime: d.Config.CacheTime,
+	}
+
+	res = Result{
+		Rules: []*ResultRule{{
+			Text:         "adguard-malware-shavar",
+			FilterListID: SafeBrowsingListID,
+		}},
+		Reason:     FilteredSafeBrowsing,
+		IsFiltered: true,
+	}
+
+	return check(sctx, res, d.safeBrowsingUpstream)
+}
+
+// TODO(a.garipov): Unify with checkSafeBrowsing.
+func (d *DNSFilter) checkParental(
+	host string,
+	_ uint16,
+	setts *Settings,
+) (res Result, err error) {
+	if !setts.ProtectionEnabled || !setts.ParentalEnabled {
+		return Result{}, nil
+	}
+
+	if log.GetLevel() >= log.DEBUG {
+		timer := log.StartTimer()
+		defer timer.LogElapsed("parental lookup for %q", host)
+	}
+
+	sctx := &sbCtx{
+		host:      host,
+		svc:       "Parental",
+		cache:     d.parentalCache,
+		cacheTime: d.Config.CacheTime,
+	}
+
+	res = Result{
+		Rules: []*ResultRule{{
+			Text:         "parental CATEGORY_BLACKLISTED",
+			FilterListID: ParentalListID,
+		}},
+		Reason:     FilteredParental,
+		IsFiltered: true,
+	}
+
+	return check(sctx, res, d.parentalUpstream)
+}
+
+// setProtectedBool sets the value of a boolean pointer under a lock.  l must
+// protect the value under ptr.
+//
+// TODO(e.burkov):  Make it generic?
+func setProtectedBool(mu *sync.RWMutex, ptr *bool, val bool) {
+	mu.Lock()
+	defer mu.Unlock()
+
+	*ptr = val
+}
+
+// protectedBool gets the value of a boolean pointer under a read lock.  l must
+// protect the value under ptr.
+//
+// TODO(e.burkov):  Make it generic?
+func protectedBool(mu *sync.RWMutex, ptr *bool) (val bool) {
+	mu.RLock()
+	defer mu.RUnlock()
+
+	return *ptr
+}
+
+func (d *DNSFilter) handleSafeBrowsingEnable(w http.ResponseWriter, r *http.Request) {
+	setProtectedBool(&d.confLock, &d.Config.SafeBrowsingEnabled, true)
+	d.Config.ConfigModified()
+}
+
+func (d *DNSFilter) handleSafeBrowsingDisable(w http.ResponseWriter, r *http.Request) {
+	setProtectedBool(&d.confLock, &d.Config.SafeBrowsingEnabled, false)
+	d.Config.ConfigModified()
+}
+
+func (d *DNSFilter) handleSafeBrowsingStatus(w http.ResponseWriter, r *http.Request) {
+	resp := &struct {
+		Enabled bool `json:"enabled"`
+	}{
+		Enabled: protectedBool(&d.confLock, &d.Config.SafeBrowsingEnabled),
+	}
+
+	_ = aghhttp.WriteJSONResponse(w, r, resp)
+}
+
+func (d *DNSFilter) handleParentalEnable(w http.ResponseWriter, r *http.Request) {
+	setProtectedBool(&d.confLock, &d.Config.ParentalEnabled, true)
+	d.Config.ConfigModified()
+}
+
+func (d *DNSFilter) handleParentalDisable(w http.ResponseWriter, r *http.Request) {
+	setProtectedBool(&d.confLock, &d.Config.ParentalEnabled, false)
+	d.Config.ConfigModified()
+}
+
+func (d *DNSFilter) handleParentalStatus(w http.ResponseWriter, r *http.Request) {
+	resp := &struct {
+		Enabled bool `json:"enabled"`
+	}{
+		Enabled: protectedBool(&d.confLock, &d.Config.ParentalEnabled),
+	}
+
+	_ = aghhttp.WriteJSONResponse(w, r, resp)
+}

internal/filtering/safebrowsing_test.go

@@ -0,0 +1,226 @@
+package filtering
+
+import (
+	"crypto/sha256"
+	"strings"
+	"testing"
+
+	"github.com/AdguardTeam/AdGuardHome/internal/aghtest"
+	"github.com/AdguardTeam/golibs/cache"
+	"github.com/miekg/dns"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSafeBrowsingHash(t *testing.T) {
+	// test hostnameToHashes()
+	hashes := hostnameToHashes("1.2.3.sub.host.com")
+	assert.Len(t, hashes, 3)
+	_, ok := hashes[sha256.Sum256([]byte("3.sub.host.com"))]
+	assert.True(t, ok)
+	_, ok = hashes[sha256.Sum256([]byte("sub.host.com"))]
+	assert.True(t, ok)
+	_, ok = hashes[sha256.Sum256([]byte("host.com"))]
+	assert.True(t, ok)
+	_, ok = hashes[sha256.Sum256([]byte("com"))]
+	assert.False(t, ok)
+
+	c := &sbCtx{
+		svc:        "SafeBrowsing",
+		hashToHost: hashes,
+	}
+
+	q := c.getQuestion()
+
+	assert.Contains(t, q, "7a1b.")
+	assert.Contains(t, q, "af5a.")
+	assert.Contains(t, q, "eb11.")
+	assert.True(t, strings.HasSuffix(q, "sb.dns.adguard.com."))
+}
+
+func TestSafeBrowsingCache(t *testing.T) {
+	c := &sbCtx{
+		svc:       "SafeBrowsing",
+		cacheTime: 100,
+	}
+	conf := cache.Config{}
+	c.cache = cache.New(conf)
+
+	// store in cache hashes for "3.sub.host.com" and "host.com"
+	//  and empty data for hash-prefix for "sub.host.com"
+	hash := sha256.Sum256([]byte("sub.host.com"))
+	c.hashToHost = make(map[[32]byte]string)
+	c.hashToHost[hash] = "sub.host.com"
+	var hashesArray [][]byte
+	hash4 := sha256.Sum256([]byte("3.sub.host.com"))
+	hashesArray = append(hashesArray, hash4[:])
+	hash2 := sha256.Sum256([]byte("host.com"))
+	hashesArray = append(hashesArray, hash2[:])
+	c.storeCache(hashesArray)
+
+	// match "3.sub.host.com" or "host.com" from cache
+	c.hashToHost = make(map[[32]byte]string)
+	hash = sha256.Sum256([]byte("3.sub.host.com"))
+	c.hashToHost[hash] = "3.sub.host.com"
+	hash = sha256.Sum256([]byte("sub.host.com"))
+	c.hashToHost[hash] = "sub.host.com"
+	hash = sha256.Sum256([]byte("host.com"))
+	c.hashToHost[hash] = "host.com"
+	assert.Equal(t, 1, c.getCached())
+
+	// match "sub.host.com" from cache
+	c.hashToHost = make(map[[32]byte]string)
+	hash = sha256.Sum256([]byte("sub.host.com"))
+	c.hashToHost[hash] = "sub.host.com"
+	assert.Equal(t, -1, c.getCached())
+
+	// Match "sub.host.com" from cache.  Another hash for "host.example" is not
+	// in the cache, so get data for it from the server.
+	c.hashToHost = make(map[[32]byte]string)
+	hash = sha256.Sum256([]byte("sub.host.com"))
+	c.hashToHost[hash] = "sub.host.com"
+	hash = sha256.Sum256([]byte("host.example"))
+	c.hashToHost[hash] = "host.example"
+	assert.Empty(t, c.getCached())
+
+	hash = sha256.Sum256([]byte("sub.host.com"))
+	_, ok := c.hashToHost[hash]
+	assert.False(t, ok)
+
+	hash = sha256.Sum256([]byte("host.example"))
+	_, ok = c.hashToHost[hash]
+	assert.True(t, ok)
+
+	c = &sbCtx{
+		svc:       "SafeBrowsing",
+		cacheTime: 100,
+	}
+	conf = cache.Config{}
+	c.cache = cache.New(conf)
+
+	hash = sha256.Sum256([]byte("sub.host.com"))
+	c.hashToHost = make(map[[32]byte]string)
+	c.hashToHost[hash] = "sub.host.com"
+
+	c.cache.Set(hash[0:2], make([]byte, 32))
+	assert.Empty(t, c.getCached())
+}
+
+func TestSBPC_checkErrorUpstream(t *testing.T) {
+	d, _ := newForTest(t, &Config{SafeBrowsingEnabled: true}, nil)
+	t.Cleanup(d.Close)
+
+	ups := aghtest.NewErrorUpstream()
+	d.SetSafeBrowsingUpstream(ups)
+	d.SetParentalUpstream(ups)
+
+	setts := &Settings{
+		ProtectionEnabled:   true,
+		SafeBrowsingEnabled: true,
+		ParentalEnabled:     true,
+	}
+
+	_, err := d.checkSafeBrowsing("smthng.com", dns.TypeA, setts)
+	assert.Error(t, err)
+
+	_, err = d.checkParental("smthng.com", dns.TypeA, setts)
+	assert.Error(t, err)
+}
+
+func TestSBPC(t *testing.T) {
+	d, _ := newForTest(t, &Config{SafeBrowsingEnabled: true}, nil)
+	t.Cleanup(d.Close)
+
+	const hostname = "example.org"
+
+	setts := &Settings{
+		ProtectionEnabled:   true,
+		SafeBrowsingEnabled: true,
+		ParentalEnabled:     true,
+	}
+
+	testCases := []struct {
+		testCache cache.Cache
+		testFunc  func(host string, _ uint16, _ *Settings) (res Result, err error)
+		name      string
+		block     bool
+	}{{
+		testCache: d.safebrowsingCache,
+		testFunc:  d.checkSafeBrowsing,
+		name:      "sb_no_block",
+		block:     false,
+	}, {
+		testCache: d.safebrowsingCache,
+		testFunc:  d.checkSafeBrowsing,
+		name:      "sb_block",
+		block:     true,
+	}, {
+		testCache: d.parentalCache,
+		testFunc:  d.checkParental,
+		name:      "pc_no_block",
+		block:     false,
+	}, {
+		testCache: d.parentalCache,
+		testFunc:  d.checkParental,
+		name:      "pc_block",
+		block:     true,
+	}}
+
+	for _, tc := range testCases {
+		// Prepare the upstream.
+		ups := aghtest.NewBlockUpstream(hostname, tc.block)
+
+		var numReq int
+		onExchange := ups.OnExchange
+		ups.OnExchange = func(req *dns.Msg) (resp *dns.Msg, err error) {
+			numReq++
+
+			return onExchange(req)
+		}
+
+		d.SetSafeBrowsingUpstream(ups)
+		d.SetParentalUpstream(ups)
+
+		t.Run(tc.name, func(t *testing.T) {
+			// Firstly, check the request blocking.
+			hits := 0
+			res, err := tc.testFunc(hostname, dns.TypeA, setts)
+			require.NoError(t, err)
+
+			if tc.block {
+				assert.True(t, res.IsFiltered)
+				require.Len(t, res.Rules, 1)
+				hits++
+			} else {
+				require.False(t, res.IsFiltered)
+			}
+
+			// Check the cache state, check the response is now cached.
+			assert.Equal(t, 1, tc.testCache.Stats().Count)
+			assert.Equal(t, hits, tc.testCache.Stats().Hit)
+
+			// There was one request to an upstream.
+			assert.Equal(t, 1, numReq)
+
+			// Now make the same request to check the cache was used.
+			res, err = tc.testFunc(hostname, dns.TypeA, setts)
+			require.NoError(t, err)
+
+			if tc.block {
+				assert.True(t, res.IsFiltered)
+				require.Len(t, res.Rules, 1)
+			} else {
+				require.False(t, res.IsFiltered)
+			}
+
+			// Check the cache state, it should've been used.
+			assert.Equal(t, 1, tc.testCache.Stats().Count)
+			assert.Equal(t, hits+1, tc.testCache.Stats().Hit)
+
+			// Check that there were no additional requests.
+			assert.Equal(t, 1, numReq)
+		})
+
+		purgeCaches(d)
+	}
+}

internal/home/config.go

@@ -399,39 +399,19 @@ func (c *configuration) getConfigFilename() string {
 	return configFile
 }
 
-// readLogSettings reads logging settings from the config file.  We do it in a
-// separate method in order to configure logger before the actual configuration
-// is parsed and applied.
-func readLogSettings() (ls *logSettings) {
-	ls = &logSettings{}
-
+// getLogSettings reads logging settings from the config file.
+// we do it in a separate method in order to configure logger before the actual configuration is parsed and applied.
+func getLogSettings() logSettings {
+	l := logSettings{}
 	yamlFile, err := readConfigFile()
 	if err != nil {
-		return ls
+		return l
 	}
-
-	err = yaml.Unmarshal(yamlFile, ls)
+	err = yaml.Unmarshal(yamlFile, &l)
 	if err != nil {
 		log.Error("Couldn't get logging settings from the configuration: %s", err)
 	}
-
-	return ls
-}
-
-// validateBindHosts returns error if any of binding hosts from configuration is
-// not a valid IP address.
-func validateBindHosts(conf *configuration) (err error) {
-	if !conf.BindHost.IsValid() {
-		return errors.Error("bind_host is not a valid ip address")
-	}
-
-	for i, addr := range conf.DNS.BindHosts {
-		if !addr.IsValid() {
-			return fmt.Errorf("dns.bind_hosts at index %d is not a valid ip address", i)
-		}
-	}
-
-	return nil
+	return l
 }
 
 // parseConfig loads configuration from the YAML file
@@ -445,13 +425,6 @@ func parseConfig() (err error) {
 	config.fileData = nil
 	err = yaml.Unmarshal(fileData, &config)
 	if err != nil {
-		// Don't wrap the error since it's informative enough as is.
-		return err
-	}
-
-	err = validateBindHosts(config)
-	if err != nil {
-		// Don't wrap the error since it's informative enough as is.
 		return err
 	}
 

internal/home/control.go

@@ -180,7 +180,7 @@ func registerControlHandlers() {
 	httpRegister(http.MethodGet, "/control/status", handleStatus)
 	httpRegister(http.MethodPost, "/control/i18n/change_language", handleI18nChangeLanguage)
 	httpRegister(http.MethodGet, "/control/i18n/current_language", handleI18nCurrentLanguage)
-	Context.mux.HandleFunc("/control/version.json", postInstall(optionalAuth(handleVersionJSON)))
+	Context.mux.HandleFunc("/control/version.json", postInstall(optionalAuth(handleGetVersionJSON)))
 	httpRegister(http.MethodPost, "/control/update", handleUpdate)
 	httpRegister(http.MethodGet, "/control/profile", handleGetProfile)
 	httpRegister(http.MethodPut, "/control/profile/update", handlePutProfile)

internal/home/controlupdate.go

@@ -26,14 +26,15 @@ type temporaryError interface {
 	Temporary() (ok bool)
 }
 
-// handleVersionJSON is the handler for the POST /control/version.json HTTP API.
-//
-// TODO(a.garipov): Find out if this API used with a GET method by anyone.
-func handleVersionJSON(w http.ResponseWriter, r *http.Request) {
+// Get the latest available version from the Internet
+func handleGetVersionJSON(w http.ResponseWriter, r *http.Request) {
 	resp := &versionResponse{}
 	if Context.disableUpdate {
 		resp.Disabled = true
-		_ = aghhttp.WriteJSONResponse(w, r, resp)
+		err := json.NewEncoder(w).Encode(resp)
+		if err != nil {
+			aghhttp.Error(r, w, http.StatusInternalServerError, "writing body: %s", err)
+		}
 
 		return
 	}

internal/home/home.go

@@ -27,17 +27,14 @@ import (
 	"github.com/AdguardTeam/AdGuardHome/internal/dhcpd"
 	"github.com/AdguardTeam/AdGuardHome/internal/dnsforward"
 	"github.com/AdguardTeam/AdGuardHome/internal/filtering"
-	"github.com/AdguardTeam/AdGuardHome/internal/filtering/hashprefix"
 	"github.com/AdguardTeam/AdGuardHome/internal/filtering/safesearch"
 	"github.com/AdguardTeam/AdGuardHome/internal/querylog"
 	"github.com/AdguardTeam/AdGuardHome/internal/stats"
 	"github.com/AdguardTeam/AdGuardHome/internal/updater"
 	"github.com/AdguardTeam/AdGuardHome/internal/version"
-	"github.com/AdguardTeam/dnsproxy/upstream"
 	"github.com/AdguardTeam/golibs/errors"
 	"github.com/AdguardTeam/golibs/log"
 	"github.com/AdguardTeam/golibs/netutil"
-	"github.com/AdguardTeam/golibs/stringutil"
 	"golang.org/x/exp/slices"
 	"gopkg.in/natefinch/lumberjack.v2"
 )
@@ -146,9 +143,7 @@ func Main(clientBuildFS fs.FS) {
 	run(opts, clientBuildFS)
 }
 
-// setupContext initializes [Context] fields.  It also reads and upgrades
-// config file if necessary.
-func setupContext(opts options) (err error) {
+func setupContext(opts options) {
 	setupContextFlags(opts)
 
 	Context.tlsRoots = aghtls.SystemRootCAs()
@@ -165,15 +160,10 @@ func setupContext(opts options) (err error) {
 		},
 	}
 
-	Context.mux = http.NewServeMux()
-
 	if !Context.firstRun {
 		// Do the upgrade if necessary.
-		err = upgradeConfig()
-		if err != nil {
-			// Don't wrap the error, because it's informative enough as is.
-			return err
-		}
+		err := upgradeConfig()
+		fatalOnError(err)
 
 		if err = parseConfig(); err != nil {
 			log.Error("parsing configuration file: %s", err)
@@ -189,14 +179,11 @@ func setupContext(opts options) (err error) {
 
 		if !opts.noEtcHosts && config.Clients.Sources.HostsFile {
 			err = setupHostsContainer()
-			if err != nil {
-				// Don't wrap the error, because it's informative enough as is.
-				return err
-			}
+			fatalOnError(err)
 		}
 	}
 
-	return nil
+	Context.mux = http.NewServeMux()
 }
 
 // setupContextFlags sets global flags and prints their status to the log.
@@ -298,27 +285,25 @@ func setupHostsContainer() (err error) {
 	return nil
 }
 
-// setupOpts sets up command-line options.
-func setupOpts(opts options) (err error) {
-	err = setupBindOpts(opts)
+func setupConfig(opts options) (err error) {
+	config.DNS.DnsfilterConf.EtcHosts = Context.etcHosts
+	config.DNS.DnsfilterConf.ConfigModified = onConfigModified
+	config.DNS.DnsfilterConf.HTTPRegister = httpRegister
+	config.DNS.DnsfilterConf.DataDir = Context.getDataDir()
+	config.DNS.DnsfilterConf.Filters = slices.Clone(config.Filters)
+	config.DNS.DnsfilterConf.WhitelistFilters = slices.Clone(config.WhitelistFilters)
+	config.DNS.DnsfilterConf.UserRules = slices.Clone(config.UserRules)
+	config.DNS.DnsfilterConf.HTTPClient = Context.client
+
+	config.DNS.DnsfilterConf.SafeSearchConf.CustomResolver = safeSearchResolver{}
+	config.DNS.DnsfilterConf.SafeSearch, err = safesearch.NewDefault(
+		config.DNS.DnsfilterConf.SafeSearchConf,
+		"default",
+		config.DNS.DnsfilterConf.SafeSearchCacheSize,
+		time.Minute*time.Duration(config.DNS.DnsfilterConf.CacheTime),
+	)
 	if err != nil {
-		// Don't wrap the error, because it's informative enough as is.
-		return err
-	}
-
-	if len(opts.pidFile) != 0 && writePIDFile(opts.pidFile) {
-		Context.pidFileName = opts.pidFile
-	}
-
-	return nil
-}
-
-// initContextClients initializes Context clients and related fields.
-func initContextClients() (err error) {
-	err = setupDNSFilteringConf(config.DNS.DnsfilterConf)
-	if err != nil {
-		// Don't wrap the error, because it's informative enough as is.
-		return err
+		return fmt.Errorf("initializing safesearch: %w", err)
 	}
 
 	//lint:ignore SA1019  Migration is not over.
@@ -353,19 +338,8 @@ func initContextClients() (err error) {
 		arpdb = aghnet.NewARPDB()
 	}
 
-	Context.clients.Init(
-		config.Clients.Persistent,
-		Context.dhcpServer,
-		Context.etcHosts,
-		arpdb,
-		config.DNS.DnsfilterConf,
-	)
+	Context.clients.Init(config.Clients.Persistent, Context.dhcpServer, Context.etcHosts, arpdb, config.DNS.DnsfilterConf)
 
-	return nil
-}
-
-// setupBindOpts overrides bind host/port from the opts.
-func setupBindOpts(opts options) (err error) {
 	if opts.bindPort != 0 {
 		config.BindPort = opts.bindPort
 
@@ -376,83 +350,12 @@ func setupBindOpts(opts options) (err error) {
 		}
 	}
 
+	// override bind host/port from the console
 	if opts.bindHost.IsValid() {
 		config.BindHost = opts.bindHost
 	}
-
-	return nil
-}
-
-// setupDNSFilteringConf sets up DNS filtering configuration settings.
-func setupDNSFilteringConf(conf *filtering.Config) (err error) {
-	const (
-		dnsTimeout = 3 * time.Second
-
-		sbService                 = "safe browsing"
-		defaultSafeBrowsingServer = `https://family.adguard-dns.com/dns-query`
-		sbTXTSuffix               = `sb.dns.adguard.com.`
-
-		pcService             = "parental control"
-		defaultParentalServer = `https://family.adguard-dns.com/dns-query`
-		pcTXTSuffix           = `pc.dns.adguard.com.`
-	)
-
-	conf.EtcHosts = Context.etcHosts
-	conf.ConfigModified = onConfigModified
-	conf.HTTPRegister = httpRegister
-	conf.DataDir = Context.getDataDir()
-	conf.Filters = slices.Clone(config.Filters)
-	conf.WhitelistFilters = slices.Clone(config.WhitelistFilters)
-	conf.UserRules = slices.Clone(config.UserRules)
-	conf.HTTPClient = Context.client
-
-	cacheTime := time.Duration(conf.CacheTime) * time.Minute
-
-	upsOpts := &upstream.Options{
-		Timeout: dnsTimeout,
-		ServerIPAddrs: []net.IP{
-			{94, 140, 14, 15},
-			{94, 140, 15, 16},
-			net.ParseIP("2a10:50c0::bad1:ff"),
-			net.ParseIP("2a10:50c0::bad2:ff"),
-		},
-	}
-
-	sbUps, err := upstream.AddressToUpstream(defaultSafeBrowsingServer, upsOpts)
-	if err != nil {
-		return fmt.Errorf("converting safe browsing server: %w", err)
-	}
-
-	conf.SafeBrowsingChecker = hashprefix.New(&hashprefix.Config{
-		Upstream:    sbUps,
-		ServiceName: sbService,
-		TXTSuffix:   sbTXTSuffix,
-		CacheTime:   cacheTime,
-		CacheSize:   conf.SafeBrowsingCacheSize,
-	})
-
-	parUps, err := upstream.AddressToUpstream(defaultParentalServer, upsOpts)
-	if err != nil {
-		return fmt.Errorf("converting parental server: %w", err)
-	}
-
-	conf.ParentalControlChecker = hashprefix.New(&hashprefix.Config{
-		Upstream:    parUps,
-		ServiceName: pcService,
-		TXTSuffix:   pcTXTSuffix,
-		CacheTime:   cacheTime,
-		CacheSize:   conf.SafeBrowsingCacheSize,
-	})
-
-	conf.SafeSearchConf.CustomResolver = safeSearchResolver{}
-	conf.SafeSearch, err = safesearch.NewDefault(
-		conf.SafeSearchConf,
-		"default",
-		conf.SafeSearchCacheSize,
-		cacheTime,
-	)
-	if err != nil {
-		return fmt.Errorf("initializing safesearch: %w", err)
+	if len(opts.pidFile) != 0 && writePIDFile(opts.pidFile) {
+		Context.pidFileName = opts.pidFile
 	}
 
 	return nil
@@ -529,16 +432,14 @@ func fatalOnError(err error) {
 
 // run configures and starts AdGuard Home.
 func run(opts options, clientBuildFS fs.FS) {
-	// Configure config filename.
+	// configure config filename
 	initConfigFilename(opts)
 
-	// Configure working dir and config path.
-	err := initWorkingDir(opts)
-	fatalOnError(err)
+	// configure working dir and config path
+	initWorkingDir(opts)
 
-	// Configure log level and output.
-	err = configureLogger(opts)
-	fatalOnError(err)
+	// configure log level and output
+	configureLogger(opts)
 
 	// Print the first message after logger is configured.
 	log.Info(version.Full())
@@ -547,29 +448,25 @@ func run(opts options, clientBuildFS fs.FS) {
 		log.Info("AdGuard Home is running as a service")
 	}
 
-	err = setupContext(opts)
+	setupContext(opts)
+
+	err := configureOS(config)
 	fatalOnError(err)
 
-	err = configureOS(config)
-	fatalOnError(err)
-
-	// Clients package uses filtering package's static data
-	// (filtering.BlockedSvcKnown()), so we have to initialize filtering static
-	// data first, but also to avoid relying on automatic Go init() function.
+	// clients package uses filtering package's static data (filtering.BlockedSvcKnown()),
+	//  so we have to initialize filtering's static data first,
+	//  but also avoid relying on automatic Go init() function
 	filtering.InitModule()
 
-	err = initContextClients()
+	err = setupConfig(opts)
 	fatalOnError(err)
 
-	err = setupOpts(opts)
-	fatalOnError(err)
-
-	// TODO(e.burkov): This could be made earlier, probably as the option's
+	// TODO(e.burkov):  This could be made earlier, probably as the option's
 	// effect.
 	cmdlineUpdate(opts)
 
 	if !Context.firstRun {
-		// Save the updated config.
+		// Save the updated config
 		err = config.write()
 		fatalOnError(err)
 
@@ -579,15 +476,33 @@ func run(opts options, clientBuildFS fs.FS) {
 		}
 	}
 
-	dir := Context.getDataDir()
-	err = os.MkdirAll(dir, 0o755)
-	fatalOnError(errors.Annotate(err, "creating DNS data dir at %s: %w", dir))
+	err = os.MkdirAll(Context.getDataDir(), 0o755)
+	if err != nil {
+		log.Fatalf("Cannot create DNS data dir at %s: %s", Context.getDataDir(), err)
+	}
 
+	sessFilename := filepath.Join(Context.getDataDir(), "sessions.db")
 	GLMode = opts.glinetMode
+	var rateLimiter *authRateLimiter
+	if config.AuthAttempts > 0 && config.AuthBlockMin > 0 {
+		rateLimiter = newAuthRateLimiter(
+			time.Duration(config.AuthBlockMin)*time.Minute,
+			config.AuthAttempts,
+		)
+	} else {
+		log.Info("authratelimiter is disabled")
+	}
 
-	// Init auth module.
-	Context.auth, err = initUsers()
-	fatalOnError(err)
+	Context.auth = InitAuth(
+		sessFilename,
+		config.Users,
+		config.WebSessionTTLHours*60*60,
+		rateLimiter,
+	)
+	if Context.auth == nil {
+		log.Fatalf("Couldn't initialize Auth module")
+	}
+	config.Users = nil
 
 	Context.tls, err = newTLSManager(config.TLS)
 	if err != nil {
@@ -605,10 +520,10 @@ func run(opts options, clientBuildFS fs.FS) {
 		Context.tls.start()
 
 		go func() {
-			sErr := startDNSServer()
-			if sErr != nil {
+			serr := startDNSServer()
+			if serr != nil {
 				closeDNSServer()
-				fatalOnError(sErr)
+				fatalOnError(serr)
 			}
 		}()
 
@@ -622,33 +537,10 @@ func run(opts options, clientBuildFS fs.FS) {
 
 	Context.web.start()
 
-	// Wait indefinitely for other goroutines to complete their job.
+	// wait indefinitely for other go-routines to complete their job
 	select {}
 }
 
-// initUsers initializes context auth module.  Clears config users field.
-func initUsers() (auth *Auth, err error) {
-	sessFilename := filepath.Join(Context.getDataDir(), "sessions.db")
-
-	var rateLimiter *authRateLimiter
-	if config.AuthAttempts > 0 && config.AuthBlockMin > 0 {
-		blockDur := time.Duration(config.AuthBlockMin) * time.Minute
-		rateLimiter = newAuthRateLimiter(blockDur, config.AuthAttempts)
-	} else {
-		log.Info("authratelimiter is disabled")
-	}
-
-	sessionTTL := config.WebSessionTTLHours * 60 * 60
-	auth = InitAuth(sessFilename, config.Users, sessionTTL, rateLimiter)
-	if auth == nil {
-		return nil, errors.Error("initializing auth module failed")
-	}
-
-	config.Users = nil
-
-	return auth, nil
-}
-
 func (c *configuration) anonymizer() (ipmut *aghnet.IPMut) {
 	var anonFunc aghnet.IPMutFunc
 	if c.DNS.AnonymizeClientIP {
@@ -721,19 +613,22 @@ func writePIDFile(fn string) bool {
 	return true
 }
 
-// initConfigFilename sets up context config file path.  This file path can be
-// overridden by command-line arguments, or is set to default.
 func initConfigFilename(opts options) {
-	Context.configFilename = stringutil.Coalesce(opts.confFilename, "AdGuardHome.yaml")
+	// config file path can be overridden by command-line arguments:
+	if opts.confFilename != "" {
+		Context.configFilename = opts.confFilename
+	} else {
+		// Default config file name
+		Context.configFilename = "AdGuardHome.yaml"
+	}
 }
 
-// initWorkingDir initializes the workDir.  If no command-line arguments are
-// specified, the directory with the binary file is used.
-func initWorkingDir(opts options) (err error) {
+// initWorkingDir initializes the workDir
+// if no command-line arguments specified, we use the directory where our binary file is located
+func initWorkingDir(opts options) {
 	execPath, err := os.Executable()
 	if err != nil {
-		// Don't wrap the error, because it's informative enough as is.
-		return err
+		panic(err)
 	}
 
 	if opts.workDir != "" {
@@ -745,20 +640,34 @@ func initWorkingDir(opts options) (err error) {
 
 	workDir, err := filepath.EvalSymlinks(Context.workDir)
 	if err != nil {
-		// Don't wrap the error, because it's informative enough as is.
-		return err
+		panic(err)
 	}
 
 	Context.workDir = workDir
-
-	return nil
 }
 
-// configureLogger configures logger level and output.
-func configureLogger(opts options) (err error) {
-	ls := getLogSettings(opts)
+// configureLogger configures logger level and output
+func configureLogger(opts options) {
+	ls := getLogSettings()
 
-	// Configure logger level.
+	// command-line arguments can override config settings
+	if opts.verbose || config.Verbose {
+		ls.Verbose = true
+	}
+	if opts.logFile != "" {
+		ls.File = opts.logFile
+	} else if config.File != "" {
+		ls.File = config.File
+	}
+
+	// Handle default log settings overrides
+	ls.Compress = config.Compress
+	ls.LocalTime = config.LocalTime
+	ls.MaxBackups = config.MaxBackups
+	ls.MaxSize = config.MaxSize
+	ls.MaxAge = config.MaxAge
+
+	// log.SetLevel(log.INFO) - default
 	if ls.Verbose {
 		log.SetLevel(log.DEBUG)
 	}
@@ -767,63 +676,38 @@ func configureLogger(opts options) (err error) {
 	// happen pretty quickly.
 	log.SetFlags(log.LstdFlags | log.Lmicroseconds)
 
-	// Write logs to stdout by default.
-	if ls.File == "" {
-		return nil
-	}
-
-	if ls.File == configSyslog {
-		// Use syslog where it is possible and eventlog on Windows.
-		err = aghos.ConfigureSyslog(serviceName)
-		if err != nil {
-			return fmt.Errorf("cannot initialize syslog: %w", err)
-		}
-
-		return nil
-	}
-
-	logFilePath := ls.File
-	if !filepath.IsAbs(logFilePath) {
-		logFilePath = filepath.Join(Context.workDir, logFilePath)
-	}
-
-	log.SetOutput(&lumberjack.Logger{
-		Filename:   logFilePath,
-		Compress:   ls.Compress,
-		LocalTime:  ls.LocalTime,
-		MaxBackups: ls.MaxBackups,
-		MaxSize:    ls.MaxSize,
-		MaxAge:     ls.MaxAge,
-	})
-
-	return nil
-}
-
-// getLogSettings returns a log settings object properly initialized from opts.
-func getLogSettings(opts options) (ls *logSettings) {
-	ls = readLogSettings()
-
-	// Command-line arguments can override config settings.
-	if opts.verbose || config.Verbose {
-		ls.Verbose = true
-	}
-
-	ls.File = stringutil.Coalesce(opts.logFile, config.File, ls.File)
-
-	// Handle default log settings overrides.
-	ls.Compress = config.Compress
-	ls.LocalTime = config.LocalTime
-	ls.MaxBackups = config.MaxBackups
-	ls.MaxSize = config.MaxSize
-	ls.MaxAge = config.MaxAge
-
 	if opts.runningAsService && ls.File == "" && runtime.GOOS == "windows" {
-		// When running as a Windows service, use eventlog by default if
-		// nothing else is configured.  Otherwise, we'll lose the log output.
+		// When running as a Windows service, use eventlog by default if nothing
+		// else is configured.  Otherwise, we'll simply lose the log output.
 		ls.File = configSyslog
 	}
 
-	return ls
+	// logs are written to stdout (default)
+	if ls.File == "" {
+		return
+	}
+
+	if ls.File == configSyslog {
+		// Use syslog where it is possible and eventlog on Windows
+		err := aghos.ConfigureSyslog(serviceName)
+		if err != nil {
+			log.Fatalf("cannot initialize syslog: %s", err)
+		}
+	} else {
+		logFilePath := ls.File
+		if !filepath.IsAbs(logFilePath) {
+			logFilePath = filepath.Join(Context.workDir, logFilePath)
+		}
+
+		log.SetOutput(&lumberjack.Logger{
+			Filename:   logFilePath,
+			Compress:   ls.Compress, // disabled by default
+			LocalTime:  ls.LocalTime,
+			MaxBackups: ls.MaxBackups,
+			MaxSize:    ls.MaxSize, // megabytes
+			MaxAge:     ls.MaxAge,  // days
+		})
+	}
 }
 
 // cleanup stops and resets all the modules.

internal/home/service.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"io/fs"
 	"os"
+	"path/filepath"
 	"runtime"
 	"strconv"
 	"strings"
@@ -83,9 +84,14 @@ func svcStatus(s service.Service) (status service.Status, err error) {
 // On OpenWrt, the service utility may not exist.  We use our service script
 // directly in this case.
 func svcAction(s service.Service, action string) (err error) {
-	if action == "start" {
-		if err = aghos.PreCheckActionStart(); err != nil {
-			log.Error("starting service: %s", err)
+	if runtime.GOOS == "darwin" && action == "start" {
+		var exe string
+		if exe, err = os.Executable(); err != nil {
+			log.Error("starting service: getting executable path: %s", err)
+		} else if exe, err = filepath.EvalSymlinks(exe); err != nil {
+			log.Error("starting service: evaluating executable symlinks: %s", err)
+		} else if !strings.HasPrefix(exe, "/Applications/") {
+			log.Info("warning: service must be started from within the /Applications directory")
 		}
 	}
 
@@ -93,6 +99,8 @@ func svcAction(s service.Service, action string) (err error) {
 	if err != nil && service.Platform() == "unix-systemv" &&
 		(action == "start" || action == "stop" || action == "restart") {
 		_, err = runInitdCommand(action)
+
+		return err
 	}
 
 	return err
@@ -216,7 +224,6 @@ func handleServiceControlAction(opts options, clientBuildFS fs.FS) {
 
 	runOpts := opts
 	runOpts.serviceControlAction = "run"
-
 	svcConfig := &service.Config{
 		Name:             serviceName,
 		DisplayName:      serviceDisplayName,
@@ -226,48 +233,35 @@ func handleServiceControlAction(opts options, clientBuildFS fs.FS) {
 	}
 	configureService(svcConfig)
 
-	s, err := service.New(&program{clientBuildFS: clientBuildFS, opts: runOpts}, svcConfig)
-	if err != nil {
+	prg := &program{
+		clientBuildFS: clientBuildFS,
+		opts:          runOpts,
+	}
+	var s service.Service
+	if s, err = service.New(prg, svcConfig); err != nil {
 		log.Fatalf("service: initializing service: %s", err)
 	}
 
-	err = handleServiceCommand(s, action, opts)
-	if err != nil {
-		log.Fatalf("service: %s", err)
-	}
-
-	log.Printf(
-		"service: action %s has been done successfully on %s",
-		action,
-		service.ChosenSystem(),
-	)
-}
-
-// handleServiceCommand handles service command.
-func handleServiceCommand(s service.Service, action string, opts options) (err error) {
 	switch action {
 	case "status":
 		handleServiceStatusCommand(s)
 	case "run":
 		if err = s.Run(); err != nil {
-			return fmt.Errorf("failed to run service: %w", err)
+			log.Fatalf("service: failed to run service: %s", err)
 		}
 	case "install":
 		initConfigFilename(opts)
-		if err = initWorkingDir(opts); err != nil {
-			return fmt.Errorf("failed to init working dir: %w", err)
-		}
-
+		initWorkingDir(opts)
 		handleServiceInstallCommand(s)
 	case "uninstall":
 		handleServiceUninstallCommand(s)
 	default:
 		if err = svcAction(s, action); err != nil {
-			return fmt.Errorf("executing action %q: %w", action, err)
+			log.Fatalf("service: executing action %q: %s", action, err)
 		}
 	}
 
-	return nil
+	log.Printf("service: action %s has been done successfully on %s", action, service.ChosenSystem())
 }
 
 // handleServiceStatusCommand handles service "status" command.

internal/home/tls.go

@@ -172,32 +172,9 @@ func loadTLSConf(tlsConf *tlsConfigSettings, status *tlsConfigStatus) (err error
 		}
 	}()
 
-	err = loadCertificateChainData(tlsConf, status)
-	if err != nil {
-		// Don't wrap the error, because it's informative enough as is.
-		return err
-	}
-
-	err = loadPrivateKeyData(tlsConf, status)
-	if err != nil {
-		// Don't wrap the error, because it's informative enough as is.
-		return err
-	}
-
-	err = validateCertificates(
-		status,
-		tlsConf.CertificateChainData,
-		tlsConf.PrivateKeyData,
-		tlsConf.ServerName,
-	)
-
-	return errors.Annotate(err, "validating certificate pair: %w")
-}
-
-// loadCertificateChainData loads PEM-encoded certificates chain data to the
-// TLS configuration.
-func loadCertificateChainData(tlsConf *tlsConfigSettings, status *tlsConfigStatus) (err error) {
 	tlsConf.CertificateChainData = []byte(tlsConf.CertificateChain)
+	tlsConf.PrivateKeyData = []byte(tlsConf.PrivateKey)
+
 	if tlsConf.CertificatePath != "" {
 		if tlsConf.CertificateChain != "" {
 			return errors.Error("certificate data and file can't be set together")
@@ -213,13 +190,6 @@ func loadCertificateChainData(tlsConf *tlsConfigSettings, status *tlsConfigStatu
 		status.ValidCert = true
 	}
 
-	return nil
-}
-
-// loadPrivateKeyData loads PEM-encoded private key data to the TLS
-// configuration.
-func loadPrivateKeyData(tlsConf *tlsConfigSettings, status *tlsConfigStatus) (err error) {
-	tlsConf.PrivateKeyData = []byte(tlsConf.PrivateKey)
 	if tlsConf.PrivateKeyPath != "" {
 		if tlsConf.PrivateKey != "" {
 			return errors.Error("private key data and file can't be set together")
@@ -233,6 +203,16 @@ func loadPrivateKeyData(tlsConf *tlsConfigSettings, status *tlsConfigStatus) (er
 		status.ValidKey = true
 	}
 
+	err = validateCertificates(
+		status,
+		tlsConf.CertificateChainData,
+		tlsConf.PrivateKeyData,
+		tlsConf.ServerName,
+	)
+	if err != nil {
+		return fmt.Errorf("validating certificate pair: %w", err)
+	}
+
 	return nil
 }
 

internal/home/upgrade.go

@@ -41,8 +41,7 @@ func upgradeConfig() error {
 
 	err = yaml.Unmarshal(body, &diskConf)
 	if err != nil {
-		log.Printf("parsing config file for upgrade: %s", err)
-
+		log.Printf("Couldn't parse config file: %s", err)
 		return err
 	}
 
@@ -294,61 +293,71 @@ func upgradeSchema4to5(diskConf yobj) error {
 	return nil
 }
 
-// upgradeSchema5to6 performs the following changes:
+// clients:
+// ...
 //
-//	# BEFORE:
-//	  'clients':
-//	    ...
-//	    'ip': 127.0.0.1
-//	    'mac': ...
+//	ip: 127.0.0.1
+//	mac: ...
 //
-//	# AFTER:
-//	  'clients':
-//	    ...
-//	    'ids':
-//		  - 127.0.0.1
-//		  - ...
+// ->
+//
+// clients:
+// ...
+//
+//	ids:
+//	- 127.0.0.1
+//	- ...
 func upgradeSchema5to6(diskConf yobj) error {
-	log.Printf("Upgrade yaml: 5 to 6")
+	log.Printf("%s(): called", funcName())
+
 	diskConf["schema_version"] = 6
 
-	clientsVal, ok := diskConf["clients"]
+	clients, ok := diskConf["clients"]
 	if !ok {
 		return nil
 	}
 
-	clients, ok := clientsVal.([]yobj)
-	if !ok {
-		return fmt.Errorf("unexpected type of clients: %T", clientsVal)
-	}
+	switch arr := clients.(type) {
+	case []any:
+		for i := range arr {
+			switch c := arr[i].(type) {
+			case map[any]any:
+				var ipVal any
+				ipVal, ok = c["ip"]
+				ids := []string{}
+				if ok {
+					var ip string
+					ip, ok = ipVal.(string)
+					if !ok {
+						log.Fatalf("client.ip is not a string: %v", ipVal)
+						return nil
+					}
+					if len(ip) != 0 {
+						ids = append(ids, ip)
+					}
+				}
 
-	for i := range clients {
-		c := clients[i]
-		var ids []string
+				var macVal any
+				macVal, ok = c["mac"]
+				if ok {
+					var mac string
+					mac, ok = macVal.(string)
+					if !ok {
+						log.Fatalf("client.mac is not a string: %v", macVal)
+						return nil
+					}
+					if len(mac) != 0 {
+						ids = append(ids, mac)
+					}
+				}
 
-		if ipVal, hasIP := c["ip"]; hasIP {
-			var ip string
-			if ip, ok = ipVal.(string); !ok {
-				return fmt.Errorf("client.ip is not a string: %v", ipVal)
-			}
-
-			if ip != "" {
-				ids = append(ids, ip)
+				c["ids"] = ids
+			default:
+				continue
 			}
 		}
-
-		if macVal, hasMac := c["mac"]; hasMac {
-			var mac string
-			if mac, ok = macVal.(string); !ok {
-				return fmt.Errorf("client.mac is not a string: %v", macVal)
-			}
-
-			if mac != "" {
-				ids = append(ids, mac)
-			}
-		}
-
-		c["ids"] = ids
+	default:
+		return nil
 	}
 
 	return nil

internal/home/upgrade_test.go

@@ -68,95 +68,6 @@ func TestUpgradeSchema2to3(t *testing.T) {
 	assertEqualExcept(t, oldDiskConf, diskConf, excludedEntries, excludedEntries)
 }
 
-func TestUpgradeSchema5to6(t *testing.T) {
-	const newSchemaVer = 6
-
-	testCases := []struct {
-		in      yobj
-		want    yobj
-		wantErr string
-		name    string
-	}{{
-		in: yobj{
-			"clients": []yobj{},
-		},
-		want: yobj{
-			"clients":        []yobj{},
-			"schema_version": newSchemaVer,
-		},
-		wantErr: "",
-		name:    "no_clients",
-	}, {
-		in: yobj{
-			"clients": []yobj{{"ip": "127.0.0.1"}},
-		},
-		want: yobj{
-			"clients": []yobj{{
-				"ids": []string{"127.0.0.1"},
-				"ip":  "127.0.0.1",
-			}},
-			"schema_version": newSchemaVer,
-		},
-		wantErr: "",
-		name:    "client_ip",
-	}, {
-		in: yobj{
-			"clients": []yobj{{"mac": "mac"}},
-		},
-		want: yobj{
-			"clients": []yobj{{
-				"ids": []string{"mac"},
-				"mac": "mac",
-			}},
-			"schema_version": newSchemaVer,
-		},
-		wantErr: "",
-		name:    "client_mac",
-	}, {
-		in: yobj{
-			"clients": []yobj{{"ip": "127.0.0.1", "mac": "mac"}},
-		},
-		want: yobj{
-			"clients": []yobj{{
-				"ids": []string{"127.0.0.1", "mac"},
-				"ip":  "127.0.0.1",
-				"mac": "mac",
-			}},
-			"schema_version": newSchemaVer,
-		},
-		wantErr: "",
-		name:    "client_ip_mac",
-	}, {
-		in: yobj{
-			"clients": []yobj{{"ip": 1, "mac": "mac"}},
-		},
-		want: yobj{
-			"clients":        []yobj{{"ip": 1, "mac": "mac"}},
-			"schema_version": newSchemaVer,
-		},
-		wantErr: "client.ip is not a string: 1",
-		name:    "inv_client_ip",
-	}, {
-		in: yobj{
-			"clients": []yobj{{"ip": "127.0.0.1", "mac": 1}},
-		},
-		want: yobj{
-			"clients":        []yobj{{"ip": "127.0.0.1", "mac": 1}},
-			"schema_version": newSchemaVer,
-		},
-		wantErr: "client.mac is not a string: 1",
-		name:    "inv_client_mac",
-	}}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			err := upgradeSchema5to6(tc.in)
-			testutil.AssertErrorMsg(t, tc.wantErr, err)
-			assert.Equal(t, tc.want, tc.in)
-		})
-	}
-}
-
 func TestUpgradeSchema7to8(t *testing.T) {
 	const host = "1.2.3.4"
 	oldConf := yobj{

internal/next/agh/agh.go

@@ -1,63 +0,0 @@
-// Package agh contains common entities and interfaces of AdGuard Home.
-package agh
-
-import "context"
-
-// Service is the interface for API servers.
-//
-// TODO(a.garipov): Consider adding a context to Start.
-//
-// TODO(a.garipov): Consider adding a Wait method or making an extension
-// interface for that.
-type Service interface {
-	// Start starts the service.  It does not block.
-	Start() (err error)
-
-	// Shutdown gracefully stops the service.  ctx is used to determine
-	// a timeout before trying to stop the service less gracefully.
-	Shutdown(ctx context.Context) (err error)
-}
-
-// type check
-var _ Service = EmptyService{}
-
-// EmptyService is a [Service] that does nothing.
-//
-// TODO(a.garipov): Remove if unnecessary.
-type EmptyService struct{}
-
-// Start implements the [Service] interface for EmptyService.
-func (EmptyService) Start() (err error) { return nil }
-
-// Shutdown implements the [Service] interface for EmptyService.
-func (EmptyService) Shutdown(_ context.Context) (err error) { return nil }
-
-// ServiceWithConfig is an extension of the [Service] interface for services
-// that can return their configuration.
-//
-// TODO(a.garipov): Consider removing this generic interface if we figure out
-// how to make it testable in a better way.
-type ServiceWithConfig[ConfigType any] interface {
-	Service
-
-	Config() (c ConfigType)
-}
-
-// type check
-var _ ServiceWithConfig[struct{}] = (*EmptyServiceWithConfig[struct{}])(nil)
-
-// EmptyServiceWithConfig is a ServiceWithConfig that does nothing.  Its Config
-// method returns Conf.
-//
-// TODO(a.garipov): Remove if unnecessary.
-type EmptyServiceWithConfig[ConfigType any] struct {
-	EmptyService
-
-	Conf ConfigType
-}
-
-// Config implements the [ServiceWithConfig] interface for
-// *EmptyServiceWithConfig.
-func (s *EmptyServiceWithConfig[ConfigType]) Config() (conf ConfigType) {
-	return s.Conf
-}

internal/next/cmd/cmd.go

@@ -1,77 +0,0 @@
-// Package cmd is the AdGuard Home entry point.  It contains the on-disk
-// configuration file utilities, signal processing logic, and so on.
-//
-// TODO(a.garipov): Move to the upper-level internal/.
-package cmd
-
-import (
-	"context"
-	"io/fs"
-	"math/rand"
-	"os"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/next/configmgr"
-	"github.com/AdguardTeam/AdGuardHome/internal/version"
-	"github.com/AdguardTeam/golibs/log"
-)
-
-// Main is the entry point of application.
-func Main(clientBuildFS fs.FS) {
-	// Initial Configuration
-
-	start := time.Now()
-	rand.Seed(start.UnixNano())
-
-	// TODO(a.garipov): Set up logging.
-
-	log.Info("starting adguard home, version %s, pid %d", version.Version(), os.Getpid())
-
-	// Web Service
-
-	// TODO(a.garipov): Use in the Web service.
-	_ = clientBuildFS
-
-	// TODO(a.garipov): Set up configuration file name.
-	const confFile = "AdGuardHome.1.yaml"
-
-	confMgr, err := configmgr.New(confFile, start)
-	fatalOnError(err)
-
-	web := confMgr.Web()
-	err = web.Start()
-	fatalOnError(err)
-
-	dns := confMgr.DNS()
-	err = dns.Start()
-	fatalOnError(err)
-
-	sigHdlr := newSignalHandler(
-		confFile,
-		start,
-		web,
-		dns,
-	)
-
-	go sigHdlr.handle()
-
-	select {}
-}
-
-// defaultTimeout is the timeout used for some operations where another timeout
-// hasn't been defined yet.
-const defaultTimeout = 15 * time.Second
-
-// ctxWithDefaultTimeout is a helper function that returns a context with
-// timeout set to defaultTimeout.
-func ctxWithDefaultTimeout() (ctx context.Context, cancel context.CancelFunc) {
-	return context.WithTimeout(context.Background(), defaultTimeout)
-}
-
-// fatalOnError is a helper that exits the program with an error code if err is
-// not nil.  It must only be used within Main.
-func fatalOnError(err error) {
-	if err != nil {
-		log.Fatal(err)
-	}
-}

internal/next/cmd/signal.go

@@ -1,118 +0,0 @@
-package cmd
-
-import (
-	"os"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/aghos"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/agh"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/configmgr"
-	"github.com/AdguardTeam/golibs/log"
-)
-
-// signalHandler processes incoming signals and shuts services down.
-type signalHandler struct {
-	// signal is the channel to which OS signals are sent.
-	signal chan os.Signal
-
-	// confFile is the path to the configuration file.
-	confFile string
-
-	// start is the time at which AdGuard Home has been started.
-	start time.Time
-
-	// services are the services that are shut down before application exiting.
-	services []agh.Service
-}
-
-// handle processes OS signals.
-func (h *signalHandler) handle() {
-	defer log.OnPanic("signalHandler.handle")
-
-	for sig := range h.signal {
-		log.Info("sighdlr: received signal %q", sig)
-
-		if aghos.IsReconfigureSignal(sig) {
-			h.reconfigure()
-		} else if aghos.IsShutdownSignal(sig) {
-			status := h.shutdown()
-			log.Info("sighdlr: exiting with status %d", status)
-
-			os.Exit(status)
-		}
-	}
-}
-
-// reconfigure rereads the configuration file and updates and restarts services.
-func (h *signalHandler) reconfigure() {
-	log.Info("sighdlr: reconfiguring adguard home")
-
-	status := h.shutdown()
-	if status != statusSuccess {
-		log.Info("sighdlr: reconfiruging: exiting with status %d", status)
-
-		os.Exit(status)
-	}
-
-	// TODO(a.garipov): This is a very rough way to do it.  Some services can be
-	// reconfigured without the full shutdown, and the error handling is
-	// currently not the best.
-
-	confMgr, err := configmgr.New(h.confFile, h.start)
-	fatalOnError(err)
-
-	web := confMgr.Web()
-	err = web.Start()
-	fatalOnError(err)
-
-	dns := confMgr.DNS()
-	err = dns.Start()
-	fatalOnError(err)
-
-	h.services = []agh.Service{
-		dns,
-		web,
-	}
-
-	log.Info("sighdlr: successfully reconfigured adguard home")
-}
-
-// Exit status constants.
-const (
-	statusSuccess = 0
-	statusError   = 1
-)
-
-// shutdown gracefully shuts down all services.
-func (h *signalHandler) shutdown() (status int) {
-	ctx, cancel := ctxWithDefaultTimeout()
-	defer cancel()
-
-	status = statusSuccess
-
-	log.Info("sighdlr: shutting down services")
-	for i, service := range h.services {
-		err := service.Shutdown(ctx)
-		if err != nil {
-			log.Error("sighdlr: shutting down service at index %d: %s", i, err)
-			status = statusError
-		}
-	}
-
-	return status
-}
-
-// newSignalHandler returns a new signalHandler that shuts down svcs.
-func newSignalHandler(confFile string, start time.Time, svcs ...agh.Service) (h *signalHandler) {
-	h = &signalHandler{
-		signal:   make(chan os.Signal, 1),
-		confFile: confFile,
-		start:    start,
-		services: svcs,
-	}
-
-	aghos.NotifyShutdownSignal(h.signal)
-	aghos.NotifyReconfigureSignal(h.signal)
-
-	return h
-}

internal/next/configmgr/config.go

@@ -1,40 +0,0 @@
-package configmgr
-
-import (
-	"net/netip"
-
-	"github.com/AdguardTeam/golibs/timeutil"
-)
-
-// Configuration Structures
-
-// config is the top-level on-disk configuration structure.
-type config struct {
-	DNS  *dnsConfig  `yaml:"dns"`
-	HTTP *httpConfig `yaml:"http"`
-	// TODO(a.garipov): Use.
-	SchemaVersion int `yaml:"schema_version"`
-	// TODO(a.garipov): Use.
-	DebugPprof bool `yaml:"debug_pprof"`
-	Verbose    bool `yaml:"verbose"`
-}
-
-// dnsConfig is the on-disk DNS configuration.
-//
-// TODO(a.garipov): Validate.
-type dnsConfig struct {
-	Addresses       []netip.AddrPort  `yaml:"addresses"`
-	BootstrapDNS    []string          `yaml:"bootstrap_dns"`
-	UpstreamDNS     []string          `yaml:"upstream_dns"`
-	UpstreamTimeout timeutil.Duration `yaml:"upstream_timeout"`
-}
-
-// httpConfig is the on-disk web API configuration.
-//
-// TODO(a.garipov): Validate.
-type httpConfig struct {
-	Addresses       []netip.AddrPort  `yaml:"addresses"`
-	SecureAddresses []netip.AddrPort  `yaml:"secure_addresses"`
-	Timeout         timeutil.Duration `yaml:"timeout"`
-	ForceHTTPS      bool              `yaml:"force_https"`
-}

internal/next/configmgr/configmgr.go

@@ -1,205 +0,0 @@
-// Package configmgr defines the AdGuard Home on-disk configuration entities and
-// configuration manager.
-package configmgr
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"sync"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/next/agh"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/dnssvc"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/websvc"
-	"github.com/AdguardTeam/golibs/errors"
-	"github.com/AdguardTeam/golibs/log"
-	"gopkg.in/yaml.v3"
-)
-
-// Configuration Manager
-
-// Manager handles full and partial changes in the configuration, persisting
-// them to disk if necessary.
-type Manager struct {
-	// updMu makes sure that at most one reconfiguration is performed at a time.
-	// updMu protects all fields below.
-	updMu *sync.RWMutex
-
-	// dns is the DNS service.
-	dns *dnssvc.Service
-
-	// Web is the Web API service.
-	web *websvc.Service
-
-	// current is the current configuration.
-	current *config
-
-	// fileName is the name of the configuration file.
-	fileName string
-}
-
-// New creates a new *Manager that persists changes to the file pointed to by
-// fileName.  It reads the configuration file and populates the service fields.
-// start is the startup time of AdGuard Home.
-func New(fileName string, start time.Time) (m *Manager, err error) {
-	defer func() { err = errors.Annotate(err, "reading config") }()
-
-	conf := &config{}
-	f, err := os.Open(fileName)
-	if err != nil {
-		// Don't wrap the error, because it's informative enough as is.
-		return nil, err
-	}
-	defer func() { err = errors.WithDeferred(err, f.Close()) }()
-
-	err = yaml.NewDecoder(f).Decode(conf)
-	if err != nil {
-		// Don't wrap the error, because it's informative enough as is.
-		return nil, err
-	}
-
-	// TODO(a.garipov): Move into a separate function and add other logging
-	// settings.
-	if conf.Verbose {
-		log.SetLevel(log.DEBUG)
-	}
-
-	// TODO(a.garipov): Validate the configuration structure.  Return an error
-	// if it's incorrect.
-
-	m = &Manager{
-		updMu:    &sync.RWMutex{},
-		current:  conf,
-		fileName: fileName,
-	}
-
-	// TODO(a.garipov): Get the context with the timeout from the arguments?
-	const assemblyTimeout = 5 * time.Second
-	ctx, cancel := context.WithTimeout(context.Background(), assemblyTimeout)
-	defer cancel()
-
-	err = m.assemble(ctx, conf, start)
-	if err != nil {
-		// Don't wrap the error, because it's informative enough as is.
-		return nil, err
-	}
-
-	return m, nil
-}
-
-// assemble creates all services and puts them into the corresponding fields.
-// The fields of conf must not be modified after calling assemble.
-func (m *Manager) assemble(ctx context.Context, conf *config, start time.Time) (err error) {
-	dnsConf := &dnssvc.Config{
-		Addresses:        conf.DNS.Addresses,
-		BootstrapServers: conf.DNS.BootstrapDNS,
-		UpstreamServers:  conf.DNS.UpstreamDNS,
-		UpstreamTimeout:  conf.DNS.UpstreamTimeout.Duration,
-	}
-	err = m.updateDNS(ctx, dnsConf)
-	if err != nil {
-		return fmt.Errorf("assembling dnssvc: %w", err)
-	}
-
-	webSvcConf := &websvc.Config{
-		ConfigManager: m,
-		// TODO(a.garipov): Fill from config file.
-		TLS:             nil,
-		Start:           start,
-		Addresses:       conf.HTTP.Addresses,
-		SecureAddresses: conf.HTTP.SecureAddresses,
-		Timeout:         conf.HTTP.Timeout.Duration,
-		ForceHTTPS:      conf.HTTP.ForceHTTPS,
-	}
-
-	err = m.updateWeb(ctx, webSvcConf)
-	if err != nil {
-		return fmt.Errorf("assembling websvc: %w", err)
-	}
-
-	return nil
-}
-
-// DNS returns the current DNS service.  It is safe for concurrent use.
-func (m *Manager) DNS() (dns agh.ServiceWithConfig[*dnssvc.Config]) {
-	m.updMu.RLock()
-	defer m.updMu.RUnlock()
-
-	return m.dns
-}
-
-// UpdateDNS implements the [websvc.ConfigManager] interface for *Manager.  The
-// fields of c must not be modified after calling UpdateDNS.
-func (m *Manager) UpdateDNS(ctx context.Context, c *dnssvc.Config) (err error) {
-	m.updMu.Lock()
-	defer m.updMu.Unlock()
-
-	// TODO(a.garipov): Update and write the configuration file.  Return an
-	// error if something went wrong.
-
-	err = m.updateDNS(ctx, c)
-	if err != nil {
-		return fmt.Errorf("reassembling dnssvc: %w", err)
-	}
-
-	return nil
-}
-
-// updateDNS recreates the DNS service.  m.updMu is expected to be locked.
-func (m *Manager) updateDNS(ctx context.Context, c *dnssvc.Config) (err error) {
-	if prev := m.dns; prev != nil {
-		err = prev.Shutdown(ctx)
-		if err != nil {
-			return fmt.Errorf("shutting down dns svc: %w", err)
-		}
-	}
-
-	svc, err := dnssvc.New(c)
-	if err != nil {
-		return fmt.Errorf("creating dns svc: %w", err)
-	}
-
-	m.dns = svc
-
-	return nil
-}
-
-// Web returns the current web service.  It is safe for concurrent use.
-func (m *Manager) Web() (web agh.ServiceWithConfig[*websvc.Config]) {
-	m.updMu.RLock()
-	defer m.updMu.RUnlock()
-
-	return m.web
-}
-
-// UpdateWeb implements the [websvc.ConfigManager] interface for *Manager.  The
-// fields of c must not be modified after calling UpdateWeb.
-func (m *Manager) UpdateWeb(ctx context.Context, c *websvc.Config) (err error) {
-	m.updMu.Lock()
-	defer m.updMu.Unlock()
-
-	// TODO(a.garipov): Update and write the configuration file.  Return an
-	// error if something went wrong.
-
-	err = m.updateWeb(ctx, c)
-	if err != nil {
-		return fmt.Errorf("reassembling websvc: %w", err)
-	}
-
-	return nil
-}
-
-// updateWeb recreates the web service.  m.upd is expected to be locked.
-func (m *Manager) updateWeb(ctx context.Context, c *websvc.Config) (err error) {
-	if prev := m.web; prev != nil {
-		err = prev.Shutdown(ctx)
-		if err != nil {
-			return fmt.Errorf("shutting down web svc: %w", err)
-		}
-	}
-
-	m.web = websvc.New(c)
-
-	return nil
-}

internal/next/dnssvc/dnssvc.go

@@ -1,216 +0,0 @@
-// Package dnssvc contains the AdGuard Home DNS service.
-//
-// TODO(a.garipov): Define, if all methods of a *Service should work with a nil
-// receiver.
-package dnssvc
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"net/netip"
-	"sync/atomic"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/next/agh"
-	// TODO(a.garipov): Add a “dnsproxy proxy” package to shield us from changes
-	// and replacement of module dnsproxy.
-	"github.com/AdguardTeam/dnsproxy/proxy"
-	"github.com/AdguardTeam/dnsproxy/upstream"
-)
-
-// Config is the AdGuard Home DNS service configuration structure.
-//
-// TODO(a.garipov): Add timeout for incoming requests.
-type Config struct {
-	// Addresses are the addresses on which to serve plain DNS queries.
-	Addresses []netip.AddrPort
-
-	// Upstreams are the DNS upstreams to use.  If not set, upstreams are
-	// created using data from BootstrapServers, UpstreamServers, and
-	// UpstreamTimeout.
-	//
-	// TODO(a.garipov): Think of a better scheme.  Those other three parameters
-	// are here only to make Config work properly.
-	Upstreams []upstream.Upstream
-
-	// BootstrapServers are the addresses for bootstrapping the upstream DNS
-	// server addresses.
-	BootstrapServers []string
-
-	// UpstreamServers are the upstream DNS server addresses to use.
-	UpstreamServers []string
-
-	// UpstreamTimeout is the timeout for upstream requests.
-	UpstreamTimeout time.Duration
-}
-
-// Service is the AdGuard Home DNS service.  A nil *Service is a valid
-// [agh.Service] that does nothing.
-type Service struct {
-	proxy      *proxy.Proxy
-	bootstraps []string
-	upstreams  []string
-	upsTimeout time.Duration
-	running    atomic.Bool
-}
-
-// New returns a new properly initialized *Service.  If c is nil, svc is a nil
-// *Service that does nothing.  The fields of c must not be modified after
-// calling New.
-func New(c *Config) (svc *Service, err error) {
-	if c == nil {
-		return nil, nil
-	}
-
-	svc = &Service{
-		bootstraps: c.BootstrapServers,
-		upstreams:  c.UpstreamServers,
-		upsTimeout: c.UpstreamTimeout,
-	}
-
-	var upstreams []upstream.Upstream
-	if len(c.Upstreams) > 0 {
-		upstreams = c.Upstreams
-	} else {
-		upstreams, err = addressesToUpstreams(
-			c.UpstreamServers,
-			c.BootstrapServers,
-			c.UpstreamTimeout,
-		)
-		if err != nil {
-			return nil, fmt.Errorf("converting upstreams: %w", err)
-		}
-	}
-
-	svc.proxy = &proxy.Proxy{
-		Config: proxy.Config{
-			UDPListenAddr: udpAddrs(c.Addresses),
-			TCPListenAddr: tcpAddrs(c.Addresses),
-			UpstreamConfig: &proxy.UpstreamConfig{
-				Upstreams: upstreams,
-			},
-		},
-	}
-
-	err = svc.proxy.Init()
-	if err != nil {
-		return nil, fmt.Errorf("proxy: %w", err)
-	}
-
-	return svc, nil
-}
-
-// addressesToUpstreams is a wrapper around [upstream.AddressToUpstream].  It
-// accepts a slice of addresses and other upstream parameters, and returns a
-// slice of upstreams.
-func addressesToUpstreams(
-	upsStrs []string,
-	bootstraps []string,
-	timeout time.Duration,
-) (upstreams []upstream.Upstream, err error) {
-	upstreams = make([]upstream.Upstream, len(upsStrs))
-	for i, upsStr := range upsStrs {
-		upstreams[i], err = upstream.AddressToUpstream(upsStr, &upstream.Options{
-			Bootstrap: bootstraps,
-			Timeout:   timeout,
-		})
-		if err != nil {
-			return nil, fmt.Errorf("upstream at index %d: %w", i, err)
-		}
-	}
-
-	return upstreams, nil
-}
-
-// tcpAddrs converts []netip.AddrPort into []*net.TCPAddr.
-func tcpAddrs(addrPorts []netip.AddrPort) (tcpAddrs []*net.TCPAddr) {
-	if addrPorts == nil {
-		return nil
-	}
-
-	tcpAddrs = make([]*net.TCPAddr, len(addrPorts))
-	for i, a := range addrPorts {
-		tcpAddrs[i] = net.TCPAddrFromAddrPort(a)
-	}
-
-	return tcpAddrs
-}
-
-// udpAddrs converts []netip.AddrPort into []*net.UDPAddr.
-func udpAddrs(addrPorts []netip.AddrPort) (udpAddrs []*net.UDPAddr) {
-	if addrPorts == nil {
-		return nil
-	}
-
-	udpAddrs = make([]*net.UDPAddr, len(addrPorts))
-	for i, a := range addrPorts {
-		udpAddrs[i] = net.UDPAddrFromAddrPort(a)
-	}
-
-	return udpAddrs
-}
-
-// type check
-var _ agh.Service = (*Service)(nil)
-
-// Start implements the [agh.Service] interface for *Service.  svc may be nil.
-// After Start exits, all DNS servers have tried to start, but there is no
-// guarantee that they did.  Errors from the servers are written to the log.
-func (svc *Service) Start() (err error) {
-	if svc == nil {
-		return nil
-	}
-
-	defer func() {
-		// TODO(a.garipov): [proxy.Proxy.Start] doesn't actually have any way to
-		// tell when all servers are actually up, so at best this is merely an
-		// assumption.
-		svc.running.Store(err == nil)
-	}()
-
-	return svc.proxy.Start()
-}
-
-// Shutdown implements the [agh.Service] interface for *Service.  svc may be
-// nil.
-func (svc *Service) Shutdown(ctx context.Context) (err error) {
-	if svc == nil {
-		return nil
-	}
-
-	return svc.proxy.Stop()
-}
-
-// Config returns the current configuration of the web service.  Config must not
-// be called simultaneously with Start.  If svc was initialized with ":0"
-// addresses, addrs will not return the actual bound ports until Start is
-// finished.
-func (svc *Service) Config() (c *Config) {
-	// TODO(a.garipov): Do we need to get the TCP addresses separately?
-
-	var addrs []netip.AddrPort
-	if svc.running.Load() {
-		udpAddrs := svc.proxy.Addrs(proxy.ProtoUDP)
-		addrs = make([]netip.AddrPort, len(udpAddrs))
-		for i, a := range udpAddrs {
-			addrs[i] = a.(*net.UDPAddr).AddrPort()
-		}
-	} else {
-		conf := svc.proxy.Config
-		udpAddrs := conf.UDPListenAddr
-		addrs = make([]netip.AddrPort, len(udpAddrs))
-		for i, a := range udpAddrs {
-			addrs[i] = a.AddrPort()
-		}
-	}
-
-	c = &Config{
-		Addresses:        addrs,
-		BootstrapServers: svc.bootstraps,
-		UpstreamServers:  svc.upstreams,
-		UpstreamTimeout:  svc.upsTimeout,
-	}
-
-	return c
-}

internal/next/dnssvc/dnssvc_test.go

@@ -1,96 +0,0 @@
-package dnssvc_test
-
-import (
-	"context"
-	"net/netip"
-	"testing"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/aghtest"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/dnssvc"
-	"github.com/AdguardTeam/dnsproxy/upstream"
-	"github.com/AdguardTeam/golibs/errors"
-	"github.com/AdguardTeam/golibs/testutil"
-	"github.com/miekg/dns"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestMain(m *testing.M) {
-	testutil.DiscardLogOutput(m)
-}
-
-// testTimeout is the common timeout for tests.
-const testTimeout = 100 * time.Millisecond
-
-func TestService(t *testing.T) {
-	const (
-		bootstrapAddr = "bootstrap.example"
-		upstreamAddr  = "upstream.example"
-
-		closeErr errors.Error = "closing failed"
-	)
-
-	ups := &aghtest.UpstreamMock{
-		OnAddress: func() (addr string) {
-			return upstreamAddr
-		},
-		OnExchange: func(req *dns.Msg) (resp *dns.Msg, err error) {
-			resp = (&dns.Msg{}).SetReply(req)
-
-			return resp, nil
-		},
-		OnClose: func() (err error) {
-			return closeErr
-		},
-	}
-
-	c := &dnssvc.Config{
-		Addresses:        []netip.AddrPort{netip.MustParseAddrPort("127.0.0.1:0")},
-		Upstreams:        []upstream.Upstream{ups},
-		BootstrapServers: []string{bootstrapAddr},
-		UpstreamServers:  []string{upstreamAddr},
-		UpstreamTimeout:  testTimeout,
-	}
-
-	svc, err := dnssvc.New(c)
-	require.NoError(t, err)
-
-	err = svc.Start()
-	require.NoError(t, err)
-
-	gotConf := svc.Config()
-	require.NotNil(t, gotConf)
-	require.Len(t, gotConf.Addresses, 1)
-
-	addr := gotConf.Addresses[0]
-
-	t.Run("dns", func(t *testing.T) {
-		req := &dns.Msg{
-			MsgHdr: dns.MsgHdr{
-				Id:               dns.Id(),
-				RecursionDesired: true,
-			},
-			Question: []dns.Question{{
-				Name:   "example.com.",
-				Qtype:  dns.TypeA,
-				Qclass: dns.ClassINET,
-			}},
-		}
-
-		ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
-		defer cancel()
-
-		cli := &dns.Client{}
-		resp, _, excErr := cli.ExchangeContext(ctx, req, addr.String())
-		require.NoError(t, excErr)
-
-		assert.NotNil(t, resp)
-	})
-
-	ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
-	defer cancel()
-
-	err = svc.Shutdown(ctx)
-	require.ErrorIs(t, err, closeErr)
-}

internal/next/websvc/dns.go

@@ -1,84 +0,0 @@
-package websvc
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/netip"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/next/dnssvc"
-)
-
-// DNS Settings Handlers
-
-// ReqPatchSettingsDNS describes the request to the PATCH /api/v1/settings/dns
-// HTTP API.
-type ReqPatchSettingsDNS struct {
-	// TODO(a.garipov): Add more as we go.
-
-	Addresses        []netip.AddrPort `json:"addresses"`
-	BootstrapServers []string         `json:"bootstrap_servers"`
-	UpstreamServers  []string         `json:"upstream_servers"`
-	UpstreamTimeout  JSONDuration     `json:"upstream_timeout"`
-}
-
-// HTTPAPIDNSSettings are the DNS settings as used by the HTTP API.  See the
-// DnsSettings object in the OpenAPI specification.
-type HTTPAPIDNSSettings struct {
-	// TODO(a.garipov): Add more as we go.
-
-	Addresses        []netip.AddrPort `json:"addresses"`
-	BootstrapServers []string         `json:"bootstrap_servers"`
-	UpstreamServers  []string         `json:"upstream_servers"`
-	UpstreamTimeout  JSONDuration     `json:"upstream_timeout"`
-}
-
-// handlePatchSettingsDNS is the handler for the PATCH /api/v1/settings/dns HTTP
-// API.
-func (svc *Service) handlePatchSettingsDNS(w http.ResponseWriter, r *http.Request) {
-	req := &ReqPatchSettingsDNS{
-		Addresses:        []netip.AddrPort{},
-		BootstrapServers: []string{},
-		UpstreamServers:  []string{},
-	}
-
-	// TODO(a.garipov): Validate nulls and proper JSON patch.
-
-	err := json.NewDecoder(r.Body).Decode(&req)
-	if err != nil {
-		writeJSONErrorResponse(w, r, fmt.Errorf("decoding: %w", err))
-
-		return
-	}
-
-	newConf := &dnssvc.Config{
-		Addresses:        req.Addresses,
-		BootstrapServers: req.BootstrapServers,
-		UpstreamServers:  req.UpstreamServers,
-		UpstreamTimeout:  time.Duration(req.UpstreamTimeout),
-	}
-
-	ctx := r.Context()
-	err = svc.confMgr.UpdateDNS(ctx, newConf)
-	if err != nil {
-		writeJSONErrorResponse(w, r, fmt.Errorf("updating: %w", err))
-
-		return
-	}
-
-	newSvc := svc.confMgr.DNS()
-	err = newSvc.Start()
-	if err != nil {
-		writeJSONErrorResponse(w, r, fmt.Errorf("starting new service: %w", err))
-
-		return
-	}
-
-	writeJSONOKResponse(w, r, &HTTPAPIDNSSettings{
-		Addresses:        newConf.Addresses,
-		BootstrapServers: newConf.BootstrapServers,
-		UpstreamServers:  newConf.UpstreamServers,
-		UpstreamTimeout:  JSONDuration(newConf.UpstreamTimeout),
-	})
-}

internal/next/websvc/dns_test.go

@@ -1,68 +0,0 @@
-package websvc_test
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"net/netip"
-	"net/url"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/aghtest"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/agh"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/dnssvc"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/websvc"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestService_HandlePatchSettingsDNS(t *testing.T) {
-	wantDNS := &websvc.HTTPAPIDNSSettings{
-		Addresses:        []netip.AddrPort{netip.MustParseAddrPort("127.0.1.1:53")},
-		BootstrapServers: []string{"1.0.0.1"},
-		UpstreamServers:  []string{"1.1.1.1"},
-		UpstreamTimeout:  websvc.JSONDuration(2 * time.Second),
-	}
-
-	var started atomic.Bool
-	confMgr := newConfigManager()
-	confMgr.onDNS = func() (s agh.ServiceWithConfig[*dnssvc.Config]) {
-		return &aghtest.ServiceWithConfig[*dnssvc.Config]{
-			OnStart: func() (err error) {
-				started.Store(true)
-
-				return nil
-			},
-			OnShutdown: func(_ context.Context) (err error) { panic("not implemented") },
-			OnConfig:   func() (c *dnssvc.Config) { panic("not implemented") },
-		}
-	}
-	confMgr.onUpdateDNS = func(ctx context.Context, c *dnssvc.Config) (err error) {
-		return nil
-	}
-
-	_, addr := newTestServer(t, confMgr)
-	u := &url.URL{
-		Scheme: "http",
-		Host:   addr.String(),
-		Path:   websvc.PathV1SettingsDNS,
-	}
-
-	req := jobj{
-		"addresses":         wantDNS.Addresses,
-		"bootstrap_servers": wantDNS.BootstrapServers,
-		"upstream_servers":  wantDNS.UpstreamServers,
-		"upstream_timeout":  wantDNS.UpstreamTimeout,
-	}
-
-	respBody := httpPatch(t, u, req, http.StatusOK)
-	resp := &websvc.HTTPAPIDNSSettings{}
-	err := json.Unmarshal(respBody, resp)
-	require.NoError(t, err)
-
-	assert.True(t, started.Load())
-	assert.Equal(t, wantDNS, resp)
-	assert.Equal(t, wantDNS, resp)
-}

internal/next/websvc/http.go

@@ -1,110 +0,0 @@
-package websvc
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/netip"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/next/agh"
-	"github.com/AdguardTeam/golibs/log"
-)
-
-// HTTP Settings Handlers
-
-// ReqPatchSettingsHTTP describes the request to the PATCH /api/v1/settings/http
-// HTTP API.
-type ReqPatchSettingsHTTP struct {
-	// TODO(a.garipov): Add more as we go.
-	//
-	// TODO(a.garipov): Add wait time.
-
-	Addresses       []netip.AddrPort `json:"addresses"`
-	SecureAddresses []netip.AddrPort `json:"secure_addresses"`
-	Timeout         JSONDuration     `json:"timeout"`
-}
-
-// HTTPAPIHTTPSettings are the HTTP settings as used by the HTTP API.  See the
-// HttpSettings object in the OpenAPI specification.
-type HTTPAPIHTTPSettings struct {
-	// TODO(a.garipov): Add more as we go.
-
-	Addresses       []netip.AddrPort `json:"addresses"`
-	SecureAddresses []netip.AddrPort `json:"secure_addresses"`
-	Timeout         JSONDuration     `json:"timeout"`
-	ForceHTTPS      bool             `json:"force_https"`
-}
-
-// handlePatchSettingsHTTP is the handler for the PATCH /api/v1/settings/http
-// HTTP API.
-func (svc *Service) handlePatchSettingsHTTP(w http.ResponseWriter, r *http.Request) {
-	req := &ReqPatchSettingsHTTP{}
-
-	// TODO(a.garipov): Validate nulls and proper JSON patch.
-
-	err := json.NewDecoder(r.Body).Decode(&req)
-	if err != nil {
-		writeJSONErrorResponse(w, r, fmt.Errorf("decoding: %w", err))
-
-		return
-	}
-
-	newConf := &Config{
-		ConfigManager:   svc.confMgr,
-		TLS:             svc.tls,
-		Addresses:       req.Addresses,
-		SecureAddresses: req.SecureAddresses,
-		Timeout:         time.Duration(req.Timeout),
-		ForceHTTPS:      svc.forceHTTPS,
-	}
-
-	writeJSONOKResponse(w, r, &HTTPAPIHTTPSettings{
-		Addresses:       newConf.Addresses,
-		SecureAddresses: newConf.SecureAddresses,
-		Timeout:         JSONDuration(newConf.Timeout),
-		ForceHTTPS:      newConf.ForceHTTPS,
-	})
-
-	cancelUpd := func() {}
-	updCtx := context.Background()
-
-	ctx := r.Context()
-	if deadline, ok := ctx.Deadline(); ok {
-		updCtx, cancelUpd = context.WithDeadline(updCtx, deadline)
-	}
-
-	// Launch the new HTTP service in a separate goroutine to let this handler
-	// finish and thus, this server to shutdown.
-	go func() {
-		defer cancelUpd()
-
-		updErr := svc.confMgr.UpdateWeb(updCtx, newConf)
-		if updErr != nil {
-			writeJSONErrorResponse(w, r, fmt.Errorf("updating: %w", updErr))
-
-			return
-		}
-
-		// TODO(a.garipov): Consider better ways to do this.
-		const maxUpdDur = 10 * time.Second
-		updStart := time.Now()
-		var newSvc agh.ServiceWithConfig[*Config]
-		for newSvc = svc.confMgr.Web(); newSvc == svc; {
-			if time.Since(updStart) >= maxUpdDur {
-				log.Error("websvc: failed to update svc after %s", maxUpdDur)
-
-				return
-			}
-
-			log.Debug("websvc: waiting for new websvc to be configured")
-			time.Sleep(1 * time.Second)
-		}
-
-		updErr = newSvc.Start()
-		if updErr != nil {
-			log.Error("websvc: new svc failed to start with error: %s", updErr)
-		}
-	}()
-}

internal/next/websvc/http_test.go

@@ -1,63 +0,0 @@
-package websvc_test
-
-import (
-	"context"
-	"crypto/tls"
-	"encoding/json"
-	"net/http"
-	"net/netip"
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/next/agh"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/websvc"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestService_HandlePatchSettingsHTTP(t *testing.T) {
-	wantWeb := &websvc.HTTPAPIHTTPSettings{
-		Addresses:       []netip.AddrPort{netip.MustParseAddrPort("127.0.1.1:80")},
-		SecureAddresses: []netip.AddrPort{netip.MustParseAddrPort("127.0.1.1:443")},
-		Timeout:         websvc.JSONDuration(10 * time.Second),
-		ForceHTTPS:      false,
-	}
-
-	confMgr := newConfigManager()
-	confMgr.onWeb = func() (s agh.ServiceWithConfig[*websvc.Config]) {
-		return websvc.New(&websvc.Config{
-			TLS: &tls.Config{
-				Certificates: []tls.Certificate{{}},
-			},
-			Addresses:       []netip.AddrPort{netip.MustParseAddrPort("127.0.0.1:80")},
-			SecureAddresses: []netip.AddrPort{netip.MustParseAddrPort("127.0.0.1:443")},
-			Timeout:         5 * time.Second,
-			ForceHTTPS:      true,
-		})
-	}
-	confMgr.onUpdateWeb = func(ctx context.Context, c *websvc.Config) (err error) {
-		return nil
-	}
-
-	_, addr := newTestServer(t, confMgr)
-	u := &url.URL{
-		Scheme: "http",
-		Host:   addr.String(),
-		Path:   websvc.PathV1SettingsHTTP,
-	}
-
-	req := jobj{
-		"addresses":        wantWeb.Addresses,
-		"secure_addresses": wantWeb.SecureAddresses,
-		"timeout":          wantWeb.Timeout,
-		"force_https":      wantWeb.ForceHTTPS,
-	}
-
-	respBody := httpPatch(t, u, req, http.StatusOK)
-	resp := &websvc.HTTPAPIHTTPSettings{}
-	err := json.Unmarshal(respBody, resp)
-	require.NoError(t, err)
-
-	assert.Equal(t, wantWeb, resp)
-}

internal/next/websvc/json.go

@@ -1,144 +0,0 @@
-package websvc
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"strconv"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/aghhttp"
-	"github.com/AdguardTeam/golibs/httphdr"
-	"github.com/AdguardTeam/golibs/log"
-)
-
-// JSON Utilities
-
-// nsecPerMsec is the number of nanoseconds in a millisecond.
-const nsecPerMsec = float64(time.Millisecond / time.Nanosecond)
-
-// JSONDuration is a time.Duration that can be decoded from JSON and encoded
-// into JSON according to our API conventions.
-type JSONDuration time.Duration
-
-// type check
-var _ json.Marshaler = JSONDuration(0)
-
-// MarshalJSON implements the json.Marshaler interface for JSONDuration.  err is
-// always nil.
-func (d JSONDuration) MarshalJSON() (b []byte, err error) {
-	msec := float64(time.Duration(d)) / nsecPerMsec
-	b = strconv.AppendFloat(nil, msec, 'f', -1, 64)
-
-	return b, nil
-}
-
-// type check
-var _ json.Unmarshaler = (*JSONDuration)(nil)
-
-// UnmarshalJSON implements the json.Marshaler interface for *JSONDuration.
-func (d *JSONDuration) UnmarshalJSON(b []byte) (err error) {
-	if d == nil {
-		return fmt.Errorf("json duration is nil")
-	}
-
-	msec, err := strconv.ParseFloat(string(b), 64)
-	if err != nil {
-		return fmt.Errorf("parsing json time: %w", err)
-	}
-
-	*d = JSONDuration(int64(msec * nsecPerMsec))
-
-	return nil
-}
-
-// JSONTime is a time.Time that can be decoded from JSON and encoded into JSON
-// according to our API conventions.
-type JSONTime time.Time
-
-// type check
-var _ json.Marshaler = JSONTime{}
-
-// MarshalJSON implements the json.Marshaler interface for JSONTime.  err is
-// always nil.
-func (t JSONTime) MarshalJSON() (b []byte, err error) {
-	msec := float64(time.Time(t).UnixNano()) / nsecPerMsec
-	b = strconv.AppendFloat(nil, msec, 'f', -1, 64)
-
-	return b, nil
-}
-
-// type check
-var _ json.Unmarshaler = (*JSONTime)(nil)
-
-// UnmarshalJSON implements the json.Marshaler interface for *JSONTime.
-func (t *JSONTime) UnmarshalJSON(b []byte) (err error) {
-	if t == nil {
-		return fmt.Errorf("json time is nil")
-	}
-
-	msec, err := strconv.ParseFloat(string(b), 64)
-	if err != nil {
-		return fmt.Errorf("parsing json time: %w", err)
-	}
-
-	*t = JSONTime(time.Unix(0, int64(msec*nsecPerMsec)).UTC())
-
-	return nil
-}
-
-// writeJSONOKResponse writes headers with the code 200 OK, encodes v into w,
-// and logs any errors it encounters.  r is used to get additional information
-// from the request.
-func writeJSONOKResponse(w http.ResponseWriter, r *http.Request, v any) {
-	writeJSONResponse(w, r, v, http.StatusOK)
-}
-
-// writeJSONResponse writes headers with code, encodes v into w, and logs any
-// errors it encounters.  r is used to get additional information from the
-// request.
-func writeJSONResponse(w http.ResponseWriter, r *http.Request, v any, code int) {
-	// TODO(a.garipov): Put some of these to a middleware.
-	h := w.Header()
-	h.Set(httphdr.ContentType, aghhttp.HdrValApplicationJSON)
-	h.Set(httphdr.Server, aghhttp.UserAgent())
-
-	w.WriteHeader(code)
-
-	err := json.NewEncoder(w).Encode(v)
-	if err != nil {
-		log.Error("websvc: writing resp to %s %s: %s", r.Method, r.URL.Path, err)
-	}
-}
-
-// ErrorCode is the error code as used by the HTTP API.  See the ErrorCode
-// definition in the OpenAPI specification.
-type ErrorCode string
-
-// ErrorCode constants.
-//
-// TODO(a.garipov): Expand and document codes.
-const (
-	// ErrorCodeTMP000 is the temporary error code used for all errors.
-	ErrorCodeTMP000 = ""
-)
-
-// HTTPAPIErrorResp is the error response as used by the HTTP API.  See the
-// BadRequestResp, InternalServerErrorResp, and similar objects in the OpenAPI
-// specification.
-type HTTPAPIErrorResp struct {
-	Code ErrorCode `json:"code"`
-	Msg  string    `json:"msg"`
-}
-
-// writeJSONErrorResponse encodes err as a JSON error into w, and logs any
-// errors it encounters.  r is used to get additional information from the
-// request.
-func writeJSONErrorResponse(w http.ResponseWriter, r *http.Request, err error) {
-	log.Error("websvc: %s %s: %s", r.Method, r.URL.Path, err)
-
-	writeJSONResponse(w, r, &HTTPAPIErrorResp{
-		Code: ErrorCodeTMP000,
-		Msg:  err.Error(),
-	}, http.StatusUnprocessableEntity)
-}

internal/next/websvc/json_test.go

@@ -1,114 +0,0 @@
-package websvc_test
-
-import (
-	"encoding/json"
-	"testing"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/next/websvc"
-	"github.com/AdguardTeam/golibs/testutil"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// testJSONTime is the JSON time for tests.
-var testJSONTime = websvc.JSONTime(time.Unix(1_234_567_890, 123_456_000).UTC())
-
-// testJSONTimeStr is the string with the JSON encoding of testJSONTime.
-const testJSONTimeStr = "1234567890123.456"
-
-func TestJSONTime_MarshalJSON(t *testing.T) {
-	testCases := []struct {
-		name       string
-		wantErrMsg string
-		in         websvc.JSONTime
-		want       []byte
-	}{{
-		name:       "unix_zero",
-		wantErrMsg: "",
-		in:         websvc.JSONTime(time.Unix(0, 0)),
-		want:       []byte("0"),
-	}, {
-		name:       "empty",
-		wantErrMsg: "",
-		in:         websvc.JSONTime{},
-		want:       []byte("-6795364578871.345"),
-	}, {
-		name:       "time",
-		wantErrMsg: "",
-		in:         testJSONTime,
-		want:       []byte(testJSONTimeStr),
-	}}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			got, err := tc.in.MarshalJSON()
-			testutil.AssertErrorMsg(t, tc.wantErrMsg, err)
-
-			assert.Equal(t, tc.want, got)
-		})
-	}
-
-	t.Run("json", func(t *testing.T) {
-		in := &struct {
-			A websvc.JSONTime
-		}{
-			A: testJSONTime,
-		}
-
-		got, err := json.Marshal(in)
-		require.NoError(t, err)
-
-		assert.Equal(t, []byte(`{"A":`+testJSONTimeStr+`}`), got)
-	})
-}
-
-func TestJSONTime_UnmarshalJSON(t *testing.T) {
-	testCases := []struct {
-		name       string
-		wantErrMsg string
-		want       websvc.JSONTime
-		data       []byte
-	}{{
-		name:       "time",
-		wantErrMsg: "",
-		want:       testJSONTime,
-		data:       []byte(testJSONTimeStr),
-	}, {
-		name: "bad",
-		wantErrMsg: `parsing json time: strconv.ParseFloat: parsing "{}": ` +
-			`invalid syntax`,
-		want: websvc.JSONTime{},
-		data: []byte(`{}`),
-	}}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			var got websvc.JSONTime
-			err := got.UnmarshalJSON(tc.data)
-			testutil.AssertErrorMsg(t, tc.wantErrMsg, err)
-
-			assert.Equal(t, tc.want, got)
-		})
-	}
-
-	t.Run("nil", func(t *testing.T) {
-		err := (*websvc.JSONTime)(nil).UnmarshalJSON([]byte("0"))
-		require.Error(t, err)
-
-		msg := err.Error()
-		assert.Equal(t, "json time is nil", msg)
-	})
-
-	t.Run("json", func(t *testing.T) {
-		want := testJSONTime
-		var got struct {
-			A websvc.JSONTime
-		}
-
-		err := json.Unmarshal([]byte(`{"A":`+testJSONTimeStr+`}`), &got)
-		require.NoError(t, err)
-
-		assert.Equal(t, want, got.A)
-	})
-}

internal/next/websvc/middleware.go

@@ -1,21 +0,0 @@
-package websvc
-
-import (
-	"net/http"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/aghhttp"
-	"github.com/AdguardTeam/golibs/httphdr"
-)
-
-// Middlewares
-
-// jsonMw sets the content type of the response to application/json.
-func jsonMw(h http.Handler) (wrapped http.HandlerFunc) {
-	f := func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set(httphdr.ContentType, aghhttp.HdrValApplicationJSON)
-
-		h.ServeHTTP(w, r)
-	}
-
-	return http.HandlerFunc(f)
-}

internal/next/websvc/path.go

@@ -1,11 +0,0 @@
-package websvc
-
-// Path constants
-const (
-	PathHealthCheck = "/health-check"
-
-	PathV1SettingsAll  = "/api/v1/settings/all"
-	PathV1SettingsDNS  = "/api/v1/settings/dns"
-	PathV1SettingsHTTP = "/api/v1/settings/http"
-	PathV1SystemInfo   = "/api/v1/system/info"
-)

internal/next/websvc/settings.go

@@ -1,42 +0,0 @@
-package websvc
-
-import (
-	"net/http"
-)
-
-// All Settings Handlers
-
-// RespGetV1SettingsAll describes the response of the GET /api/v1/settings/all
-// HTTP API.
-type RespGetV1SettingsAll struct {
-	// TODO(a.garipov): Add more as we go.
-
-	DNS  *HTTPAPIDNSSettings  `json:"dns"`
-	HTTP *HTTPAPIHTTPSettings `json:"http"`
-}
-
-// handleGetSettingsAll is the handler for the GET /api/v1/settings/all HTTP
-// API.
-func (svc *Service) handleGetSettingsAll(w http.ResponseWriter, r *http.Request) {
-	dnsSvc := svc.confMgr.DNS()
-	dnsConf := dnsSvc.Config()
-
-	webSvc := svc.confMgr.Web()
-	httpConf := webSvc.Config()
-
-	// TODO(a.garipov): Add all currently supported parameters.
-	writeJSONOKResponse(w, r, &RespGetV1SettingsAll{
-		DNS: &HTTPAPIDNSSettings{
-			Addresses:        dnsConf.Addresses,
-			BootstrapServers: dnsConf.BootstrapServers,
-			UpstreamServers:  dnsConf.UpstreamServers,
-			UpstreamTimeout:  JSONDuration(dnsConf.UpstreamTimeout),
-		},
-		HTTP: &HTTPAPIHTTPSettings{
-			Addresses:       httpConf.Addresses,
-			SecureAddresses: httpConf.SecureAddresses,
-			Timeout:         JSONDuration(httpConf.Timeout),
-			ForceHTTPS:      httpConf.ForceHTTPS,
-		},
-	})
-}

internal/next/websvc/settings_test.go

@@ -1,75 +0,0 @@
-package websvc_test
-
-import (
-	"crypto/tls"
-	"encoding/json"
-	"net/http"
-	"net/netip"
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/next/agh"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/dnssvc"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/websvc"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestService_HandleGetSettingsAll(t *testing.T) {
-	// TODO(a.garipov): Add all currently supported parameters.
-
-	wantDNS := &websvc.HTTPAPIDNSSettings{
-		Addresses:        []netip.AddrPort{netip.MustParseAddrPort("127.0.0.1:53")},
-		BootstrapServers: []string{"94.140.14.140", "94.140.14.141"},
-		UpstreamServers:  []string{"94.140.14.14", "1.1.1.1"},
-		UpstreamTimeout:  websvc.JSONDuration(1 * time.Second),
-	}
-
-	wantWeb := &websvc.HTTPAPIHTTPSettings{
-		Addresses:       []netip.AddrPort{netip.MustParseAddrPort("127.0.0.1:80")},
-		SecureAddresses: []netip.AddrPort{netip.MustParseAddrPort("127.0.0.1:443")},
-		Timeout:         websvc.JSONDuration(5 * time.Second),
-		ForceHTTPS:      true,
-	}
-
-	confMgr := newConfigManager()
-	confMgr.onDNS = func() (s agh.ServiceWithConfig[*dnssvc.Config]) {
-		c, err := dnssvc.New(&dnssvc.Config{
-			Addresses:        wantDNS.Addresses,
-			UpstreamServers:  wantDNS.UpstreamServers,
-			BootstrapServers: wantDNS.BootstrapServers,
-			UpstreamTimeout:  time.Duration(wantDNS.UpstreamTimeout),
-		})
-		require.NoError(t, err)
-
-		return c
-	}
-
-	confMgr.onWeb = func() (s agh.ServiceWithConfig[*websvc.Config]) {
-		return websvc.New(&websvc.Config{
-			TLS: &tls.Config{
-				Certificates: []tls.Certificate{{}},
-			},
-			Addresses:       wantWeb.Addresses,
-			SecureAddresses: wantWeb.SecureAddresses,
-			Timeout:         time.Duration(wantWeb.Timeout),
-			ForceHTTPS:      true,
-		})
-	}
-
-	_, addr := newTestServer(t, confMgr)
-	u := &url.URL{
-		Scheme: "http",
-		Host:   addr.String(),
-		Path:   websvc.PathV1SettingsAll,
-	}
-
-	body := httpGet(t, u, http.StatusOK)
-	resp := &websvc.RespGetV1SettingsAll{}
-	err := json.Unmarshal(body, resp)
-	require.NoError(t, err)
-
-	assert.Equal(t, wantDNS, resp.DNS)
-	assert.Equal(t, wantWeb, resp.HTTP)
-}

internal/next/websvc/system.go

@@ -1,35 +0,0 @@
-package websvc
-
-import (
-	"net/http"
-	"runtime"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/version"
-)
-
-// System Handlers
-
-// RespGetV1SystemInfo describes the response of the GET /api/v1/system/info
-// HTTP API.
-type RespGetV1SystemInfo struct {
-	Arch       string   `json:"arch"`
-	Channel    string   `json:"channel"`
-	OS         string   `json:"os"`
-	NewVersion string   `json:"new_version,omitempty"`
-	Start      JSONTime `json:"start"`
-	Version    string   `json:"version"`
-}
-
-// handleGetV1SystemInfo is the handler for the GET /api/v1/system/info HTTP
-// API.
-func (svc *Service) handleGetV1SystemInfo(w http.ResponseWriter, r *http.Request) {
-	writeJSONOKResponse(w, r, &RespGetV1SystemInfo{
-		Arch:    runtime.GOARCH,
-		Channel: version.Channel(),
-		OS:      runtime.GOOS,
-		// TODO(a.garipov): Fill this when we have an updater.
-		NewVersion: "",
-		Start:      JSONTime(svc.start),
-		Version:    version.Version(),
-	})
-}

internal/next/websvc/system_test.go

@@ -1,37 +0,0 @@
-package websvc_test
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/url"
-	"runtime"
-	"testing"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/next/websvc"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestService_handleGetV1SystemInfo(t *testing.T) {
-	confMgr := newConfigManager()
-	_, addr := newTestServer(t, confMgr)
-	u := &url.URL{
-		Scheme: "http",
-		Host:   addr.String(),
-		Path:   websvc.PathV1SystemInfo,
-	}
-
-	body := httpGet(t, u, http.StatusOK)
-	resp := &websvc.RespGetV1SystemInfo{}
-	err := json.Unmarshal(body, resp)
-	require.NoError(t, err)
-
-	// TODO(a.garipov): Consider making version.Channel and version.Version
-	// testable and test these better.
-	assert.NotEmpty(t, resp.Channel)
-
-	assert.Equal(t, resp.Arch, runtime.GOARCH)
-	assert.Equal(t, resp.OS, runtime.GOOS)
-	assert.Equal(t, testStart, time.Time(resp.Start))
-}

internal/next/websvc/waitlistener.go

@@ -1,31 +0,0 @@
-package websvc
-
-import (
-	"net"
-	"sync"
-)
-
-// Wait Listener
-
-// waitListener is a wrapper around a listener that also calls wg.Done() on the
-// first call to Accept.  It is useful in situations where it is important to
-// catch the precise moment of the first call to Accept, for example when
-// starting an HTTP server.
-//
-// TODO(a.garipov): Move to aghnet?
-type waitListener struct {
-	net.Listener
-
-	firstAcceptWG   *sync.WaitGroup
-	firstAcceptOnce sync.Once
-}
-
-// type check
-var _ net.Listener = (*waitListener)(nil)
-
-// Accept implements the [net.Listener] interface for *waitListener.
-func (l *waitListener) Accept() (conn net.Conn, err error) {
-	l.firstAcceptOnce.Do(l.firstAcceptWG.Done)
-
-	return l.Listener.Accept()
-}

internal/next/websvc/waitlistener_internal_test.go

@@ -1,45 +0,0 @@
-package websvc
-
-import (
-	"net"
-	"sync"
-	"sync/atomic"
-	"testing"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/aghchan"
-	"github.com/AdguardTeam/AdGuardHome/internal/aghtest"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestWaitListener_Accept(t *testing.T) {
-	var accepted atomic.Bool
-	var l net.Listener = &aghtest.Listener{
-		OnAccept: func() (conn net.Conn, err error) {
-			accepted.Store(true)
-
-			return nil, nil
-		},
-		OnAddr:  func() (addr net.Addr) { panic("not implemented") },
-		OnClose: func() (err error) { panic("not implemented") },
-	}
-
-	wg := &sync.WaitGroup{}
-	wg.Add(1)
-
-	done := make(chan struct{})
-	go aghchan.MustReceive(done, testTimeout)
-
-	go func() {
-		var wrapper net.Listener = &waitListener{
-			Listener:      l,
-			firstAcceptWG: wg,
-		}
-
-		_, _ = wrapper.Accept()
-	}()
-
-	wg.Wait()
-	close(done)
-
-	assert.True(t, accepted.Load())
-}

internal/next/websvc/websvc.go

@@ -1,305 +0,0 @@
-// Package websvc contains the AdGuard Home HTTP API service.
-//
-// NOTE: Packages other than cmd must not import this package, as it imports
-// most other packages.
-//
-// TODO(a.garipov): Add tests.
-package websvc
-
-import (
-	"context"
-	"crypto/tls"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"net/netip"
-	"sync"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/next/agh"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/dnssvc"
-	"github.com/AdguardTeam/golibs/errors"
-	"github.com/AdguardTeam/golibs/log"
-	httptreemux "github.com/dimfeld/httptreemux/v5"
-)
-
-// ConfigManager is the configuration manager interface.
-type ConfigManager interface {
-	DNS() (svc agh.ServiceWithConfig[*dnssvc.Config])
-	Web() (svc agh.ServiceWithConfig[*Config])
-
-	UpdateDNS(ctx context.Context, c *dnssvc.Config) (err error)
-	UpdateWeb(ctx context.Context, c *Config) (err error)
-}
-
-// Config is the AdGuard Home web service configuration structure.
-type Config struct {
-	// ConfigManager is used to show information about services as well as
-	// dynamically reconfigure them.
-	ConfigManager ConfigManager
-
-	// TLS is the optional TLS configuration.  If TLS is not nil,
-	// SecureAddresses must not be empty.
-	TLS *tls.Config
-
-	// Start is the time of start of AdGuard Home.
-	Start time.Time
-
-	// Addresses are the addresses on which to serve the plain HTTP API.
-	Addresses []netip.AddrPort
-
-	// SecureAddresses are the addresses on which to serve the HTTPS API.  If
-	// SecureAddresses is not empty, TLS must not be nil.
-	SecureAddresses []netip.AddrPort
-
-	// Timeout is the timeout for all server operations.
-	Timeout time.Duration
-
-	// ForceHTTPS tells if all requests to Addresses should be redirected to a
-	// secure address instead.
-	//
-	// TODO(a.garipov): Use; define rules, which address to redirect to.
-	ForceHTTPS bool
-}
-
-// Service is the AdGuard Home web service.  A nil *Service is a valid
-// [agh.Service] that does nothing.
-type Service struct {
-	confMgr    ConfigManager
-	tls        *tls.Config
-	start      time.Time
-	servers    []*http.Server
-	timeout    time.Duration
-	forceHTTPS bool
-}
-
-// New returns a new properly initialized *Service.  If c is nil, svc is a nil
-// *Service that does nothing.  The fields of c must not be modified after
-// calling New.
-func New(c *Config) (svc *Service) {
-	if c == nil {
-		return nil
-	}
-
-	svc = &Service{
-		confMgr:    c.ConfigManager,
-		tls:        c.TLS,
-		start:      c.Start,
-		timeout:    c.Timeout,
-		forceHTTPS: c.ForceHTTPS,
-	}
-
-	mux := newMux(svc)
-
-	for _, a := range c.Addresses {
-		addr := a.String()
-		errLog := log.StdLog("websvc: plain http: "+addr, log.ERROR)
-		svc.servers = append(svc.servers, &http.Server{
-			Addr:              addr,
-			Handler:           mux,
-			ErrorLog:          errLog,
-			ReadTimeout:       c.Timeout,
-			WriteTimeout:      c.Timeout,
-			IdleTimeout:       c.Timeout,
-			ReadHeaderTimeout: c.Timeout,
-		})
-	}
-
-	for _, a := range c.SecureAddresses {
-		addr := a.String()
-		errLog := log.StdLog("websvc: https: "+addr, log.ERROR)
-		svc.servers = append(svc.servers, &http.Server{
-			Addr:              addr,
-			Handler:           mux,
-			TLSConfig:         c.TLS,
-			ErrorLog:          errLog,
-			ReadTimeout:       c.Timeout,
-			WriteTimeout:      c.Timeout,
-			IdleTimeout:       c.Timeout,
-			ReadHeaderTimeout: c.Timeout,
-		})
-	}
-
-	return svc
-}
-
-// newMux returns a new HTTP request multiplexor for the AdGuard Home web
-// service.
-func newMux(svc *Service) (mux *httptreemux.ContextMux) {
-	mux = httptreemux.NewContextMux()
-
-	routes := []struct {
-		handler http.HandlerFunc
-		method  string
-		path    string
-		isJSON  bool
-	}{{
-		handler: svc.handleGetHealthCheck,
-		method:  http.MethodGet,
-		path:    PathHealthCheck,
-		isJSON:  false,
-	}, {
-		handler: svc.handleGetSettingsAll,
-		method:  http.MethodGet,
-		path:    PathV1SettingsAll,
-		isJSON:  true,
-	}, {
-		handler: svc.handlePatchSettingsDNS,
-		method:  http.MethodPatch,
-		path:    PathV1SettingsDNS,
-		isJSON:  true,
-	}, {
-		handler: svc.handlePatchSettingsHTTP,
-		method:  http.MethodPatch,
-		path:    PathV1SettingsHTTP,
-		isJSON:  true,
-	}, {
-		handler: svc.handleGetV1SystemInfo,
-		method:  http.MethodGet,
-		path:    PathV1SystemInfo,
-		isJSON:  true,
-	}}
-
-	for _, r := range routes {
-		if r.isJSON {
-			mux.Handle(r.method, r.path, jsonMw(r.handler))
-		} else {
-			mux.Handle(r.method, r.path, r.handler)
-		}
-	}
-
-	return mux
-}
-
-// addrs returns all addresses on which this server serves the HTTP API.  addrs
-// must not be called simultaneously with Start.  If svc was initialized with
-// ":0" addresses, addrs will not return the actual bound ports until Start is
-// finished.
-func (svc *Service) addrs() (addrs, secureAddrs []netip.AddrPort) {
-	for _, srv := range svc.servers {
-		addrPort, err := netip.ParseAddrPort(srv.Addr)
-		if err != nil {
-			// Technically shouldn't happen, since all servers must have a valid
-			// address.
-			panic(fmt.Errorf("websvc: server %q: bad address: %w", srv.Addr, err))
-		}
-
-		// srv.Serve will set TLSConfig to an almost empty value, so, instead of
-		// relying only on the nilness of TLSConfig, check the length of the
-		// certificates field as well.
-		if srv.TLSConfig == nil || len(srv.TLSConfig.Certificates) == 0 {
-			addrs = append(addrs, addrPort)
-		} else {
-			secureAddrs = append(secureAddrs, addrPort)
-		}
-
-	}
-
-	return addrs, secureAddrs
-}
-
-// handleGetHealthCheck is the handler for the GET /health-check HTTP API.
-func (svc *Service) handleGetHealthCheck(w http.ResponseWriter, _ *http.Request) {
-	_, _ = io.WriteString(w, "OK")
-}
-
-// type check
-var _ agh.Service = (*Service)(nil)
-
-// Start implements the [agh.Service] interface for *Service.  svc may be nil.
-// After Start exits, all HTTP servers have tried to start, possibly failing and
-// writing error messages to the log.
-func (svc *Service) Start() (err error) {
-	if svc == nil {
-		return nil
-	}
-
-	wg := &sync.WaitGroup{}
-	wg.Add(len(svc.servers))
-	for _, srv := range svc.servers {
-		go serve(srv, wg)
-	}
-
-	wg.Wait()
-
-	return nil
-}
-
-// serve starts and runs srv and writes all errors into its log.
-func serve(srv *http.Server, wg *sync.WaitGroup) {
-	addr := srv.Addr
-	defer log.OnPanic(addr)
-
-	var proto string
-	var l net.Listener
-	var err error
-	if srv.TLSConfig == nil {
-		proto = "http"
-		l, err = net.Listen("tcp", addr)
-	} else {
-		proto = "https"
-		l, err = tls.Listen("tcp", addr, srv.TLSConfig)
-	}
-	if err != nil {
-		srv.ErrorLog.Printf("starting srv %s: binding: %s", addr, err)
-	}
-
-	// Update the server's address in case the address had the port zero, which
-	// would mean that a random available port was automatically chosen.
-	srv.Addr = l.Addr().String()
-
-	log.Info("websvc: starting srv %s://%s", proto, srv.Addr)
-
-	l = &waitListener{
-		Listener:      l,
-		firstAcceptWG: wg,
-	}
-
-	err = srv.Serve(l)
-	if err != nil && !errors.Is(err, http.ErrServerClosed) {
-		srv.ErrorLog.Printf("starting srv %s: %s", addr, err)
-	}
-}
-
-// Shutdown implements the [agh.Service] interface for *Service.  svc may be
-// nil.
-func (svc *Service) Shutdown(ctx context.Context) (err error) {
-	if svc == nil {
-		return nil
-	}
-
-	var errs []error
-	for _, srv := range svc.servers {
-		serr := srv.Shutdown(ctx)
-		if serr != nil {
-			errs = append(errs, fmt.Errorf("shutting down srv %s: %w", srv.Addr, serr))
-		}
-	}
-
-	if len(errs) > 0 {
-		return errors.List("shutting down", errs...)
-	}
-
-	return nil
-}
-
-// Config returns the current configuration of the web service.  Config must not
-// be called simultaneously with Start.  If svc was initialized with ":0"
-// addresses, addrs will not return the actual bound ports until Start is
-// finished.
-func (svc *Service) Config() (c *Config) {
-	c = &Config{
-		ConfigManager: svc.confMgr,
-		TLS:           svc.tls,
-		// Leave Addresses and SecureAddresses empty and get the actual
-		// addresses that include the :0 ones later.
-		Start:      svc.start,
-		Timeout:    svc.timeout,
-		ForceHTTPS: svc.forceHTTPS,
-	}
-
-	c.Addresses, c.SecureAddresses = svc.addrs()
-
-	return c
-}

internal/next/websvc/websvc_internal_test.go

@@ -1,6 +0,0 @@
-package websvc
-
-import "time"
-
-// testTimeout is the common timeout for tests.
-const testTimeout = 1 * time.Second

internal/next/websvc/websvc_test.go

@@ -1,187 +0,0 @@
-package websvc_test
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"io"
-	"net/http"
-	"net/netip"
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/next/agh"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/dnssvc"
-	"github.com/AdguardTeam/AdGuardHome/internal/next/websvc"
-	"github.com/AdguardTeam/golibs/testutil"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestMain(m *testing.M) {
-	testutil.DiscardLogOutput(m)
-}
-
-// testTimeout is the common timeout for tests.
-const testTimeout = 1 * time.Second
-
-// testStart is the server start value for tests.
-var testStart = time.Date(2022, 1, 1, 0, 0, 0, 0, time.UTC)
-
-// type check
-var _ websvc.ConfigManager = (*configManager)(nil)
-
-// configManager is a [websvc.ConfigManager] for tests.
-type configManager struct {
-	onDNS func() (svc agh.ServiceWithConfig[*dnssvc.Config])
-	onWeb func() (svc agh.ServiceWithConfig[*websvc.Config])
-
-	onUpdateDNS func(ctx context.Context, c *dnssvc.Config) (err error)
-	onUpdateWeb func(ctx context.Context, c *websvc.Config) (err error)
-}
-
-// DNS implements the [websvc.ConfigManager] interface for *configManager.
-func (m *configManager) DNS() (svc agh.ServiceWithConfig[*dnssvc.Config]) {
-	return m.onDNS()
-}
-
-// Web implements the [websvc.ConfigManager] interface for *configManager.
-func (m *configManager) Web() (svc agh.ServiceWithConfig[*websvc.Config]) {
-	return m.onWeb()
-}
-
-// UpdateDNS implements the [websvc.ConfigManager] interface for *configManager.
-func (m *configManager) UpdateDNS(ctx context.Context, c *dnssvc.Config) (err error) {
-	return m.onUpdateDNS(ctx, c)
-}
-
-// UpdateWeb implements the [websvc.ConfigManager] interface for *configManager.
-func (m *configManager) UpdateWeb(ctx context.Context, c *websvc.Config) (err error) {
-	return m.onUpdateWeb(ctx, c)
-}
-
-// newConfigManager returns a *configManager all methods of which panic.
-func newConfigManager() (m *configManager) {
-	return &configManager{
-		onDNS: func() (svc agh.ServiceWithConfig[*dnssvc.Config]) { panic("not implemented") },
-		onWeb: func() (svc agh.ServiceWithConfig[*websvc.Config]) { panic("not implemented") },
-		onUpdateDNS: func(_ context.Context, _ *dnssvc.Config) (err error) {
-			panic("not implemented")
-		},
-		onUpdateWeb: func(_ context.Context, _ *websvc.Config) (err error) {
-			panic("not implemented")
-		},
-	}
-}
-
-// newTestServer creates and starts a new web service instance as well as its
-// sole address.  It also registers a cleanup procedure, which shuts the
-// instance down.
-//
-// TODO(a.garipov): Use svc or remove it.
-func newTestServer(
-	t testing.TB,
-	confMgr websvc.ConfigManager,
-) (svc *websvc.Service, addr netip.AddrPort) {
-	t.Helper()
-
-	c := &websvc.Config{
-		ConfigManager:   confMgr,
-		TLS:             nil,
-		Addresses:       []netip.AddrPort{netip.MustParseAddrPort("127.0.0.1:0")},
-		SecureAddresses: nil,
-		Timeout:         testTimeout,
-		Start:           testStart,
-		ForceHTTPS:      false,
-	}
-
-	svc = websvc.New(c)
-
-	err := svc.Start()
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		ctx, cancel := context.WithTimeout(context.Background(), testTimeout)
-		t.Cleanup(cancel)
-
-		err = svc.Shutdown(ctx)
-		require.NoError(t, err)
-	})
-
-	c = svc.Config()
-	require.NotNil(t, c)
-	require.Len(t, c.Addresses, 1)
-
-	return svc, c.Addresses[0]
-}
-
-// jobj is a utility alias for JSON objects.
-type jobj map[string]any
-
-// httpGet is a helper that performs an HTTP GET request and returns the body of
-// the response as well as checks that the status code is correct.
-//
-// TODO(a.garipov): Add helpers for other methods.
-func httpGet(t testing.TB, u *url.URL, wantCode int) (body []byte) {
-	t.Helper()
-
-	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
-	require.NoErrorf(t, err, "creating req")
-
-	httpCli := &http.Client{
-		Timeout: testTimeout,
-	}
-	resp, err := httpCli.Do(req)
-	require.NoErrorf(t, err, "performing req")
-	require.Equal(t, wantCode, resp.StatusCode)
-
-	testutil.CleanupAndRequireSuccess(t, resp.Body.Close)
-
-	body, err = io.ReadAll(resp.Body)
-	require.NoErrorf(t, err, "reading body")
-
-	return body
-}
-
-// httpPatch is a helper that performs an HTTP PATCH request with JSON-encoded
-// reqBody as the request body and returns the body of the response as well as
-// checks that the status code is correct.
-//
-// TODO(a.garipov): Add helpers for other methods.
-func httpPatch(t testing.TB, u *url.URL, reqBody any, wantCode int) (body []byte) {
-	t.Helper()
-
-	b, err := json.Marshal(reqBody)
-	require.NoErrorf(t, err, "marshaling reqBody")
-
-	req, err := http.NewRequest(http.MethodPatch, u.String(), bytes.NewReader(b))
-	require.NoErrorf(t, err, "creating req")
-
-	httpCli := &http.Client{
-		Timeout: testTimeout,
-	}
-	resp, err := httpCli.Do(req)
-	require.NoErrorf(t, err, "performing req")
-	require.Equal(t, wantCode, resp.StatusCode)
-
-	testutil.CleanupAndRequireSuccess(t, resp.Body.Close)
-
-	body, err = io.ReadAll(resp.Body)
-	require.NoErrorf(t, err, "reading body")
-
-	return body
-}
-
-func TestService_Start_getHealthCheck(t *testing.T) {
-	confMgr := newConfigManager()
-	_, addr := newTestServer(t, confMgr)
-	u := &url.URL{
-		Scheme: "http",
-		Host:   addr.String(),
-		Path:   websvc.PathHealthCheck,
-	}
-
-	body := httpGet(t, u, http.StatusOK)
-
-	assert.Equal(t, []byte("OK"), body)
-}

internal/querylog/decode_test.go

@@ -182,7 +182,8 @@ func TestDecodeLogEntry(t *testing.T) {
 			if tc.want == "" {
 				assert.Empty(t, s)
 			} else {
-				assert.True(t, strings.HasSuffix(s, tc.want), "got %q", s)
+				assert.True(t, strings.HasSuffix(s, tc.want),
+					"got %q", s)
 			}
 
 			logOutput.Reset()

internal/querylog/qlog_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/AdguardTeam/AdGuardHome/internal/filtering"
+	"github.com/AdguardTeam/dnsproxy/proxyutil"
 	"github.com/AdguardTeam/golibs/stringutil"
 	"github.com/AdguardTeam/golibs/testutil"
 	"github.com/AdguardTeam/golibs/timeutil"
@@ -366,6 +367,6 @@ func assertLogEntry(t *testing.T, entry *logEntry, host string, answer, client n
 	require.NoError(t, msg.Unpack(entry.Answer))
 	require.Len(t, msg.Answer, 1)
 
-	a := testutil.RequireTypeAssert[*dns.A](t, msg.Answer[0])
-	assert.Equal(t, answer, a.A.To16())
+	ip := proxyutil.IPFromRR(msg.Answer[0]).To16()
+	assert.Equal(t, answer, ip)
 }

main.go

@@ -1,5 +1,3 @@
-//go:build !next
-
 package main
 
 import (

main_next.go

@@ -1,20 +0,0 @@
-//go:build next
-
-package main
-
-import (
-	"embed"
-
-	"github.com/AdguardTeam/AdGuardHome/internal/next/cmd"
-)
-
-// Embed the prebuilt client here since we strive to keep .go files inside the
-// internal directory and the embed package is unable to embed files located
-// outside of the same or underlying directory.
-
-//go:embed build
-var clientBuildFS embed.FS
-
-func main() {
-	cmd.Main(clientBuildFS)
-}

openapi/CHANGELOG.md

@@ -4,16 +4,6 @@
 
 ## v0.108.0: API changes
 
-## v0.107.30: API changes
-
-### `POST /control/version.json` and `GET /control/dhcp/interfaces` content type
-
-* The value of the `Content-Type` header in the `POST /control/version.json` and
-  `GET /control/dhcp/interfaces` HTTP APIs is now correctly set to
-  `application/json` as opposed to `text/plain`.
-
-
-
 ## v0.107.29: API changes
 
 ### `GET /control/clients` And `GET /control/clients/find`
@@ -26,8 +16,6 @@
   set AdGuard Home will use default value (false).  It can be changed in the
   future versions.
 
-
-
 ## v0.107.27: API changes
 
 ### The new optional fields `"edns_cs_use_custom"` and `"edns_cs_custom_ip"` in `DNSConfig`

scripts/make/go-build.sh

@@ -128,13 +128,7 @@ export CGO_ENABLED
 GO111MODULE='on'
 export GO111MODULE
 
-# Build the new binary if requested.
-if [ "${NEXTAPI:-0}" -eq '0' ]
-then
-	tags_flags='--tags='
-else
-	tags_flags='--tags=next'
-fi
+tags_flags='--tags='
 readonly tags_flags
 
 if [ "$verbose" -gt '0' ]

scripts/make/go-lint.sh

@@ -122,7 +122,6 @@ underscores() {
 			-e '_freebsd.go'\
 			-e '_linux.go'\
 			-e '_little.go'\
-			-e '_next.go'\
 			-e '_openbsd.go'\
 			-e '_others.go'\
 			-e '_test.go'\
@@ -161,8 +160,11 @@ run_linter "$GO" vet ./...
 run_linter govulncheck ./...
 
 # Apply more lax standards to the code we haven't properly refactored yet.
-run_linter gocyclo --over 13 ./internal/querylog
-run_linter gocyclo --over 12 ./internal/dhcpd
+run_linter gocyclo --over 13\
+	./internal/dhcpd\
+	./internal/home/\
+	./internal/querylog/\
+	;
 
 # Apply the normal standards to new or somewhat refactored code.
 run_linter gocyclo --over 10\
@@ -172,11 +174,9 @@ run_linter gocyclo --over 10\
 	./internal/aghtest/\
 	./internal/dnsforward/\
 	./internal/filtering/\
-	./internal/home/\
 	./internal/stats/\
 	./internal/tools/\
 	./internal/updater/\
-	./internal/next/\
 	./internal/version/\
 	./scripts/blocked-services/\
 	./scripts/vetted-filters/\