...
Run Format

Source file src/net/dial_test.go

Documentation: net

  // Copyright 2011 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.
  
  package net
  
  import (
  	"bufio"
  	"context"
  	"internal/poll"
  	"internal/testenv"
  	"io"
  	"runtime"
  	"sync"
  	"testing"
  	"time"
  )
  
  var prohibitionaryDialArgTests = []struct {
  	network string
  	address string
  }{
  	{"tcp6", "127.0.0.1"},
  	{"tcp6", "::ffff:127.0.0.1"},
  }
  
  func TestProhibitionaryDialArg(t *testing.T) {
  	testenv.MustHaveExternalNetwork(t)
  
  	switch runtime.GOOS {
  	case "plan9":
  		t.Skipf("not supported on %s", runtime.GOOS)
  	}
  	if !supportsIPv4map() {
  		t.Skip("mapping ipv4 address inside ipv6 address not supported")
  	}
  
  	ln, err := Listen("tcp", "[::]:0")
  	if err != nil {
  		t.Fatal(err)
  	}
  	defer ln.Close()
  
  	_, port, err := SplitHostPort(ln.Addr().String())
  	if err != nil {
  		t.Fatal(err)
  	}
  
  	for i, tt := range prohibitionaryDialArgTests {
  		c, err := Dial(tt.network, JoinHostPort(tt.address, port))
  		if err == nil {
  			c.Close()
  			t.Errorf("#%d: %v", i, err)
  		}
  	}
  }
  
  func TestDialLocal(t *testing.T) {
  	ln, err := newLocalListener("tcp")
  	if err != nil {
  		t.Fatal(err)
  	}
  	defer ln.Close()
  	_, port, err := SplitHostPort(ln.Addr().String())
  	if err != nil {
  		t.Fatal(err)
  	}
  	c, err := Dial("tcp", JoinHostPort("", port))
  	if err != nil {
  		t.Fatal(err)
  	}
  	c.Close()
  }
  
  func TestDialerDualStackFDLeak(t *testing.T) {
  	switch runtime.GOOS {
  	case "plan9":
  		t.Skipf("%s does not have full support of socktest", runtime.GOOS)
  	case "windows":
  		t.Skipf("not implemented a way to cancel dial racers in TCP SYN-SENT state on %s", runtime.GOOS)
  	case "openbsd":
  		testenv.SkipFlaky(t, 15157)
  	}
  	if !supportsIPv4() || !supportsIPv6() {
  		t.Skip("both IPv4 and IPv6 are required")
  	}
  
  	closedPortDelay, expectClosedPortDelay := dialClosedPort()
  	if closedPortDelay > expectClosedPortDelay {
  		t.Errorf("got %v; want <= %v", closedPortDelay, expectClosedPortDelay)
  	}
  
  	before := sw.Sockets()
  	origTestHookLookupIP := testHookLookupIP
  	defer func() { testHookLookupIP = origTestHookLookupIP }()
  	testHookLookupIP = lookupLocalhost
  	handler := func(dss *dualStackServer, ln Listener) {
  		for {
  			c, err := ln.Accept()
  			if err != nil {
  				return
  			}
  			c.Close()
  		}
  	}
  	dss, err := newDualStackServer()
  	if err != nil {
  		t.Fatal(err)
  	}
  	if err := dss.buildup(handler); err != nil {
  		dss.teardown()
  		t.Fatal(err)
  	}
  
  	const N = 10
  	var wg sync.WaitGroup
  	wg.Add(N)
  	d := &Dialer{DualStack: true, Timeout: 100*time.Millisecond + closedPortDelay}
  	for i := 0; i < N; i++ {
  		go func() {
  			defer wg.Done()
  			c, err := d.Dial("tcp", JoinHostPort("localhost", dss.port))
  			if err != nil {
  				t.Error(err)
  				return
  			}
  			c.Close()
  		}()
  	}
  	wg.Wait()
  	dss.teardown()
  	after := sw.Sockets()
  	if len(after) != len(before) {
  		t.Errorf("got %d; want %d", len(after), len(before))
  	}
  }
  
  // Define a pair of blackholed (IPv4, IPv6) addresses, for which dialTCP is
  // expected to hang until the timeout elapses. These addresses are reserved
  // for benchmarking by RFC 6890.
  const (
  	slowDst4 = "198.18.0.254"
  	slowDst6 = "2001:2::254"
  )
  
  // In some environments, the slow IPs may be explicitly unreachable, and fail
  // more quickly than expected. This test hook prevents dialTCP from returning
  // before the deadline.
  func slowDialTCP(ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error) {
  	c, err := doDialTCP(ctx, net, laddr, raddr)
  	if ParseIP(slowDst4).Equal(raddr.IP) || ParseIP(slowDst6).Equal(raddr.IP) {
  		// Wait for the deadline, or indefinitely if none exists.
  		<-ctx.Done()
  	}
  	return c, err
  }
  
  func dialClosedPort() (actual, expected time.Duration) {
  	// Estimate the expected time for this platform.
  	// On Windows, dialing a closed port takes roughly 1 second,
  	// but other platforms should be instantaneous.
  	if runtime.GOOS == "windows" {
  		expected = 1500 * time.Millisecond
  	} else if runtime.GOOS == "darwin" {
  		expected = 150 * time.Millisecond
  	} else {
  		expected = 95 * time.Millisecond
  	}
  
  	l, err := Listen("tcp", "127.0.0.1:0")
  	if err != nil {
  		return 999 * time.Hour, expected
  	}
  	addr := l.Addr().String()
  	l.Close()
  	// On OpenBSD, interference from TestSelfConnect is mysteriously
  	// causing the first attempt to hang for a few seconds, so we throw
  	// away the first result and keep the second.
  	for i := 1; ; i++ {
  		startTime := time.Now()
  		c, err := Dial("tcp", addr)
  		if err == nil {
  			c.Close()
  		}
  		elapsed := time.Now().Sub(startTime)
  		if i == 2 {
  			return elapsed, expected
  		}
  	}
  }
  
  func TestDialParallel(t *testing.T) {
  	testenv.MustHaveExternalNetwork(t)
  
  	if !supportsIPv4() || !supportsIPv6() {
  		t.Skip("both IPv4 and IPv6 are required")
  	}
  
  	closedPortDelay, expectClosedPortDelay := dialClosedPort()
  	if closedPortDelay > expectClosedPortDelay {
  		t.Errorf("got %v; want <= %v", closedPortDelay, expectClosedPortDelay)
  	}
  
  	const instant time.Duration = 0
  	const fallbackDelay = 200 * time.Millisecond
  
  	// Some cases will run quickly when "connection refused" is fast,
  	// or trigger the fallbackDelay on Windows. This value holds the
  	// lesser of the two delays.
  	var closedPortOrFallbackDelay time.Duration
  	if closedPortDelay < fallbackDelay {
  		closedPortOrFallbackDelay = closedPortDelay
  	} else {
  		closedPortOrFallbackDelay = fallbackDelay
  	}
  
  	origTestHookDialTCP := testHookDialTCP
  	defer func() { testHookDialTCP = origTestHookDialTCP }()
  	testHookDialTCP = slowDialTCP
  
  	nCopies := func(s string, n int) []string {
  		out := make([]string, n)
  		for i := 0; i < n; i++ {
  			out[i] = s
  		}
  		return out
  	}
  
  	var testCases = []struct {
  		primaries       []string
  		fallbacks       []string
  		teardownNetwork string
  		expectOk        bool
  		expectElapsed   time.Duration
  	}{
  		// These should just work on the first try.
  		{[]string{"127.0.0.1"}, []string{}, "", true, instant},
  		{[]string{"::1"}, []string{}, "", true, instant},
  		{[]string{"127.0.0.1", "::1"}, []string{slowDst6}, "tcp6", true, instant},
  		{[]string{"::1", "127.0.0.1"}, []string{slowDst4}, "tcp4", true, instant},
  		// Primary is slow; fallback should kick in.
  		{[]string{slowDst4}, []string{"::1"}, "", true, fallbackDelay},
  		// Skip a "connection refused" in the primary thread.
  		{[]string{"127.0.0.1", "::1"}, []string{}, "tcp4", true, closedPortDelay},
  		{[]string{"::1", "127.0.0.1"}, []string{}, "tcp6", true, closedPortDelay},
  		// Skip a "connection refused" in the fallback thread.
  		{[]string{slowDst4, slowDst6}, []string{"::1", "127.0.0.1"}, "tcp6", true, fallbackDelay + closedPortDelay},
  		// Primary refused, fallback without delay.
  		{[]string{"127.0.0.1"}, []string{"::1"}, "tcp4", true, closedPortOrFallbackDelay},
  		{[]string{"::1"}, []string{"127.0.0.1"}, "tcp6", true, closedPortOrFallbackDelay},
  		// Everything is refused.
  		{[]string{"127.0.0.1"}, []string{}, "tcp4", false, closedPortDelay},
  		// Nothing to do; fail instantly.
  		{[]string{}, []string{}, "", false, instant},
  		// Connecting to tons of addresses should not trip the deadline.
  		{nCopies("::1", 1000), []string{}, "", true, instant},
  	}
  
  	handler := func(dss *dualStackServer, ln Listener) {
  		for {
  			c, err := ln.Accept()
  			if err != nil {
  				return
  			}
  			c.Close()
  		}
  	}
  
  	// Convert a list of IP strings into TCPAddrs.
  	makeAddrs := func(ips []string, port string) addrList {
  		var out addrList
  		for _, ip := range ips {
  			addr, err := ResolveTCPAddr("tcp", JoinHostPort(ip, port))
  			if err != nil {
  				t.Fatal(err)
  			}
  			out = append(out, addr)
  		}
  		return out
  	}
  
  	for i, tt := range testCases {
  		dss, err := newDualStackServer()
  		if err != nil {
  			t.Fatal(err)
  		}
  		defer dss.teardown()
  		if err := dss.buildup(handler); err != nil {
  			t.Fatal(err)
  		}
  		if tt.teardownNetwork != "" {
  			// Destroy one of the listening sockets, creating an unreachable port.
  			dss.teardownNetwork(tt.teardownNetwork)
  		}
  
  		primaries := makeAddrs(tt.primaries, dss.port)
  		fallbacks := makeAddrs(tt.fallbacks, dss.port)
  		d := Dialer{
  			FallbackDelay: fallbackDelay,
  		}
  		startTime := time.Now()
  		dp := &dialParam{
  			Dialer:  d,
  			network: "tcp",
  			address: "?",
  		}
  		c, err := dialParallel(context.Background(), dp, primaries, fallbacks)
  		elapsed := time.Since(startTime)
  
  		if c != nil {
  			c.Close()
  		}
  
  		if tt.expectOk && err != nil {
  			t.Errorf("#%d: got %v; want nil", i, err)
  		} else if !tt.expectOk && err == nil {
  			t.Errorf("#%d: got nil; want non-nil", i)
  		}
  
  		expectElapsedMin := tt.expectElapsed - 95*time.Millisecond
  		expectElapsedMax := tt.expectElapsed + 95*time.Millisecond
  		if !(elapsed >= expectElapsedMin) {
  			t.Errorf("#%d: got %v; want >= %v", i, elapsed, expectElapsedMin)
  		} else if !(elapsed <= expectElapsedMax) {
  			t.Errorf("#%d: got %v; want <= %v", i, elapsed, expectElapsedMax)
  		}
  
  		// Repeat each case, ensuring that it can be canceled quickly.
  		ctx, cancel := context.WithCancel(context.Background())
  		var wg sync.WaitGroup
  		wg.Add(1)
  		go func() {
  			time.Sleep(5 * time.Millisecond)
  			cancel()
  			wg.Done()
  		}()
  		startTime = time.Now()
  		c, err = dialParallel(ctx, dp, primaries, fallbacks)
  		if c != nil {
  			c.Close()
  		}
  		elapsed = time.Now().Sub(startTime)
  		if elapsed > 100*time.Millisecond {
  			t.Errorf("#%d (cancel): got %v; want <= 100ms", i, elapsed)
  		}
  		wg.Wait()
  	}
  }
  
  func lookupSlowFast(ctx context.Context, fn func(context.Context, string) ([]IPAddr, error), host string) ([]IPAddr, error) {
  	switch host {
  	case "slow6loopback4":
  		// Returns a slow IPv6 address, and a local IPv4 address.
  		return []IPAddr{
  			{IP: ParseIP(slowDst6)},
  			{IP: ParseIP("127.0.0.1")},
  		}, nil
  	default:
  		return fn(ctx, host)
  	}
  }
  
  func TestDialerFallbackDelay(t *testing.T) {
  	testenv.MustHaveExternalNetwork(t)
  
  	if !supportsIPv4() || !supportsIPv6() {
  		t.Skip("both IPv4 and IPv6 are required")
  	}
  
  	origTestHookLookupIP := testHookLookupIP
  	defer func() { testHookLookupIP = origTestHookLookupIP }()
  	testHookLookupIP = lookupSlowFast
  
  	origTestHookDialTCP := testHookDialTCP
  	defer func() { testHookDialTCP = origTestHookDialTCP }()
  	testHookDialTCP = slowDialTCP
  
  	var testCases = []struct {
  		dualstack     bool
  		delay         time.Duration
  		expectElapsed time.Duration
  	}{
  		// Use a very brief delay, which should fallback immediately.
  		{true, 1 * time.Nanosecond, 0},
  		// Use a 200ms explicit timeout.
  		{true, 200 * time.Millisecond, 200 * time.Millisecond},
  		// The default is 300ms.
  		{true, 0, 300 * time.Millisecond},
  	}
  
  	handler := func(dss *dualStackServer, ln Listener) {
  		for {
  			c, err := ln.Accept()
  			if err != nil {
  				return
  			}
  			c.Close()
  		}
  	}
  	dss, err := newDualStackServer()
  	if err != nil {
  		t.Fatal(err)
  	}
  	defer dss.teardown()
  	if err := dss.buildup(handler); err != nil {
  		t.Fatal(err)
  	}
  
  	for i, tt := range testCases {
  		d := &Dialer{DualStack: tt.dualstack, FallbackDelay: tt.delay}
  
  		startTime := time.Now()
  		c, err := d.Dial("tcp", JoinHostPort("slow6loopback4", dss.port))
  		elapsed := time.Now().Sub(startTime)
  		if err == nil {
  			c.Close()
  		} else if tt.dualstack {
  			t.Error(err)
  		}
  		expectMin := tt.expectElapsed - 1*time.Millisecond
  		expectMax := tt.expectElapsed + 95*time.Millisecond
  		if !(elapsed >= expectMin) {
  			t.Errorf("#%d: got %v; want >= %v", i, elapsed, expectMin)
  		}
  		if !(elapsed <= expectMax) {
  			t.Errorf("#%d: got %v; want <= %v", i, elapsed, expectMax)
  		}
  	}
  }
  
  func TestDialParallelSpuriousConnection(t *testing.T) {
  	if !supportsIPv4() || !supportsIPv6() {
  		t.Skip("both IPv4 and IPv6 are required")
  	}
  
  	var wg sync.WaitGroup
  	wg.Add(2)
  	handler := func(dss *dualStackServer, ln Listener) {
  		// Accept one connection per address.
  		c, err := ln.Accept()
  		if err != nil {
  			t.Fatal(err)
  		}
  		// The client should close itself, without sending data.
  		c.SetReadDeadline(time.Now().Add(1 * time.Second))
  		var b [1]byte
  		if _, err := c.Read(b[:]); err != io.EOF {
  			t.Errorf("got %v; want %v", err, io.EOF)
  		}
  		c.Close()
  		wg.Done()
  	}
  	dss, err := newDualStackServer()
  	if err != nil {
  		t.Fatal(err)
  	}
  	defer dss.teardown()
  	if err := dss.buildup(handler); err != nil {
  		t.Fatal(err)
  	}
  
  	const fallbackDelay = 100 * time.Millisecond
  
  	origTestHookDialTCP := testHookDialTCP
  	defer func() { testHookDialTCP = origTestHookDialTCP }()
  	testHookDialTCP = func(ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error) {
  		// Sleep long enough for Happy Eyeballs to kick in, and inhibit cancelation.
  		// This forces dialParallel to juggle two successful connections.
  		time.Sleep(fallbackDelay * 2)
  
  		// Now ignore the provided context (which will be canceled) and use a
  		// different one to make sure this completes with a valid connection,
  		// which we hope to be closed below:
  		return doDialTCP(context.Background(), net, laddr, raddr)
  	}
  
  	d := Dialer{
  		FallbackDelay: fallbackDelay,
  	}
  	dp := &dialParam{
  		Dialer:  d,
  		network: "tcp",
  		address: "?",
  	}
  
  	makeAddr := func(ip string) addrList {
  		addr, err := ResolveTCPAddr("tcp", JoinHostPort(ip, dss.port))
  		if err != nil {
  			t.Fatal(err)
  		}
  		return addrList{addr}
  	}
  
  	// dialParallel returns one connection (and closes the other.)
  	c, err := dialParallel(context.Background(), dp, makeAddr("127.0.0.1"), makeAddr("::1"))
  	if err != nil {
  		t.Fatal(err)
  	}
  	c.Close()
  
  	// The server should've seen both connections.
  	wg.Wait()
  }
  
  func TestDialerPartialDeadline(t *testing.T) {
  	now := time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC)
  	var testCases = []struct {
  		now            time.Time
  		deadline       time.Time
  		addrs          int
  		expectDeadline time.Time
  		expectErr      error
  	}{
  		// Regular division.
  		{now, now.Add(12 * time.Second), 1, now.Add(12 * time.Second), nil},
  		{now, now.Add(12 * time.Second), 2, now.Add(6 * time.Second), nil},
  		{now, now.Add(12 * time.Second), 3, now.Add(4 * time.Second), nil},
  		// Bump against the 2-second sane minimum.
  		{now, now.Add(12 * time.Second), 999, now.Add(2 * time.Second), nil},
  		// Total available is now below the sane minimum.
  		{now, now.Add(1900 * time.Millisecond), 999, now.Add(1900 * time.Millisecond), nil},
  		// Null deadline.
  		{now, noDeadline, 1, noDeadline, nil},
  		// Step the clock forward and cross the deadline.
  		{now.Add(-1 * time.Millisecond), now, 1, now, nil},
  		{now.Add(0 * time.Millisecond), now, 1, noDeadline, poll.ErrTimeout},
  		{now.Add(1 * time.Millisecond), now, 1, noDeadline, poll.ErrTimeout},
  	}
  	for i, tt := range testCases {
  		deadline, err := partialDeadline(tt.now, tt.deadline, tt.addrs)
  		if err != tt.expectErr {
  			t.Errorf("#%d: got %v; want %v", i, err, tt.expectErr)
  		}
  		if !deadline.Equal(tt.expectDeadline) {
  			t.Errorf("#%d: got %v; want %v", i, deadline, tt.expectDeadline)
  		}
  	}
  }
  
  func TestDialerLocalAddr(t *testing.T) {
  	if !supportsIPv4() || !supportsIPv6() {
  		t.Skip("both IPv4 and IPv6 are required")
  	}
  
  	type test struct {
  		network, raddr string
  		laddr          Addr
  		error
  	}
  	var tests = []test{
  		{"tcp4", "127.0.0.1", nil, nil},
  		{"tcp4", "127.0.0.1", &TCPAddr{}, nil},
  		{"tcp4", "127.0.0.1", &TCPAddr{IP: ParseIP("0.0.0.0")}, nil},
  		{"tcp4", "127.0.0.1", &TCPAddr{IP: ParseIP("0.0.0.0").To4()}, nil},
  		{"tcp4", "127.0.0.1", &TCPAddr{IP: ParseIP("::")}, &AddrError{Err: "some error"}},
  		{"tcp4", "127.0.0.1", &TCPAddr{IP: ParseIP("127.0.0.1").To4()}, nil},
  		{"tcp4", "127.0.0.1", &TCPAddr{IP: ParseIP("127.0.0.1").To16()}, nil},
  		{"tcp4", "127.0.0.1", &TCPAddr{IP: IPv6loopback}, errNoSuitableAddress},
  		{"tcp4", "127.0.0.1", &UDPAddr{}, &AddrError{Err: "some error"}},
  		{"tcp4", "127.0.0.1", &UnixAddr{}, &AddrError{Err: "some error"}},
  
  		{"tcp6", "::1", nil, nil},
  		{"tcp6", "::1", &TCPAddr{}, nil},
  		{"tcp6", "::1", &TCPAddr{IP: ParseIP("0.0.0.0")}, nil},
  		{"tcp6", "::1", &TCPAddr{IP: ParseIP("0.0.0.0").To4()}, nil},
  		{"tcp6", "::1", &TCPAddr{IP: ParseIP("::")}, nil},
  		{"tcp6", "::1", &TCPAddr{IP: ParseIP("127.0.0.1").To4()}, errNoSuitableAddress},
  		{"tcp6", "::1", &TCPAddr{IP: ParseIP("127.0.0.1").To16()}, errNoSuitableAddress},
  		{"tcp6", "::1", &TCPAddr{IP: IPv6loopback}, nil},
  		{"tcp6", "::1", &UDPAddr{}, &AddrError{Err: "some error"}},
  		{"tcp6", "::1", &UnixAddr{}, &AddrError{Err: "some error"}},
  
  		{"tcp", "127.0.0.1", nil, nil},
  		{"tcp", "127.0.0.1", &TCPAddr{}, nil},
  		{"tcp", "127.0.0.1", &TCPAddr{IP: ParseIP("0.0.0.0")}, nil},
  		{"tcp", "127.0.0.1", &TCPAddr{IP: ParseIP("0.0.0.0").To4()}, nil},
  		{"tcp", "127.0.0.1", &TCPAddr{IP: ParseIP("127.0.0.1").To4()}, nil},
  		{"tcp", "127.0.0.1", &TCPAddr{IP: ParseIP("127.0.0.1").To16()}, nil},
  		{"tcp", "127.0.0.1", &TCPAddr{IP: IPv6loopback}, errNoSuitableAddress},
  		{"tcp", "127.0.0.1", &UDPAddr{}, &AddrError{Err: "some error"}},
  		{"tcp", "127.0.0.1", &UnixAddr{}, &AddrError{Err: "some error"}},
  
  		{"tcp", "::1", nil, nil},
  		{"tcp", "::1", &TCPAddr{}, nil},
  		{"tcp", "::1", &TCPAddr{IP: ParseIP("0.0.0.0")}, nil},
  		{"tcp", "::1", &TCPAddr{IP: ParseIP("0.0.0.0").To4()}, nil},
  		{"tcp", "::1", &TCPAddr{IP: ParseIP("::")}, nil},
  		{"tcp", "::1", &TCPAddr{IP: ParseIP("127.0.0.1").To4()}, errNoSuitableAddress},
  		{"tcp", "::1", &TCPAddr{IP: ParseIP("127.0.0.1").To16()}, errNoSuitableAddress},
  		{"tcp", "::1", &TCPAddr{IP: IPv6loopback}, nil},
  		{"tcp", "::1", &UDPAddr{}, &AddrError{Err: "some error"}},
  		{"tcp", "::1", &UnixAddr{}, &AddrError{Err: "some error"}},
  	}
  
  	if supportsIPv4map() {
  		tests = append(tests, test{
  			"tcp", "127.0.0.1", &TCPAddr{IP: ParseIP("::")}, nil,
  		})
  	} else {
  		tests = append(tests, test{
  			"tcp", "127.0.0.1", &TCPAddr{IP: ParseIP("::")}, &AddrError{Err: "some error"},
  		})
  	}
  
  	origTestHookLookupIP := testHookLookupIP
  	defer func() { testHookLookupIP = origTestHookLookupIP }()
  	testHookLookupIP = lookupLocalhost
  	handler := func(ls *localServer, ln Listener) {
  		for {
  			c, err := ln.Accept()
  			if err != nil {
  				return
  			}
  			c.Close()
  		}
  	}
  	var err error
  	var lss [2]*localServer
  	for i, network := range []string{"tcp4", "tcp6"} {
  		lss[i], err = newLocalServer(network)
  		if err != nil {
  			t.Fatal(err)
  		}
  		defer lss[i].teardown()
  		if err := lss[i].buildup(handler); err != nil {
  			t.Fatal(err)
  		}
  	}
  
  	for _, tt := range tests {
  		d := &Dialer{LocalAddr: tt.laddr}
  		var addr string
  		ip := ParseIP(tt.raddr)
  		if ip.To4() != nil {
  			addr = lss[0].Listener.Addr().String()
  		}
  		if ip.To16() != nil && ip.To4() == nil {
  			addr = lss[1].Listener.Addr().String()
  		}
  		c, err := d.Dial(tt.network, addr)
  		if err == nil && tt.error != nil || err != nil && tt.error == nil {
  			t.Errorf("%s %v->%s: got %v; want %v", tt.network, tt.laddr, tt.raddr, err, tt.error)
  		}
  		if err != nil {
  			if perr := parseDialError(err); perr != nil {
  				t.Error(perr)
  			}
  			continue
  		}
  		c.Close()
  	}
  }
  
  func TestDialerDualStack(t *testing.T) {
  	testenv.SkipFlaky(t, 13324)
  
  	if !supportsIPv4() || !supportsIPv6() {
  		t.Skip("both IPv4 and IPv6 are required")
  	}
  
  	closedPortDelay, expectClosedPortDelay := dialClosedPort()
  	if closedPortDelay > expectClosedPortDelay {
  		t.Errorf("got %v; want <= %v", closedPortDelay, expectClosedPortDelay)
  	}
  
  	origTestHookLookupIP := testHookLookupIP
  	defer func() { testHookLookupIP = origTestHookLookupIP }()
  	testHookLookupIP = lookupLocalhost
  	handler := func(dss *dualStackServer, ln Listener) {
  		for {
  			c, err := ln.Accept()
  			if err != nil {
  				return
  			}
  			c.Close()
  		}
  	}
  
  	var timeout = 150*time.Millisecond + closedPortDelay
  	for _, dualstack := range []bool{false, true} {
  		dss, err := newDualStackServer()
  		if err != nil {
  			t.Fatal(err)
  		}
  		defer dss.teardown()
  		if err := dss.buildup(handler); err != nil {
  			t.Fatal(err)
  		}
  
  		d := &Dialer{DualStack: dualstack, Timeout: timeout}
  		for range dss.lns {
  			c, err := d.Dial("tcp", JoinHostPort("localhost", dss.port))
  			if err != nil {
  				t.Error(err)
  				continue
  			}
  			switch addr := c.LocalAddr().(*TCPAddr); {
  			case addr.IP.To4() != nil:
  				dss.teardownNetwork("tcp4")
  			case addr.IP.To16() != nil && addr.IP.To4() == nil:
  				dss.teardownNetwork("tcp6")
  			}
  			c.Close()
  		}
  	}
  }
  
  func TestDialerKeepAlive(t *testing.T) {
  	handler := func(ls *localServer, ln Listener) {
  		for {
  			c, err := ln.Accept()
  			if err != nil {
  				return
  			}
  			c.Close()
  		}
  	}
  	ls, err := newLocalServer("tcp")
  	if err != nil {
  		t.Fatal(err)
  	}
  	defer ls.teardown()
  	if err := ls.buildup(handler); err != nil {
  		t.Fatal(err)
  	}
  	defer func() { testHookSetKeepAlive = func() {} }()
  
  	for _, keepAlive := range []bool{false, true} {
  		got := false
  		testHookSetKeepAlive = func() { got = true }
  		var d Dialer
  		if keepAlive {
  			d.KeepAlive = 30 * time.Second
  		}
  		c, err := d.Dial("tcp", ls.Listener.Addr().String())
  		if err != nil {
  			t.Fatal(err)
  		}
  		c.Close()
  		if got != keepAlive {
  			t.Errorf("Dialer.KeepAlive = %v: SetKeepAlive called = %v, want %v", d.KeepAlive, got, !got)
  		}
  	}
  }
  
  func TestDialCancel(t *testing.T) {
  	switch testenv.Builder() {
  	case "linux-arm64-buildlet":
  		t.Skip("skipping on linux-arm64-buildlet; incompatible network config? issue 15191")
  	case "":
  		testenv.MustHaveExternalNetwork(t)
  	}
  
  	if runtime.GOOS == "nacl" {
  		// nacl doesn't have external network access.
  		t.Skipf("skipping on %s", runtime.GOOS)
  	}
  
  	blackholeIPPort := JoinHostPort(slowDst4, "1234")
  	if !supportsIPv4() {
  		blackholeIPPort = JoinHostPort(slowDst6, "1234")
  	}
  
  	ticker := time.NewTicker(10 * time.Millisecond)
  	defer ticker.Stop()
  
  	const cancelTick = 5 // the timer tick we cancel the dial at
  	const timeoutTick = 100
  
  	var d Dialer
  	cancel := make(chan struct{})
  	d.Cancel = cancel
  	errc := make(chan error, 1)
  	connc := make(chan Conn, 1)
  	go func() {
  		if c, err := d.Dial("tcp", blackholeIPPort); err != nil {
  			errc <- err
  		} else {
  			connc <- c
  		}
  	}()
  	ticks := 0
  	for {
  		select {
  		case <-ticker.C:
  			ticks++
  			if ticks == cancelTick {
  				close(cancel)
  			}
  			if ticks == timeoutTick {
  				t.Fatal("timeout waiting for dial to fail")
  			}
  		case c := <-connc:
  			c.Close()
  			t.Fatal("unexpected successful connection")
  		case err := <-errc:
  			if perr := parseDialError(err); perr != nil {
  				t.Error(perr)
  			}
  			if ticks < cancelTick {
  				t.Fatalf("dial error after %d ticks (%d before cancel sent): %v",
  					ticks, cancelTick-ticks, err)
  			}
  			if oe, ok := err.(*OpError); !ok || oe.Err != errCanceled {
  				t.Fatalf("dial error = %v (%T); want OpError with Err == errCanceled", err, err)
  			}
  			return // success.
  		}
  	}
  }
  
  func TestCancelAfterDial(t *testing.T) {
  	if testing.Short() {
  		t.Skip("avoiding time.Sleep")
  	}
  
  	ln, err := newLocalListener("tcp")
  	if err != nil {
  		t.Fatal(err)
  	}
  
  	var wg sync.WaitGroup
  	wg.Add(1)
  	defer func() {
  		ln.Close()
  		wg.Wait()
  	}()
  
  	// Echo back the first line of each incoming connection.
  	go func() {
  		for {
  			c, err := ln.Accept()
  			if err != nil {
  				break
  			}
  			rb := bufio.NewReader(c)
  			line, err := rb.ReadString('\n')
  			if err != nil {
  				t.Error(err)
  				c.Close()
  				continue
  			}
  			if _, err := c.Write([]byte(line)); err != nil {
  				t.Error(err)
  			}
  			c.Close()
  		}
  		wg.Done()
  	}()
  
  	try := func() {
  		cancel := make(chan struct{})
  		d := &Dialer{Cancel: cancel}
  		c, err := d.Dial("tcp", ln.Addr().String())
  
  		// Immediately after dialing, request cancelation and sleep.
  		// Before Issue 15078 was fixed, this would cause subsequent operations
  		// to fail with an i/o timeout roughly 50% of the time.
  		close(cancel)
  		time.Sleep(10 * time.Millisecond)
  
  		if err != nil {
  			t.Fatal(err)
  		}
  		defer c.Close()
  
  		// Send some data to confirm that the connection is still alive.
  		const message = "echo!\n"
  		if _, err := c.Write([]byte(message)); err != nil {
  			t.Fatal(err)
  		}
  
  		// The server should echo the line, and close the connection.
  		rb := bufio.NewReader(c)
  		line, err := rb.ReadString('\n')
  		if err != nil {
  			t.Fatal(err)
  		}
  		if line != message {
  			t.Errorf("got %q; want %q", line, message)
  		}
  		if _, err := rb.ReadByte(); err != io.EOF {
  			t.Errorf("got %v; want %v", err, io.EOF)
  		}
  	}
  
  	// This bug manifested about 50% of the time, so try it a few times.
  	for i := 0; i < 10; i++ {
  		try()
  	}
  }
  
  // Issue 18806: it should always be possible to net.Dial a
  // net.Listener().Addr().String when the listen address was ":n", even
  // if the machine has halfway configured IPv6 such that it can bind on
  // "::" not connect back to that same address.
  func TestDialListenerAddr(t *testing.T) {
  	if testenv.Builder() == "" {
  		testenv.MustHaveExternalNetwork(t)
  	}
  	ln, err := Listen("tcp", ":0")
  	if err != nil {
  		t.Fatal(err)
  	}
  	defer ln.Close()
  	addr := ln.Addr().String()
  	c, err := Dial("tcp", addr)
  	if err != nil {
  		t.Fatalf("for addr %q, dial error: %v", addr, err)
  	}
  	c.Close()
  }
  

View as plain text