mirror of
https://github.com/autc04/Retro68.git
synced 2024-08-31 09:29:37 +00:00
1390 lines
35 KiB
Go
1390 lines
35 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
//go:build !js
|
|
|
|
package net
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"internal/testenv"
|
|
"reflect"
|
|
"runtime"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func hasSuffixFold(s, suffix string) bool {
|
|
return strings.HasSuffix(strings.ToLower(s), strings.ToLower(suffix))
|
|
}
|
|
|
|
func lookupLocalhost(ctx context.Context, fn func(context.Context, string, string) ([]IPAddr, error), network, host string) ([]IPAddr, error) {
|
|
switch host {
|
|
case "localhost":
|
|
return []IPAddr{
|
|
{IP: IPv4(127, 0, 0, 1)},
|
|
{IP: IPv6loopback},
|
|
}, nil
|
|
default:
|
|
return fn(ctx, network, host)
|
|
}
|
|
}
|
|
|
|
// The Lookup APIs use various sources such as local database, DNS or
|
|
// mDNS, and may use platform-dependent DNS stub resolver if possible.
|
|
// The APIs accept any of forms for a query; host name in various
|
|
// encodings, UTF-8 encoded net name, domain name, FQDN or absolute
|
|
// FQDN, but the result would be one of the forms and it depends on
|
|
// the circumstances.
|
|
|
|
var lookupGoogleSRVTests = []struct {
|
|
service, proto, name string
|
|
cname, target string
|
|
}{
|
|
{
|
|
"xmpp-server", "tcp", "google.com",
|
|
"google.com.", "google.com.",
|
|
},
|
|
{
|
|
"xmpp-server", "tcp", "google.com.",
|
|
"google.com.", "google.com.",
|
|
},
|
|
|
|
// non-standard back door
|
|
{
|
|
"", "", "_xmpp-server._tcp.google.com",
|
|
"google.com.", "google.com.",
|
|
},
|
|
{
|
|
"", "", "_xmpp-server._tcp.google.com.",
|
|
"google.com.", "google.com.",
|
|
},
|
|
}
|
|
|
|
var backoffDuration = [...]time.Duration{time.Second, 5 * time.Second, 30 * time.Second}
|
|
|
|
func TestLookupGoogleSRV(t *testing.T) {
|
|
t.Parallel()
|
|
mustHaveExternalNetwork(t)
|
|
|
|
if iOS() {
|
|
t.Skip("no resolv.conf on iOS")
|
|
}
|
|
|
|
if !supportsIPv4() || !*testIPv4 {
|
|
t.Skip("IPv4 is required")
|
|
}
|
|
|
|
attempts := 0
|
|
for i := 0; i < len(lookupGoogleSRVTests); i++ {
|
|
tt := lookupGoogleSRVTests[i]
|
|
cname, srvs, err := LookupSRV(tt.service, tt.proto, tt.name)
|
|
if err != nil {
|
|
testenv.SkipFlakyNet(t)
|
|
if attempts < len(backoffDuration) {
|
|
dur := backoffDuration[attempts]
|
|
t.Logf("backoff %v after failure %v\n", dur, err)
|
|
time.Sleep(dur)
|
|
attempts++
|
|
i--
|
|
continue
|
|
}
|
|
t.Fatal(err)
|
|
}
|
|
if len(srvs) == 0 {
|
|
t.Error("got no record")
|
|
}
|
|
if !hasSuffixFold(cname, tt.cname) {
|
|
t.Errorf("got %s; want %s", cname, tt.cname)
|
|
}
|
|
for _, srv := range srvs {
|
|
if !hasSuffixFold(srv.Target, tt.target) {
|
|
t.Errorf("got %v; want a record containing %s", srv, tt.target)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var lookupGmailMXTests = []struct {
|
|
name, host string
|
|
}{
|
|
{"gmail.com", "google.com."},
|
|
{"gmail.com.", "google.com."},
|
|
}
|
|
|
|
func TestLookupGmailMX(t *testing.T) {
|
|
t.Parallel()
|
|
mustHaveExternalNetwork(t)
|
|
|
|
if iOS() {
|
|
t.Skip("no resolv.conf on iOS")
|
|
}
|
|
|
|
if !supportsIPv4() || !*testIPv4 {
|
|
t.Skip("IPv4 is required")
|
|
}
|
|
|
|
attempts := 0
|
|
for i := 0; i < len(lookupGmailMXTests); i++ {
|
|
tt := lookupGmailMXTests[i]
|
|
mxs, err := LookupMX(tt.name)
|
|
if err != nil {
|
|
testenv.SkipFlakyNet(t)
|
|
if attempts < len(backoffDuration) {
|
|
dur := backoffDuration[attempts]
|
|
t.Logf("backoff %v after failure %v\n", dur, err)
|
|
time.Sleep(dur)
|
|
attempts++
|
|
i--
|
|
continue
|
|
}
|
|
t.Fatal(err)
|
|
}
|
|
if len(mxs) == 0 {
|
|
t.Error("got no record")
|
|
}
|
|
for _, mx := range mxs {
|
|
if !hasSuffixFold(mx.Host, tt.host) {
|
|
t.Errorf("got %v; want a record containing %s", mx, tt.host)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var lookupGmailNSTests = []struct {
|
|
name, host string
|
|
}{
|
|
{"gmail.com", "google.com."},
|
|
{"gmail.com.", "google.com."},
|
|
}
|
|
|
|
func TestLookupGmailNS(t *testing.T) {
|
|
t.Parallel()
|
|
mustHaveExternalNetwork(t)
|
|
|
|
if iOS() {
|
|
t.Skip("no resolv.conf on iOS")
|
|
}
|
|
|
|
if !supportsIPv4() || !*testIPv4 {
|
|
t.Skip("IPv4 is required")
|
|
}
|
|
|
|
attempts := 0
|
|
for i := 0; i < len(lookupGmailNSTests); i++ {
|
|
tt := lookupGmailNSTests[i]
|
|
nss, err := LookupNS(tt.name)
|
|
if err != nil {
|
|
testenv.SkipFlakyNet(t)
|
|
if attempts < len(backoffDuration) {
|
|
dur := backoffDuration[attempts]
|
|
t.Logf("backoff %v after failure %v\n", dur, err)
|
|
time.Sleep(dur)
|
|
attempts++
|
|
i--
|
|
continue
|
|
}
|
|
t.Fatal(err)
|
|
}
|
|
if len(nss) == 0 {
|
|
t.Error("got no record")
|
|
}
|
|
for _, ns := range nss {
|
|
if !hasSuffixFold(ns.Host, tt.host) {
|
|
t.Errorf("got %v; want a record containing %s", ns, tt.host)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var lookupGmailTXTTests = []struct {
|
|
name, txt, host string
|
|
}{
|
|
{"gmail.com", "spf", "google.com"},
|
|
{"gmail.com.", "spf", "google.com"},
|
|
}
|
|
|
|
func TestLookupGmailTXT(t *testing.T) {
|
|
if runtime.GOOS == "plan9" {
|
|
t.Skip("skipping on plan9; see https://golang.org/issue/29722")
|
|
}
|
|
t.Parallel()
|
|
mustHaveExternalNetwork(t)
|
|
|
|
if iOS() {
|
|
t.Skip("no resolv.conf on iOS")
|
|
}
|
|
|
|
if !supportsIPv4() || !*testIPv4 {
|
|
t.Skip("IPv4 is required")
|
|
}
|
|
|
|
attempts := 0
|
|
for i := 0; i < len(lookupGmailTXTTests); i++ {
|
|
tt := lookupGmailTXTTests[i]
|
|
txts, err := LookupTXT(tt.name)
|
|
if err != nil {
|
|
testenv.SkipFlakyNet(t)
|
|
if attempts < len(backoffDuration) {
|
|
dur := backoffDuration[attempts]
|
|
t.Logf("backoff %v after failure %v\n", dur, err)
|
|
time.Sleep(dur)
|
|
attempts++
|
|
i--
|
|
continue
|
|
}
|
|
t.Fatal(err)
|
|
}
|
|
if len(txts) == 0 {
|
|
t.Error("got no record")
|
|
}
|
|
found := false
|
|
for _, txt := range txts {
|
|
if strings.Contains(txt, tt.txt) && (strings.HasSuffix(txt, tt.host) || strings.HasSuffix(txt, tt.host+".")) {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Errorf("got %v; want a record containing %s, %s", txts, tt.txt, tt.host)
|
|
}
|
|
}
|
|
}
|
|
|
|
var lookupGooglePublicDNSAddrTests = []string{
|
|
"8.8.8.8",
|
|
"8.8.4.4",
|
|
"2001:4860:4860::8888",
|
|
"2001:4860:4860::8844",
|
|
}
|
|
|
|
func TestLookupGooglePublicDNSAddr(t *testing.T) {
|
|
mustHaveExternalNetwork(t)
|
|
|
|
if !supportsIPv4() || !supportsIPv6() || !*testIPv4 || !*testIPv6 {
|
|
t.Skip("both IPv4 and IPv6 are required")
|
|
}
|
|
|
|
defer dnsWaitGroup.Wait()
|
|
|
|
for _, ip := range lookupGooglePublicDNSAddrTests {
|
|
names, err := LookupAddr(ip)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(names) == 0 {
|
|
t.Error("got no record")
|
|
}
|
|
for _, name := range names {
|
|
if !hasSuffixFold(name, ".google.com.") && !hasSuffixFold(name, ".google.") {
|
|
t.Errorf("got %q; want a record ending in .google.com. or .google.", name)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestLookupIPv6LinkLocalAddr(t *testing.T) {
|
|
if !supportsIPv6() || !*testIPv6 {
|
|
t.Skip("IPv6 is required")
|
|
}
|
|
|
|
defer dnsWaitGroup.Wait()
|
|
|
|
addrs, err := LookupHost("localhost")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
found := false
|
|
for _, addr := range addrs {
|
|
if addr == "fe80::1%lo0" {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Skipf("not supported on %s", runtime.GOOS)
|
|
}
|
|
if _, err := LookupAddr("fe80::1%lo0"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestLookupIPv6LinkLocalAddrWithZone(t *testing.T) {
|
|
if !supportsIPv6() || !*testIPv6 {
|
|
t.Skip("IPv6 is required")
|
|
}
|
|
|
|
ipaddrs, err := DefaultResolver.LookupIPAddr(context.Background(), "fe80::1%lo0")
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
for _, addr := range ipaddrs {
|
|
if e, a := "lo0", addr.Zone; e != a {
|
|
t.Errorf("wrong zone: want %q, got %q", e, a)
|
|
}
|
|
}
|
|
|
|
addrs, err := DefaultResolver.LookupHost(context.Background(), "fe80::1%lo0")
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
for _, addr := range addrs {
|
|
if e, a := "fe80::1%lo0", addr; e != a {
|
|
t.Errorf("wrong host: want %q got %q", e, a)
|
|
}
|
|
}
|
|
}
|
|
|
|
var lookupCNAMETests = []struct {
|
|
name, cname string
|
|
}{
|
|
{"www.iana.org", "icann.org."},
|
|
{"www.iana.org.", "icann.org."},
|
|
{"www.google.com", "google.com."},
|
|
}
|
|
|
|
func TestLookupCNAME(t *testing.T) {
|
|
mustHaveExternalNetwork(t)
|
|
testenv.SkipFlakyNet(t)
|
|
|
|
if !supportsIPv4() || !*testIPv4 {
|
|
t.Skip("IPv4 is required")
|
|
}
|
|
|
|
defer dnsWaitGroup.Wait()
|
|
|
|
attempts := 0
|
|
for i := 0; i < len(lookupCNAMETests); i++ {
|
|
tt := lookupCNAMETests[i]
|
|
cname, err := LookupCNAME(tt.name)
|
|
if err != nil {
|
|
testenv.SkipFlakyNet(t)
|
|
if attempts < len(backoffDuration) {
|
|
dur := backoffDuration[attempts]
|
|
t.Logf("backoff %v after failure %v\n", dur, err)
|
|
time.Sleep(dur)
|
|
attempts++
|
|
i--
|
|
continue
|
|
}
|
|
t.Fatal(err)
|
|
}
|
|
if !hasSuffixFold(cname, tt.cname) {
|
|
t.Errorf("got %s; want a record containing %s", cname, tt.cname)
|
|
}
|
|
}
|
|
}
|
|
|
|
var lookupGoogleHostTests = []struct {
|
|
name string
|
|
}{
|
|
{"google.com"},
|
|
{"google.com."},
|
|
}
|
|
|
|
func TestLookupGoogleHost(t *testing.T) {
|
|
mustHaveExternalNetwork(t)
|
|
testenv.SkipFlakyNet(t)
|
|
|
|
if !supportsIPv4() || !*testIPv4 {
|
|
t.Skip("IPv4 is required")
|
|
}
|
|
|
|
defer dnsWaitGroup.Wait()
|
|
|
|
for _, tt := range lookupGoogleHostTests {
|
|
addrs, err := LookupHost(tt.name)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(addrs) == 0 {
|
|
t.Error("got no record")
|
|
}
|
|
for _, addr := range addrs {
|
|
if ParseIP(addr) == nil {
|
|
t.Errorf("got %q; want a literal IP address", addr)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestLookupLongTXT(t *testing.T) {
|
|
testenv.SkipFlaky(t, 22857)
|
|
mustHaveExternalNetwork(t)
|
|
|
|
defer dnsWaitGroup.Wait()
|
|
|
|
txts, err := LookupTXT("golang.rsc.io")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sort.Strings(txts)
|
|
want := []string{
|
|
strings.Repeat("abcdefghijklmnopqrstuvwxyABCDEFGHJIKLMNOPQRSTUVWXY", 10),
|
|
"gophers rule",
|
|
}
|
|
if !reflect.DeepEqual(txts, want) {
|
|
t.Fatalf("LookupTXT golang.rsc.io incorrect\nhave %q\nwant %q", txts, want)
|
|
}
|
|
}
|
|
|
|
var lookupGoogleIPTests = []struct {
|
|
name string
|
|
}{
|
|
{"google.com"},
|
|
{"google.com."},
|
|
}
|
|
|
|
func TestLookupGoogleIP(t *testing.T) {
|
|
mustHaveExternalNetwork(t)
|
|
testenv.SkipFlakyNet(t)
|
|
|
|
if !supportsIPv4() || !*testIPv4 {
|
|
t.Skip("IPv4 is required")
|
|
}
|
|
|
|
defer dnsWaitGroup.Wait()
|
|
|
|
for _, tt := range lookupGoogleIPTests {
|
|
ips, err := LookupIP(tt.name)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(ips) == 0 {
|
|
t.Error("got no record")
|
|
}
|
|
for _, ip := range ips {
|
|
if ip.To4() == nil && ip.To16() == nil {
|
|
t.Errorf("got %v; want an IP address", ip)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var revAddrTests = []struct {
|
|
Addr string
|
|
Reverse string
|
|
ErrPrefix string
|
|
}{
|
|
{"1.2.3.4", "4.3.2.1.in-addr.arpa.", ""},
|
|
{"245.110.36.114", "114.36.110.245.in-addr.arpa.", ""},
|
|
{"::ffff:12.34.56.78", "78.56.34.12.in-addr.arpa.", ""},
|
|
{"::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.", ""},
|
|
{"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.", ""},
|
|
{"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.", ""},
|
|
{"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.", ""},
|
|
{"1.2.3", "", "unrecognized address"},
|
|
{"1.2.3.4.5", "", "unrecognized address"},
|
|
{"1234:567:bcbca::89a:bcde", "", "unrecognized address"},
|
|
{"1234:567::bcbc:adad::89a:bcde", "", "unrecognized address"},
|
|
}
|
|
|
|
func TestReverseAddress(t *testing.T) {
|
|
defer dnsWaitGroup.Wait()
|
|
for i, tt := range revAddrTests {
|
|
a, err := reverseaddr(tt.Addr)
|
|
if len(tt.ErrPrefix) > 0 && err == nil {
|
|
t.Errorf("#%d: expected %q, got <nil> (error)", i, tt.ErrPrefix)
|
|
continue
|
|
}
|
|
if len(tt.ErrPrefix) == 0 && err != nil {
|
|
t.Errorf("#%d: expected <nil>, got %q (error)", i, err)
|
|
}
|
|
if err != nil && err.(*DNSError).Err != tt.ErrPrefix {
|
|
t.Errorf("#%d: expected %q, got %q (mismatched error)", i, tt.ErrPrefix, err.(*DNSError).Err)
|
|
}
|
|
if a != tt.Reverse {
|
|
t.Errorf("#%d: expected %q, got %q (reverse address)", i, tt.Reverse, a)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDNSFlood(t *testing.T) {
|
|
if !*testDNSFlood {
|
|
t.Skip("test disabled; use -dnsflood to enable")
|
|
}
|
|
|
|
defer dnsWaitGroup.Wait()
|
|
|
|
var N = 5000
|
|
if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
|
|
// On Darwin this test consumes kernel threads much
|
|
// than other platforms for some reason.
|
|
// When we monitor the number of allocated Ms by
|
|
// observing on runtime.newm calls, we can see that it
|
|
// easily reaches the per process ceiling
|
|
// kern.num_threads when CGO_ENABLED=1 and
|
|
// GODEBUG=netdns=go.
|
|
N = 500
|
|
}
|
|
|
|
const timeout = 3 * time.Second
|
|
ctxHalfTimeout, cancel := context.WithTimeout(context.Background(), timeout/2)
|
|
defer cancel()
|
|
ctxTimeout, cancel := context.WithTimeout(context.Background(), timeout)
|
|
defer cancel()
|
|
|
|
c := make(chan error, 2*N)
|
|
for i := 0; i < N; i++ {
|
|
name := fmt.Sprintf("%d.net-test.golang.org", i)
|
|
go func() {
|
|
_, err := DefaultResolver.LookupIPAddr(ctxHalfTimeout, name)
|
|
c <- err
|
|
}()
|
|
go func() {
|
|
_, err := DefaultResolver.LookupIPAddr(ctxTimeout, name)
|
|
c <- err
|
|
}()
|
|
}
|
|
qstats := struct {
|
|
succeeded, failed int
|
|
timeout, temporary, other int
|
|
unknown int
|
|
}{}
|
|
deadline := time.After(timeout + time.Second)
|
|
for i := 0; i < 2*N; i++ {
|
|
select {
|
|
case <-deadline:
|
|
t.Fatal("deadline exceeded")
|
|
case err := <-c:
|
|
switch err := err.(type) {
|
|
case nil:
|
|
qstats.succeeded++
|
|
case Error:
|
|
qstats.failed++
|
|
if err.Timeout() {
|
|
qstats.timeout++
|
|
}
|
|
if err.Temporary() {
|
|
qstats.temporary++
|
|
}
|
|
if !err.Timeout() && !err.Temporary() {
|
|
qstats.other++
|
|
}
|
|
default:
|
|
qstats.failed++
|
|
qstats.unknown++
|
|
}
|
|
}
|
|
}
|
|
|
|
// A high volume of DNS queries for sub-domain of golang.org
|
|
// would be coordinated by authoritative or recursive server,
|
|
// or stub resolver which implements query-response rate
|
|
// limitation, so we can expect some query successes and more
|
|
// failures including timeout, temporary and other here.
|
|
// As a rule, unknown must not be shown but it might possibly
|
|
// happen due to issue 4856 for now.
|
|
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)
|
|
}
|
|
|
|
func TestLookupDotsWithLocalSource(t *testing.T) {
|
|
if !supportsIPv4() || !*testIPv4 {
|
|
t.Skip("IPv4 is required")
|
|
}
|
|
|
|
mustHaveExternalNetwork(t)
|
|
|
|
defer dnsWaitGroup.Wait()
|
|
|
|
for i, fn := range []func() func(){forceGoDNS, forceCgoDNS} {
|
|
fixup := fn()
|
|
if fixup == nil {
|
|
continue
|
|
}
|
|
names, err := LookupAddr("127.0.0.1")
|
|
fixup()
|
|
if err != nil {
|
|
t.Logf("#%d: %v", i, err)
|
|
continue
|
|
}
|
|
mode := "netgo"
|
|
if i == 1 {
|
|
mode = "netcgo"
|
|
}
|
|
loop:
|
|
for i, name := range names {
|
|
if strings.Index(name, ".") == len(name)-1 { // "localhost" not "localhost."
|
|
for j := range names {
|
|
if j == i {
|
|
continue
|
|
}
|
|
if names[j] == name[:len(name)-1] {
|
|
// It's OK if we find the name without the dot,
|
|
// as some systems say 127.0.0.1 localhost localhost.
|
|
continue loop
|
|
}
|
|
}
|
|
t.Errorf("%s: got %s; want %s", mode, name, name[:len(name)-1])
|
|
} else if strings.Contains(name, ".") && !strings.HasSuffix(name, ".") { // "localhost.localdomain." not "localhost.localdomain"
|
|
t.Errorf("%s: got %s; want name ending with trailing dot", mode, name)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestLookupDotsWithRemoteSource(t *testing.T) {
|
|
if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
|
|
testenv.SkipFlaky(t, 27992)
|
|
}
|
|
mustHaveExternalNetwork(t)
|
|
testenv.SkipFlakyNet(t)
|
|
|
|
if !supportsIPv4() || !*testIPv4 {
|
|
t.Skip("IPv4 is required")
|
|
}
|
|
|
|
if iOS() {
|
|
t.Skip("no resolv.conf on iOS")
|
|
}
|
|
|
|
defer dnsWaitGroup.Wait()
|
|
|
|
if fixup := forceGoDNS(); fixup != nil {
|
|
testDots(t, "go")
|
|
fixup()
|
|
}
|
|
if fixup := forceCgoDNS(); fixup != nil {
|
|
testDots(t, "cgo")
|
|
fixup()
|
|
}
|
|
}
|
|
|
|
func testDots(t *testing.T, mode string) {
|
|
names, err := LookupAddr("8.8.8.8") // Google dns server
|
|
if err != nil {
|
|
t.Errorf("LookupAddr(8.8.8.8): %v (mode=%v)", err, mode)
|
|
} else {
|
|
for _, name := range names {
|
|
if !hasSuffixFold(name, ".google.com.") && !hasSuffixFold(name, ".google.") {
|
|
t.Errorf("LookupAddr(8.8.8.8) = %v, want names ending in .google.com or .google with trailing dot (mode=%v)", names, mode)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
cname, err := LookupCNAME("www.mit.edu")
|
|
if err != nil {
|
|
t.Errorf("LookupCNAME(www.mit.edu, mode=%v): %v", mode, err)
|
|
} else if !strings.HasSuffix(cname, ".") {
|
|
t.Errorf("LookupCNAME(www.mit.edu) = %v, want cname ending in . with trailing dot (mode=%v)", cname, mode)
|
|
}
|
|
|
|
mxs, err := LookupMX("google.com")
|
|
if err != nil {
|
|
t.Errorf("LookupMX(google.com): %v (mode=%v)", err, mode)
|
|
} else {
|
|
for _, mx := range mxs {
|
|
if !hasSuffixFold(mx.Host, ".google.com.") {
|
|
t.Errorf("LookupMX(google.com) = %v, want names ending in .google.com. with trailing dot (mode=%v)", mxString(mxs), mode)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
nss, err := LookupNS("google.com")
|
|
if err != nil {
|
|
t.Errorf("LookupNS(google.com): %v (mode=%v)", err, mode)
|
|
} else {
|
|
for _, ns := range nss {
|
|
if !hasSuffixFold(ns.Host, ".google.com.") {
|
|
t.Errorf("LookupNS(google.com) = %v, want names ending in .google.com. with trailing dot (mode=%v)", nsString(nss), mode)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
cname, srvs, err := LookupSRV("xmpp-server", "tcp", "google.com")
|
|
if err != nil {
|
|
t.Errorf("LookupSRV(xmpp-server, tcp, google.com): %v (mode=%v)", err, mode)
|
|
} else {
|
|
if !hasSuffixFold(cname, ".google.com.") {
|
|
t.Errorf("LookupSRV(xmpp-server, tcp, google.com) returned cname=%v, want name ending in .google.com. with trailing dot (mode=%v)", cname, mode)
|
|
}
|
|
for _, srv := range srvs {
|
|
if !hasSuffixFold(srv.Target, ".google.com.") {
|
|
t.Errorf("LookupSRV(xmpp-server, tcp, google.com) returned addrs=%v, want names ending in .google.com. with trailing dot (mode=%v)", srvString(srvs), mode)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func mxString(mxs []*MX) string {
|
|
var buf bytes.Buffer
|
|
sep := ""
|
|
fmt.Fprintf(&buf, "[")
|
|
for _, mx := range mxs {
|
|
fmt.Fprintf(&buf, "%s%s:%d", sep, mx.Host, mx.Pref)
|
|
sep = " "
|
|
}
|
|
fmt.Fprintf(&buf, "]")
|
|
return buf.String()
|
|
}
|
|
|
|
func nsString(nss []*NS) string {
|
|
var buf bytes.Buffer
|
|
sep := ""
|
|
fmt.Fprintf(&buf, "[")
|
|
for _, ns := range nss {
|
|
fmt.Fprintf(&buf, "%s%s", sep, ns.Host)
|
|
sep = " "
|
|
}
|
|
fmt.Fprintf(&buf, "]")
|
|
return buf.String()
|
|
}
|
|
|
|
func srvString(srvs []*SRV) string {
|
|
var buf bytes.Buffer
|
|
sep := ""
|
|
fmt.Fprintf(&buf, "[")
|
|
for _, srv := range srvs {
|
|
fmt.Fprintf(&buf, "%s%s:%d:%d:%d", sep, srv.Target, srv.Port, srv.Priority, srv.Weight)
|
|
sep = " "
|
|
}
|
|
fmt.Fprintf(&buf, "]")
|
|
return buf.String()
|
|
}
|
|
|
|
func TestLookupPort(t *testing.T) {
|
|
// See https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml
|
|
//
|
|
// Please be careful about adding new test cases.
|
|
// There are platforms which have incomplete mappings for
|
|
// restricted resource access and security reasons.
|
|
type test struct {
|
|
network string
|
|
name string
|
|
port int
|
|
ok bool
|
|
}
|
|
var tests = []test{
|
|
{"tcp", "0", 0, true},
|
|
{"udp", "0", 0, true},
|
|
{"udp", "domain", 53, true},
|
|
|
|
{"--badnet--", "zzz", 0, false},
|
|
{"tcp", "--badport--", 0, false},
|
|
{"tcp", "-1", 0, false},
|
|
{"tcp", "65536", 0, false},
|
|
{"udp", "-1", 0, false},
|
|
{"udp", "65536", 0, false},
|
|
{"tcp", "123456789", 0, false},
|
|
|
|
// Issue 13610: LookupPort("tcp", "")
|
|
{"tcp", "", 0, true},
|
|
{"tcp4", "", 0, true},
|
|
{"tcp6", "", 0, true},
|
|
{"udp", "", 0, true},
|
|
{"udp4", "", 0, true},
|
|
{"udp6", "", 0, true},
|
|
}
|
|
|
|
switch runtime.GOOS {
|
|
case "android":
|
|
if netGo {
|
|
t.Skipf("not supported on %s without cgo; see golang.org/issues/14576", runtime.GOOS)
|
|
}
|
|
default:
|
|
tests = append(tests, test{"tcp", "http", 80, true})
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
port, err := LookupPort(tt.network, tt.name)
|
|
if port != tt.port || (err == nil) != tt.ok {
|
|
t.Errorf("LookupPort(%q, %q) = %d, %v; want %d, error=%t", tt.network, tt.name, port, err, tt.port, !tt.ok)
|
|
}
|
|
if err != nil {
|
|
if perr := parseLookupPortError(err); perr != nil {
|
|
t.Error(perr)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Like TestLookupPort but with minimal tests that should always pass
|
|
// because the answers are baked-in to the net package.
|
|
func TestLookupPort_Minimal(t *testing.T) {
|
|
type test struct {
|
|
network string
|
|
name string
|
|
port int
|
|
}
|
|
var tests = []test{
|
|
{"tcp", "http", 80},
|
|
{"tcp", "HTTP", 80}, // case shouldn't matter
|
|
{"tcp", "https", 443},
|
|
{"tcp", "ssh", 22},
|
|
{"tcp", "gopher", 70},
|
|
{"tcp4", "http", 80},
|
|
{"tcp6", "http", 80},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
port, err := LookupPort(tt.network, tt.name)
|
|
if port != tt.port || err != nil {
|
|
t.Errorf("LookupPort(%q, %q) = %d, %v; want %d, error=nil", tt.network, tt.name, port, err, tt.port)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestLookupProtocol_Minimal(t *testing.T) {
|
|
type test struct {
|
|
name string
|
|
want int
|
|
}
|
|
var tests = []test{
|
|
{"tcp", 6},
|
|
{"TcP", 6}, // case shouldn't matter
|
|
{"icmp", 1},
|
|
{"igmp", 2},
|
|
{"udp", 17},
|
|
{"ipv6-icmp", 58},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
got, err := lookupProtocol(context.Background(), tt.name)
|
|
if got != tt.want || err != nil {
|
|
t.Errorf("LookupProtocol(%q) = %d, %v; want %d, error=nil", tt.name, got, err, tt.want)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func TestLookupNonLDH(t *testing.T) {
|
|
defer dnsWaitGroup.Wait()
|
|
|
|
if fixup := forceGoDNS(); fixup != nil {
|
|
defer fixup()
|
|
}
|
|
|
|
// "LDH" stands for letters, digits, and hyphens and is the usual
|
|
// description of standard DNS names.
|
|
// This test is checking that other kinds of names are reported
|
|
// as not found, not reported as invalid names.
|
|
addrs, err := LookupHost("!!!.###.bogus..domain.")
|
|
if err == nil {
|
|
t.Fatalf("lookup succeeded: %v", addrs)
|
|
}
|
|
if !strings.HasSuffix(err.Error(), errNoSuchHost.Error()) {
|
|
t.Fatalf("lookup error = %v, want %v", err, errNoSuchHost)
|
|
}
|
|
if !err.(*DNSError).IsNotFound {
|
|
t.Fatalf("lookup error = %v, want true", err.(*DNSError).IsNotFound)
|
|
}
|
|
}
|
|
|
|
func TestLookupContextCancel(t *testing.T) {
|
|
mustHaveExternalNetwork(t)
|
|
testenv.SkipFlakyNet(t)
|
|
|
|
origTestHookLookupIP := testHookLookupIP
|
|
defer func() {
|
|
dnsWaitGroup.Wait()
|
|
testHookLookupIP = origTestHookLookupIP
|
|
}()
|
|
|
|
lookupCtx, cancelLookup := context.WithCancel(context.Background())
|
|
unblockLookup := make(chan struct{})
|
|
|
|
// Set testHookLookupIP to start a new, concurrent call to LookupIPAddr
|
|
// and cancel the original one, then block until the canceled call has returned
|
|
// (ensuring that it has performed any synchronous cleanup).
|
|
testHookLookupIP = func(
|
|
ctx context.Context,
|
|
fn func(context.Context, string, string) ([]IPAddr, error),
|
|
network string,
|
|
host string,
|
|
) ([]IPAddr, error) {
|
|
select {
|
|
case <-unblockLookup:
|
|
default:
|
|
// Start a concurrent LookupIPAddr for the same host while the caller is
|
|
// still blocked, and sleep a little to give it time to be deduplicated
|
|
// before we cancel (and unblock) the caller.
|
|
// (If the timing doesn't quite work out, we'll end up testing sequential
|
|
// calls instead of concurrent ones, but the test should still pass.)
|
|
t.Logf("starting concurrent LookupIPAddr")
|
|
dnsWaitGroup.Add(1)
|
|
go func() {
|
|
defer dnsWaitGroup.Done()
|
|
_, err := DefaultResolver.LookupIPAddr(context.Background(), host)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}()
|
|
time.Sleep(1 * time.Millisecond)
|
|
}
|
|
|
|
cancelLookup()
|
|
<-unblockLookup
|
|
// If the concurrent lookup above is deduplicated to this one
|
|
// (as we expect to happen most of the time), it is important
|
|
// that the original call does not cancel the shared Context.
|
|
// (See https://go.dev/issue/22724.) Explicitly check for
|
|
// cancellation now, just in case fn itself doesn't notice it.
|
|
if err := ctx.Err(); err != nil {
|
|
t.Logf("testHookLookupIP canceled")
|
|
return nil, err
|
|
}
|
|
t.Logf("testHookLookupIP performing lookup")
|
|
return fn(ctx, network, host)
|
|
}
|
|
|
|
_, err := DefaultResolver.LookupIPAddr(lookupCtx, "google.com")
|
|
if dnsErr, ok := err.(*DNSError); !ok || dnsErr.Err != errCanceled.Error() {
|
|
t.Errorf("unexpected error from canceled, blocked LookupIPAddr: %v", err)
|
|
}
|
|
close(unblockLookup)
|
|
}
|
|
|
|
// Issue 24330: treat the nil *Resolver like a zero value. Verify nothing
|
|
// crashes if nil is used.
|
|
func TestNilResolverLookup(t *testing.T) {
|
|
mustHaveExternalNetwork(t)
|
|
var r *Resolver = nil
|
|
ctx := context.Background()
|
|
|
|
// Don't care about the results, just that nothing panics:
|
|
r.LookupAddr(ctx, "8.8.8.8")
|
|
r.LookupCNAME(ctx, "google.com")
|
|
r.LookupHost(ctx, "google.com")
|
|
r.LookupIPAddr(ctx, "google.com")
|
|
r.LookupIP(ctx, "ip", "google.com")
|
|
r.LookupMX(ctx, "gmail.com")
|
|
r.LookupNS(ctx, "google.com")
|
|
r.LookupPort(ctx, "tcp", "smtp")
|
|
r.LookupSRV(ctx, "service", "proto", "name")
|
|
r.LookupTXT(ctx, "gmail.com")
|
|
}
|
|
|
|
// TestLookupHostCancel verifies that lookup works even after many
|
|
// canceled lookups (see golang.org/issue/24178 for details).
|
|
func TestLookupHostCancel(t *testing.T) {
|
|
mustHaveExternalNetwork(t)
|
|
testenv.SkipFlakyNet(t)
|
|
t.Parallel() // Executes 600ms worth of sequential sleeps.
|
|
|
|
const (
|
|
google = "www.google.com"
|
|
invalidDomain = "invalid.invalid" // RFC 2606 reserves .invalid
|
|
n = 600 // this needs to be larger than threadLimit size
|
|
)
|
|
|
|
_, err := LookupHost(google)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
for i := 0; i < n; i++ {
|
|
addr, err := DefaultResolver.LookupHost(ctx, invalidDomain)
|
|
if err == nil {
|
|
t.Fatalf("LookupHost(%q): returns %v, but should fail", invalidDomain, addr)
|
|
}
|
|
|
|
// Don't verify what the actual error is.
|
|
// We know that it must be non-nil because the domain is invalid,
|
|
// but we don't have any guarantee that LookupHost actually bothers
|
|
// to check for cancellation on the fast path.
|
|
// (For example, it could use a local cache to avoid blocking entirely.)
|
|
|
|
// The lookup may deduplicate in-flight requests, so give it time to settle
|
|
// in between.
|
|
time.Sleep(time.Millisecond * 1)
|
|
}
|
|
|
|
_, err = LookupHost(google)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
type lookupCustomResolver struct {
|
|
*Resolver
|
|
mu sync.RWMutex
|
|
dialed bool
|
|
}
|
|
|
|
func (lcr *lookupCustomResolver) dial() func(ctx context.Context, network, address string) (Conn, error) {
|
|
return func(ctx context.Context, network, address string) (Conn, error) {
|
|
lcr.mu.Lock()
|
|
lcr.dialed = true
|
|
lcr.mu.Unlock()
|
|
return Dial(network, address)
|
|
}
|
|
}
|
|
|
|
// TestConcurrentPreferGoResolversDial tests that multiple resolvers with the
|
|
// PreferGo option used concurrently are all dialed properly.
|
|
func TestConcurrentPreferGoResolversDial(t *testing.T) {
|
|
// The windows and plan9 implementation of the resolver does not use
|
|
// the Dial function.
|
|
switch runtime.GOOS {
|
|
case "windows", "plan9":
|
|
t.Skipf("skip on %v", runtime.GOOS)
|
|
}
|
|
|
|
testenv.MustHaveExternalNetwork(t)
|
|
testenv.SkipFlakyNet(t)
|
|
|
|
defer dnsWaitGroup.Wait()
|
|
|
|
resolvers := make([]*lookupCustomResolver, 2)
|
|
for i := range resolvers {
|
|
cs := lookupCustomResolver{Resolver: &Resolver{PreferGo: true}}
|
|
cs.Dial = cs.dial()
|
|
resolvers[i] = &cs
|
|
}
|
|
|
|
var wg sync.WaitGroup
|
|
wg.Add(len(resolvers))
|
|
for i, resolver := range resolvers {
|
|
go func(r *Resolver, index int) {
|
|
defer wg.Done()
|
|
_, err := r.LookupIPAddr(context.Background(), "google.com")
|
|
if err != nil {
|
|
t.Errorf("lookup failed for resolver %d: %q", index, err)
|
|
}
|
|
}(resolver.Resolver, i)
|
|
}
|
|
wg.Wait()
|
|
|
|
if t.Failed() {
|
|
t.FailNow()
|
|
}
|
|
|
|
for i, resolver := range resolvers {
|
|
if !resolver.dialed {
|
|
t.Errorf("custom resolver %d not dialed during lookup", i)
|
|
}
|
|
}
|
|
}
|
|
|
|
var ipVersionTests = []struct {
|
|
network string
|
|
version byte
|
|
}{
|
|
{"tcp", 0},
|
|
{"tcp4", '4'},
|
|
{"tcp6", '6'},
|
|
{"udp", 0},
|
|
{"udp4", '4'},
|
|
{"udp6", '6'},
|
|
{"ip", 0},
|
|
{"ip4", '4'},
|
|
{"ip6", '6'},
|
|
{"ip7", 0},
|
|
{"", 0},
|
|
}
|
|
|
|
func TestIPVersion(t *testing.T) {
|
|
for _, tt := range ipVersionTests {
|
|
if version := ipVersion(tt.network); version != tt.version {
|
|
t.Errorf("Family for: %s. Expected: %s, Got: %s", tt.network,
|
|
string(tt.version), string(version))
|
|
}
|
|
}
|
|
}
|
|
|
|
// Issue 28600: The context that is used to lookup ips should always
|
|
// preserve the values from the context that was passed into LookupIPAddr.
|
|
func TestLookupIPAddrPreservesContextValues(t *testing.T) {
|
|
origTestHookLookupIP := testHookLookupIP
|
|
defer func() { testHookLookupIP = origTestHookLookupIP }()
|
|
|
|
keyValues := []struct {
|
|
key, value any
|
|
}{
|
|
{"key-1", 12},
|
|
{384, "value2"},
|
|
{new(float64), 137},
|
|
}
|
|
ctx := context.Background()
|
|
for _, kv := range keyValues {
|
|
ctx = context.WithValue(ctx, kv.key, kv.value)
|
|
}
|
|
|
|
wantIPs := []IPAddr{
|
|
{IP: IPv4(127, 0, 0, 1)},
|
|
{IP: IPv6loopback},
|
|
}
|
|
|
|
checkCtxValues := func(ctx_ context.Context, fn func(context.Context, string, string) ([]IPAddr, error), network, host string) ([]IPAddr, error) {
|
|
for _, kv := range keyValues {
|
|
g, w := ctx_.Value(kv.key), kv.value
|
|
if !reflect.DeepEqual(g, w) {
|
|
t.Errorf("Value lookup:\n\tGot: %v\n\tWant: %v", g, w)
|
|
}
|
|
}
|
|
return wantIPs, nil
|
|
}
|
|
testHookLookupIP = checkCtxValues
|
|
|
|
resolvers := []*Resolver{
|
|
nil,
|
|
new(Resolver),
|
|
}
|
|
|
|
for i, resolver := range resolvers {
|
|
gotIPs, err := resolver.LookupIPAddr(ctx, "golang.org")
|
|
if err != nil {
|
|
t.Errorf("Resolver #%d: unexpected error: %v", i, err)
|
|
}
|
|
if !reflect.DeepEqual(gotIPs, wantIPs) {
|
|
t.Errorf("#%d: mismatched IPAddr results\n\tGot: %v\n\tWant: %v", i, gotIPs, wantIPs)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Issue 30521: The lookup group should call the resolver for each network.
|
|
func TestLookupIPAddrConcurrentCallsForNetworks(t *testing.T) {
|
|
origTestHookLookupIP := testHookLookupIP
|
|
defer func() { testHookLookupIP = origTestHookLookupIP }()
|
|
|
|
queries := [][]string{
|
|
{"udp", "golang.org"},
|
|
{"udp4", "golang.org"},
|
|
{"udp6", "golang.org"},
|
|
{"udp", "golang.org"},
|
|
{"udp", "golang.org"},
|
|
}
|
|
results := map[[2]string][]IPAddr{
|
|
{"udp", "golang.org"}: {
|
|
{IP: IPv4(127, 0, 0, 1)},
|
|
{IP: IPv6loopback},
|
|
},
|
|
{"udp4", "golang.org"}: {
|
|
{IP: IPv4(127, 0, 0, 1)},
|
|
},
|
|
{"udp6", "golang.org"}: {
|
|
{IP: IPv6loopback},
|
|
},
|
|
}
|
|
calls := int32(0)
|
|
waitCh := make(chan struct{})
|
|
testHookLookupIP = func(ctx context.Context, fn func(context.Context, string, string) ([]IPAddr, error), network, host string) ([]IPAddr, error) {
|
|
// We'll block until this is called one time for each different
|
|
// expected result. This will ensure that the lookup group would wait
|
|
// for the existing call if it was to be reused.
|
|
if atomic.AddInt32(&calls, 1) == int32(len(results)) {
|
|
close(waitCh)
|
|
}
|
|
select {
|
|
case <-waitCh:
|
|
case <-ctx.Done():
|
|
return nil, ctx.Err()
|
|
}
|
|
return results[[2]string{network, host}], nil
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
wg := sync.WaitGroup{}
|
|
for _, q := range queries {
|
|
network := q[0]
|
|
host := q[1]
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
gotIPs, err := DefaultResolver.lookupIPAddr(ctx, network, host)
|
|
if err != nil {
|
|
t.Errorf("lookupIPAddr(%v, %v): unexpected error: %v", network, host, err)
|
|
}
|
|
wantIPs := results[[2]string{network, host}]
|
|
if !reflect.DeepEqual(gotIPs, wantIPs) {
|
|
t.Errorf("lookupIPAddr(%v, %v): mismatched IPAddr results\n\tGot: %v\n\tWant: %v", network, host, gotIPs, wantIPs)
|
|
}
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
func TestWithUnexpiredValuesPreserved(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
|
|
// Insert a value into it.
|
|
key, value := "key-1", 2
|
|
ctx = context.WithValue(ctx, key, value)
|
|
|
|
// Now use the "values preserving context" like
|
|
// we would for LookupIPAddr. See Issue 28600.
|
|
ctx = withUnexpiredValuesPreserved(ctx)
|
|
|
|
// Lookup before expiry.
|
|
if g, w := ctx.Value(key), value; g != w {
|
|
t.Errorf("Lookup before expiry: Got %v Want %v", g, w)
|
|
}
|
|
|
|
// Cancel the context.
|
|
cancel()
|
|
|
|
// Lookup after expiry should return nil
|
|
if g := ctx.Value(key); g != nil {
|
|
t.Errorf("Lookup after expiry: Got %v want nil", g)
|
|
}
|
|
}
|
|
|
|
// Issue 31597: don't panic on null byte in name
|
|
func TestLookupNullByte(t *testing.T) {
|
|
testenv.MustHaveExternalNetwork(t)
|
|
testenv.SkipFlakyNet(t)
|
|
LookupHost("foo\x00bar") // check that it doesn't panic; it used to on Windows
|
|
}
|
|
|
|
func TestResolverLookupIP(t *testing.T) {
|
|
testenv.MustHaveExternalNetwork(t)
|
|
|
|
v4Ok := supportsIPv4() && *testIPv4
|
|
v6Ok := supportsIPv6() && *testIPv6
|
|
|
|
defer dnsWaitGroup.Wait()
|
|
|
|
for _, impl := range []struct {
|
|
name string
|
|
fn func() func()
|
|
}{
|
|
{"go", forceGoDNS},
|
|
{"cgo", forceCgoDNS},
|
|
} {
|
|
t.Run("implementation: "+impl.name, func(t *testing.T) {
|
|
fixup := impl.fn()
|
|
if fixup == nil {
|
|
t.Skip("not supported")
|
|
}
|
|
defer fixup()
|
|
|
|
for _, network := range []string{"ip", "ip4", "ip6"} {
|
|
t.Run("network: "+network, func(t *testing.T) {
|
|
switch {
|
|
case network == "ip4" && !v4Ok:
|
|
t.Skip("IPv4 is not supported")
|
|
case network == "ip6" && !v6Ok:
|
|
t.Skip("IPv6 is not supported")
|
|
}
|
|
|
|
// google.com has both A and AAAA records.
|
|
const host = "google.com"
|
|
ips, err := DefaultResolver.LookupIP(context.Background(), network, host)
|
|
if err != nil {
|
|
testenv.SkipFlakyNet(t)
|
|
t.Fatalf("DefaultResolver.LookupIP(%q, %q): failed with unexpected error: %v", network, host, err)
|
|
}
|
|
|
|
var v4Addrs []IP
|
|
var v6Addrs []IP
|
|
for _, ip := range ips {
|
|
switch {
|
|
case ip.To4() != nil:
|
|
// We need to skip the test below because To16 will
|
|
// convent an IPv4 address to an IPv4-mapped IPv6
|
|
// address.
|
|
v4Addrs = append(v4Addrs, ip)
|
|
case ip.To16() != nil:
|
|
v6Addrs = append(v6Addrs, ip)
|
|
default:
|
|
t.Fatalf("IP=%q is neither IPv4 nor IPv6", ip)
|
|
}
|
|
}
|
|
|
|
// Check that we got the expected addresses.
|
|
if network == "ip4" || network == "ip" && v4Ok {
|
|
if len(v4Addrs) == 0 {
|
|
t.Errorf("DefaultResolver.LookupIP(%q, %q): no IPv4 addresses", network, host)
|
|
}
|
|
}
|
|
if network == "ip6" || network == "ip" && v6Ok {
|
|
if len(v6Addrs) == 0 {
|
|
t.Errorf("DefaultResolver.LookupIP(%q, %q): no IPv6 addresses", network, host)
|
|
}
|
|
}
|
|
|
|
// Check that we didn't get any unexpected addresses.
|
|
if network == "ip6" && len(v4Addrs) > 0 {
|
|
t.Errorf("DefaultResolver.LookupIP(%q, %q): unexpected IPv4 addresses: %v", network, host, v4Addrs)
|
|
}
|
|
if network == "ip4" && len(v6Addrs) > 0 {
|
|
t.Errorf("DefaultResolver.LookupIP(%q, %q): unexpected IPv6 addresses: %v", network, host, v6Addrs)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// A context timeout should still return a DNSError.
|
|
func TestDNSTimeout(t *testing.T) {
|
|
origTestHookLookupIP := testHookLookupIP
|
|
defer func() { testHookLookupIP = origTestHookLookupIP }()
|
|
defer dnsWaitGroup.Wait()
|
|
|
|
timeoutHookGo := make(chan bool, 1)
|
|
timeoutHook := func(ctx context.Context, fn func(context.Context, string, string) ([]IPAddr, error), network, host string) ([]IPAddr, error) {
|
|
<-timeoutHookGo
|
|
return nil, context.DeadlineExceeded
|
|
}
|
|
testHookLookupIP = timeoutHook
|
|
|
|
checkErr := func(err error) {
|
|
t.Helper()
|
|
if err == nil {
|
|
t.Error("expected an error")
|
|
} else if dnserr, ok := err.(*DNSError); !ok {
|
|
t.Errorf("got error type %T, want %T", err, (*DNSError)(nil))
|
|
} else if !dnserr.IsTimeout {
|
|
t.Errorf("got error %#v, want IsTimeout == true", dnserr)
|
|
} else if isTimeout := dnserr.Timeout(); !isTimeout {
|
|
t.Errorf("got err.Timeout() == %t, want true", isTimeout)
|
|
}
|
|
}
|
|
|
|
// Single lookup.
|
|
timeoutHookGo <- true
|
|
_, err := LookupIP("golang.org")
|
|
checkErr(err)
|
|
|
|
// Double lookup.
|
|
var err1, err2 error
|
|
var wg sync.WaitGroup
|
|
wg.Add(2)
|
|
go func() {
|
|
defer wg.Done()
|
|
_, err1 = LookupIP("golang1.org")
|
|
}()
|
|
go func() {
|
|
defer wg.Done()
|
|
_, err2 = LookupIP("golang1.org")
|
|
}()
|
|
close(timeoutHookGo)
|
|
wg.Wait()
|
|
checkErr(err1)
|
|
checkErr(err2)
|
|
|
|
// Double lookup with context.
|
|
timeoutHookGo = make(chan bool)
|
|
ctx, cancel := context.WithTimeout(context.Background(), time.Nanosecond)
|
|
wg.Add(2)
|
|
go func() {
|
|
defer wg.Done()
|
|
_, err1 = DefaultResolver.LookupIPAddr(ctx, "golang2.org")
|
|
}()
|
|
go func() {
|
|
defer wg.Done()
|
|
_, err2 = DefaultResolver.LookupIPAddr(ctx, "golang2.org")
|
|
}()
|
|
time.Sleep(10 * time.Nanosecond)
|
|
close(timeoutHookGo)
|
|
wg.Wait()
|
|
checkErr(err1)
|
|
checkErr(err2)
|
|
cancel()
|
|
}
|