| // Copyright 2013 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 ( |
| "context" |
| "errors" |
| "fmt" |
| "internal/testenv" |
| "log" |
| "os" |
| "path/filepath" |
| "runtime" |
| "strconv" |
| "sync" |
| "testing" |
| "time" |
| ) |
| |
| // testUnixAddr uses os.MkdirTemp to get a name that is unique. |
| func testUnixAddr(t testing.TB) string { |
| // Pass an empty pattern to get a directory name that is as short as possible. |
| // If we end up with a name longer than the sun_path field in the sockaddr_un |
| // struct, we won't be able to make the syscall to open the socket. |
| d, err := os.MkdirTemp("", "") |
| if err != nil { |
| t.Fatal(err) |
| } |
| t.Cleanup(func() { |
| if err := os.RemoveAll(d); err != nil { |
| t.Error(err) |
| } |
| }) |
| return filepath.Join(d, "sock") |
| } |
| |
| func newLocalListener(t testing.TB, network string, lcOpt ...*ListenConfig) Listener { |
| var lc *ListenConfig |
| switch len(lcOpt) { |
| case 0: |
| lc = new(ListenConfig) |
| case 1: |
| lc = lcOpt[0] |
| default: |
| t.Helper() |
| t.Fatal("too many ListenConfigs passed to newLocalListener: want 0 or 1") |
| } |
| |
| listen := func(net, addr string) Listener { |
| ln, err := lc.Listen(context.Background(), net, addr) |
| if err != nil { |
| t.Helper() |
| t.Fatal(err) |
| } |
| return ln |
| } |
| |
| switch network { |
| case "tcp": |
| if supportsIPv4() { |
| return listen("tcp4", "127.0.0.1:0") |
| } |
| if supportsIPv6() { |
| return listen("tcp6", "[::1]:0") |
| } |
| case "tcp4": |
| if supportsIPv4() { |
| return listen("tcp4", "127.0.0.1:0") |
| } |
| case "tcp6": |
| if supportsIPv6() { |
| return listen("tcp6", "[::1]:0") |
| } |
| case "unix", "unixpacket": |
| return listen(network, testUnixAddr(t)) |
| } |
| |
| t.Helper() |
| t.Fatalf("%s is not supported", network) |
| return nil |
| } |
| |
| func newDualStackListener() (lns []*TCPListener, err error) { |
| var args = []struct { |
| network string |
| TCPAddr |
| }{ |
| {"tcp4", TCPAddr{IP: IPv4(127, 0, 0, 1)}}, |
| {"tcp6", TCPAddr{IP: IPv6loopback}}, |
| } |
| for i := 0; i < 64; i++ { |
| var port int |
| var lns []*TCPListener |
| for _, arg := range args { |
| arg.TCPAddr.Port = port |
| ln, err := ListenTCP(arg.network, &arg.TCPAddr) |
| if err != nil { |
| continue |
| } |
| port = ln.Addr().(*TCPAddr).Port |
| lns = append(lns, ln) |
| } |
| if len(lns) != len(args) { |
| for _, ln := range lns { |
| ln.Close() |
| } |
| continue |
| } |
| return lns, nil |
| } |
| return nil, errors.New("no dualstack port available") |
| } |
| |
| type localServer struct { |
| lnmu sync.RWMutex |
| Listener |
| done chan bool // signal that indicates server stopped |
| cl []Conn // accepted connection list |
| } |
| |
| func (ls *localServer) buildup(handler func(*localServer, Listener)) error { |
| go func() { |
| handler(ls, ls.Listener) |
| close(ls.done) |
| }() |
| return nil |
| } |
| |
| func (ls *localServer) teardown() error { |
| ls.lnmu.Lock() |
| defer ls.lnmu.Unlock() |
| if ls.Listener != nil { |
| network := ls.Listener.Addr().Network() |
| address := ls.Listener.Addr().String() |
| ls.Listener.Close() |
| for _, c := range ls.cl { |
| if err := c.Close(); err != nil { |
| return err |
| } |
| } |
| <-ls.done |
| ls.Listener = nil |
| switch network { |
| case "unix", "unixpacket": |
| os.Remove(address) |
| } |
| } |
| return nil |
| } |
| |
| func newLocalServer(t testing.TB, network string) *localServer { |
| t.Helper() |
| ln := newLocalListener(t, network) |
| return &localServer{Listener: ln, done: make(chan bool)} |
| } |
| |
| type streamListener struct { |
| network, address string |
| Listener |
| done chan bool // signal that indicates server stopped |
| } |
| |
| func (sl *streamListener) newLocalServer() *localServer { |
| return &localServer{Listener: sl.Listener, done: make(chan bool)} |
| } |
| |
| type dualStackServer struct { |
| lnmu sync.RWMutex |
| lns []streamListener |
| port string |
| |
| cmu sync.RWMutex |
| cs []Conn // established connections at the passive open side |
| } |
| |
| func (dss *dualStackServer) buildup(handler func(*dualStackServer, Listener)) error { |
| for i := range dss.lns { |
| go func(i int) { |
| handler(dss, dss.lns[i].Listener) |
| close(dss.lns[i].done) |
| }(i) |
| } |
| return nil |
| } |
| |
| func (dss *dualStackServer) teardownNetwork(network string) error { |
| dss.lnmu.Lock() |
| for i := range dss.lns { |
| if network == dss.lns[i].network && dss.lns[i].Listener != nil { |
| dss.lns[i].Listener.Close() |
| <-dss.lns[i].done |
| dss.lns[i].Listener = nil |
| } |
| } |
| dss.lnmu.Unlock() |
| return nil |
| } |
| |
| func (dss *dualStackServer) teardown() error { |
| dss.lnmu.Lock() |
| for i := range dss.lns { |
| if dss.lns[i].Listener != nil { |
| dss.lns[i].Listener.Close() |
| <-dss.lns[i].done |
| } |
| } |
| dss.lns = dss.lns[:0] |
| dss.lnmu.Unlock() |
| dss.cmu.Lock() |
| for _, c := range dss.cs { |
| c.Close() |
| } |
| dss.cs = dss.cs[:0] |
| dss.cmu.Unlock() |
| return nil |
| } |
| |
| func newDualStackServer() (*dualStackServer, error) { |
| lns, err := newDualStackListener() |
| if err != nil { |
| return nil, err |
| } |
| _, port, err := SplitHostPort(lns[0].Addr().String()) |
| if err != nil { |
| lns[0].Close() |
| lns[1].Close() |
| return nil, err |
| } |
| return &dualStackServer{ |
| lns: []streamListener{ |
| {network: "tcp4", address: lns[0].Addr().String(), Listener: lns[0], done: make(chan bool)}, |
| {network: "tcp6", address: lns[1].Addr().String(), Listener: lns[1], done: make(chan bool)}, |
| }, |
| port: port, |
| }, nil |
| } |
| |
| func (ls *localServer) transponder(ln Listener, ch chan<- error) { |
| defer close(ch) |
| |
| switch ln := ln.(type) { |
| case *TCPListener: |
| ln.SetDeadline(time.Now().Add(someTimeout)) |
| case *UnixListener: |
| ln.SetDeadline(time.Now().Add(someTimeout)) |
| } |
| c, err := ln.Accept() |
| if err != nil { |
| if perr := parseAcceptError(err); perr != nil { |
| ch <- perr |
| } |
| ch <- err |
| return |
| } |
| ls.cl = append(ls.cl, c) |
| |
| network := ln.Addr().Network() |
| if c.LocalAddr().Network() != network || c.RemoteAddr().Network() != network { |
| ch <- fmt.Errorf("got %v->%v; expected %v->%v", c.LocalAddr().Network(), c.RemoteAddr().Network(), network, network) |
| return |
| } |
| c.SetDeadline(time.Now().Add(someTimeout)) |
| c.SetReadDeadline(time.Now().Add(someTimeout)) |
| c.SetWriteDeadline(time.Now().Add(someTimeout)) |
| |
| b := make([]byte, 256) |
| n, err := c.Read(b) |
| if err != nil { |
| if perr := parseReadError(err); perr != nil { |
| ch <- perr |
| } |
| ch <- err |
| return |
| } |
| if _, err := c.Write(b[:n]); err != nil { |
| if perr := parseWriteError(err); perr != nil { |
| ch <- perr |
| } |
| ch <- err |
| return |
| } |
| } |
| |
| func transceiver(c Conn, wb []byte, ch chan<- error) { |
| defer close(ch) |
| |
| c.SetDeadline(time.Now().Add(someTimeout)) |
| c.SetReadDeadline(time.Now().Add(someTimeout)) |
| c.SetWriteDeadline(time.Now().Add(someTimeout)) |
| |
| n, err := c.Write(wb) |
| if err != nil { |
| if perr := parseWriteError(err); perr != nil { |
| ch <- perr |
| } |
| ch <- err |
| return |
| } |
| if n != len(wb) { |
| ch <- fmt.Errorf("wrote %d; want %d", n, len(wb)) |
| } |
| rb := make([]byte, len(wb)) |
| n, err = c.Read(rb) |
| if err != nil { |
| if perr := parseReadError(err); perr != nil { |
| ch <- perr |
| } |
| ch <- err |
| return |
| } |
| if n != len(wb) { |
| ch <- fmt.Errorf("read %d; want %d", n, len(wb)) |
| } |
| } |
| |
| func newLocalPacketListener(t testing.TB, network string, lcOpt ...*ListenConfig) PacketConn { |
| var lc *ListenConfig |
| switch len(lcOpt) { |
| case 0: |
| lc = new(ListenConfig) |
| case 1: |
| lc = lcOpt[0] |
| default: |
| t.Helper() |
| t.Fatal("too many ListenConfigs passed to newLocalListener: want 0 or 1") |
| } |
| |
| listenPacket := func(net, addr string) PacketConn { |
| c, err := lc.ListenPacket(context.Background(), net, addr) |
| if err != nil { |
| t.Helper() |
| t.Fatal(err) |
| } |
| return c |
| } |
| |
| t.Helper() |
| switch network { |
| case "udp": |
| if supportsIPv4() { |
| return listenPacket("udp4", "127.0.0.1:0") |
| } |
| if supportsIPv6() { |
| return listenPacket("udp6", "[::1]:0") |
| } |
| case "udp4": |
| if supportsIPv4() { |
| return listenPacket("udp4", "127.0.0.1:0") |
| } |
| case "udp6": |
| if supportsIPv6() { |
| return listenPacket("udp6", "[::1]:0") |
| } |
| case "unixgram": |
| return listenPacket(network, testUnixAddr(t)) |
| } |
| |
| t.Fatalf("%s is not supported", network) |
| return nil |
| } |
| |
| func newDualStackPacketListener() (cs []*UDPConn, err error) { |
| var args = []struct { |
| network string |
| UDPAddr |
| }{ |
| {"udp4", UDPAddr{IP: IPv4(127, 0, 0, 1)}}, |
| {"udp6", UDPAddr{IP: IPv6loopback}}, |
| } |
| for i := 0; i < 64; i++ { |
| var port int |
| var cs []*UDPConn |
| for _, arg := range args { |
| arg.UDPAddr.Port = port |
| c, err := ListenUDP(arg.network, &arg.UDPAddr) |
| if err != nil { |
| continue |
| } |
| port = c.LocalAddr().(*UDPAddr).Port |
| cs = append(cs, c) |
| } |
| if len(cs) != len(args) { |
| for _, c := range cs { |
| c.Close() |
| } |
| continue |
| } |
| return cs, nil |
| } |
| return nil, errors.New("no dualstack port available") |
| } |
| |
| type localPacketServer struct { |
| pcmu sync.RWMutex |
| PacketConn |
| done chan bool // signal that indicates server stopped |
| } |
| |
| func (ls *localPacketServer) buildup(handler func(*localPacketServer, PacketConn)) error { |
| go func() { |
| handler(ls, ls.PacketConn) |
| close(ls.done) |
| }() |
| return nil |
| } |
| |
| func (ls *localPacketServer) teardown() error { |
| ls.pcmu.Lock() |
| if ls.PacketConn != nil { |
| network := ls.PacketConn.LocalAddr().Network() |
| address := ls.PacketConn.LocalAddr().String() |
| ls.PacketConn.Close() |
| <-ls.done |
| ls.PacketConn = nil |
| switch network { |
| case "unixgram": |
| os.Remove(address) |
| } |
| } |
| ls.pcmu.Unlock() |
| return nil |
| } |
| |
| func newLocalPacketServer(t testing.TB, network string) *localPacketServer { |
| t.Helper() |
| c := newLocalPacketListener(t, network) |
| return &localPacketServer{PacketConn: c, done: make(chan bool)} |
| } |
| |
| type packetListener struct { |
| PacketConn |
| } |
| |
| func (pl *packetListener) newLocalServer() *localPacketServer { |
| return &localPacketServer{PacketConn: pl.PacketConn, done: make(chan bool)} |
| } |
| |
| func packetTransponder(c PacketConn, ch chan<- error) { |
| defer close(ch) |
| |
| c.SetDeadline(time.Now().Add(someTimeout)) |
| c.SetReadDeadline(time.Now().Add(someTimeout)) |
| c.SetWriteDeadline(time.Now().Add(someTimeout)) |
| |
| b := make([]byte, 256) |
| n, peer, err := c.ReadFrom(b) |
| if err != nil { |
| if perr := parseReadError(err); perr != nil { |
| ch <- perr |
| } |
| ch <- err |
| return |
| } |
| if peer == nil { // for connected-mode sockets |
| switch c.LocalAddr().Network() { |
| case "udp": |
| peer, err = ResolveUDPAddr("udp", string(b[:n])) |
| case "unixgram": |
| peer, err = ResolveUnixAddr("unixgram", string(b[:n])) |
| } |
| if err != nil { |
| ch <- err |
| return |
| } |
| } |
| if _, err := c.WriteTo(b[:n], peer); err != nil { |
| if perr := parseWriteError(err); perr != nil { |
| ch <- perr |
| } |
| ch <- err |
| return |
| } |
| } |
| |
| func packetTransceiver(c PacketConn, wb []byte, dst Addr, ch chan<- error) { |
| defer close(ch) |
| |
| c.SetDeadline(time.Now().Add(someTimeout)) |
| c.SetReadDeadline(time.Now().Add(someTimeout)) |
| c.SetWriteDeadline(time.Now().Add(someTimeout)) |
| |
| n, err := c.WriteTo(wb, dst) |
| if err != nil { |
| if perr := parseWriteError(err); perr != nil { |
| ch <- perr |
| } |
| ch <- err |
| return |
| } |
| if n != len(wb) { |
| ch <- fmt.Errorf("wrote %d; want %d", n, len(wb)) |
| } |
| rb := make([]byte, len(wb)) |
| n, _, err = c.ReadFrom(rb) |
| if err != nil { |
| if perr := parseReadError(err); perr != nil { |
| ch <- perr |
| } |
| ch <- err |
| return |
| } |
| if n != len(wb) { |
| ch <- fmt.Errorf("read %d; want %d", n, len(wb)) |
| } |
| } |
| |
| func spawnTestSocketPair(t testing.TB, net string) (client, server Conn) { |
| t.Helper() |
| |
| ln := newLocalListener(t, net) |
| defer ln.Close() |
| var cerr, serr error |
| acceptDone := make(chan struct{}) |
| go func() { |
| server, serr = ln.Accept() |
| acceptDone <- struct{}{} |
| }() |
| client, cerr = Dial(ln.Addr().Network(), ln.Addr().String()) |
| <-acceptDone |
| if cerr != nil { |
| if server != nil { |
| server.Close() |
| } |
| t.Fatal(cerr) |
| } |
| if serr != nil { |
| if client != nil { |
| client.Close() |
| } |
| t.Fatal(serr) |
| } |
| return client, server |
| } |
| |
| func startTestSocketPeer(t testing.TB, conn Conn, op string, chunkSize, totalSize int) (func(t testing.TB), error) { |
| t.Helper() |
| |
| if runtime.GOOS == "windows" { |
| // TODO(panjf2000): Windows has not yet implemented FileConn, |
| // remove this when it's implemented in https://go.dev/issues/9503. |
| t.Fatalf("startTestSocketPeer is not supported on %s", runtime.GOOS) |
| } |
| |
| f, err := conn.(interface{ File() (*os.File, error) }).File() |
| if err != nil { |
| return nil, err |
| } |
| |
| cmd := testenv.Command(t, os.Args[0]) |
| cmd.Env = []string{ |
| "GO_NET_TEST_TRANSFER=1", |
| "GO_NET_TEST_TRANSFER_OP=" + op, |
| "GO_NET_TEST_TRANSFER_CHUNK_SIZE=" + strconv.Itoa(chunkSize), |
| "GO_NET_TEST_TRANSFER_TOTAL_SIZE=" + strconv.Itoa(totalSize), |
| "TMPDIR=" + os.Getenv("TMPDIR"), |
| } |
| cmd.ExtraFiles = append(cmd.ExtraFiles, f) |
| cmd.Stdout = os.Stdout |
| cmd.Stderr = os.Stderr |
| |
| if err := cmd.Start(); err != nil { |
| return nil, err |
| } |
| |
| cmdCh := make(chan error, 1) |
| go func() { |
| err := cmd.Wait() |
| conn.Close() |
| f.Close() |
| cmdCh <- err |
| }() |
| |
| return func(tb testing.TB) { |
| err := <-cmdCh |
| if err != nil { |
| tb.Errorf("process exited with error: %v", err) |
| } |
| }, nil |
| } |
| |
| func init() { |
| if os.Getenv("GO_NET_TEST_TRANSFER") == "" { |
| return |
| } |
| defer os.Exit(0) |
| |
| f := os.NewFile(uintptr(3), "splice-test-conn") |
| defer f.Close() |
| |
| conn, err := FileConn(f) |
| if err != nil { |
| log.Fatal(err) |
| } |
| |
| var chunkSize int |
| if chunkSize, err = strconv.Atoi(os.Getenv("GO_NET_TEST_TRANSFER_CHUNK_SIZE")); err != nil { |
| log.Fatal(err) |
| } |
| buf := make([]byte, chunkSize) |
| |
| var totalSize int |
| if totalSize, err = strconv.Atoi(os.Getenv("GO_NET_TEST_TRANSFER_TOTAL_SIZE")); err != nil { |
| log.Fatal(err) |
| } |
| |
| var fn func([]byte) (int, error) |
| switch op := os.Getenv("GO_NET_TEST_TRANSFER_OP"); op { |
| case "r": |
| fn = conn.Read |
| case "w": |
| defer conn.Close() |
| |
| fn = conn.Write |
| default: |
| log.Fatalf("unknown op %q", op) |
| } |
| |
| var n int |
| for count := 0; count < totalSize; count += n { |
| if count+chunkSize > totalSize { |
| buf = buf[:totalSize-count] |
| } |
| |
| var err error |
| if n, err = fn(buf); err != nil { |
| return |
| } |
| } |
| } |
