Source file src/net/net_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  	"errors"
     9  	"fmt"
    10  	"io"
    11  	"net/internal/socktest"
    12  	"os"
    13  	"runtime"
    14  	"testing"
    15  	"time"
    16  )
    17  
    18  func TestCloseRead(t *testing.T) {
    19  	switch runtime.GOOS {
    20  	case "plan9":
    21  		t.Skipf("not supported on %s", runtime.GOOS)
    22  	}
    23  	t.Parallel()
    24  
    25  	for _, network := range []string{"tcp", "unix", "unixpacket"} {
    26  		network := network
    27  		t.Run(network, func(t *testing.T) {
    28  			if !testableNetwork(network) {
    29  				t.Skipf("network %s is not testable on the current platform", network)
    30  			}
    31  			t.Parallel()
    32  
    33  			ln := newLocalListener(t, network)
    34  			switch network {
    35  			case "unix", "unixpacket":
    36  				defer os.Remove(ln.Addr().String())
    37  			}
    38  			defer ln.Close()
    39  
    40  			c, err := Dial(ln.Addr().Network(), ln.Addr().String())
    41  			if err != nil {
    42  				t.Fatal(err)
    43  			}
    44  			switch network {
    45  			case "unix", "unixpacket":
    46  				defer os.Remove(c.LocalAddr().String())
    47  			}
    48  			defer c.Close()
    49  
    50  			switch c := c.(type) {
    51  			case *TCPConn:
    52  				err = c.CloseRead()
    53  			case *UnixConn:
    54  				err = c.CloseRead()
    55  			}
    56  			if err != nil {
    57  				if perr := parseCloseError(err, true); perr != nil {
    58  					t.Error(perr)
    59  				}
    60  				t.Fatal(err)
    61  			}
    62  			var b [1]byte
    63  			n, err := c.Read(b[:])
    64  			if n != 0 || err == nil {
    65  				t.Fatalf("got (%d, %v); want (0, error)", n, err)
    66  			}
    67  		})
    68  	}
    69  }
    70  
    71  func TestCloseWrite(t *testing.T) {
    72  	switch runtime.GOOS {
    73  	case "plan9":
    74  		t.Skipf("not supported on %s", runtime.GOOS)
    75  	}
    76  
    77  	t.Parallel()
    78  	deadline, _ := t.Deadline()
    79  	if !deadline.IsZero() {
    80  		// Leave 10% headroom on the deadline to report errors and clean up.
    81  		deadline = deadline.Add(-time.Until(deadline) / 10)
    82  	}
    83  
    84  	for _, network := range []string{"tcp", "unix", "unixpacket"} {
    85  		network := network
    86  		t.Run(network, func(t *testing.T) {
    87  			if !testableNetwork(network) {
    88  				t.Skipf("network %s is not testable on the current platform", network)
    89  			}
    90  			t.Parallel()
    91  
    92  			handler := func(ls *localServer, ln Listener) {
    93  				c, err := ln.Accept()
    94  				if err != nil {
    95  					t.Error(err)
    96  					return
    97  				}
    98  
    99  				// Workaround for https://go.dev/issue/49352.
   100  				// On arm64 macOS (current as of macOS 12.4),
   101  				// reading from a socket at the same time as the client
   102  				// is closing it occasionally hangs for 60 seconds before
   103  				// returning ECONNRESET. Sleep for a bit to give the
   104  				// socket time to close before trying to read from it.
   105  				if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
   106  					time.Sleep(10 * time.Millisecond)
   107  				}
   108  
   109  				if !deadline.IsZero() {
   110  					c.SetDeadline(deadline)
   111  				}
   112  				defer c.Close()
   113  
   114  				var b [1]byte
   115  				n, err := c.Read(b[:])
   116  				if n != 0 || err != io.EOF {
   117  					t.Errorf("got (%d, %v); want (0, io.EOF)", n, err)
   118  					return
   119  				}
   120  				switch c := c.(type) {
   121  				case *TCPConn:
   122  					err = c.CloseWrite()
   123  				case *UnixConn:
   124  					err = c.CloseWrite()
   125  				}
   126  				if err != nil {
   127  					if perr := parseCloseError(err, true); perr != nil {
   128  						t.Error(perr)
   129  					}
   130  					t.Error(err)
   131  					return
   132  				}
   133  				n, err = c.Write(b[:])
   134  				if err == nil {
   135  					t.Errorf("got (%d, %v); want (any, error)", n, err)
   136  					return
   137  				}
   138  			}
   139  
   140  			ls := newLocalServer(t, network)
   141  			defer ls.teardown()
   142  			if err := ls.buildup(handler); err != nil {
   143  				t.Fatal(err)
   144  			}
   145  
   146  			c, err := Dial(ls.Listener.Addr().Network(), ls.Listener.Addr().String())
   147  			if err != nil {
   148  				t.Fatal(err)
   149  			}
   150  			if !deadline.IsZero() {
   151  				c.SetDeadline(deadline)
   152  			}
   153  			switch network {
   154  			case "unix", "unixpacket":
   155  				defer os.Remove(c.LocalAddr().String())
   156  			}
   157  			defer c.Close()
   158  
   159  			switch c := c.(type) {
   160  			case *TCPConn:
   161  				err = c.CloseWrite()
   162  			case *UnixConn:
   163  				err = c.CloseWrite()
   164  			}
   165  			if err != nil {
   166  				if perr := parseCloseError(err, true); perr != nil {
   167  					t.Error(perr)
   168  				}
   169  				t.Fatal(err)
   170  			}
   171  			var b [1]byte
   172  			n, err := c.Read(b[:])
   173  			if n != 0 || err != io.EOF {
   174  				t.Fatalf("got (%d, %v); want (0, io.EOF)", n, err)
   175  			}
   176  			n, err = c.Write(b[:])
   177  			if err == nil {
   178  				t.Fatalf("got (%d, %v); want (any, error)", n, err)
   179  			}
   180  		})
   181  	}
   182  }
   183  
   184  func TestConnClose(t *testing.T) {
   185  	t.Parallel()
   186  	for _, network := range []string{"tcp", "unix", "unixpacket"} {
   187  		network := network
   188  		t.Run(network, func(t *testing.T) {
   189  			if !testableNetwork(network) {
   190  				t.Skipf("network %s is not testable on the current platform", network)
   191  			}
   192  			t.Parallel()
   193  
   194  			ln := newLocalListener(t, network)
   195  			switch network {
   196  			case "unix", "unixpacket":
   197  				defer os.Remove(ln.Addr().String())
   198  			}
   199  			defer ln.Close()
   200  
   201  			c, err := Dial(ln.Addr().Network(), ln.Addr().String())
   202  			if err != nil {
   203  				t.Fatal(err)
   204  			}
   205  			switch network {
   206  			case "unix", "unixpacket":
   207  				defer os.Remove(c.LocalAddr().String())
   208  			}
   209  			defer c.Close()
   210  
   211  			if err := c.Close(); err != nil {
   212  				if perr := parseCloseError(err, false); perr != nil {
   213  					t.Error(perr)
   214  				}
   215  				t.Fatal(err)
   216  			}
   217  			var b [1]byte
   218  			n, err := c.Read(b[:])
   219  			if n != 0 || err == nil {
   220  				t.Fatalf("got (%d, %v); want (0, error)", n, err)
   221  			}
   222  		})
   223  	}
   224  }
   225  
   226  func TestListenerClose(t *testing.T) {
   227  	t.Parallel()
   228  	for _, network := range []string{"tcp", "unix", "unixpacket"} {
   229  		network := network
   230  		t.Run(network, func(t *testing.T) {
   231  			if !testableNetwork(network) {
   232  				t.Skipf("network %s is not testable on the current platform", network)
   233  			}
   234  			t.Parallel()
   235  
   236  			ln := newLocalListener(t, network)
   237  			switch network {
   238  			case "unix", "unixpacket":
   239  				defer os.Remove(ln.Addr().String())
   240  			}
   241  
   242  			if err := ln.Close(); err != nil {
   243  				if perr := parseCloseError(err, false); perr != nil {
   244  					t.Error(perr)
   245  				}
   246  				t.Fatal(err)
   247  			}
   248  			c, err := ln.Accept()
   249  			if err == nil {
   250  				c.Close()
   251  				t.Fatal("should fail")
   252  			}
   253  
   254  			// Note: we cannot ensure that a subsequent Dial does not succeed, because
   255  			// we do not in general have any guarantee that ln.Addr is not immediately
   256  			// reused. (TCP sockets enter a TIME_WAIT state when closed, but that only
   257  			// applies to existing connections for the port — it does not prevent the
   258  			// port itself from being used for entirely new connections in the
   259  			// meantime.)
   260  		})
   261  	}
   262  }
   263  
   264  func TestPacketConnClose(t *testing.T) {
   265  	t.Parallel()
   266  	for _, network := range []string{"udp", "unixgram"} {
   267  		network := network
   268  		t.Run(network, func(t *testing.T) {
   269  			if !testableNetwork(network) {
   270  				t.Skipf("network %s is not testable on the current platform", network)
   271  			}
   272  			t.Parallel()
   273  
   274  			c := newLocalPacketListener(t, network)
   275  			switch network {
   276  			case "unixgram":
   277  				defer os.Remove(c.LocalAddr().String())
   278  			}
   279  			defer c.Close()
   280  
   281  			if err := c.Close(); err != nil {
   282  				if perr := parseCloseError(err, false); perr != nil {
   283  					t.Error(perr)
   284  				}
   285  				t.Fatal(err)
   286  			}
   287  			var b [1]byte
   288  			n, _, err := c.ReadFrom(b[:])
   289  			if n != 0 || err == nil {
   290  				t.Fatalf("got (%d, %v); want (0, error)", n, err)
   291  			}
   292  		})
   293  	}
   294  }
   295  
   296  func TestListenCloseListen(t *testing.T) {
   297  	const maxTries = 10
   298  	for tries := 0; tries < maxTries; tries++ {
   299  		ln := newLocalListener(t, "tcp")
   300  		addr := ln.Addr().String()
   301  		// TODO: This is racy. The selected address could be reused in between this
   302  		// Close and the subsequent Listen.
   303  		if err := ln.Close(); err != nil {
   304  			if perr := parseCloseError(err, false); perr != nil {
   305  				t.Error(perr)
   306  			}
   307  			t.Fatal(err)
   308  		}
   309  		ln, err := Listen("tcp", addr)
   310  		if err == nil {
   311  			// Success. (This test didn't always make it here earlier.)
   312  			ln.Close()
   313  			return
   314  		}
   315  		t.Errorf("failed on try %d/%d: %v", tries+1, maxTries, err)
   316  	}
   317  	t.Fatalf("failed to listen/close/listen on same address after %d tries", maxTries)
   318  }
   319  
   320  // See golang.org/issue/6163, golang.org/issue/6987.
   321  func TestAcceptIgnoreAbortedConnRequest(t *testing.T) {
   322  	switch runtime.GOOS {
   323  	case "plan9":
   324  		t.Skipf("%s does not have full support of socktest", runtime.GOOS)
   325  	}
   326  
   327  	syserr := make(chan error)
   328  	go func() {
   329  		defer close(syserr)
   330  		for _, err := range abortedConnRequestErrors {
   331  			syserr <- err
   332  		}
   333  	}()
   334  	sw.Set(socktest.FilterAccept, func(so *socktest.Status) (socktest.AfterFilter, error) {
   335  		if err, ok := <-syserr; ok {
   336  			return nil, err
   337  		}
   338  		return nil, nil
   339  	})
   340  	defer sw.Set(socktest.FilterAccept, nil)
   341  
   342  	operr := make(chan error, 1)
   343  	handler := func(ls *localServer, ln Listener) {
   344  		defer close(operr)
   345  		c, err := ln.Accept()
   346  		if err != nil {
   347  			if perr := parseAcceptError(err); perr != nil {
   348  				operr <- perr
   349  			}
   350  			operr <- err
   351  			return
   352  		}
   353  		c.Close()
   354  	}
   355  	ls := newLocalServer(t, "tcp")
   356  	defer ls.teardown()
   357  	if err := ls.buildup(handler); err != nil {
   358  		t.Fatal(err)
   359  	}
   360  
   361  	c, err := Dial(ls.Listener.Addr().Network(), ls.Listener.Addr().String())
   362  	if err != nil {
   363  		t.Fatal(err)
   364  	}
   365  	c.Close()
   366  
   367  	for err := range operr {
   368  		t.Error(err)
   369  	}
   370  }
   371  
   372  func TestZeroByteRead(t *testing.T) {
   373  	t.Parallel()
   374  	for _, network := range []string{"tcp", "unix", "unixpacket"} {
   375  		network := network
   376  		t.Run(network, func(t *testing.T) {
   377  			if !testableNetwork(network) {
   378  				t.Skipf("network %s is not testable on the current platform", network)
   379  			}
   380  			t.Parallel()
   381  
   382  			ln := newLocalListener(t, network)
   383  			connc := make(chan Conn, 1)
   384  			defer func() {
   385  				ln.Close()
   386  				for c := range connc {
   387  					if c != nil {
   388  						c.Close()
   389  					}
   390  				}
   391  			}()
   392  			go func() {
   393  				defer close(connc)
   394  				c, err := ln.Accept()
   395  				if err != nil {
   396  					t.Error(err)
   397  				}
   398  				connc <- c // might be nil
   399  			}()
   400  			c, err := Dial(network, ln.Addr().String())
   401  			if err != nil {
   402  				t.Fatal(err)
   403  			}
   404  			defer c.Close()
   405  			sc := <-connc
   406  			if sc == nil {
   407  				return
   408  			}
   409  			defer sc.Close()
   410  
   411  			if runtime.GOOS == "windows" {
   412  				// A zero byte read on Windows caused a wait for readability first.
   413  				// Rather than change that behavior, satisfy it in this test.
   414  				// See Issue 15735.
   415  				go io.WriteString(sc, "a")
   416  			}
   417  
   418  			n, err := c.Read(nil)
   419  			if n != 0 || err != nil {
   420  				t.Errorf("%s: zero byte client read = %v, %v; want 0, nil", network, n, err)
   421  			}
   422  
   423  			if runtime.GOOS == "windows" {
   424  				// Same as comment above.
   425  				go io.WriteString(c, "a")
   426  			}
   427  			n, err = sc.Read(nil)
   428  			if n != 0 || err != nil {
   429  				t.Errorf("%s: zero byte server read = %v, %v; want 0, nil", network, n, err)
   430  			}
   431  		})
   432  	}
   433  }
   434  
   435  // withTCPConnPair sets up a TCP connection between two peers, then
   436  // runs peer1 and peer2 concurrently. withTCPConnPair returns when
   437  // both have completed.
   438  func withTCPConnPair(t *testing.T, peer1, peer2 func(c *TCPConn) error) {
   439  	t.Helper()
   440  	ln := newLocalListener(t, "tcp")
   441  	defer ln.Close()
   442  	errc := make(chan error, 2)
   443  	go func() {
   444  		c1, err := ln.Accept()
   445  		if err != nil {
   446  			errc <- err
   447  			return
   448  		}
   449  		err = peer1(c1.(*TCPConn))
   450  		c1.Close()
   451  		errc <- err
   452  	}()
   453  	go func() {
   454  		c2, err := Dial("tcp", ln.Addr().String())
   455  		if err != nil {
   456  			errc <- err
   457  			return
   458  		}
   459  		err = peer2(c2.(*TCPConn))
   460  		c2.Close()
   461  		errc <- err
   462  	}()
   463  	for i := 0; i < 2; i++ {
   464  		if err := <-errc; err != nil {
   465  			t.Error(err)
   466  		}
   467  	}
   468  }
   469  
   470  // Tests that a blocked Read is interrupted by a concurrent SetReadDeadline
   471  // modifying that Conn's read deadline to the past.
   472  // See golang.org/cl/30164 which documented this. The net/http package
   473  // depends on this.
   474  func TestReadTimeoutUnblocksRead(t *testing.T) {
   475  	serverDone := make(chan struct{})
   476  	server := func(cs *TCPConn) error {
   477  		defer close(serverDone)
   478  		errc := make(chan error, 1)
   479  		go func() {
   480  			defer close(errc)
   481  			go func() {
   482  				// TODO: find a better way to wait
   483  				// until we're blocked in the cs.Read
   484  				// call below. Sleep is lame.
   485  				time.Sleep(100 * time.Millisecond)
   486  
   487  				// Interrupt the upcoming Read, unblocking it:
   488  				cs.SetReadDeadline(time.Unix(123, 0)) // time in the past
   489  			}()
   490  			var buf [1]byte
   491  			n, err := cs.Read(buf[:1])
   492  			if n != 0 || err == nil {
   493  				errc <- fmt.Errorf("Read = %v, %v; want 0, non-nil", n, err)
   494  			}
   495  		}()
   496  		select {
   497  		case err := <-errc:
   498  			return err
   499  		case <-time.After(5 * time.Second):
   500  			buf := make([]byte, 2<<20)
   501  			buf = buf[:runtime.Stack(buf, true)]
   502  			println("Stacks at timeout:\n", string(buf))
   503  			return errors.New("timeout waiting for Read to finish")
   504  		}
   505  
   506  	}
   507  	// Do nothing in the client. Never write. Just wait for the
   508  	// server's half to be done.
   509  	client := func(*TCPConn) error {
   510  		<-serverDone
   511  		return nil
   512  	}
   513  	withTCPConnPair(t, client, server)
   514  }
   515  
   516  // Issue 17695: verify that a blocked Read is woken up by a Close.
   517  func TestCloseUnblocksRead(t *testing.T) {
   518  	t.Parallel()
   519  	server := func(cs *TCPConn) error {
   520  		// Give the client time to get stuck in a Read:
   521  		time.Sleep(20 * time.Millisecond)
   522  		cs.Close()
   523  		return nil
   524  	}
   525  	client := func(ss *TCPConn) error {
   526  		n, err := ss.Read([]byte{0})
   527  		if n != 0 || err != io.EOF {
   528  			return fmt.Errorf("Read = %v, %v; want 0, EOF", n, err)
   529  		}
   530  		return nil
   531  	}
   532  	withTCPConnPair(t, client, server)
   533  }
   534  
   535  // Issue 24808: verify that ECONNRESET is not temporary for read.
   536  func TestNotTemporaryRead(t *testing.T) {
   537  	t.Parallel()
   538  
   539  	ln := newLocalListener(t, "tcp")
   540  	serverDone := make(chan struct{})
   541  	dialed := make(chan struct{})
   542  	go func() {
   543  		defer close(serverDone)
   544  
   545  		cs, err := ln.Accept()
   546  		if err != nil {
   547  			return
   548  		}
   549  		<-dialed
   550  		cs.(*TCPConn).SetLinger(0)
   551  		cs.Close()
   552  	}()
   553  	defer func() {
   554  		ln.Close()
   555  		<-serverDone
   556  	}()
   557  
   558  	ss, err := Dial("tcp", ln.Addr().String())
   559  	close(dialed)
   560  	if err != nil {
   561  		t.Fatal(err)
   562  	}
   563  	defer ss.Close()
   564  
   565  	_, err = ss.Read([]byte{0})
   566  	if err == nil {
   567  		t.Fatal("Read succeeded unexpectedly")
   568  	} else if err == io.EOF {
   569  		// This happens on Plan 9, but for some reason (prior to CL 385314) it was
   570  		// accepted everywhere else too.
   571  		if runtime.GOOS == "plan9" {
   572  			return
   573  		}
   574  		t.Fatal("Read unexpectedly returned io.EOF after socket was abruptly closed")
   575  	}
   576  	if ne, ok := err.(Error); !ok {
   577  		t.Errorf("Read error does not implement net.Error: %v", err)
   578  	} else if ne.Temporary() {
   579  		t.Errorf("Read error is unexpectedly temporary: %v", err)
   580  	}
   581  }
   582  
   583  // The various errors should implement the Error interface.
   584  func TestErrors(t *testing.T) {
   585  	var (
   586  		_ Error = &OpError{}
   587  		_ Error = &ParseError{}
   588  		_ Error = &AddrError{}
   589  		_ Error = UnknownNetworkError("")
   590  		_ Error = InvalidAddrError("")
   591  		_ Error = &timeoutError{}
   592  		_ Error = &DNSConfigError{}
   593  		_ Error = &DNSError{}
   594  	)
   595  
   596  	// ErrClosed was introduced as type error, so we can't check
   597  	// it using a declaration.
   598  	if _, ok := ErrClosed.(Error); !ok {
   599  		t.Fatal("ErrClosed does not implement Error")
   600  	}
   601  }
   602  

View as plain text