AGDNS-4357 Do not embed config

Author: makazantsev

proxy/bogusnxdomain.go

@@ -9,13 +9,13 @@ import (
 // isBogusNXDomain returns true if m contains at least a single IP address in
 // the Answer section contained in BogusNXDomain subnets of p.
 func (p *Proxy) isBogusNXDomain(m *dns.Msg) (ok bool) {
-	if m == nil || len(p.BogusNXDomain) == 0 || len(m.Question) == 0 {
+	if m == nil || len(p.bogusNXDomain) == 0 || len(m.Question) == 0 {
 		return false
 	} else if qt := m.Question[0].Qtype; qt != dns.TypeA && qt != dns.TypeAAAA {
 		return false
 	}
 
-	set := netutil.SliceSubnetSet(p.BogusNXDomain)
+	set := netutil.SliceSubnetSet(p.bogusNXDomain)
 	for _, rr := range m.Answer {
 		ip := proxyutil.IPFromRR(rr)
 		if set.Contains(ip) {

proxy/bogusnxdomain_internal_test.go

@@ -78,7 +78,7 @@ func TestProxy_IsBogusNXDomain(t *testing.T) {
 	}}
 
 	u := testUpstream{}
-	prx.UpstreamConfig.Upstreams = []upstream.Upstream{&u}
+	prx.upstreamConf.Upstreams = []upstream.Upstream{&u}
 
 	servicetest.RequireRun(t, prx, testTimeout)
 

proxy/cache.go

@@ -165,20 +165,20 @@ func (c *cache) unpackItem(data []byte, req *dns.Msg) (ci *cacheItem, expired bo
 
 // initCache initializes cache if it's enabled.
 func (p *Proxy) initCache() {
-	if !p.CacheEnabled {
+	if !p.cacheEnabled {
 		p.logger.Info("cache disabled")
 
 		return
 	}
 
-	size := p.CacheSizeBytes
+	size := p.cacheSizeBytes
 	p.logger.Info("cache enabled", "size", size)
 	p.cache = newCache(&cacheConfig{
 		size:             size,
-		optimisticTTL:    p.CacheOptimisticAnswerTTL,
-		optimisticMaxAge: p.CacheOptimisticMaxAge,
-		withECS:          p.EnableEDNSClientSubnet,
-		optimistic:       p.CacheOptimistic,
+		optimisticTTL:    p.cacheOptimisticAnswerTTL,
+		optimisticMaxAge: p.cacheOptimisticMaxAge,
+		withECS:          p.enableEDNSClientSubnet,
+		optimistic:       p.cacheOptimistic,
 	})
 	p.shortFlighter = newOptimisticResolver(p)
 }

proxy/cache_internal_test.go

@@ -402,7 +402,7 @@ func TestCacheExpirationWithTTLOverride(t *testing.T) {
 		assert.Equal(t, msgToKey(d.Req), key)
 
 		require.NotNil(t, ci)
-		assert.Equal(t, dnsProxy.CacheMinTTL, ci.m.Answer[0].Header().Ttl)
+		assert.Equal(t, dnsProxy.cacheMinTTL, ci.m.Answer[0].Header().Ttl)
 	})
 
 	t.Run("replace_max", func(t *testing.T) {
@@ -426,7 +426,7 @@ func TestCacheExpirationWithTTLOverride(t *testing.T) {
 		assert.Equal(t, msgToKey(d.Req), key)
 
 		require.NotNil(t, ci)
-		assert.Equal(t, dnsProxy.CacheMaxTTL, ci.m.Answer[0].Header().Ttl)
+		assert.Equal(t, dnsProxy.cacheMaxTTL, ci.m.Answer[0].Header().Ttl)
 	})
 }
 

proxy/config.go

@@ -274,38 +274,38 @@ type HTTPConfig struct {
 }
 
 // validateConfig verifies that the supplied configuration is valid and returns
-// an error if it's not.
+// an error if it's not.  c must be non-nil and valid.
 //
 // TODO(s.chzhen):  Use [validate.Interface] from golibs.
-func (p *Proxy) validateConfig() (err error) {
-	err = p.UpstreamConfig.validate()
+func (p *Proxy) validateConfig(c *Config) (err error) {
+	err = c.UpstreamConfig.validate()
 	if err != nil {
 		return fmt.Errorf("general upstreams: %w", err)
 	}
 
-	err = ValidatePrivateConfig(p.PrivateRDNSUpstreamConfig, p.privateNets)
+	err = ValidatePrivateConfig(c.PrivateRDNSUpstreamConfig, c.PrivateSubnets)
 	if err != nil {
-		if p.UsePrivateRDNS || errors.Is(err, upstream.ErrNoUpstreams) {
+		if c.UsePrivateRDNS || errors.Is(err, upstream.ErrNoUpstreams) {
 			return fmt.Errorf("private rdns upstreams: %w", err)
 		}
 	}
 
-	err = p.Fallbacks.validate()
-	// Allow [Proxy.Fallbacks] to be nil, but not empty.  nil means not to use
+	err = c.Fallbacks.validate()
+	// Allow [Config.Fallbacks] to be nil, but not empty.  nil means not to use
 	// fallbacks at all.
 	if errors.Is(err, upstream.ErrNoUpstreams) {
 		return fmt.Errorf("fallbacks: %w", err)
 	}
 
-	switch p.UpstreamMode {
+	switch c.UpstreamMode {
 	case
 		"",
 		UpstreamModeFastestAddr,
 		UpstreamModeLoadBalance,
 		UpstreamModeParallel:
 		// Go on.
 	default:
-		return fmt.Errorf("upstream mode: %w: %q", errors.ErrBadEnumValue, p.UpstreamMode)
+		return fmt.Errorf("upstream mode: %w: %q", errors.ErrBadEnumValue, c.UpstreamMode)
 	}
 
 	err = p.validateBasicAuth()
@@ -320,20 +320,20 @@ func (p *Proxy) validateConfig() (err error) {
 
 // logConfigInfo logs proxy configuration information.
 func (p *Proxy) logConfigInfo() {
-	if p.CacheMinTTL > 0 || p.CacheMaxTTL > 0 {
-		p.logger.Info("cache ttl override is enabled", "min", p.CacheMinTTL, "max", p.CacheMaxTTL)
+	if p.cacheMinTTL > 0 || p.cacheMaxTTL > 0 {
+		p.logger.Info("cache ttl override is enabled", "min", p.cacheMinTTL, "max", p.cacheMaxTTL)
 	}
 
-	if p.RefuseAny {
+	if p.refuseAny {
 		p.logger.Info("server will refuse requests of type any")
 	}
 
-	if len(p.BogusNXDomain) > 0 {
-		p.logger.Info("bogus-nxdomain ip specified", "prefix_len", len(p.BogusNXDomain))
+	if len(p.bogusNXDomain) > 0 {
+		p.logger.Info("bogus-nxdomain ip specified", "prefix_len", len(p.bogusNXDomain))
 	}
 
-	if p.UpstreamMode != "" {
-		p.logger.Info("upstream mode is set", "mode", p.UpstreamMode)
+	if p.upstreamMode != "" {
+		p.logger.Info("upstream mode is set", "mode", p.upstreamMode)
 	}
 }
 
@@ -351,12 +351,12 @@ func (p *Proxy) validateListenAddrs() (err error) {
 		return fmt.Errorf("invalid tls configuration: %w", err)
 	}
 
-	if p.DNSCryptResolverCert == nil || p.DNSCryptProviderName == "" {
-		if p.DNSCryptTCPListenAddr != nil {
+	if p.dnsCryptResolverCert == nil || p.dnsCryptProviderName == "" {
+		if p.dnsCryptTCPListenAddr != nil {
 			return errors.Error("cannot create dnscrypt tcp listener without dnscrypt config")
 		}
 
-		if p.DNSCryptUDPListenAddr != nil {
+		if p.dnsCryptUDPListenAddr != nil {
 			return errors.Error("cannot create dnscrypt udp listener without dnscrypt config")
 		}
 	}
@@ -367,19 +367,19 @@ func (p *Proxy) validateListenAddrs() (err error) {
 // validateTLSConfig returns an error if proxy TLS configuration parameters are
 // needed but aren't provided.
 func (p *Proxy) validateTLSConfig() (err error) {
-	if p.TLSConfig != nil {
+	if p.tlsConf != nil {
 		return nil
 	}
 
-	if p.TLSListenAddr != nil {
+	if p.tlsListenAddr != nil {
 		return errors.Error("tls listener configuration not found")
 	}
 
-	if p.HTTPConfig != nil && p.HTTPConfig.ListenAddresses != nil {
+	if p.httpConf != nil && p.httpConf.ListenAddresses != nil {
 		return errors.Error("https listener configuration not found")
 	}
 
-	if p.QUICListenAddr != nil {
+	if p.quicListenAddr != nil {
 		return errors.Error("quic listener configuration not found")
 	}
 
@@ -388,11 +388,11 @@ func (p *Proxy) validateTLSConfig() (err error) {
 
 // hasListenAddrs - is there any addresses to listen to?
 func (p *Proxy) hasListenAddrs() (ok bool) {
-	return p.UDPListenAddr != nil ||
-		p.TCPListenAddr != nil ||
-		p.TLSListenAddr != nil ||
-		(p.HTTPConfig != nil && p.HTTPConfig.ListenAddresses != nil) ||
-		p.QUICListenAddr != nil ||
-		p.DNSCryptUDPListenAddr != nil ||
-		p.DNSCryptTCPListenAddr != nil
+	return p.udpListenAddr != nil ||
+		p.tcpListenAddr != nil ||
+		p.tlsListenAddr != nil ||
+		(p.httpConf != nil && p.httpConf.ListenAddresses != nil) ||
+		p.quicListenAddr != nil ||
+		p.dnsCryptUDPListenAddr != nil ||
+		p.dnsCryptTCPListenAddr != nil
 }

proxy/dns64.go

@@ -40,24 +40,24 @@ const (
 // synthesize AAAA records.
 //
 // TODO(e.burkov):  Split validation and initialization.
-func (p *Proxy) setupDNS64() (err error) {
-	if !p.Config.UseDNS64 {
+func (p *Proxy) setupDNS64(dns64Prefs netutil.SliceSubnetSet) (err error) {
+	if !p.useDNS64 {
 		return nil
 	}
 
-	if len(p.Config.DNS64Prefs) == 0 {
+	if len(dns64Prefs) == 0 {
 		p.dns64Prefs = netutil.SliceSubnetSet{dns64WellKnownPref}
 
 		return nil
 	}
 
-	for i, pref := range p.Config.DNS64Prefs {
+	for i, pref := range dns64Prefs {
 		if !pref.Addr().Is6() {
-			return fmt.Errorf("prefix at index %d: %q is not an IPv6 prefix", i, pref)
+			return fmt.Errorf("prefix at index %d: %q is not an ipv6 prefix", i, pref)
 		}
 
 		if pref.Bits() > maxNAT64PrefixBitLen {
-			return fmt.Errorf("prefix at index %d: %q is too long for DNS64", i, pref)
+			return fmt.Errorf("prefix at index %d: %q is too long for dns64", i, pref)
 		}
 
 		p.dns64Prefs = append(p.dns64Prefs, pref.Masked())

proxy/exchange.go

@@ -18,7 +18,7 @@ func (p *Proxy) exchangeUpstreams(
 	req *dns.Msg,
 	ups []upstream.Upstream,
 ) (resp *dns.Msg, u upstream.Upstream, err error) {
-	switch p.UpstreamMode {
+	switch p.upstreamMode {
 	case UpstreamModeParallel:
 		return upstream.ExchangeParallel(ups, req)
 	case UpstreamModeFastestAddr:

proxy/lookup.go

@@ -81,7 +81,7 @@ func (p *Proxy) LookupNetIP(
 		return addrs, errors.Join(errs...)
 	}
 
-	if p.Config.PreferIPv6 {
+	if p.preferIPv6 {
 		slices.SortStableFunc(addrs, netutil.PreferIPv6)
 	} else {
 		slices.SortStableFunc(addrs, netutil.PreferIPv4)