From 25b381e138c7d9fd2e49af95f1ba5ca20be3df39 Mon Sep 17 00:00:00 2001 From: Quentin McGaw Date: Mon, 17 Nov 2025 15:17:57 +0000 Subject: [PATCH] fix linting errors --- internal/configuration/settings/dns.go | 18 ++++++------- internal/dns/settings.go | 35 +++++++++++++------------- 2 files changed, 27 insertions(+), 26 deletions(-) diff --git a/internal/configuration/settings/dns.go b/internal/configuration/settings/dns.go index 74f7d9ae..74185c7d 100644 --- a/internal/configuration/settings/dns.go +++ b/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 } diff --git a/internal/dns/settings.go b/internal/dns/settings.go index 7bf7b735..60bb0c25 100644 --- a/internal/dns/settings.go +++ b/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(), }