webnet
/
tailscale
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tailcfg,all: change structs to []*dnstype.Resolver

Browse Source 
Signed-off-by: Maisem Ali <maisem@tailscale.com>
main
Maisem Ali 4 years ago committed by Maisem Ali
parent 679415f3a8
commit fd99c54e10
14 changed files with 69 additions and 68 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 30
      ipn/ipnlocal/dnsconfig_test.go
  2. 9
      ipn/ipnlocal/local.go
  3. 10
      net/dns/config.go
  4. 8
      net/dns/manager.go
  5. 14
      net/dns/manager_test.go
  6. 8
      net/dns/resolver/forwarder.go
  7. 8
      net/dns/resolver/forwarder_test.go
  8. 10
      net/dns/resolver/tsdns.go
  9. 10
      net/dns/resolver/tsdns_test.go
  10. 6
      tailcfg/tailcfg.go
  11. 18
      tailcfg/tailcfg_clone.go
  12. 2
      tstest/integration/vms/harness_test.go
  13. 2
      util/deephash/deephash_test.go
  14. 2
      wgengine/userspace.go

30
ipn/ipnlocal/dnsconfig_test.go
Unescape View File

@ -51,7 +51,7 @@ func TestDNSConfigForNetmap(t *testing.T) {
nm: &netmap.NetworkMap{},
prefs: &ipn.Prefs{},
want: &dns.Config{
Routes: map[dnsname.FQDN][]dnstype.Resolver{},
Routes: map[dnsname.FQDN][]*dnstype.Resolver{},
Hosts: map[dnsname.FQDN][]netaddr.IP{},
},
},
@ -77,7 +77,7 @@ func TestDNSConfigForNetmap(t *testing.T) {
},
prefs: &ipn.Prefs{},
want: &dns.Config{
Routes: map[dnsname.FQDN][]dnstype.Resolver{},
Routes: map[dnsname.FQDN][]*dnstype.Resolver{},
Hosts: map[dnsname.FQDN][]netaddr.IP{
"b.net.": ips("100.102.0.1", "100.102.0.2"),
"myname.net.": ips("100.101.101.101"),
@ -112,7 +112,7 @@ func TestDNSConfigForNetmap(t *testing.T) {
prefs: &ipn.Prefs{},
want: &dns.Config{
OnlyIPv6: true,
Routes: map[dnsname.FQDN][]dnstype.Resolver{},
Routes: map[dnsname.FQDN][]*dnstype.Resolver{},
Hosts: map[dnsname.FQDN][]netaddr.IP{
"b.net.": ips("fe75::2"),
"myname.net.": ips("fe75::1"),
@ -136,7 +136,7 @@ func TestDNSConfigForNetmap(t *testing.T) {
},
prefs: &ipn.Prefs{},
want: &dns.Config{
Routes: map[dnsname.FQDN][]dnstype.Resolver{},
Routes: map[dnsname.FQDN][]*dnstype.Resolver{},
Hosts: map[dnsname.FQDN][]netaddr.IP{
"myname.net.": ips("100.101.101.101"),
"foo.com.": ips("1.2.3.4"),
@ -158,7 +158,7 @@ func TestDNSConfigForNetmap(t *testing.T) {
},
want: &dns.Config{
Hosts: map[dnsname.FQDN][]netaddr.IP{},
Routes: map[dnsname.FQDN][]dnstype.Resolver{
Routes: map[dnsname.FQDN][]*dnstype.Resolver{
"0.e.1.a.c.5.1.1.a.7.d.f.ip6.arpa.": nil,
"100.100.in-addr.arpa.": nil,
"101.100.in-addr.arpa.": nil,
@ -242,13 +242,13 @@ func TestDNSConfigForNetmap(t *testing.T) {
os: "android",
nm: &netmap.NetworkMap{
DNS: tailcfg.DNSConfig{
Resolvers: []dnstype.Resolver{
Resolvers: []*dnstype.Resolver{
{Addr: "8.8.8.8"},
},
FallbackResolvers: []dnstype.Resolver{
FallbackResolvers: []*dnstype.Resolver{
{Addr: "8.8.4.4"},
},
Routes: map[string][]dnstype.Resolver{
Routes: map[string][]*dnstype.Resolver{
"foo.com.": {{Addr: "1.2.3.4"}},
},
},
@ -258,10 +258,10 @@ func TestDNSConfigForNetmap(t *testing.T) {
},
want: &dns.Config{
Hosts: map[dnsname.FQDN][]netaddr.IP{},
DefaultResolvers: []dnstype.Resolver{
DefaultResolvers: []*dnstype.Resolver{
{Addr: "8.8.8.8"},
},
Routes: map[dnsname.FQDN][]dnstype.Resolver{
Routes: map[dnsname.FQDN][]*dnstype.Resolver{
"foo.com.": {{Addr: "1.2.3.4"}},
},
},
@ -270,7 +270,7 @@ func TestDNSConfigForNetmap(t *testing.T) {
name: "exit_nodes_need_fallbacks",
nm: &netmap.NetworkMap{
DNS: tailcfg.DNSConfig{
FallbackResolvers: []dnstype.Resolver{
FallbackResolvers: []*dnstype.Resolver{
{Addr: "8.8.4.4"},
},
},
@ -281,8 +281,8 @@ func TestDNSConfigForNetmap(t *testing.T) {
},
want: &dns.Config{
Hosts: map[dnsname.FQDN][]netaddr.IP{},
Routes: map[dnsname.FQDN][]dnstype.Resolver{},
DefaultResolvers: []dnstype.Resolver{
Routes: map[dnsname.FQDN][]*dnstype.Resolver{},
DefaultResolvers: []*dnstype.Resolver{
{Addr: "8.8.4.4"},
},
},
@ -291,7 +291,7 @@ func TestDNSConfigForNetmap(t *testing.T) {
name: "not_exit_node_NOT_need_fallbacks",
nm: &netmap.NetworkMap{
DNS: tailcfg.DNSConfig{
FallbackResolvers: []dnstype.Resolver{
FallbackResolvers: []*dnstype.Resolver{
{Addr: "8.8.4.4"},
},
},
@ -301,7 +301,7 @@ func TestDNSConfigForNetmap(t *testing.T) {
},
want: &dns.Config{
Hosts: map[dnsname.FQDN][]netaddr.IP{},
Routes: map[dnsname.FQDN][]dnstype.Resolver{},
Routes: map[dnsname.FQDN][]*dnstype.Resolver{},
},
},
}

9
ipn/ipnlocal/local.go
Unescape View File

@ -2112,7 +2112,7 @@ func (b *LocalBackend) authReconfig() {
// a runtime.GOOS.
func dnsConfigForNetmap(nm *netmap.NetworkMap, prefs *ipn.Prefs, logf logger.Logf, versionOS string) *dns.Config {
dcfg := &dns.Config{
Routes: map[dnsname.FQDN][]dnstype.Resolver{},
Routes: map[dnsname.FQDN][]*dnstype.Resolver{},
Hosts: map[dnsname.FQDN][]netaddr.IP{},
}
@ -2199,8 +2199,9 @@ func dnsConfigForNetmap(nm *netmap.NetworkMap, prefs *ipn.Prefs, logf logger.Log
}
}
addDefault := func(resolvers []dnstype.Resolver) {
addDefault := func(resolvers []*dnstype.Resolver) {
for _, r := range resolvers {
r := r
dcfg.DefaultResolvers = append(dcfg.DefaultResolvers, r)
}
}
@ -2208,7 +2209,7 @@ func dnsConfigForNetmap(nm *netmap.NetworkMap, prefs *ipn.Prefs, logf logger.Log
// If we're using an exit node and that exit node is new enough (1.19.x+)
// to run a DoH DNS proxy, then send all our DNS traffic through it.
if dohURL, ok := exitNodeCanProxyDNS(nm, prefs.ExitNodeID); ok {
addDefault([]dnstype.Resolver{{Addr: dohURL}})
addDefault([]*dnstype.Resolver{{Addr: dohURL}})
return dcfg
}
@ -2227,7 +2228,7 @@ func dnsConfigForNetmap(nm *netmap.NetworkMap, prefs *ipn.Prefs, logf logger.Log
//
// While we're already populating it, might as well size the
// slice appropriately.
dcfg.Routes[fqdn] = make([]dnstype.Resolver, 0, len(resolvers))
dcfg.Routes[fqdn] = make([]*dnstype.Resolver, 0, len(resolvers))
for _, r := range resolvers {
dcfg.Routes[fqdn] = append(dcfg.Routes[fqdn], r)

10
net/dns/config.go
Unescape View File

@ -22,14 +22,14 @@ type Config struct {
// which aren't covered by more specific per-domain routes below.
// If empty, the OS's default resolvers (the ones that predate
// Tailscale altering the configuration) are used.
DefaultResolvers []dnstype.Resolver
DefaultResolvers []*dnstype.Resolver
// Routes maps a DNS suffix to the resolvers that should be used
// for queries that fall within that suffix.
// If a query doesn't match any entry in Routes, the
// DefaultResolvers are used.
// A Routes entry with no resolvers means the route should be
// authoritatively answered using the contents of Hosts.
Routes map[dnsname.FQDN][]dnstype.Resolver
Routes map[dnsname.FQDN][]*dnstype.Resolver
// SearchDomains are DNS suffixes to try when expanding
// single-label queries.
SearchDomains []dnsname.FQDN
@ -98,9 +98,9 @@ func (c Config) hasDefaultResolvers() bool {
// singleResolverSet returns the resolvers used by c.Routes if all
// routes use the same resolvers, or nil if multiple sets of resolvers
// are specified.
func (c Config) singleResolverSet() []dnstype.Resolver {
func (c Config) singleResolverSet() []*dnstype.Resolver {
var (
prev []dnstype.Resolver
prev []*dnstype.Resolver
prevInitialized bool
)
for _, resolvers := range c.Routes {
@ -128,7 +128,7 @@ func (c Config) matchDomains() []dnsname.FQDN {
return ret
}
func sameResolverNames(a, b []dnstype.Resolver) bool {
func sameResolverNames(a, b []*dnstype.Resolver) bool {
if len(a) != len(b) {
return false
}

8
net/dns/manager.go
Unescape View File

@ -144,7 +144,7 @@ func (m *Manager) compileConfig(cfg Config) (rcfg resolver.Config, ocfg OSConfig
// authoritative suffixes, even if we don't propagate MagicDNS to
// the OS.
rcfg.Hosts = cfg.Hosts
routes := map[dnsname.FQDN][]dnstype.Resolver{} // assigned conditionally to rcfg.Routes below.
routes := map[dnsname.FQDN][]*dnstype.Resolver{} // assigned conditionally to rcfg.Routes below.
for suffix, resolvers := range cfg.Routes {
if len(resolvers) == 0 {
rcfg.LocalDomains = append(rcfg.LocalDomains, suffix)
@ -225,9 +225,9 @@ func (m *Manager) compileConfig(cfg Config) (rcfg resolver.Config, ocfg OSConfig
health.SetDNSOSHealth(err)
return resolver.Config{}, OSConfig{}, err
}
var defaultRoutes []dnstype.Resolver
var defaultRoutes []*dnstype.Resolver
for _, ip := range bcfg.Nameservers {
defaultRoutes = append(defaultRoutes, dnstype.Resolver{Addr: ip.String()})
defaultRoutes = append(defaultRoutes, &dnstype.Resolver{Addr: ip.String()})
}
rcfg.Routes["."] = defaultRoutes
ocfg.SearchDomains = append(ocfg.SearchDomains, bcfg.SearchDomains...)
@ -239,7 +239,7 @@ func (m *Manager) compileConfig(cfg Config) (rcfg resolver.Config, ocfg OSConfig
// toIPsOnly returns only the IP portion of dnstype.Resolver.
// Only safe to use if the resolvers slice has been cleared of
// DoH or custom-port entries with something like hasDefaultIPResolversOnly.
func toIPsOnly(resolvers []dnstype.Resolver) (ret []netaddr.IP) {
func toIPsOnly(resolvers []*dnstype.Resolver) (ret []netaddr.IP) {
for _, r := range resolvers {
if ipp, ok := r.IPPort(); ok && ipp.Port() == 53 {
ret = append(ret, ipp.IP())

14
net/dns/manager_test.go
Unescape View File

@ -437,9 +437,9 @@ func mustIPPs(strs ...string) (ret []netaddr.IPPort) {
return ret
}
func mustRes(strs ...string) (ret []dnstype.Resolver) {
func mustRes(strs ...string) (ret []*dnstype.Resolver) {
for _, s := range strs {
ret = append(ret, dnstype.Resolver{Addr: s})
ret = append(ret, &dnstype.Resolver{Addr: s})
}
return ret
}
@ -495,9 +495,9 @@ func hostsR(strs ...string) (ret map[dnsname.FQDN][]dnstype.Resolver) {
return ret
}
func upstreams(strs ...string) (ret map[dnsname.FQDN][]dnstype.Resolver) {
func upstreams(strs ...string) (ret map[dnsname.FQDN][]*dnstype.Resolver) {
var key dnsname.FQDN
ret = map[dnsname.FQDN][]dnstype.Resolver{}
ret = map[dnsname.FQDN][]*dnstype.Resolver{}
for _, s := range strs {
if s == "" {
if key == "" {
@ -508,14 +508,14 @@ func upstreams(strs ...string) (ret map[dnsname.FQDN][]dnstype.Resolver) {
if key == "" {
panic("IPPort provided before suffix")
}
ret[key] = append(ret[key], dnstype.Resolver{Addr: ipp.String()})
ret[key] = append(ret[key], &dnstype.Resolver{Addr: ipp.String()})
} else if _, err := netaddr.ParseIP(s); err == nil {
if key == "" {
panic("IPPort provided before suffix")
}
ret[key] = append(ret[key], dnstype.Resolver{Addr: s})
ret[key] = append(ret[key], &dnstype.Resolver{Addr: s})
} else if strings.HasPrefix(s, "http") {
ret[key] = append(ret[key], dnstype.Resolver{Addr: s})
ret[key] = append(ret[key], &dnstype.Resolver{Addr: s})
} else {
fqdn, err := dnsname.ToFQDN(s)
if err != nil {

8
net/dns/resolver/forwarder.go
Unescape View File

@ -170,7 +170,7 @@ type route struct {
// long to wait before querying it.
type resolverAndDelay struct {
// name is the upstream resolver.
name dnstype.Resolver
name *dnstype.Resolver
// startDelay is an amount to delay this resolver at
// start. It's used when, say, there are four Google or
@ -246,7 +246,7 @@ func (f *forwarder) Close() error {
// resolversWithDelays maps from a set of DNS server names to a slice of a type
// that included a startDelay, upgrading any well-known DoH (DNS-over-HTTP)
// servers in the process, insert a DoH lookup first before UDP fallbacks.
func resolversWithDelays(resolvers []dnstype.Resolver) []resolverAndDelay {
func resolversWithDelays(resolvers []*dnstype.Resolver) []resolverAndDelay {
rr := make([]resolverAndDelay, 0, len(resolvers)+2)
// Add the known DoH ones first, starting immediately.
@ -261,7 +261,7 @@ func resolversWithDelays(resolvers []dnstype.Resolver) []resolverAndDelay {
continue
}
didDoH[dohBase] = true
rr = append(rr, resolverAndDelay{name: dnstype.Resolver{Addr: dohBase}})
rr = append(rr, resolverAndDelay{name: &dnstype.Resolver{Addr: dohBase}})
}
type hostAndFam struct {
@ -300,7 +300,7 @@ func resolversWithDelays(resolvers []dnstype.Resolver) []resolverAndDelay {
// Resolver.SetConfig on reconfig.
//
// The memory referenced by routesBySuffix should not be modified.
func (f *forwarder) setRoutes(routesBySuffix map[dnsname.FQDN][]dnstype.Resolver) {
func (f *forwarder) setRoutes(routesBySuffix map[dnsname.FQDN][]*dnstype.Resolver) {
routes := make([]route, 0, len(routesBySuffix))
for suffix, rs := range routesBySuffix {
routes = append(routes, route{

8
net/dns/resolver/forwarder_test.go
Unescape View File

@ -23,9 +23,9 @@ func (rr resolverAndDelay) String() string {
func TestResolversWithDelays(t *testing.T) {
// query
q := func(ss ...string) (ipps []dnstype.Resolver) {
q := func(ss ...string) (ipps []*dnstype.Resolver) {
for _, host := range ss {
ipps = append(ipps, dnstype.Resolver{Addr: host})
ipps = append(ipps, &dnstype.Resolver{Addr: host})
}
return
}
@ -42,7 +42,7 @@ func TestResolversWithDelays(t *testing.T) {
}
}
rr = append(rr, resolverAndDelay{
name: dnstype.Resolver{Addr: s},
name: &dnstype.Resolver{Addr: s},
startDelay: d,
})
}
@ -51,7 +51,7 @@ func TestResolversWithDelays(t *testing.T) {
tests := []struct {
name string
in []dnstype.Resolver
in []*dnstype.Resolver
want []resolverAndDelay
}{
{

10
net/dns/resolver/tsdns.go
Unescape View File

@ -66,7 +66,7 @@ type Config struct {
// queries within that suffix.
// Queries only match the most specific suffix.
// To register a "default route", add an entry for ".".
Routes map[dnsname.FQDN][]dnstype.Resolver
Routes map[dnsname.FQDN][]*dnstype.Resolver
// LocalHosts is a map of FQDNs to corresponding IPs.
Hosts map[dnsname.FQDN][]netaddr.IP
// LocalDomains is a list of DNS name suffixes that should not be
@ -115,7 +115,7 @@ func WriteIPPorts(w *bufio.Writer, vv []netaddr.IPPort) {
}
// WriteDNSResolver writes r to w.
func WriteDNSResolver(w *bufio.Writer, r dnstype.Resolver) {
func WriteDNSResolver(w *bufio.Writer, r *dnstype.Resolver) {
io.WriteString(w, r.Addr)
if len(r.BootstrapResolution) > 0 {
w.WriteByte('(')
@ -129,7 +129,7 @@ func WriteDNSResolver(w *bufio.Writer, r dnstype.Resolver) {
}
// WriteDNSResolvers writes resolvers to w.
func WriteDNSResolvers(w *bufio.Writer, resolvers []dnstype.Resolver) {
func WriteDNSResolvers(w *bufio.Writer, resolvers []*dnstype.Resolver) {
w.WriteByte('[')
for i, r := range resolvers {
if i > 0 {
@ -142,7 +142,7 @@ func WriteDNSResolvers(w *bufio.Writer, resolvers []dnstype.Resolver) {
// WriteRoutes writes routes to w, omitting *.arpa routes and instead
// summarizing how many of them there were.
func WriteRoutes(w *bufio.Writer, routes map[dnsname.FQDN][]dnstype.Resolver) {
func WriteRoutes(w *bufio.Writer, routes map[dnsname.FQDN][]*dnstype.Resolver) {
var kk []dnsname.FQDN
arpa := 0
for k := range routes {
@ -347,7 +347,7 @@ func (r *Resolver) HandleExitNodeDNSQuery(ctx context.Context, q []byte, from ne
// will use its default ones from our DNS config.
} else {
resolvers = []resolverAndDelay{{
name: dnstype.Resolver{Addr: net.JoinHostPort(nameserver.String(), "53")},
name: &dnstype.Resolver{Addr: net.JoinHostPort(nameserver.String(), "53")},
}}
}

10
net/dns/resolver/tsdns_test.go
Unescape View File

@ -480,10 +480,10 @@ func TestDelegate(t *testing.T) {
defer r.Close()
cfg := dnsCfg
cfg.Routes = map[dnsname.FQDN][]dnstype.Resolver{
cfg.Routes = map[dnsname.FQDN][]*dnstype.Resolver{
".": {
dnstype.Resolver{Addr: v4server.PacketConn.LocalAddr().String()},
dnstype.Resolver{Addr: v6server.PacketConn.LocalAddr().String()},
&dnstype.Resolver{Addr: v4server.PacketConn.LocalAddr().String()},
&dnstype.Resolver{Addr: v6server.PacketConn.LocalAddr().String()},
},
}
r.SetConfig(cfg)
@ -655,7 +655,7 @@ func TestDelegateSplitRoute(t *testing.T) {
defer r.Close()
cfg := dnsCfg
cfg.Routes = map[dnsname.FQDN][]dnstype.Resolver{
cfg.Routes = map[dnsname.FQDN][]*dnstype.Resolver{
".": {{Addr: server1.PacketConn.LocalAddr().String()}},
"other.": {{Addr: server2.PacketConn.LocalAddr().String()}},
}
@ -947,7 +947,7 @@ func BenchmarkFull(b *testing.B) {
defer r.Close()
cfg := dnsCfg
cfg.Routes = map[dnsname.FQDN][]dnstype.Resolver{
cfg.Routes = map[dnsname.FQDN][]*dnstype.Resolver{
".": {{Addr: server.PacketConn.LocalAddr().String()}},
}

6
tailcfg/tailcfg.go
Unescape View File

@ -1003,7 +1003,7 @@ var FilterAllowAll = []FilterRule{
// DNSConfig is the DNS configuration.
type DNSConfig struct {
// Resolvers are the DNS resolvers to use, in order of preference.
Resolvers []dnstype.Resolver `json:",omitempty"`
Resolvers []*dnstype.Resolver `json:",omitempty"`
// Routes maps DNS name suffixes to a set of DNS resolvers to
// use. It is used to implement "split DNS" and other advanced DNS
@ -1015,13 +1015,13 @@ type DNSConfig struct {
// If the value is an empty slice, that means the suffix should still
// be handled by Tailscale's built-in resolver (100.100.100.100), such
// as for the purpose of handling ExtraRecords.
Routes map[string][]dnstype.Resolver `json:",omitempty"`
Routes map[string][]*dnstype.Resolver `json:",omitempty"`
// FallbackResolvers is like Resolvers, but is only used if a
// split DNS configuration is requested in a configuration that
// doesn't work yet without explicit default resolvers.
// https://github.com/tailscale/tailscale/issues/1743
FallbackResolvers []dnstype.Resolver `json:",omitempty"`
FallbackResolvers []*dnstype.Resolver `json:",omitempty"`
// Domains are the search domains to use.
// Search domains must be FQDNs, but *without* the trailing dot.
Domains []string `json:",omitempty"`

18
tailcfg/tailcfg_clone.go
Unescape View File

@ -193,19 +193,19 @@ func (src *DNSConfig) Clone() *DNSConfig {
}
dst := new(DNSConfig)
*dst = *src
dst.Resolvers = make([]dnstype.Resolver, len(src.Resolvers))
dst.Resolvers = make([]*dnstype.Resolver, len(src.Resolvers))
for i := range dst.Resolvers {
dst.Resolvers[i] = *src.Resolvers[i].Clone()
dst.Resolvers[i] = src.Resolvers[i].Clone()
}
if dst.Routes != nil {
dst.Routes = map[string][]dnstype.Resolver{}
dst.Routes = map[string][]*dnstype.Resolver{}
for k := range src.Routes {
dst.Routes[k] = append([]dnstype.Resolver{}, src.Routes[k]...)
dst.Routes[k] = append([]*dnstype.Resolver{}, src.Routes[k]...)
}
}
dst.FallbackResolvers = make([]dnstype.Resolver, len(src.FallbackResolvers))
dst.FallbackResolvers = make([]*dnstype.Resolver, len(src.FallbackResolvers))
for i := range dst.FallbackResolvers {
dst.FallbackResolvers[i] = *src.FallbackResolvers[i].Clone()
dst.FallbackResolvers[i] = src.FallbackResolvers[i].Clone()
}
dst.Domains = append(src.Domains[:0:0], src.Domains...)
dst.Nameservers = append(src.Nameservers[:0:0], src.Nameservers...)
@ -217,9 +217,9 @@ func (src *DNSConfig) Clone() *DNSConfig {
// A compilation failure here means this code must be regenerated, with the command at the top of this file.
var _DNSConfigCloneNeedsRegeneration = DNSConfig(struct {
Resolvers []dnstype.Resolver
Routes map[string][]dnstype.Resolver
FallbackResolvers []dnstype.Resolver
Resolvers []*dnstype.Resolver
Routes map[string][]*dnstype.Resolver
FallbackResolvers []*dnstype.Resolver
Domains []string
Proxied bool
Nameservers []netaddr.IP

2
tstest/integration/vms/harness_test.go
Unescape View File

@ -64,7 +64,7 @@ func newHarness(t *testing.T) *Harness {
// TODO: this is wrong.
// It is also only one of many configurations.
// Figure out how to scale it up.
Resolvers: []dnstype.Resolver{{Addr: "100.100.100.100"}, {Addr: "8.8.8.8"}},
Resolvers: []*dnstype.Resolver{{Addr: "100.100.100.100"}, {Addr: "8.8.8.8"}},
Domains: []string{"record"},
Proxied: true,
ExtraRecords: []tailcfg.DNSRecord{{Name: "extratest.record", Type: "A", Value: "1.2.3.4"}},

2
util/deephash/deephash_test.go
Unescape View File

@ -192,7 +192,7 @@ func getVal() []any {
},
},
DNSConfig: &tailcfg.DNSConfig{
Resolvers: []dnstype.Resolver{
Resolvers: []*dnstype.Resolver{
{Addr: "10.0.0.1"},
},
},

2
wgengine/userspace.go
Unescape View File

@ -1586,7 +1586,7 @@ func ipInPrefixes(ip netaddr.IP, pp []netaddr.IPPrefix) bool {
func dnsIPsOverTailscale(dnsCfg *dns.Config, routerCfg *router.Config) (ret []netaddr.IPPrefix) {
m := map[netaddr.IP]bool{}
add := func(resolvers []dnstype.Resolver) {
add := func(resolvers []*dnstype.Resolver) {
for _, r := range resolvers {
ip, err := netaddr.ParseIP(r.Addr)
if err != nil {

Write Preview
Loading…
Cancel
Save