fix linting errors

internal/configuration/settings/dns.go

@@ -15,9 +15,9 @@ import (
 )
 
 const (
-	dnsUpstreamTypeDot   = "dot"
-	dnsUpstreamTypeDoh   = "doh"
-	dnsUpstreamTypePlain = "plain"
+	DNSUpstreamTypeDot   = "dot"
+	DNSUpstreamTypeDoh   = "doh"
+	DNSUpstreamTypePlain = "plain"
 )
 
 // DNS contains settings to configure DNS.
@@ -58,7 +58,7 @@ var (
 )
 
 func (d DNS) validate() (err error) {
-	if !helpers.IsOneOf(d.UpstreamType, dnsUpstreamTypeDot, dnsUpstreamTypeDoh, dnsUpstreamTypePlain) {
+	if !helpers.IsOneOf(d.UpstreamType, DNSUpstreamTypeDot, DNSUpstreamTypeDoh, DNSUpstreamTypePlain) {
 		return fmt.Errorf("%w: %s", ErrDNSUpstreamTypeNotValid, d.UpstreamType)
 	}
 
@@ -76,7 +76,7 @@ func (d DNS) validate() (err error) {
 		}
 	}
 
-	if d.UpstreamType == dnsUpstreamTypePlain {
+	if d.UpstreamType == DNSUpstreamTypePlain {
 		if *d.IPv6 && !slices.ContainsFunc(d.UpstreamPlainAddresses, func(addrPort netip.AddrPort) bool {
 			return addrPort.Addr().Is6()
 		}) {
@@ -122,7 +122,7 @@ func (d *DNS) overrideWith(other DNS) {
 }
 
 func (d *DNS) setDefaults() {
-	d.UpstreamType = gosettings.DefaultComparable(d.UpstreamType, dnsUpstreamTypeDot)
+	d.UpstreamType = gosettings.DefaultComparable(d.UpstreamType, DNSUpstreamTypeDot)
 	const defaultUpdatePeriod = 24 * time.Hour
 	d.UpdatePeriod = gosettings.DefaultPointer(d.UpdatePeriod, defaultUpdatePeriod)
 	d.Providers = gosettings.DefaultSlice(d.Providers, []string{
@@ -141,7 +141,7 @@ func defaultDNSProviders() []string {
 }
 
 func (d DNS) GetFirstPlaintextIPv4() (ipv4 netip.Addr) {
-	if d.UpstreamType == dnsUpstreamTypePlain {
+	if d.UpstreamType == DNSUpstreamTypePlain {
 		for _, addrPort := range d.UpstreamPlainAddresses {
 			if addrPort.Addr().Is4() {
 				return addrPort.Addr()
@@ -191,7 +191,7 @@ func (d DNS) toLinesNode() (node *gotree.Node) {
 
 	upstreamResolvers := node.Append("Upstream resolvers:")
 	if len(d.UpstreamPlainAddresses) > 0 {
-		if d.UpstreamType == dnsUpstreamTypePlain {
+		if d.UpstreamType == DNSUpstreamTypePlain {
 			for _, addr := range d.UpstreamPlainAddresses {
 				upstreamResolvers.Append(addr.String())
 			}
@@ -279,7 +279,7 @@ func (d *DNS) readUpstreamPlainAddresses(r *reader.Reader) (err error) {
 	const defaultPlainPort = 53
 	addrPort := netip.AddrPortFrom(serverAddress, defaultPlainPort)
 	d.UpstreamPlainAddresses = append(d.UpstreamPlainAddresses, addrPort)
-	d.UpstreamType = dnsUpstreamTypePlain
+	d.UpstreamType = DNSUpstreamTypePlain
 	d.Providers = []string{}
 	return nil
 }

internal/dns/settings.go

@@ -26,23 +26,23 @@ func (l *Loop) SetSettings(ctx context.Context, settings settings.DNS) (
 	return l.state.SetSettings(ctx, settings)
 }
 
-func buildServerSettings(settings settings.DNS,
+func buildServerSettings(userSettings settings.DNS,
 	filter *mapfilter.Filter, localResolvers []netip.Addr,
 	logger Logger) (
 	serverSettings server.Settings, err error,
 ) {
 	serverSettings.Logger = logger
 
-	upstreamResolvers := buildProviders(settings)
+	upstreamResolvers := buildProviders(userSettings)
 
 	ipVersion := "ipv4"
-	if *settings.IPv6 {
+	if *userSettings.IPv6 {
 		ipVersion = "ipv6"
 	}
 
 	var dialer server.Dialer
-	switch settings.UpstreamType {
-	case "dot":
+	switch userSettings.UpstreamType {
+	case settings.DNSUpstreamTypeDot:
 		dialerSettings := dot.Settings{
 			UpstreamResolvers: upstreamResolvers,
 			IPVersion:         ipVersion,
@@ -51,7 +51,7 @@ func buildServerSettings(settings settings.DNS,
 		if err != nil {
 			return server.Settings{}, fmt.Errorf("creating DNS over TLS dialer: %w", err)
 		}
-	case "doh":
+	case settings.DNSUpstreamTypeDoh:
 		dialerSettings := doh.Settings{
 			UpstreamResolvers: upstreamResolvers,
 			IPVersion:         ipVersion,
@@ -60,7 +60,7 @@ func buildServerSettings(settings settings.DNS,
 		if err != nil {
 			return server.Settings{}, fmt.Errorf("creating DNS over HTTPS dialer: %w", err)
 		}
-	case "plain":
+	case settings.DNSUpstreamTypePlain:
 		dialerSettings := plain.Settings{
 			UpstreamResolvers: upstreamResolvers,
 			IPVersion:         ipVersion,
@@ -70,11 +70,11 @@ func buildServerSettings(settings settings.DNS,
 			return server.Settings{}, fmt.Errorf("creating plain DNS dialer: %w", err)
 		}
 	default:
-		panic("unknown upstream type: " + settings.UpstreamType)
+		panic("unknown upstream type: " + userSettings.UpstreamType)
 	}
 	serverSettings.Dialer = dialer
 
-	if *settings.Caching {
+	if *userSettings.Caching {
 		lruCache, err := lru.New(lru.Settings{})
 		if err != nil {
 			return server.Settings{}, fmt.Errorf("creating LRU cache: %w", err)
@@ -116,10 +116,11 @@ func buildServerSettings(settings settings.DNS,
 	return serverSettings, nil
 }
 
-func buildProviders(settings settings.DNS) []provider.Provider {
-	if settings.UpstreamType == "plain" && len(settings.UpstreamPlainAddresses) > 0 {
-		providers := make([]provider.Provider, len(settings.UpstreamPlainAddresses))
-		for i, addrPort := range settings.UpstreamPlainAddresses {
+func buildProviders(userSettings settings.DNS) []provider.Provider {
+	if userSettings.UpstreamType == settings.DNSUpstreamTypePlain &&
+		len(userSettings.UpstreamPlainAddresses) > 0 {
+		providers := make([]provider.Provider, len(userSettings.UpstreamPlainAddresses))
+		for i, addrPort := range userSettings.UpstreamPlainAddresses {
 			providers[i] = provider.Provider{
 				Name: addrPort.String(),
 			}
@@ -132,8 +133,8 @@ func buildProviders(settings settings.DNS) []provider.Provider {
 	}
 
 	providersData := provider.NewProviders()
-	providers := make([]provider.Provider, 0, len(settings.Providers)+len(settings.UpstreamPlainAddresses))
-	for _, providerName := range settings.Providers {
+	providers := make([]provider.Provider, 0, len(userSettings.Providers)+len(userSettings.UpstreamPlainAddresses))
+	for _, providerName := range userSettings.Providers {
 		provider, err := providersData.Get(providerName)
 		if err != nil {
 			panic(err) // this should already had been checked
@@ -141,11 +142,11 @@ func buildProviders(settings settings.DNS) []provider.Provider {
 		providers = append(providers, provider)
 	}
 
-	if settings.UpstreamType != "plain" {
+	if userSettings.UpstreamType != settings.DNSUpstreamTypePlain {
 		return providers
 	}
 
-	for _, addrPort := range settings.UpstreamPlainAddresses {
+	for _, addrPort := range userSettings.UpstreamPlainAddresses {
 		newProvider := provider.Provider{
 			Name: addrPort.String(),
 		}