elmprodvpn/selective-vpn-api/app/resolver_bridge_dns.go

package app

import (
	"strings"
	"time"

	resolverpkg "selective-vpn-api/app/resolver"
)

func loadDNSConfig(path string, logf func(string, ...any)) dnsConfig {
	cfg := resolverpkg.LoadDNSConfig(
		path,
		resolverpkg.DNSConfig{
			Default:  []string{defaultDNS1, defaultDNS2},
			Meta:     []string{defaultMeta1, defaultMeta2},
			SmartDNS: smartDNSAddr(),
			Mode:     string(DNSModeDirect),
		},
		resolverpkg.DNSConfigDeps{
			ActivePool:         loadEnabledDNSUpstreamPool(),
			IsSmartDNSForced:   smartDNSForced(),
			SmartDNSAddr:       smartDNSAddr(),
			SmartDNSForcedMode: string(DNSModeSmartDNS),
			ResolveFallbackPool: func() []string {
				return resolverFallbackPool()
			},
			MergeDNSUpstreamPools: func(primary, fallback []string) []string {
				return mergeDNSUpstreamPools(primary, fallback)
			},
			NormalizeDNSUpstream: func(raw string, defaultPort string) string {
				return normalizeDNSUpstream(raw, defaultPort)
			},
			NormalizeSmartDNSAddr: normalizeSmartDNSAddr,
			NormalizeDNSResolverMode: func(raw string) string {
				return string(normalizeDNSResolverMode(DNSResolverMode(raw), false))
			},
		},
		logf,
	)
	return dnsConfig{
		Default:  cfg.Default,
		Meta:     cfg.Meta,
		SmartDNS: cfg.SmartDNS,
		Mode:     DNSResolverMode(cfg.Mode),
	}
}

type resolverCooldownAdapter struct {
	inner *dnsRunCooldown
}

func (a resolverCooldownAdapter) ShouldSkip(upstream string, now int64) bool {
	if a.inner == nil {
		return false
	}
	return a.inner.shouldSkip(upstream, now)
}

func (a resolverCooldownAdapter) ObserveSuccess(upstream string) {
	if a.inner == nil {
		return
	}
	a.inner.observeSuccess(upstream)
}

func (a resolverCooldownAdapter) ObserveError(upstream string, kind resolverpkg.DNSErrorKind, now int64) (bool, int) {
	if a.inner == nil {
		return false, 0
	}
	return a.inner.observeError(upstream, dnsErrorKind(kind), now)
}

func toResolverPolicy(policy dnsAttemptPolicy) resolverpkg.DNSAttemptPolicy {
	return resolverpkg.DNSAttemptPolicy{
		TryLimit:     policy.TryLimit,
		DomainBudget: policy.DomainBudget,
		StopOnNX:     policy.StopOnNX,
	}
}

func resolveHostGo(host string, cfg dnsConfig, metaSpecial []string, wildcards wildcardMatcher, timeout time.Duration, cooldown *dnsRunCooldown, logf func(string, ...any)) ([]string, dnsMetrics) {
	return resolverpkg.ResolveHost(
		host,
		resolverpkg.DNSConfig{
			Default:  cfg.Default,
			Meta:     cfg.Meta,
			SmartDNS: cfg.SmartDNS,
			Mode:     string(cfg.Mode),
		},
		metaSpecial,
		func(h string) bool { return wildcards.Match(h) },
		timeout,
		resolverCooldownAdapter{inner: cooldown},
		func(dnsCount int) resolverpkg.DNSAttemptPolicy {
			return toResolverPolicy(directDNSAttemptPolicy(dnsCount))
		},
		func(dnsCount int) resolverpkg.DNSAttemptPolicy {
			return toResolverPolicy(wildcardDNSAttemptPolicy(dnsCount))
		},
		smartDNSFallbackForTimeoutEnabled(),
		logf,
	)
}

func digA(host string, dnsList []string, timeout time.Duration, logf func(string, ...any)) ([]string, dnsMetrics) {
	policy := toResolverPolicy(defaultDNSAttemptPolicy(len(dnsList)))
	return resolverpkg.DigAWithPolicy(host, dnsList, timeout, policy, nil, logf)
}

func digAWithPolicy(host string, dnsList []string, timeout time.Duration, logf func(string, ...any), policy dnsAttemptPolicy, cooldown *dnsRunCooldown) ([]string, dnsMetrics) {
	return resolverpkg.DigAWithPolicy(host, dnsList, timeout, toResolverPolicy(policy), resolverCooldownAdapter{inner: cooldown}, logf)
}

func applyResolverDNSModeRuntime(cfg dnsConfig, opts ResolverOpts) dnsConfig {
	out := resolverpkg.ApplyDNSModeRuntime(resolverpkg.DNSModeRuntimeInput{
		Config: resolverpkg.DNSConfig{
			Default:  cfg.Default,
			Meta:     cfg.Meta,
			SmartDNS: cfg.SmartDNS,
			Mode:     string(cfg.Mode),
		},
		Mode:            string(opts.Mode),
		ViaSmartDNS:     opts.ViaSmartDNS,
		SmartDNSAddr:    opts.SmartDNSAddr,
		SmartDNSForced:  smartDNSForced(),
		SmartDNSDefault: smartDNSAddr(),
		NormalizeMode: func(mode string, viaSmartDNS bool) string {
			return string(normalizeDNSResolverMode(DNSResolverMode(mode), viaSmartDNS))
		},
		NormalizeSmartDNSAddr: normalizeSmartDNSAddr,
	})
	return dnsConfig{
		Default:  out.Default,
		Meta:     out.Meta,
		SmartDNS: out.SmartDNS,
		Mode:     DNSResolverMode(out.Mode),
	}
}

func logResolverDNSMode(cfg dnsConfig, wildcards wildcardMatcher, logf func(string, ...any)) {
	resolverpkg.LogDNSMode(
		resolverpkg.DNSConfig{
			Default:  cfg.Default,
			Meta:     cfg.Meta,
			SmartDNS: cfg.SmartDNS,
			Mode:     string(cfg.Mode),
		},
		wildcards.Count(),
		logf,
	)
}

func parseStaticEntriesGo(lines []string, logf func(string, ...any)) (entries [][3]string, skipped int) {
	return resolverpkg.ParseStaticEntries(lines, logf)
}

func resolveStaticLabels(entries [][3]string, cfg dnsConfig, ptrCache map[string]any, ttl int, logf func(string, ...any)) (map[string][]string, int, int) {
	dnsForPtr := defaultDNS1
	if len(cfg.Default) > 0 && strings.TrimSpace(cfg.Default[0]) != "" {
		dnsForPtr = cfg.Default[0]
	}
	return resolverpkg.ResolveStaticLabels(entries, dnsForPtr, ptrCache, ttl, logf)
}

func digPTR(ip, upstream string, timeout time.Duration, logf func(string, ...any)) ([]string, error) {
	return resolverpkg.DigPTR(ip, upstream, timeout, logf)
}

func logResolverSummary(input resolverpkg.ResolverSummaryLogInput, logf func(string, ...any)) {
	resolverpkg.LogResolverSummary(input, logf)
}