TheArchive/tailscale
1
0
Fork 0
mirror of https://github.com/tailscale/tailscale.git synced 2024-11-29 04:55:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
Signed-off-by: Maisem Ali <maisem@tailscale.com>
This commit is contained in:
Maisem Ali 2022-05-03 14:41:58 -07:00 committed by Maisem Ali
parent 679415f3a8
commit fd99c54e10
14 changed files with 69 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
ipn/ipnlocal/dnsconfig_test.go
View File

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

9
ipn/ipnlocal/local.go
View File

@ -2112,7 +2112,7 @@ func (b *LocalBackend) authReconfig() {
// a runtime.GOOS. // a runtime.GOOS.
func dnsConfigForNetmap(nm *netmap.NetworkMap, prefs *ipn.Prefs, logf logger.Logf, versionOS string) *dns.Config { func dnsConfigForNetmap(nm *netmap.NetworkMap, prefs *ipn.Prefs, logf logger.Logf, versionOS string) *dns.Config {
dcfg := &dns.Config{ dcfg := &dns.Config{
Routes: map[dnsname.FQDN][]dnstype.Resolver{}, Routes: map[dnsname.FQDN][]*dnstype.Resolver{},
Hosts: map[dnsname.FQDN][]netaddr.IP{}, 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 { for _, r := range resolvers {
r := r
dcfg.DefaultResolvers = append(dcfg.DefaultResolvers, 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+) // 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. // to run a DoH DNS proxy, then send all our DNS traffic through it.
if dohURL, ok := exitNodeCanProxyDNS(nm, prefs.ExitNodeID); ok { if dohURL, ok := exitNodeCanProxyDNS(nm, prefs.ExitNodeID); ok {
addDefault([]dnstype.Resolver{{Addr: dohURL}}) addDefault([]*dnstype.Resolver{{Addr: dohURL}})
return dcfg 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 // While we're already populating it, might as well size the
// slice appropriately. // slice appropriately.
dcfg.Routes[fqdn] = make([]dnstype.Resolver, 0, len(resolvers)) dcfg.Routes[fqdn] = make([]*dnstype.Resolver, 0, len(resolvers))
for _, r := range resolvers { for _, r := range resolvers {
dcfg.Routes[fqdn] = append(dcfg.Routes[fqdn], r) dcfg.Routes[fqdn] = append(dcfg.Routes[fqdn], r)

10
net/dns/config.go
View File

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

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

14
net/dns/manager_test.go
View File

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

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

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

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

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

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

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

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

6
tailcfg/tailcfg.go
View File

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

18
tailcfg/tailcfg_clone.go
View File

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

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

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

2
util/deephash/deephash_test.go
View File

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

2
wgengine/userspace.go
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) { func dnsIPsOverTailscale(dnsCfg *dns.Config, routerCfg *router.Config) (ret []netaddr.IPPrefix) {
m := map[netaddr.IP]bool{} m := map[netaddr.IP]bool{}
add := func(resolvers []dnstype.Resolver) { add := func(resolvers []*dnstype.Resolver) {
for _, r := range resolvers { for _, r := range resolvers {
ip, err := netaddr.ParseIP(r.Addr) ip, err := netaddr.ParseIP(r.Addr)
if err != nil { if err != nil {