Source file src/net/lookup_test.go

Documentation: net

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package net
     6  
     7  import (
     8  	"context"
     9  	"errors"
    10  	"fmt"
    11  	"internal/testenv"
    12  	"net/netip"
    13  	"reflect"
    14  	"runtime"
    15  	"sort"
    16  	"strings"
    17  	"sync"
    18  	"sync/atomic"
    19  	"testing"
    20  	"time"
    21  )
    22  
    23  func hasSuffixFold(s, suffix string) bool {
    24  	return strings.HasSuffix(strings.ToLower(s), strings.ToLower(suffix))
    25  }
    26  
    27  func lookupLocalhost(ctx context.Context, fn func(context.Context, string, string) ([]IPAddr, error), network, host string) ([]IPAddr, error) {
    28  	switch host {
    29  	case "localhost":
    30  		return []IPAddr{
    31  			{IP: IPv4(127, 0, 0, 1)},
    32  			{IP: IPv6loopback},
    33  		}, nil
    34  	default:
    35  		return fn(ctx, network, host)
    36  	}
    37  }
    38  
    39  // The Lookup APIs use various sources such as local database, DNS or
    40  // mDNS, and may use platform-dependent DNS stub resolver if possible.
    41  // The APIs accept any of forms for a query; host name in various
    42  // encodings, UTF-8 encoded net name, domain name, FQDN or absolute
    43  // FQDN, but the result would be one of the forms and it depends on
    44  // the circumstances.
    45  
    46  var lookupGoogleSRVTests = []struct {
    47  	service, proto, name string
    48  	cname, target        string
    49  }{
    50  	{
    51  		"ldap", "tcp", "google.com",
    52  		"google.com.", "google.com.",
    53  	},
    54  	{
    55  		"ldap", "tcp", "google.com.",
    56  		"google.com.", "google.com.",
    57  	},
    58  
    59  	// non-standard back door
    60  	{
    61  		"", "", "_ldap._tcp.google.com",
    62  		"google.com.", "google.com.",
    63  	},
    64  	{
    65  		"", "", "_ldap._tcp.google.com.",
    66  		"google.com.", "google.com.",
    67  	},
    68  }
    69  
    70  var backoffDuration = [...]time.Duration{time.Second, 5 * time.Second, 30 * time.Second}
    71  
    72  func TestLookupGoogleSRV(t *testing.T) {
    73  	t.Parallel()
    74  	mustHaveExternalNetwork(t)
    75  
    76  	if runtime.GOOS == "ios" {
    77  		t.Skip("no resolv.conf on iOS")
    78  	}
    79  
    80  	if !supportsIPv4() || !*testIPv4 {
    81  		t.Skip("IPv4 is required")
    82  	}
    83  
    84  	attempts := 0
    85  	for i := 0; i < len(lookupGoogleSRVTests); i++ {
    86  		tt := lookupGoogleSRVTests[i]
    87  		cname, srvs, err := LookupSRV(tt.service, tt.proto, tt.name)
    88  		if err != nil {
    89  			testenv.SkipFlakyNet(t)
    90  			if attempts < len(backoffDuration) {
    91  				dur := backoffDuration[attempts]
    92  				t.Logf("backoff %v after failure %v\n", dur, err)
    93  				time.Sleep(dur)
    94  				attempts++
    95  				i--
    96  				continue
    97  			}
    98  			t.Fatal(err)
    99  		}
   100  		if len(srvs) == 0 {
   101  			t.Error("got no record")
   102  		}
   103  		if !hasSuffixFold(cname, tt.cname) {
   104  			t.Errorf("got %s; want %s", cname, tt.cname)
   105  		}
   106  		for _, srv := range srvs {
   107  			if !hasSuffixFold(srv.Target, tt.target) {
   108  				t.Errorf("got %v; want a record containing %s", srv, tt.target)
   109  			}
   110  		}
   111  	}
   112  }
   113  
   114  var lookupGmailMXTests = []struct {
   115  	name, host string
   116  }{
   117  	{"gmail.com", "google.com."},
   118  	{"gmail.com.", "google.com."},
   119  }
   120  
   121  func TestLookupGmailMX(t *testing.T) {
   122  	t.Parallel()
   123  	mustHaveExternalNetwork(t)
   124  
   125  	if runtime.GOOS == "ios" {
   126  		t.Skip("no resolv.conf on iOS")
   127  	}
   128  
   129  	if !supportsIPv4() || !*testIPv4 {
   130  		t.Skip("IPv4 is required")
   131  	}
   132  
   133  	attempts := 0
   134  	for i := 0; i < len(lookupGmailMXTests); i++ {
   135  		tt := lookupGmailMXTests[i]
   136  		mxs, err := LookupMX(tt.name)
   137  		if err != nil {
   138  			testenv.SkipFlakyNet(t)
   139  			if attempts < len(backoffDuration) {
   140  				dur := backoffDuration[attempts]
   141  				t.Logf("backoff %v after failure %v\n", dur, err)
   142  				time.Sleep(dur)
   143  				attempts++
   144  				i--
   145  				continue
   146  			}
   147  			t.Fatal(err)
   148  		}
   149  		if len(mxs) == 0 {
   150  			t.Error("got no record")
   151  		}
   152  		for _, mx := range mxs {
   153  			if !hasSuffixFold(mx.Host, tt.host) {
   154  				t.Errorf("got %v; want a record containing %s", mx, tt.host)
   155  			}
   156  		}
   157  	}
   158  }
   159  
   160  var lookupGmailNSTests = []struct {
   161  	name, host string
   162  }{
   163  	{"gmail.com", "google.com."},
   164  	{"gmail.com.", "google.com."},
   165  }
   166  
   167  func TestLookupGmailNS(t *testing.T) {
   168  	t.Parallel()
   169  	mustHaveExternalNetwork(t)
   170  
   171  	if runtime.GOOS == "ios" {
   172  		t.Skip("no resolv.conf on iOS")
   173  	}
   174  
   175  	if !supportsIPv4() || !*testIPv4 {
   176  		t.Skip("IPv4 is required")
   177  	}
   178  
   179  	attempts := 0
   180  	for i := 0; i < len(lookupGmailNSTests); i++ {
   181  		tt := lookupGmailNSTests[i]
   182  		nss, err := LookupNS(tt.name)
   183  		if err != nil {
   184  			testenv.SkipFlakyNet(t)
   185  			if attempts < len(backoffDuration) {
   186  				dur := backoffDuration[attempts]
   187  				t.Logf("backoff %v after failure %v\n", dur, err)
   188  				time.Sleep(dur)
   189  				attempts++
   190  				i--
   191  				continue
   192  			}
   193  			t.Fatal(err)
   194  		}
   195  		if len(nss) == 0 {
   196  			t.Error("got no record")
   197  		}
   198  		for _, ns := range nss {
   199  			if !hasSuffixFold(ns.Host, tt.host) {
   200  				t.Errorf("got %v; want a record containing %s", ns, tt.host)
   201  			}
   202  		}
   203  	}
   204  }
   205  
   206  var lookupGmailTXTTests = []struct {
   207  	name, txt, host string
   208  }{
   209  	{"gmail.com", "spf", "google.com"},
   210  	{"gmail.com.", "spf", "google.com"},
   211  }
   212  
   213  func TestLookupGmailTXT(t *testing.T) {
   214  	if runtime.GOOS == "plan9" {
   215  		t.Skip("skipping on plan9; see https://golang.org/issue/29722")
   216  	}
   217  	t.Parallel()
   218  	mustHaveExternalNetwork(t)
   219  
   220  	if runtime.GOOS == "ios" {
   221  		t.Skip("no resolv.conf on iOS")
   222  	}
   223  
   224  	if !supportsIPv4() || !*testIPv4 {
   225  		t.Skip("IPv4 is required")
   226  	}
   227  
   228  	attempts := 0
   229  	for i := 0; i < len(lookupGmailTXTTests); i++ {
   230  		tt := lookupGmailTXTTests[i]
   231  		txts, err := LookupTXT(tt.name)
   232  		if err != nil {
   233  			testenv.SkipFlakyNet(t)
   234  			if attempts < len(backoffDuration) {
   235  				dur := backoffDuration[attempts]
   236  				t.Logf("backoff %v after failure %v\n", dur, err)
   237  				time.Sleep(dur)
   238  				attempts++
   239  				i--
   240  				continue
   241  			}
   242  			t.Fatal(err)
   243  		}
   244  		if len(txts) == 0 {
   245  			t.Error("got no record")
   246  		}
   247  		found := false
   248  		for _, txt := range txts {
   249  			if strings.Contains(txt, tt.txt) && (strings.HasSuffix(txt, tt.host) || strings.HasSuffix(txt, tt.host+".")) {
   250  				found = true
   251  				break
   252  			}
   253  		}
   254  		if !found {
   255  			t.Errorf("got %v; want a record containing %s, %s", txts, tt.txt, tt.host)
   256  		}
   257  	}
   258  }
   259  
   260  var lookupGooglePublicDNSAddrTests = []string{
   261  	"8.8.8.8",
   262  	"8.8.4.4",
   263  	"2001:4860:4860::8888",
   264  	"2001:4860:4860::8844",
   265  }
   266  
   267  func TestLookupGooglePublicDNSAddr(t *testing.T) {
   268  	mustHaveExternalNetwork(t)
   269  
   270  	if !supportsIPv4() || !supportsIPv6() || !*testIPv4 || !*testIPv6 {
   271  		t.Skip("both IPv4 and IPv6 are required")
   272  	}
   273  
   274  	defer dnsWaitGroup.Wait()
   275  
   276  	for _, ip := range lookupGooglePublicDNSAddrTests {
   277  		names, err := LookupAddr(ip)
   278  		if err != nil {
   279  			t.Fatal(err)
   280  		}
   281  		if len(names) == 0 {
   282  			t.Error("got no record")
   283  		}
   284  		for _, name := range names {
   285  			if !hasSuffixFold(name, ".google.com.") && !hasSuffixFold(name, ".google.") {
   286  				t.Errorf("got %q; want a record ending in .google.com. or .google.", name)
   287  			}
   288  		}
   289  	}
   290  }
   291  
   292  func TestLookupIPv6LinkLocalAddr(t *testing.T) {
   293  	if !supportsIPv6() || !*testIPv6 {
   294  		t.Skip("IPv6 is required")
   295  	}
   296  
   297  	defer dnsWaitGroup.Wait()
   298  
   299  	addrs, err := LookupHost("localhost")
   300  	if err != nil {
   301  		t.Fatal(err)
   302  	}
   303  	found := false
   304  	for _, addr := range addrs {
   305  		if addr == "fe80::1%lo0" {
   306  			found = true
   307  			break
   308  		}
   309  	}
   310  	if !found {
   311  		t.Skipf("not supported on %s", runtime.GOOS)
   312  	}
   313  	if _, err := LookupAddr("fe80::1%lo0"); err != nil {
   314  		t.Error(err)
   315  	}
   316  }
   317  
   318  func TestLookupIPv6LinkLocalAddrWithZone(t *testing.T) {
   319  	if !supportsIPv6() || !*testIPv6 {
   320  		t.Skip("IPv6 is required")
   321  	}
   322  
   323  	ipaddrs, err := DefaultResolver.LookupIPAddr(context.Background(), "fe80::1%lo0")
   324  	if err != nil {
   325  		t.Error(err)
   326  	}
   327  	for _, addr := range ipaddrs {
   328  		if e, a := "lo0", addr.Zone; e != a {
   329  			t.Errorf("wrong zone: want %q, got %q", e, a)
   330  		}
   331  	}
   332  
   333  	addrs, err := DefaultResolver.LookupHost(context.Background(), "fe80::1%lo0")
   334  	if err != nil {
   335  		t.Error(err)
   336  	}
   337  	for _, addr := range addrs {
   338  		if e, a := "fe80::1%lo0", addr; e != a {
   339  			t.Errorf("wrong host: want %q got %q", e, a)
   340  		}
   341  	}
   342  }
   343  
   344  var lookupCNAMETests = []struct {
   345  	name, cname string
   346  }{
   347  	{"www.iana.org", "icann.org."},
   348  	{"www.iana.org.", "icann.org."},
   349  	{"www.google.com", "google.com."},
   350  	{"google.com", "google.com."},
   351  	{"cname-to-txt.go4.org", "test-txt-record.go4.org."},
   352  }
   353  
   354  func TestLookupCNAME(t *testing.T) {
   355  	mustHaveExternalNetwork(t)
   356  	testenv.SkipFlakyNet(t)
   357  
   358  	if !supportsIPv4() || !*testIPv4 {
   359  		t.Skip("IPv4 is required")
   360  	}
   361  
   362  	defer dnsWaitGroup.Wait()
   363  
   364  	attempts := 0
   365  	for i := 0; i < len(lookupCNAMETests); i++ {
   366  		tt := lookupCNAMETests[i]
   367  		cname, err := LookupCNAME(tt.name)
   368  		if err != nil {
   369  			testenv.SkipFlakyNet(t)
   370  			if attempts < len(backoffDuration) {
   371  				dur := backoffDuration[attempts]
   372  				t.Logf("backoff %v after failure %v\n", dur, err)
   373  				time.Sleep(dur)
   374  				attempts++
   375  				i--
   376  				continue
   377  			}
   378  			t.Fatal(err)
   379  		}
   380  		if !hasSuffixFold(cname, tt.cname) {
   381  			t.Errorf("got %s; want a record containing %s", cname, tt.cname)
   382  		}
   383  	}
   384  }
   385  
   386  var lookupGoogleHostTests = []struct {
   387  	name string
   388  }{
   389  	{"google.com"},
   390  	{"google.com."},
   391  }
   392  
   393  func TestLookupGoogleHost(t *testing.T) {
   394  	mustHaveExternalNetwork(t)
   395  	testenv.SkipFlakyNet(t)
   396  
   397  	if !supportsIPv4() || !*testIPv4 {
   398  		t.Skip("IPv4 is required")
   399  	}
   400  
   401  	defer dnsWaitGroup.Wait()
   402  
   403  	for _, tt := range lookupGoogleHostTests {
   404  		addrs, err := LookupHost(tt.name)
   405  		if err != nil {
   406  			t.Fatal(err)
   407  		}
   408  		if len(addrs) == 0 {
   409  			t.Error("got no record")
   410  		}
   411  		for _, addr := range addrs {
   412  			if ParseIP(addr) == nil {
   413  				t.Errorf("got %q; want a literal IP address", addr)
   414  			}
   415  		}
   416  	}
   417  }
   418  
   419  func TestLookupLongTXT(t *testing.T) {
   420  	testenv.SkipFlaky(t, 22857)
   421  	mustHaveExternalNetwork(t)
   422  
   423  	defer dnsWaitGroup.Wait()
   424  
   425  	txts, err := LookupTXT("golang.rsc.io")
   426  	if err != nil {
   427  		t.Fatal(err)
   428  	}
   429  	sort.Strings(txts)
   430  	want := []string{
   431  		strings.Repeat("abcdefghijklmnopqrstuvwxyABCDEFGHJIKLMNOPQRSTUVWXY", 10),
   432  		"gophers rule",
   433  	}
   434  	if !reflect.DeepEqual(txts, want) {
   435  		t.Fatalf("LookupTXT golang.rsc.io incorrect\nhave %q\nwant %q", txts, want)
   436  	}
   437  }
   438  
   439  var lookupGoogleIPTests = []struct {
   440  	name string
   441  }{
   442  	{"google.com"},
   443  	{"google.com."},
   444  }
   445  
   446  func TestLookupGoogleIP(t *testing.T) {
   447  	mustHaveExternalNetwork(t)
   448  	testenv.SkipFlakyNet(t)
   449  
   450  	if !supportsIPv4() || !*testIPv4 {
   451  		t.Skip("IPv4 is required")
   452  	}
   453  
   454  	defer dnsWaitGroup.Wait()
   455  
   456  	for _, tt := range lookupGoogleIPTests {
   457  		ips, err := LookupIP(tt.name)
   458  		if err != nil {
   459  			t.Fatal(err)
   460  		}
   461  		if len(ips) == 0 {
   462  			t.Error("got no record")
   463  		}
   464  		for _, ip := range ips {
   465  			if ip.To4() == nil && ip.To16() == nil {
   466  				t.Errorf("got %v; want an IP address", ip)
   467  			}
   468  		}
   469  	}
   470  }
   471  
   472  var revAddrTests = []struct {
   473  	Addr      string
   474  	Reverse   string
   475  	ErrPrefix string
   476  }{
   477  	{"1.2.3.4", "4.3.2.1.in-addr.arpa.", ""},
   478  	{"245.110.36.114", "114.36.110.245.in-addr.arpa.", ""},
   479  	{"::ffff:12.34.56.78", "78.56.34.12.in-addr.arpa.", ""},
   480  	{"::1", "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa.", ""},
   481  	{"1::", "0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.0.0.0.ip6.arpa.", ""},
   482  	{"1234:567::89a:bcde", "e.d.c.b.a.9.8.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.7.6.5.0.4.3.2.1.ip6.arpa.", ""},
   483  	{"1234:567:fefe:bcbc:adad:9e4a:89a:bcde", "e.d.c.b.a.9.8.0.a.4.e.9.d.a.d.a.c.b.c.b.e.f.e.f.7.6.5.0.4.3.2.1.ip6.arpa.", ""},
   484  	{"1.2.3", "", "unrecognized address"},
   485  	{"1.2.3.4.5", "", "unrecognized address"},
   486  	{"1234:567:bcbca::89a:bcde", "", "unrecognized address"},
   487  	{"1234:567::bcbc:adad::89a:bcde", "", "unrecognized address"},
   488  }
   489  
   490  func TestReverseAddress(t *testing.T) {
   491  	defer dnsWaitGroup.Wait()
   492  	for i, tt := range revAddrTests {
   493  		a, err := reverseaddr(tt.Addr)
   494  		if len(tt.ErrPrefix) > 0 && err == nil {
   495  			t.Errorf("#%d: expected %q, got <nil> (error)", i, tt.ErrPrefix)
   496  			continue
   497  		}
   498  		if len(tt.ErrPrefix) == 0 && err != nil {
   499  			t.Errorf("#%d: expected <nil>, got %q (error)", i, err)
   500  		}
   501  		if err != nil && err.(*DNSError).Err != tt.ErrPrefix {
   502  			t.Errorf("#%d: expected %q, got %q (mismatched error)", i, tt.ErrPrefix, err.(*DNSError).Err)
   503  		}
   504  		if a != tt.Reverse {
   505  			t.Errorf("#%d: expected %q, got %q (reverse address)", i, tt.Reverse, a)
   506  		}
   507  	}
   508  }
   509  
   510  func TestDNSFlood(t *testing.T) {
   511  	if !*testDNSFlood {
   512  		t.Skip("test disabled; use -dnsflood to enable")
   513  	}
   514  
   515  	defer dnsWaitGroup.Wait()
   516  
   517  	var N = 5000
   518  	if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
   519  		// On Darwin this test consumes kernel threads much
   520  		// than other platforms for some reason.
   521  		// When we monitor the number of allocated Ms by
   522  		// observing on runtime.newm calls, we can see that it
   523  		// easily reaches the per process ceiling
   524  		// kern.num_threads when CGO_ENABLED=1 and
   525  		// GODEBUG=netdns=go.
   526  		N = 500
   527  	}
   528  
   529  	const timeout = 3 * time.Second
   530  	ctxHalfTimeout, cancel := context.WithTimeout(context.Background(), timeout/2)
   531  	defer cancel()
   532  	ctxTimeout, cancel := context.WithTimeout(context.Background(), timeout)
   533  	defer cancel()
   534  
   535  	c := make(chan error, 2*N)
   536  	for i := 0; i < N; i++ {
   537  		name := fmt.Sprintf("%d.net-test.golang.org", i)
   538  		go func() {
   539  			_, err := DefaultResolver.LookupIPAddr(ctxHalfTimeout, name)
   540  			c <- err
   541  		}()
   542  		go func() {
   543  			_, err := DefaultResolver.LookupIPAddr(ctxTimeout, name)
   544  			c <- err
   545  		}()
   546  	}
   547  	qstats := struct {
   548  		succeeded, failed         int
   549  		timeout, temporary, other int
   550  		unknown                   int
   551  	}{}
   552  	deadline := time.After(timeout + time.Second)
   553  	for i := 0; i < 2*N; i++ {
   554  		select {
   555  		case <-deadline:
   556  			t.Fatal("deadline exceeded")
   557  		case err := <-c:
   558  			switch err := err.(type) {
   559  			case nil:
   560  				qstats.succeeded++
   561  			case Error:
   562  				qstats.failed++
   563  				if err.Timeout() {
   564  					qstats.timeout++
   565  				}
   566  				if err.Temporary() {
   567  					qstats.temporary++
   568  				}
   569  				if !err.Timeout() && !err.Temporary() {
   570  					qstats.other++
   571  				}
   572  			default:
   573  				qstats.failed++
   574  				qstats.unknown++
   575  			}
   576  		}
   577  	}
   578  
   579  	// A high volume of DNS queries for sub-domain of golang.org
   580  	// would be coordinated by authoritative or recursive server,
   581  	// or stub resolver which implements query-response rate
   582  	// limitation, so we can expect some query successes and more
   583  	// failures including timeout, temporary and other here.
   584  	// As a rule, unknown must not be shown but it might possibly
   585  	// happen due to issue 4856 for now.
   586  	t.Logf("%v succeeded, %v failed (%v timeout, %v temporary, %v other, %v unknown)", qstats.succeeded, qstats.failed, qstats.timeout, qstats.temporary, qstats.other, qstats.unknown)
   587  }
   588  
   589  func TestLookupDotsWithLocalSource(t *testing.T) {
   590  	if !supportsIPv4() || !*testIPv4 {
   591  		t.Skip("IPv4 is required")
   592  	}
   593  
   594  	mustHaveExternalNetwork(t)
   595  
   596  	defer dnsWaitGroup.Wait()
   597  
   598  	for i, fn := range []func() func(){forceGoDNS, forceCgoDNS} {
   599  		fixup := fn()
   600  		if fixup == nil {
   601  			continue
   602  		}
   603  		names, err := LookupAddr("127.0.0.1")
   604  		fixup()
   605  		if err != nil {
   606  			t.Logf("#%d: %v", i, err)
   607  			continue
   608  		}
   609  		mode := "netgo"
   610  		if i == 1 {
   611  			mode = "netcgo"
   612  		}
   613  	loop:
   614  		for i, name := range names {
   615  			if strings.Index(name, ".") == len(name)-1 { // "localhost" not "localhost."
   616  				for j := range names {
   617  					if j == i {
   618  						continue
   619  					}
   620  					if names[j] == name[:len(name)-1] {
   621  						// It's OK if we find the name without the dot,
   622  						// as some systems say 127.0.0.1 localhost localhost.
   623  						continue loop
   624  					}
   625  				}
   626  				t.Errorf("%s: got %s; want %s", mode, name, name[:len(name)-1])
   627  			} else if strings.Contains(name, ".") && !strings.HasSuffix(name, ".") { // "localhost.localdomain." not "localhost.localdomain"
   628  				t.Errorf("%s: got %s; want name ending with trailing dot", mode, name)
   629  			}
   630  		}
   631  	}
   632  }
   633  
   634  func TestLookupDotsWithRemoteSource(t *testing.T) {
   635  	if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
   636  		testenv.SkipFlaky(t, 27992)
   637  	}
   638  	mustHaveExternalNetwork(t)
   639  	testenv.SkipFlakyNet(t)
   640  
   641  	if !supportsIPv4() || !*testIPv4 {
   642  		t.Skip("IPv4 is required")
   643  	}
   644  
   645  	if runtime.GOOS == "ios" {
   646  		t.Skip("no resolv.conf on iOS")
   647  	}
   648  
   649  	defer dnsWaitGroup.Wait()
   650  
   651  	if fixup := forceGoDNS(); fixup != nil {
   652  		testDots(t, "go")
   653  		fixup()
   654  	}
   655  	if fixup := forceCgoDNS(); fixup != nil {
   656  		testDots(t, "cgo")
   657  		fixup()
   658  	}
   659  }
   660  
   661  func testDots(t *testing.T, mode string) {
   662  	names, err := LookupAddr("8.8.8.8") // Google dns server
   663  	if err != nil {
   664  		t.Errorf("LookupAddr(8.8.8.8): %v (mode=%v)", err, mode)
   665  	} else {
   666  		for _, name := range names {
   667  			if !hasSuffixFold(name, ".google.com.") && !hasSuffixFold(name, ".google.") {
   668  				t.Errorf("LookupAddr(8.8.8.8) = %v, want names ending in .google.com or .google with trailing dot (mode=%v)", names, mode)
   669  				break
   670  			}
   671  		}
   672  	}
   673  
   674  	cname, err := LookupCNAME("www.mit.edu")
   675  	if err != nil {
   676  		t.Errorf("LookupCNAME(www.mit.edu, mode=%v): %v", mode, err)
   677  	} else if !strings.HasSuffix(cname, ".") {
   678  		t.Errorf("LookupCNAME(www.mit.edu) = %v, want cname ending in . with trailing dot (mode=%v)", cname, mode)
   679  	}
   680  
   681  	mxs, err := LookupMX("google.com")
   682  	if err != nil {
   683  		t.Errorf("LookupMX(google.com): %v (mode=%v)", err, mode)
   684  	} else {
   685  		for _, mx := range mxs {
   686  			if !hasSuffixFold(mx.Host, ".google.com.") {
   687  				t.Errorf("LookupMX(google.com) = %v, want names ending in .google.com. with trailing dot (mode=%v)", mxString(mxs), mode)
   688  				break
   689  			}
   690  		}
   691  	}
   692  
   693  	nss, err := LookupNS("google.com")
   694  	if err != nil {
   695  		t.Errorf("LookupNS(google.com): %v (mode=%v)", err, mode)
   696  	} else {
   697  		for _, ns := range nss {
   698  			if !hasSuffixFold(ns.Host, ".google.com.") {
   699  				t.Errorf("LookupNS(google.com) = %v, want names ending in .google.com. with trailing dot (mode=%v)", nsString(nss), mode)
   700  				break
   701  			}
   702  		}
   703  	}
   704  
   705  	cname, srvs, err := LookupSRV("ldap", "tcp", "google.com")
   706  	if err != nil {
   707  		t.Errorf("LookupSRV(ldap, tcp, google.com): %v (mode=%v)", err, mode)
   708  	} else {
   709  		if !hasSuffixFold(cname, ".google.com.") {
   710  			t.Errorf("LookupSRV(ldap, tcp, google.com) returned cname=%v, want name ending in .google.com. with trailing dot (mode=%v)", cname, mode)
   711  		}
   712  		for _, srv := range srvs {
   713  			if !hasSuffixFold(srv.Target, ".google.com.") {
   714  				t.Errorf("LookupSRV(ldap, tcp, google.com) returned addrs=%v, want names ending in .google.com. with trailing dot (mode=%v)", srvString(srvs), mode)
   715  				break
   716  			}
   717  		}
   718  	}
   719  }
   720  
   721  func mxString(mxs []*MX) string {
   722  	var buf strings.Builder
   723  	sep := ""
   724  	fmt.Fprintf(&buf, "[")
   725  	for _, mx := range mxs {
   726  		fmt.Fprintf(&buf, "%s%s:%d", sep, mx.Host, mx.Pref)
   727  		sep = " "
   728  	}
   729  	fmt.Fprintf(&buf, "]")
   730  	return buf.String()
   731  }
   732  
   733  func nsString(nss []*NS) string {
   734  	var buf strings.Builder
   735  	sep := ""
   736  	fmt.Fprintf(&buf, "[")
   737  	for _, ns := range nss {
   738  		fmt.Fprintf(&buf, "%s%s", sep, ns.Host)
   739  		sep = " "
   740  	}
   741  	fmt.Fprintf(&buf, "]")
   742  	return buf.String()
   743  }
   744  
   745  func srvString(srvs []*SRV) string {
   746  	var buf strings.Builder
   747  	sep := ""
   748  	fmt.Fprintf(&buf, "[")
   749  	for _, srv := range srvs {
   750  		fmt.Fprintf(&buf, "%s%s:%d:%d:%d", sep, srv.Target, srv.Port, srv.Priority, srv.Weight)
   751  		sep = " "
   752  	}
   753  	fmt.Fprintf(&buf, "]")
   754  	return buf.String()
   755  }
   756  
   757  func TestLookupPort(t *testing.T) {
   758  	// See https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml
   759  	//
   760  	// Please be careful about adding new test cases.
   761  	// There are platforms which have incomplete mappings for
   762  	// restricted resource access and security reasons.
   763  	type test struct {
   764  		network string
   765  		name    string
   766  		port    int
   767  		ok      bool
   768  	}
   769  	var tests = []test{
   770  		{"tcp", "0", 0, true},
   771  		{"udp", "0", 0, true},
   772  		{"udp", "domain", 53, true},
   773  
   774  		{"--badnet--", "zzz", 0, false},
   775  		{"tcp", "--badport--", 0, false},
   776  		{"tcp", "-1", 0, false},
   777  		{"tcp", "65536", 0, false},
   778  		{"udp", "-1", 0, false},
   779  		{"udp", "65536", 0, false},
   780  		{"tcp", "123456789", 0, false},
   781  
   782  		// Issue 13610: LookupPort("tcp", "")
   783  		{"tcp", "", 0, true},
   784  		{"tcp4", "", 0, true},
   785  		{"tcp6", "", 0, true},
   786  		{"udp", "", 0, true},
   787  		{"udp4", "", 0, true},
   788  		{"udp6", "", 0, true},
   789  	}
   790  
   791  	switch runtime.GOOS {
   792  	case "android":
   793  		if netGoBuildTag {
   794  			t.Skipf("not supported on %s without cgo; see golang.org/issues/14576", runtime.GOOS)
   795  		}
   796  	default:
   797  		tests = append(tests, test{"tcp", "http", 80, true})
   798  	}
   799  
   800  	for _, tt := range tests {
   801  		port, err := LookupPort(tt.network, tt.name)
   802  		if port != tt.port || (err == nil) != tt.ok {
   803  			t.Errorf("LookupPort(%q, %q) = %d, %v; want %d, error=%t", tt.network, tt.name, port, err, tt.port, !tt.ok)
   804  		}
   805  		if err != nil {
   806  			if perr := parseLookupPortError(err); perr != nil {
   807  				t.Error(perr)
   808  			}
   809  		}
   810  	}
   811  }
   812  
   813  // Like TestLookupPort but with minimal tests that should always pass
   814  // because the answers are baked-in to the net package.
   815  func TestLookupPort_Minimal(t *testing.T) {
   816  	type test struct {
   817  		network string
   818  		name    string
   819  		port    int
   820  	}
   821  	var tests = []test{
   822  		{"tcp", "http", 80},
   823  		{"tcp", "HTTP", 80}, // case shouldn't matter
   824  		{"tcp", "https", 443},
   825  		{"tcp", "ssh", 22},
   826  		{"tcp", "gopher", 70},
   827  		{"tcp4", "http", 80},
   828  		{"tcp6", "http", 80},
   829  	}
   830  
   831  	for _, tt := range tests {
   832  		port, err := LookupPort(tt.network, tt.name)
   833  		if port != tt.port || err != nil {
   834  			t.Errorf("LookupPort(%q, %q) = %d, %v; want %d, error=nil", tt.network, tt.name, port, err, tt.port)
   835  		}
   836  	}
   837  }
   838  
   839  func TestLookupProtocol_Minimal(t *testing.T) {
   840  	type test struct {
   841  		name string
   842  		want int
   843  	}
   844  	var tests = []test{
   845  		{"tcp", 6},
   846  		{"TcP", 6}, // case shouldn't matter
   847  		{"icmp", 1},
   848  		{"igmp", 2},
   849  		{"udp", 17},
   850  		{"ipv6-icmp", 58},
   851  	}
   852  
   853  	for _, tt := range tests {
   854  		got, err := lookupProtocol(context.Background(), tt.name)
   855  		if got != tt.want || err != nil {
   856  			t.Errorf("LookupProtocol(%q) = %d, %v; want %d, error=nil", tt.name, got, err, tt.want)
   857  		}
   858  	}
   859  
   860  }
   861  
   862  func TestLookupNonLDH(t *testing.T) {
   863  	defer dnsWaitGroup.Wait()
   864  
   865  	if fixup := forceGoDNS(); fixup != nil {
   866  		defer fixup()
   867  	}
   868  
   869  	// "LDH" stands for letters, digits, and hyphens and is the usual
   870  	// description of standard DNS names.
   871  	// This test is checking that other kinds of names are reported
   872  	// as not found, not reported as invalid names.
   873  	addrs, err := LookupHost("!!!.###.bogus..domain.")
   874  	if err == nil {
   875  		t.Fatalf("lookup succeeded: %v", addrs)
   876  	}
   877  	if !strings.HasSuffix(err.Error(), errNoSuchHost.Error()) {
   878  		t.Fatalf("lookup error = %v, want %v", err, errNoSuchHost)
   879  	}
   880  	if !err.(*DNSError).IsNotFound {
   881  		t.Fatalf("lookup error = %v, want true", err.(*DNSError).IsNotFound)
   882  	}
   883  }
   884  
   885  func TestLookupContextCancel(t *testing.T) {
   886  	mustHaveExternalNetwork(t)
   887  	testenv.SkipFlakyNet(t)
   888  
   889  	origTestHookLookupIP := testHookLookupIP
   890  	defer func() {
   891  		dnsWaitGroup.Wait()
   892  		testHookLookupIP = origTestHookLookupIP
   893  	}()
   894  
   895  	lookupCtx, cancelLookup := context.WithCancel(context.Background())
   896  	unblockLookup := make(chan struct{})
   897  
   898  	// Set testHookLookupIP to start a new, concurrent call to LookupIPAddr
   899  	// and cancel the original one, then block until the canceled call has returned
   900  	// (ensuring that it has performed any synchronous cleanup).
   901  	testHookLookupIP = func(
   902  		ctx context.Context,
   903  		fn func(context.Context, string, string) ([]IPAddr, error),
   904  		network string,
   905  		host string,
   906  	) ([]IPAddr, error) {
   907  		select {
   908  		case <-unblockLookup:
   909  		default:
   910  			// Start a concurrent LookupIPAddr for the same host while the caller is
   911  			// still blocked, and sleep a little to give it time to be deduplicated
   912  			// before we cancel (and unblock) the caller.
   913  			// (If the timing doesn't quite work out, we'll end up testing sequential
   914  			// calls instead of concurrent ones, but the test should still pass.)
   915  			t.Logf("starting concurrent LookupIPAddr")
   916  			dnsWaitGroup.Add(1)
   917  			go func() {
   918  				defer dnsWaitGroup.Done()
   919  				_, err := DefaultResolver.LookupIPAddr(context.Background(), host)
   920  				if err != nil {
   921  					t.Error(err)
   922  				}
   923  			}()
   924  			time.Sleep(1 * time.Millisecond)
   925  		}
   926  
   927  		cancelLookup()
   928  		<-unblockLookup
   929  		// If the concurrent lookup above is deduplicated to this one
   930  		// (as we expect to happen most of the time), it is important
   931  		// that the original call does not cancel the shared Context.
   932  		// (See https://go.dev/issue/22724.) Explicitly check for
   933  		// cancellation now, just in case fn itself doesn't notice it.
   934  		if err := ctx.Err(); err != nil {
   935  			t.Logf("testHookLookupIP canceled")
   936  			return nil, err
   937  		}
   938  		t.Logf("testHookLookupIP performing lookup")
   939  		return fn(ctx, network, host)
   940  	}
   941  
   942  	_, err := DefaultResolver.LookupIPAddr(lookupCtx, "google.com")
   943  	if dnsErr, ok := err.(*DNSError); !ok || dnsErr.Err != errCanceled.Error() {
   944  		t.Errorf("unexpected error from canceled, blocked LookupIPAddr: %v", err)
   945  	}
   946  	close(unblockLookup)
   947  }
   948  
   949  // Issue 24330: treat the nil *Resolver like a zero value. Verify nothing
   950  // crashes if nil is used.
   951  func TestNilResolverLookup(t *testing.T) {
   952  	mustHaveExternalNetwork(t)
   953  	var r *Resolver = nil
   954  	ctx := context.Background()
   955  
   956  	// Don't care about the results, just that nothing panics:
   957  	r.LookupAddr(ctx, "8.8.8.8")
   958  	r.LookupCNAME(ctx, "google.com")
   959  	r.LookupHost(ctx, "google.com")
   960  	r.LookupIPAddr(ctx, "google.com")
   961  	r.LookupIP(ctx, "ip", "google.com")
   962  	r.LookupMX(ctx, "gmail.com")
   963  	r.LookupNS(ctx, "google.com")
   964  	r.LookupPort(ctx, "tcp", "smtp")
   965  	r.LookupSRV(ctx, "service", "proto", "name")
   966  	r.LookupTXT(ctx, "gmail.com")
   967  }
   968  
   969  // TestLookupHostCancel verifies that lookup works even after many
   970  // canceled lookups (see golang.org/issue/24178 for details).
   971  func TestLookupHostCancel(t *testing.T) {
   972  	mustHaveExternalNetwork(t)
   973  	testenv.SkipFlakyNet(t)
   974  	t.Parallel() // Executes 600ms worth of sequential sleeps.
   975  
   976  	const (
   977  		google        = "www.google.com"
   978  		invalidDomain = "invalid.invalid" // RFC 2606 reserves .invalid
   979  		n             = 600               // this needs to be larger than threadLimit size
   980  	)
   981  
   982  	_, err := LookupHost(google)
   983  	if err != nil {
   984  		t.Fatal(err)
   985  	}
   986  
   987  	ctx, cancel := context.WithCancel(context.Background())
   988  	cancel()
   989  	for i := 0; i < n; i++ {
   990  		addr, err := DefaultResolver.LookupHost(ctx, invalidDomain)
   991  		if err == nil {
   992  			t.Fatalf("LookupHost(%q): returns %v, but should fail", invalidDomain, addr)
   993  		}
   994  
   995  		// Don't verify what the actual error is.
   996  		// We know that it must be non-nil because the domain is invalid,
   997  		// but we don't have any guarantee that LookupHost actually bothers
   998  		// to check for cancellation on the fast path.
   999  		// (For example, it could use a local cache to avoid blocking entirely.)
  1000  
  1001  		// The lookup may deduplicate in-flight requests, so give it time to settle
  1002  		// in between.
  1003  		time.Sleep(time.Millisecond * 1)
  1004  	}
  1005  
  1006  	_, err = LookupHost(google)
  1007  	if err != nil {
  1008  		t.Fatal(err)
  1009  	}
  1010  }
  1011  
  1012  type lookupCustomResolver struct {
  1013  	*Resolver
  1014  	mu     sync.RWMutex
  1015  	dialed bool
  1016  }
  1017  
  1018  func (lcr *lookupCustomResolver) dial() func(ctx context.Context, network, address string) (Conn, error) {
  1019  	return func(ctx context.Context, network, address string) (Conn, error) {
  1020  		lcr.mu.Lock()
  1021  		lcr.dialed = true
  1022  		lcr.mu.Unlock()
  1023  		return Dial(network, address)
  1024  	}
  1025  }
  1026  
  1027  // TestConcurrentPreferGoResolversDial tests that multiple resolvers with the
  1028  // PreferGo option used concurrently are all dialed properly.
  1029  func TestConcurrentPreferGoResolversDial(t *testing.T) {
  1030  	switch runtime.GOOS {
  1031  	case "plan9":
  1032  		// TODO: plan9 implementation of the resolver uses the Dial function since
  1033  		// https://go.dev/cl/409234, this test could probably be reenabled.
  1034  		t.Skipf("skip on %v", runtime.GOOS)
  1035  	}
  1036  
  1037  	testenv.MustHaveExternalNetwork(t)
  1038  	testenv.SkipFlakyNet(t)
  1039  
  1040  	defer dnsWaitGroup.Wait()
  1041  
  1042  	resolvers := make([]*lookupCustomResolver, 2)
  1043  	for i := range resolvers {
  1044  		cs := lookupCustomResolver{Resolver: &Resolver{PreferGo: true}}
  1045  		cs.Dial = cs.dial()
  1046  		resolvers[i] = &cs
  1047  	}
  1048  
  1049  	var wg sync.WaitGroup
  1050  	wg.Add(len(resolvers))
  1051  	for i, resolver := range resolvers {
  1052  		go func(r *Resolver, index int) {
  1053  			defer wg.Done()
  1054  			_, err := r.LookupIPAddr(context.Background(), "google.com")
  1055  			if err != nil {
  1056  				t.Errorf("lookup failed for resolver %d: %q", index, err)
  1057  			}
  1058  		}(resolver.Resolver, i)
  1059  	}
  1060  	wg.Wait()
  1061  
  1062  	if t.Failed() {
  1063  		t.FailNow()
  1064  	}
  1065  
  1066  	for i, resolver := range resolvers {
  1067  		if !resolver.dialed {
  1068  			t.Errorf("custom resolver %d not dialed during lookup", i)
  1069  		}
  1070  	}
  1071  }
  1072  
  1073  var ipVersionTests = []struct {
  1074  	network string
  1075  	version byte
  1076  }{
  1077  	{"tcp", 0},
  1078  	{"tcp4", '4'},
  1079  	{"tcp6", '6'},
  1080  	{"udp", 0},
  1081  	{"udp4", '4'},
  1082  	{"udp6", '6'},
  1083  	{"ip", 0},
  1084  	{"ip4", '4'},
  1085  	{"ip6", '6'},
  1086  	{"ip7", 0},
  1087  	{"", 0},
  1088  }
  1089  
  1090  func TestIPVersion(t *testing.T) {
  1091  	for _, tt := range ipVersionTests {
  1092  		if version := ipVersion(tt.network); version != tt.version {
  1093  			t.Errorf("Family for: %s. Expected: %s, Got: %s", tt.network,
  1094  				string(tt.version), string(version))
  1095  		}
  1096  	}
  1097  }
  1098  
  1099  // Issue 28600: The context that is used to lookup ips should always
  1100  // preserve the values from the context that was passed into LookupIPAddr.
  1101  func TestLookupIPAddrPreservesContextValues(t *testing.T) {
  1102  	origTestHookLookupIP := testHookLookupIP
  1103  	defer func() { testHookLookupIP = origTestHookLookupIP }()
  1104  
  1105  	keyValues := []struct {
  1106  		key, value any
  1107  	}{
  1108  		{"key-1", 12},
  1109  		{384, "value2"},
  1110  		{new(float64), 137},
  1111  	}
  1112  	ctx := context.Background()
  1113  	for _, kv := range keyValues {
  1114  		ctx = context.WithValue(ctx, kv.key, kv.value)
  1115  	}
  1116  
  1117  	wantIPs := []IPAddr{
  1118  		{IP: IPv4(127, 0, 0, 1)},
  1119  		{IP: IPv6loopback},
  1120  	}
  1121  
  1122  	checkCtxValues := func(ctx_ context.Context, fn func(context.Context, string, string) ([]IPAddr, error), network, host string) ([]IPAddr, error) {
  1123  		for _, kv := range keyValues {
  1124  			g, w := ctx_.Value(kv.key), kv.value
  1125  			if !reflect.DeepEqual(g, w) {
  1126  				t.Errorf("Value lookup:\n\tGot:  %v\n\tWant: %v", g, w)
  1127  			}
  1128  		}
  1129  		return wantIPs, nil
  1130  	}
  1131  	testHookLookupIP = checkCtxValues
  1132  
  1133  	resolvers := []*Resolver{
  1134  		nil,
  1135  		new(Resolver),
  1136  	}
  1137  
  1138  	for i, resolver := range resolvers {
  1139  		gotIPs, err := resolver.LookupIPAddr(ctx, "golang.org")
  1140  		if err != nil {
  1141  			t.Errorf("Resolver #%d: unexpected error: %v", i, err)
  1142  		}
  1143  		if !reflect.DeepEqual(gotIPs, wantIPs) {
  1144  			t.Errorf("#%d: mismatched IPAddr results\n\tGot: %v\n\tWant: %v", i, gotIPs, wantIPs)
  1145  		}
  1146  	}
  1147  }
  1148  
  1149  // Issue 30521: The lookup group should call the resolver for each network.
  1150  func TestLookupIPAddrConcurrentCallsForNetworks(t *testing.T) {
  1151  	origTestHookLookupIP := testHookLookupIP
  1152  	defer func() { testHookLookupIP = origTestHookLookupIP }()
  1153  
  1154  	queries := [][]string{
  1155  		{"udp", "golang.org"},
  1156  		{"udp4", "golang.org"},
  1157  		{"udp6", "golang.org"},
  1158  		{"udp", "golang.org"},
  1159  		{"udp", "golang.org"},
  1160  	}
  1161  	results := map[[2]string][]IPAddr{
  1162  		{"udp", "golang.org"}: {
  1163  			{IP: IPv4(127, 0, 0, 1)},
  1164  			{IP: IPv6loopback},
  1165  		},
  1166  		{"udp4", "golang.org"}: {
  1167  			{IP: IPv4(127, 0, 0, 1)},
  1168  		},
  1169  		{"udp6", "golang.org"}: {
  1170  			{IP: IPv6loopback},
  1171  		},
  1172  	}
  1173  	calls := int32(0)
  1174  	waitCh := make(chan struct{})
  1175  	testHookLookupIP = func(ctx context.Context, fn func(context.Context, string, string) ([]IPAddr, error), network, host string) ([]IPAddr, error) {
  1176  		// We'll block until this is called one time for each different
  1177  		// expected result. This will ensure that the lookup group would wait
  1178  		// for the existing call if it was to be reused.
  1179  		if atomic.AddInt32(&calls, 1) == int32(len(results)) {
  1180  			close(waitCh)
  1181  		}
  1182  		select {
  1183  		case <-waitCh:
  1184  		case <-ctx.Done():
  1185  			return nil, ctx.Err()
  1186  		}
  1187  		return results[[2]string{network, host}], nil
  1188  	}
  1189  
  1190  	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
  1191  	defer cancel()
  1192  	wg := sync.WaitGroup{}
  1193  	for _, q := range queries {
  1194  		network := q[0]
  1195  		host := q[1]
  1196  		wg.Add(1)
  1197  		go func() {
  1198  			defer wg.Done()
  1199  			gotIPs, err := DefaultResolver.lookupIPAddr(ctx, network, host)
  1200  			if err != nil {
  1201  				t.Errorf("lookupIPAddr(%v, %v): unexpected error: %v", network, host, err)
  1202  			}
  1203  			wantIPs := results[[2]string{network, host}]
  1204  			if !reflect.DeepEqual(gotIPs, wantIPs) {
  1205  				t.Errorf("lookupIPAddr(%v, %v): mismatched IPAddr results\n\tGot: %v\n\tWant: %v", network, host, gotIPs, wantIPs)
  1206  			}
  1207  		}()
  1208  	}
  1209  	wg.Wait()
  1210  }
  1211  
  1212  // Issue 53995: Resolver.LookupIP should return error for empty host name.
  1213  func TestResolverLookupIPWithEmptyHost(t *testing.T) {
  1214  	_, err := DefaultResolver.LookupIP(context.Background(), "ip", "")
  1215  	if err == nil {
  1216  		t.Fatal("DefaultResolver.LookupIP for empty host success, want no host error")
  1217  	}
  1218  	if !strings.HasSuffix(err.Error(), errNoSuchHost.Error()) {
  1219  		t.Fatalf("lookup error = %v, want %v", err, errNoSuchHost)
  1220  	}
  1221  }
  1222  
  1223  func TestWithUnexpiredValuesPreserved(t *testing.T) {
  1224  	ctx, cancel := context.WithCancel(context.Background())
  1225  
  1226  	// Insert a value into it.
  1227  	key, value := "key-1", 2
  1228  	ctx = context.WithValue(ctx, key, value)
  1229  
  1230  	// Now use the "values preserving context" like
  1231  	// we would for LookupIPAddr. See Issue 28600.
  1232  	ctx = withUnexpiredValuesPreserved(ctx)
  1233  
  1234  	// Lookup before expiry.
  1235  	if g, w := ctx.Value(key), value; g != w {
  1236  		t.Errorf("Lookup before expiry: Got %v Want %v", g, w)
  1237  	}
  1238  
  1239  	// Cancel the context.
  1240  	cancel()
  1241  
  1242  	// Lookup after expiry should return nil
  1243  	if g := ctx.Value(key); g != nil {
  1244  		t.Errorf("Lookup after expiry: Got %v want nil", g)
  1245  	}
  1246  }
  1247  
  1248  // Issue 31597: don't panic on null byte in name
  1249  func TestLookupNullByte(t *testing.T) {
  1250  	testenv.MustHaveExternalNetwork(t)
  1251  	testenv.SkipFlakyNet(t)
  1252  	LookupHost("foo\x00bar") // check that it doesn't panic; it used to on Windows
  1253  }
  1254  
  1255  func TestResolverLookupIP(t *testing.T) {
  1256  	testenv.MustHaveExternalNetwork(t)
  1257  
  1258  	v4Ok := supportsIPv4() && *testIPv4
  1259  	v6Ok := supportsIPv6() && *testIPv6
  1260  
  1261  	defer dnsWaitGroup.Wait()
  1262  
  1263  	for _, impl := range []struct {
  1264  		name string
  1265  		fn   func() func()
  1266  	}{
  1267  		{"go", forceGoDNS},
  1268  		{"cgo", forceCgoDNS},
  1269  	} {
  1270  		t.Run("implementation: "+impl.name, func(t *testing.T) {
  1271  			fixup := impl.fn()
  1272  			if fixup == nil {
  1273  				t.Skip("not supported")
  1274  			}
  1275  			defer fixup()
  1276  
  1277  			for _, network := range []string{"ip", "ip4", "ip6"} {
  1278  				t.Run("network: "+network, func(t *testing.T) {
  1279  					switch {
  1280  					case network == "ip4" && !v4Ok:
  1281  						t.Skip("IPv4 is not supported")
  1282  					case network == "ip6" && !v6Ok:
  1283  						t.Skip("IPv6 is not supported")
  1284  					}
  1285  
  1286  					// google.com has both A and AAAA records.
  1287  					const host = "google.com"
  1288  					ips, err := DefaultResolver.LookupIP(context.Background(), network, host)
  1289  					if err != nil {
  1290  						testenv.SkipFlakyNet(t)
  1291  						t.Fatalf("DefaultResolver.LookupIP(%q, %q): failed with unexpected error: %v", network, host, err)
  1292  					}
  1293  
  1294  					var v4Addrs []netip.Addr
  1295  					var v6Addrs []netip.Addr
  1296  					for _, ip := range ips {
  1297  						if addr, ok := netip.AddrFromSlice(ip); ok {
  1298  							if addr.Is4() {
  1299  								v4Addrs = append(v4Addrs, addr)
  1300  							} else {
  1301  								v6Addrs = append(v6Addrs, addr)
  1302  							}
  1303  						} else {
  1304  							t.Fatalf("IP=%q is neither IPv4 nor IPv6", ip)
  1305  						}
  1306  					}
  1307  
  1308  					// Check that we got the expected addresses.
  1309  					if network == "ip4" || network == "ip" && v4Ok {
  1310  						if len(v4Addrs) == 0 {
  1311  							t.Errorf("DefaultResolver.LookupIP(%q, %q): no IPv4 addresses", network, host)
  1312  						}
  1313  					}
  1314  					if network == "ip6" || network == "ip" && v6Ok {
  1315  						if len(v6Addrs) == 0 {
  1316  							t.Errorf("DefaultResolver.LookupIP(%q, %q): no IPv6 addresses", network, host)
  1317  						}
  1318  					}
  1319  
  1320  					// Check that we didn't get any unexpected addresses.
  1321  					if network == "ip6" && len(v4Addrs) > 0 {
  1322  						t.Errorf("DefaultResolver.LookupIP(%q, %q): unexpected IPv4 addresses: %v", network, host, v4Addrs)
  1323  					}
  1324  					if network == "ip4" && len(v6Addrs) > 0 {
  1325  						t.Errorf("DefaultResolver.LookupIP(%q, %q): unexpected IPv6 or IPv4-mapped IPv6 addresses: %v", network, host, v6Addrs)
  1326  					}
  1327  				})
  1328  			}
  1329  		})
  1330  	}
  1331  }
  1332  
  1333  // A context timeout should still return a DNSError.
  1334  func TestDNSTimeout(t *testing.T) {
  1335  	origTestHookLookupIP := testHookLookupIP
  1336  	defer func() { testHookLookupIP = origTestHookLookupIP }()
  1337  	defer dnsWaitGroup.Wait()
  1338  
  1339  	timeoutHookGo := make(chan bool, 1)
  1340  	timeoutHook := func(ctx context.Context, fn func(context.Context, string, string) ([]IPAddr, error), network, host string) ([]IPAddr, error) {
  1341  		<-timeoutHookGo
  1342  		return nil, context.DeadlineExceeded
  1343  	}
  1344  	testHookLookupIP = timeoutHook
  1345  
  1346  	checkErr := func(err error) {
  1347  		t.Helper()
  1348  		if err == nil {
  1349  			t.Error("expected an error")
  1350  		} else if dnserr, ok := err.(*DNSError); !ok {
  1351  			t.Errorf("got error type %T, want %T", err, (*DNSError)(nil))
  1352  		} else if !dnserr.IsTimeout {
  1353  			t.Errorf("got error %#v, want IsTimeout == true", dnserr)
  1354  		} else if isTimeout := dnserr.Timeout(); !isTimeout {
  1355  			t.Errorf("got err.Timeout() == %t, want true", isTimeout)
  1356  		}
  1357  	}
  1358  
  1359  	// Single lookup.
  1360  	timeoutHookGo <- true
  1361  	_, err := LookupIP("golang.org")
  1362  	checkErr(err)
  1363  
  1364  	// Double lookup.
  1365  	var err1, err2 error
  1366  	var wg sync.WaitGroup
  1367  	wg.Add(2)
  1368  	go func() {
  1369  		defer wg.Done()
  1370  		_, err1 = LookupIP("golang1.org")
  1371  	}()
  1372  	go func() {
  1373  		defer wg.Done()
  1374  		_, err2 = LookupIP("golang1.org")
  1375  	}()
  1376  	close(timeoutHookGo)
  1377  	wg.Wait()
  1378  	checkErr(err1)
  1379  	checkErr(err2)
  1380  
  1381  	// Double lookup with context.
  1382  	timeoutHookGo = make(chan bool)
  1383  	ctx, cancel := context.WithTimeout(context.Background(), time.Nanosecond)
  1384  	wg.Add(2)
  1385  	go func() {
  1386  		defer wg.Done()
  1387  		_, err1 = DefaultResolver.LookupIPAddr(ctx, "golang2.org")
  1388  	}()
  1389  	go func() {
  1390  		defer wg.Done()
  1391  		_, err2 = DefaultResolver.LookupIPAddr(ctx, "golang2.org")
  1392  	}()
  1393  	time.Sleep(10 * time.Nanosecond)
  1394  	close(timeoutHookGo)
  1395  	wg.Wait()
  1396  	checkErr(err1)
  1397  	checkErr(err2)
  1398  	cancel()
  1399  }
  1400  
  1401  func TestLookupNoData(t *testing.T) {
  1402  	if runtime.GOOS == "plan9" {
  1403  		t.Skip("not supported on plan9")
  1404  	}
  1405  
  1406  	mustHaveExternalNetwork(t)
  1407  
  1408  	testLookupNoData(t, "default resolver")
  1409  
  1410  	func() {
  1411  		defer forceGoDNS()()
  1412  		testLookupNoData(t, "forced go resolver")
  1413  	}()
  1414  
  1415  	func() {
  1416  		defer forceCgoDNS()()
  1417  		testLookupNoData(t, "forced cgo resolver")
  1418  	}()
  1419  }
  1420  
  1421  func testLookupNoData(t *testing.T, prefix string) {
  1422  	attempts := 0
  1423  	for {
  1424  		// Domain that doesn't have any A/AAAA RRs, but has different one (in this case a TXT),
  1425  		// so that it returns an empty response without any error codes (NXDOMAIN).
  1426  		_, err := LookupHost("golang.rsc.io.")
  1427  		if err == nil {
  1428  			t.Errorf("%v: unexpected success", prefix)
  1429  			return
  1430  		}
  1431  
  1432  		var dnsErr *DNSError
  1433  		if errors.As(err, &dnsErr) {
  1434  			succeeded := true
  1435  			if !dnsErr.IsNotFound {
  1436  				succeeded = false
  1437  				t.Logf("%v: IsNotFound is set to false", prefix)
  1438  			}
  1439  
  1440  			if dnsErr.Err != errNoSuchHost.Error() {
  1441  				succeeded = false
  1442  				t.Logf("%v: error message is not equal to: %v", prefix, errNoSuchHost.Error())
  1443  			}
  1444  
  1445  			if succeeded {
  1446  				return
  1447  			}
  1448  		}
  1449  
  1450  		testenv.SkipFlakyNet(t)
  1451  		if attempts < len(backoffDuration) {
  1452  			dur := backoffDuration[attempts]
  1453  			t.Logf("%v: backoff %v after failure %v\n", prefix, dur, err)
  1454  			time.Sleep(dur)
  1455  			attempts++
  1456  			continue
  1457  		}
  1458  
  1459  		t.Errorf("%v: unexpected error: %v", prefix, err)
  1460  		return
  1461  	}
  1462  }
  1463  
  1464  func TestLookupPortNotFound(t *testing.T) {
  1465  	allResolvers(t, func(t *testing.T) {
  1466  		_, err := LookupPort("udp", "_-unknown-service-")
  1467  		var dnsErr *DNSError
  1468  		if !errors.As(err, &dnsErr) || !dnsErr.IsNotFound {
  1469  			t.Fatalf("unexpected error: %v", err)
  1470  		}
  1471  	})
  1472  }
  1473  
  1474  // submissions service is only available through a tcp network, see:
  1475  // https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml?search=submissions
  1476  var tcpOnlyService = func() string {
  1477  	// plan9 does not have submissions service defined in the service database.
  1478  	if runtime.GOOS == "plan9" {
  1479  		return "https"
  1480  	}
  1481  	return "submissions"
  1482  }()
  1483  
  1484  func TestLookupPortDifferentNetwork(t *testing.T) {
  1485  	allResolvers(t, func(t *testing.T) {
  1486  		_, err := LookupPort("udp", tcpOnlyService)
  1487  		var dnsErr *DNSError
  1488  		if !errors.As(err, &dnsErr) || !dnsErr.IsNotFound {
  1489  			t.Fatalf("unexpected error: %v", err)
  1490  		}
  1491  	})
  1492  }
  1493  
  1494  func TestLookupPortEmptyNetworkString(t *testing.T) {
  1495  	allResolvers(t, func(t *testing.T) {
  1496  		_, err := LookupPort("", tcpOnlyService)
  1497  		if err != nil {
  1498  			t.Fatalf("unexpected error: %v", err)
  1499  		}
  1500  	})
  1501  }
  1502  
  1503  func TestLookupPortIPNetworkString(t *testing.T) {
  1504  	allResolvers(t, func(t *testing.T) {
  1505  		_, err := LookupPort("ip", tcpOnlyService)
  1506  		if err != nil {
  1507  			t.Fatalf("unexpected error: %v", err)
  1508  		}
  1509  	})
  1510  }
  1511  
  1512  func allResolvers(t *testing.T, f func(t *testing.T)) {
  1513  	t.Run("default resolver", f)
  1514  	t.Run("forced go resolver", func(t *testing.T) {
  1515  		if fixup := forceGoDNS(); fixup != nil {
  1516  			defer fixup()
  1517  			f(t)
  1518  		}
  1519  	})
  1520  	t.Run("forced cgo resolver", func(t *testing.T) {
  1521  		if fixup := forceCgoDNS(); fixup != nil {
  1522  			defer fixup()
  1523  			f(t)
  1524  		}
  1525  	})
  1526  }
  1527  
  1528  func TestLookupNoSuchHost(t *testing.T) {
  1529  	mustHaveExternalNetwork(t)
  1530  
  1531  	const testNXDOMAIN = "invalid.invalid."
  1532  	const testNODATA = "_ldap._tcp.google.com."
  1533  
  1534  	tests := []struct {
  1535  		name  string
  1536  		query func() error
  1537  	}{
  1538  		{
  1539  			name: "LookupCNAME NXDOMAIN",
  1540  			query: func() error {
  1541  				_, err := LookupCNAME(testNXDOMAIN)
  1542  				return err
  1543  			},
  1544  		},
  1545  		{
  1546  			name: "LookupHost NXDOMAIN",
  1547  			query: func() error {
  1548  				_, err := LookupHost(testNXDOMAIN)
  1549  				return err
  1550  			},
  1551  		},
  1552  		{
  1553  			name: "LookupHost NODATA",
  1554  			query: func() error {
  1555  				_, err := LookupHost(testNODATA)
  1556  				return err
  1557  			},
  1558  		},
  1559  		{
  1560  			name: "LookupMX NXDOMAIN",
  1561  			query: func() error {
  1562  				_, err := LookupMX(testNXDOMAIN)
  1563  				return err
  1564  			},
  1565  		},
  1566  		{
  1567  			name: "LookupMX NODATA",
  1568  			query: func() error {
  1569  				_, err := LookupMX(testNODATA)
  1570  				return err
  1571  			},
  1572  		},
  1573  		{
  1574  			name: "LookupNS NXDOMAIN",
  1575  			query: func() error {
  1576  				_, err := LookupNS(testNXDOMAIN)
  1577  				return err
  1578  			},
  1579  		},
  1580  		{
  1581  			name: "LookupNS NODATA",
  1582  			query: func() error {
  1583  				_, err := LookupNS(testNODATA)
  1584  				return err
  1585  			},
  1586  		},
  1587  		{
  1588  			name: "LookupSRV NXDOMAIN",
  1589  			query: func() error {
  1590  				_, _, err := LookupSRV("unknown", "tcp", testNXDOMAIN)
  1591  				return err
  1592  			},
  1593  		},
  1594  		{
  1595  			name: "LookupTXT NXDOMAIN",
  1596  			query: func() error {
  1597  				_, err := LookupTXT(testNXDOMAIN)
  1598  				return err
  1599  			},
  1600  		},
  1601  		{
  1602  			name: "LookupTXT NODATA",
  1603  			query: func() error {
  1604  				_, err := LookupTXT(testNODATA)
  1605  				return err
  1606  			},
  1607  		},
  1608  	}
  1609  
  1610  	for _, v := range tests {
  1611  		t.Run(v.name, func(t *testing.T) {
  1612  			allResolvers(t, func(t *testing.T) {
  1613  				attempts := 0
  1614  				for {
  1615  					err := v.query()
  1616  					if err == nil {
  1617  						t.Errorf("unexpected success")
  1618  						return
  1619  					}
  1620  					if dnsErr, ok := err.(*DNSError); ok {
  1621  						succeeded := true
  1622  						if !dnsErr.IsNotFound {
  1623  							succeeded = false
  1624  							t.Log("IsNotFound is set to false")
  1625  						}
  1626  						if dnsErr.Err != errNoSuchHost.Error() {
  1627  							succeeded = false
  1628  							t.Logf("error message is not equal to: %v", errNoSuchHost.Error())
  1629  						}
  1630  						if succeeded {
  1631  							return
  1632  						}
  1633  					}
  1634  					testenv.SkipFlakyNet(t)
  1635  					if attempts < len(backoffDuration) {
  1636  						dur := backoffDuration[attempts]
  1637  						t.Logf("backoff %v after failure %v\n", dur, err)
  1638  						time.Sleep(dur)
  1639  						attempts++
  1640  						continue
  1641  					}
  1642  					t.Errorf("unexpected error: %v", err)
  1643  					return
  1644  				}
  1645  			})
  1646  		})
  1647  	}
  1648  }
  1649  

View as plain text