| // 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. |
| |
| package net |
| |
| import ( |
| "io" |
| "net/internal/socktest" |
| "os" |
| "runtime" |
| "testing" |
| "time" |
| ) |
| |
| func TestCloseRead(t *testing.T) { |
| switch runtime.GOOS { |
| case "nacl", "plan9": |
| t.Skipf("not supported on %s", runtime.GOOS) |
| } |
| |
| for _, network := range []string{"tcp", "unix", "unixpacket"} { |
| if !testableNetwork(network) { |
| t.Logf("skipping %s test", network) |
| continue |
| } |
| |
| ln, err := newLocalListener(network) |
| if err != nil { |
| t.Fatal(err) |
| } |
| switch network { |
| case "unix", "unixpacket": |
| defer os.Remove(ln.Addr().String()) |
| } |
| defer ln.Close() |
| |
| c, err := Dial(ln.Addr().Network(), ln.Addr().String()) |
| if err != nil { |
| t.Fatal(err) |
| } |
| switch network { |
| case "unix", "unixpacket": |
| defer os.Remove(c.LocalAddr().String()) |
| } |
| defer c.Close() |
| |
| switch c := c.(type) { |
| case *TCPConn: |
| err = c.CloseRead() |
| case *UnixConn: |
| err = c.CloseRead() |
| } |
| if err != nil { |
| if perr := parseCloseError(err); perr != nil { |
| t.Error(perr) |
| } |
| t.Fatal(err) |
| } |
| var b [1]byte |
| n, err := c.Read(b[:]) |
| if n != 0 || err == nil { |
| t.Fatalf("got (%d, %v); want (0, error)", n, err) |
| } |
| } |
| } |
| |
| func TestCloseWrite(t *testing.T) { |
| switch runtime.GOOS { |
| case "nacl", "plan9": |
| t.Skipf("not supported on %s", runtime.GOOS) |
| } |
| |
| handler := func(ls *localServer, ln Listener) { |
| c, err := ln.Accept() |
| if err != nil { |
| t.Error(err) |
| return |
| } |
| defer c.Close() |
| |
| var b [1]byte |
| n, err := c.Read(b[:]) |
| if n != 0 || err != io.EOF { |
| t.Errorf("got (%d, %v); want (0, io.EOF)", n, err) |
| return |
| } |
| switch c := c.(type) { |
| case *TCPConn: |
| err = c.CloseWrite() |
| case *UnixConn: |
| err = c.CloseWrite() |
| } |
| if err != nil { |
| if perr := parseCloseError(err); perr != nil { |
| t.Error(perr) |
| } |
| t.Error(err) |
| return |
| } |
| n, err = c.Write(b[:]) |
| if err == nil { |
| t.Errorf("got (%d, %v); want (any, error)", n, err) |
| return |
| } |
| } |
| |
| for _, network := range []string{"tcp", "unix", "unixpacket"} { |
| if !testableNetwork(network) { |
| t.Logf("skipping %s test", network) |
| continue |
| } |
| |
| ls, err := newLocalServer(network) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer ls.teardown() |
| if err := ls.buildup(handler); err != nil { |
| t.Fatal(err) |
| } |
| |
| c, err := Dial(ls.Listener.Addr().Network(), ls.Listener.Addr().String()) |
| if err != nil { |
| t.Fatal(err) |
| } |
| switch network { |
| case "unix", "unixpacket": |
| defer os.Remove(c.LocalAddr().String()) |
| } |
| defer c.Close() |
| |
| switch c := c.(type) { |
| case *TCPConn: |
| err = c.CloseWrite() |
| case *UnixConn: |
| err = c.CloseWrite() |
| } |
| if err != nil { |
| if perr := parseCloseError(err); perr != nil { |
| t.Error(perr) |
| } |
| t.Fatal(err) |
| } |
| var b [1]byte |
| n, err := c.Read(b[:]) |
| if n != 0 || err != io.EOF { |
| t.Fatalf("got (%d, %v); want (0, io.EOF)", n, err) |
| } |
| n, err = c.Write(b[:]) |
| if err == nil { |
| t.Fatalf("got (%d, %v); want (any, error)", n, err) |
| } |
| } |
| } |
| |
| func TestConnClose(t *testing.T) { |
| for _, network := range []string{"tcp", "unix", "unixpacket"} { |
| if !testableNetwork(network) { |
| t.Logf("skipping %s test", network) |
| continue |
| } |
| |
| ln, err := newLocalListener(network) |
| if err != nil { |
| t.Fatal(err) |
| } |
| switch network { |
| case "unix", "unixpacket": |
| defer os.Remove(ln.Addr().String()) |
| } |
| defer ln.Close() |
| |
| c, err := Dial(ln.Addr().Network(), ln.Addr().String()) |
| if err != nil { |
| t.Fatal(err) |
| } |
| switch network { |
| case "unix", "unixpacket": |
| defer os.Remove(c.LocalAddr().String()) |
| } |
| defer c.Close() |
| |
| if err := c.Close(); err != nil { |
| if perr := parseCloseError(err); perr != nil { |
| t.Error(perr) |
| } |
| t.Fatal(err) |
| } |
| var b [1]byte |
| n, err := c.Read(b[:]) |
| if n != 0 || err == nil { |
| t.Fatalf("got (%d, %v); want (0, error)", n, err) |
| } |
| } |
| } |
| |
| func TestListenerClose(t *testing.T) { |
| for _, network := range []string{"tcp", "unix", "unixpacket"} { |
| if !testableNetwork(network) { |
| t.Logf("skipping %s test", network) |
| continue |
| } |
| |
| ln, err := newLocalListener(network) |
| if err != nil { |
| t.Fatal(err) |
| } |
| switch network { |
| case "unix", "unixpacket": |
| defer os.Remove(ln.Addr().String()) |
| } |
| |
| dst := ln.Addr().String() |
| if err := ln.Close(); err != nil { |
| if perr := parseCloseError(err); perr != nil { |
| t.Error(perr) |
| } |
| t.Fatal(err) |
| } |
| c, err := ln.Accept() |
| if err == nil { |
| c.Close() |
| t.Fatal("should fail") |
| } |
| |
| if network == "tcp" { |
| // We will have two TCP FSMs inside the |
| // kernel here. There's no guarantee that a |
| // signal comes from the far end FSM will be |
| // delivered immediately to the near end FSM, |
| // especially on the platforms that allow |
| // multiple consumer threads to pull pending |
| // established connections at the same time by |
| // enabling SO_REUSEPORT option such as Linux, |
| // DragonFly BSD. So we need to give some time |
| // quantum to the kernel. |
| // |
| // Note that net.inet.tcp.reuseport_ext=1 by |
| // default on DragonFly BSD. |
| time.Sleep(time.Millisecond) |
| |
| cc, err := Dial("tcp", dst) |
| if err == nil { |
| t.Error("Dial to closed TCP listener succeeded.") |
| cc.Close() |
| } |
| } |
| } |
| } |
| |
| func TestPacketConnClose(t *testing.T) { |
| for _, network := range []string{"udp", "unixgram"} { |
| if !testableNetwork(network) { |
| t.Logf("skipping %s test", network) |
| continue |
| } |
| |
| c, err := newLocalPacketListener(network) |
| if err != nil { |
| t.Fatal(err) |
| } |
| switch network { |
| case "unixgram": |
| defer os.Remove(c.LocalAddr().String()) |
| } |
| defer c.Close() |
| |
| if err := c.Close(); err != nil { |
| if perr := parseCloseError(err); perr != nil { |
| t.Error(perr) |
| } |
| t.Fatal(err) |
| } |
| var b [1]byte |
| n, _, err := c.ReadFrom(b[:]) |
| if n != 0 || err == nil { |
| t.Fatalf("got (%d, %v); want (0, error)", n, err) |
| } |
| } |
| } |
| |
| // nacl was previous failing to reuse an address. |
| func TestListenCloseListen(t *testing.T) { |
| const maxTries = 10 |
| for tries := 0; tries < maxTries; tries++ { |
| ln, err := newLocalListener("tcp") |
| if err != nil { |
| t.Fatal(err) |
| } |
| addr := ln.Addr().String() |
| if err := ln.Close(); err != nil { |
| if perr := parseCloseError(err); perr != nil { |
| t.Error(perr) |
| } |
| t.Fatal(err) |
| } |
| ln, err = Listen("tcp", addr) |
| if err == nil { |
| // Success. nacl couldn't do this before. |
| ln.Close() |
| return |
| } |
| t.Errorf("failed on try %d/%d: %v", tries+1, maxTries, err) |
| } |
| t.Fatalf("failed to listen/close/listen on same address after %d tries", maxTries) |
| } |
| |
| // See golang.org/issue/6163, golang.org/issue/6987. |
| func TestAcceptIgnoreAbortedConnRequest(t *testing.T) { |
| switch runtime.GOOS { |
| case "plan9": |
| t.Skipf("%s does not have full support of socktest", runtime.GOOS) |
| } |
| |
| syserr := make(chan error) |
| go func() { |
| defer close(syserr) |
| for _, err := range abortedConnRequestErrors { |
| syserr <- err |
| } |
| }() |
| sw.Set(socktest.FilterAccept, func(so *socktest.Status) (socktest.AfterFilter, error) { |
| if err, ok := <-syserr; ok { |
| return nil, err |
| } |
| return nil, nil |
| }) |
| defer sw.Set(socktest.FilterAccept, nil) |
| |
| operr := make(chan error, 1) |
| handler := func(ls *localServer, ln Listener) { |
| defer close(operr) |
| c, err := ln.Accept() |
| if err != nil { |
| if perr := parseAcceptError(err); perr != nil { |
| operr <- perr |
| } |
| operr <- err |
| 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) |
| } |
| |
| c, err := Dial(ls.Listener.Addr().Network(), ls.Listener.Addr().String()) |
| if err != nil { |
| t.Fatal(err) |
| } |
| c.Close() |
| |
| for err := range operr { |
| t.Error(err) |
| } |
| } |
| |
| func TestZeroByteRead(t *testing.T) { |
| for _, network := range []string{"tcp", "unix", "unixpacket"} { |
| if !testableNetwork(network) { |
| t.Logf("skipping %s test", network) |
| continue |
| } |
| |
| ln, err := newLocalListener(network) |
| if err != nil { |
| t.Fatal(err) |
| } |
| connc := make(chan Conn, 1) |
| go func() { |
| defer ln.Close() |
| c, err := ln.Accept() |
| if err != nil { |
| t.Error(err) |
| } |
| connc <- c // might be nil |
| }() |
| c, err := Dial(network, ln.Addr().String()) |
| if err != nil { |
| t.Fatal(err) |
| } |
| defer c.Close() |
| sc := <-connc |
| if sc == nil { |
| continue |
| } |
| defer sc.Close() |
| |
| if runtime.GOOS == "windows" { |
| // A zero byte read on Windows caused a wait for readability first. |
| // Rather than change that behavior, satisfy it in this test. |
| // See Issue 15735. |
| go io.WriteString(sc, "a") |
| } |
| |
| n, err := c.Read(nil) |
| if n != 0 || err != nil { |
| t.Errorf("%s: zero byte client read = %v, %v; want 0, nil", network, n, err) |
| } |
| |
| if runtime.GOOS == "windows" { |
| // Same as comment above. |
| go io.WriteString(c, "a") |
| } |
| n, err = sc.Read(nil) |
| if n != 0 || err != nil { |
| t.Errorf("%s: zero byte server read = %v, %v; want 0, nil", network, n, err) |
| } |
| } |
| } |