| // 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. | |
| //go:build !plan9 | |
| package net | |
| import ( | |
| "fmt" | |
| "internal/testenv" | |
| "os" | |
| "runtime" | |
| "syscall" | |
| "testing" | |
| "time" | |
| ) | |
| func (ln *TCPListener) port() string { | |
| _, port, err := SplitHostPort(ln.Addr().String()) | |
| if err != nil { | |
| return "" | |
| } | |
| return port | |
| } | |
| func (c *UDPConn) port() string { | |
| _, port, err := SplitHostPort(c.LocalAddr().String()) | |
| if err != nil { | |
| return "" | |
| } | |
| return port | |
| } | |
| var tcpListenerTests = []struct { | |
| network string | |
| address string | |
| }{ | |
| {"tcp", ""}, | |
| {"tcp", "0.0.0.0"}, | |
| {"tcp", "::ffff:0.0.0.0"}, | |
| {"tcp", "::"}, | |
| {"tcp", "127.0.0.1"}, | |
| {"tcp", "::ffff:127.0.0.1"}, | |
| {"tcp", "::1"}, | |
| {"tcp4", ""}, | |
| {"tcp4", "0.0.0.0"}, | |
| {"tcp4", "::ffff:0.0.0.0"}, | |
| {"tcp4", "127.0.0.1"}, | |
| {"tcp4", "::ffff:127.0.0.1"}, | |
| {"tcp6", ""}, | |
| {"tcp6", "::"}, | |
| {"tcp6", "::1"}, | |
| } | |
| // TestTCPListener tests both single and double listen to a test | |
| // listener with same address family, same listening address and | |
| // same port. | |
| func TestTCPListener(t *testing.T) { | |
| switch runtime.GOOS { | |
| case "plan9": | |
| t.Skipf("not supported on %s", runtime.GOOS) | |
| } | |
| for _, tt := range tcpListenerTests { | |
| if !testableListenArgs(tt.network, JoinHostPort(tt.address, "0"), "") { | |
| t.Logf("skipping %s test", tt.network+" "+tt.address) | |
| continue | |
| } | |
| ln1, err := Listen(tt.network, JoinHostPort(tt.address, "0")) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if err := checkFirstListener(tt.network, ln1); err != nil { | |
| ln1.Close() | |
| t.Fatal(err) | |
| } | |
| ln2, err := Listen(tt.network, JoinHostPort(tt.address, ln1.(*TCPListener).port())) | |
| if err == nil { | |
| ln2.Close() | |
| } | |
| if err := checkSecondListener(tt.network, tt.address, err); err != nil { | |
| ln1.Close() | |
| t.Fatal(err) | |
| } | |
| ln1.Close() | |
| } | |
| } | |
| var udpListenerTests = []struct { | |
| network string | |
| address string | |
| }{ | |
| {"udp", ""}, | |
| {"udp", "0.0.0.0"}, | |
| {"udp", "::ffff:0.0.0.0"}, | |
| {"udp", "::"}, | |
| {"udp", "127.0.0.1"}, | |
| {"udp", "::ffff:127.0.0.1"}, | |
| {"udp", "::1"}, | |
| {"udp4", ""}, | |
| {"udp4", "0.0.0.0"}, | |
| {"udp4", "::ffff:0.0.0.0"}, | |
| {"udp4", "127.0.0.1"}, | |
| {"udp4", "::ffff:127.0.0.1"}, | |
| {"udp6", ""}, | |
| {"udp6", "::"}, | |
| {"udp6", "::1"}, | |
| } | |
| // TestUDPListener tests both single and double listen to a test | |
| // listener with same address family, same listening address and | |
| // same port. | |
| func TestUDPListener(t *testing.T) { | |
| switch runtime.GOOS { | |
| case "plan9": | |
| t.Skipf("not supported on %s", runtime.GOOS) | |
| } | |
| for _, tt := range udpListenerTests { | |
| if !testableListenArgs(tt.network, JoinHostPort(tt.address, "0"), "") { | |
| t.Logf("skipping %s test", tt.network+" "+tt.address) | |
| continue | |
| } | |
| c1, err := ListenPacket(tt.network, JoinHostPort(tt.address, "0")) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if err := checkFirstListener(tt.network, c1); err != nil { | |
| c1.Close() | |
| t.Fatal(err) | |
| } | |
| c2, err := ListenPacket(tt.network, JoinHostPort(tt.address, c1.(*UDPConn).port())) | |
| if err == nil { | |
| c2.Close() | |
| } | |
| if err := checkSecondListener(tt.network, tt.address, err); err != nil { | |
| c1.Close() | |
| t.Fatal(err) | |
| } | |
| c1.Close() | |
| } | |
| } | |
| var dualStackTCPListenerTests = []struct { | |
| network1, address1 string // first listener | |
| network2, address2 string // second listener | |
| xerr error // expected error value, nil or other | |
| }{ | |
| // Test cases and expected results for the attempting 2nd listen on the same port | |
| // 1st listen 2nd listen darwin freebsd linux openbsd | |
| // ------------------------------------------------------------------------------------ | |
| // "tcp" "" "tcp" "" - - - - | |
| // "tcp" "" "tcp" "0.0.0.0" - - - - | |
| // "tcp" "0.0.0.0" "tcp" "" - - - - | |
| // ------------------------------------------------------------------------------------ | |
| // "tcp" "" "tcp" "[::]" - - - ok | |
| // "tcp" "[::]" "tcp" "" - - - ok | |
| // "tcp" "0.0.0.0" "tcp" "[::]" - - - ok | |
| // "tcp" "[::]" "tcp" "0.0.0.0" - - - ok | |
| // "tcp" "[::ffff:0.0.0.0]" "tcp" "[::]" - - - ok | |
| // "tcp" "[::]" "tcp" "[::ffff:0.0.0.0]" - - - ok | |
| // ------------------------------------------------------------------------------------ | |
| // "tcp4" "" "tcp6" "" ok ok ok ok | |
| // "tcp6" "" "tcp4" "" ok ok ok ok | |
| // "tcp4" "0.0.0.0" "tcp6" "[::]" ok ok ok ok | |
| // "tcp6" "[::]" "tcp4" "0.0.0.0" ok ok ok ok | |
| // ------------------------------------------------------------------------------------ | |
| // "tcp" "127.0.0.1" "tcp" "[::1]" ok ok ok ok | |
| // "tcp" "[::1]" "tcp" "127.0.0.1" ok ok ok ok | |
| // "tcp4" "127.0.0.1" "tcp6" "[::1]" ok ok ok ok | |
| // "tcp6" "[::1]" "tcp4" "127.0.0.1" ok ok ok ok | |
| // | |
| // Platform default configurations: | |
| // darwin, kernel version 11.3.0 | |
| // net.inet6.ip6.v6only=0 (overridable by sysctl or IPV6_V6ONLY option) | |
| // freebsd, kernel version 8.2 | |
| // net.inet6.ip6.v6only=1 (overridable by sysctl or IPV6_V6ONLY option) | |
| // linux, kernel version 3.0.0 | |
| // net.ipv6.bindv6only=0 (overridable by sysctl or IPV6_V6ONLY option) | |
| // openbsd, kernel version 5.0 | |
| // net.inet6.ip6.v6only=1 (overriding is prohibited) | |
| {"tcp", "", "tcp", "", syscall.EADDRINUSE}, | |
| {"tcp", "", "tcp", "0.0.0.0", syscall.EADDRINUSE}, | |
| {"tcp", "0.0.0.0", "tcp", "", syscall.EADDRINUSE}, | |
| {"tcp", "", "tcp", "::", syscall.EADDRINUSE}, | |
| {"tcp", "::", "tcp", "", syscall.EADDRINUSE}, | |
| {"tcp", "0.0.0.0", "tcp", "::", syscall.EADDRINUSE}, | |
| {"tcp", "::", "tcp", "0.0.0.0", syscall.EADDRINUSE}, | |
| {"tcp", "::ffff:0.0.0.0", "tcp", "::", syscall.EADDRINUSE}, | |
| {"tcp", "::", "tcp", "::ffff:0.0.0.0", syscall.EADDRINUSE}, | |
| {"tcp4", "", "tcp6", "", nil}, | |
| {"tcp6", "", "tcp4", "", nil}, | |
| {"tcp4", "0.0.0.0", "tcp6", "::", nil}, | |
| {"tcp6", "::", "tcp4", "0.0.0.0", nil}, | |
| {"tcp", "127.0.0.1", "tcp", "::1", nil}, | |
| {"tcp", "::1", "tcp", "127.0.0.1", nil}, | |
| {"tcp4", "127.0.0.1", "tcp6", "::1", nil}, | |
| {"tcp6", "::1", "tcp4", "127.0.0.1", nil}, | |
| } | |
| // TestDualStackTCPListener tests both single and double listen | |
| // to a test listener with various address families, different | |
| // listening address and same port. | |
| // | |
| // On DragonFly BSD, we expect the kernel version of node under test | |
| // to be greater than or equal to 4.4. | |
| func TestDualStackTCPListener(t *testing.T) { | |
| switch runtime.GOOS { | |
| case "plan9": | |
| t.Skipf("not supported on %s", runtime.GOOS) | |
| } | |
| if !supportsIPv4() || !supportsIPv6() { | |
| t.Skip("both IPv4 and IPv6 are required") | |
| } | |
| for _, tt := range dualStackTCPListenerTests { | |
| if !testableListenArgs(tt.network1, JoinHostPort(tt.address1, "0"), "") { | |
| t.Logf("skipping %s test", tt.network1+" "+tt.address1) | |
| continue | |
| } | |
| if !supportsIPv4map() && differentWildcardAddr(tt.address1, tt.address2) { | |
| tt.xerr = nil | |
| } | |
| var firstErr, secondErr error | |
| for i := 0; i < 5; i++ { | |
| lns, err := newDualStackListener() | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| port := lns[0].port() | |
| for _, ln := range lns { | |
| ln.Close() | |
| } | |
| var ln1 Listener | |
| ln1, firstErr = Listen(tt.network1, JoinHostPort(tt.address1, port)) | |
| if firstErr != nil { | |
| continue | |
| } | |
| if err := checkFirstListener(tt.network1, ln1); err != nil { | |
| ln1.Close() | |
| t.Fatal(err) | |
| } | |
| ln2, err := Listen(tt.network2, JoinHostPort(tt.address2, ln1.(*TCPListener).port())) | |
| if err == nil { | |
| ln2.Close() | |
| } | |
| if secondErr = checkDualStackSecondListener(tt.network2, tt.address2, err, tt.xerr); secondErr != nil { | |
| ln1.Close() | |
| continue | |
| } | |
| ln1.Close() | |
| break | |
| } | |
| if firstErr != nil { | |
| t.Error(firstErr) | |
| } | |
| if secondErr != nil { | |
| t.Error(secondErr) | |
| } | |
| } | |
| } | |
| var dualStackUDPListenerTests = []struct { | |
| network1, address1 string // first listener | |
| network2, address2 string // second listener | |
| xerr error // expected error value, nil or other | |
| }{ | |
| {"udp", "", "udp", "", syscall.EADDRINUSE}, | |
| {"udp", "", "udp", "0.0.0.0", syscall.EADDRINUSE}, | |
| {"udp", "0.0.0.0", "udp", "", syscall.EADDRINUSE}, | |
| {"udp", "", "udp", "::", syscall.EADDRINUSE}, | |
| {"udp", "::", "udp", "", syscall.EADDRINUSE}, | |
| {"udp", "0.0.0.0", "udp", "::", syscall.EADDRINUSE}, | |
| {"udp", "::", "udp", "0.0.0.0", syscall.EADDRINUSE}, | |
| {"udp", "::ffff:0.0.0.0", "udp", "::", syscall.EADDRINUSE}, | |
| {"udp", "::", "udp", "::ffff:0.0.0.0", syscall.EADDRINUSE}, | |
| {"udp4", "", "udp6", "", nil}, | |
| {"udp6", "", "udp4", "", nil}, | |
| {"udp4", "0.0.0.0", "udp6", "::", nil}, | |
| {"udp6", "::", "udp4", "0.0.0.0", nil}, | |
| {"udp", "127.0.0.1", "udp", "::1", nil}, | |
| {"udp", "::1", "udp", "127.0.0.1", nil}, | |
| {"udp4", "127.0.0.1", "udp6", "::1", nil}, | |
| {"udp6", "::1", "udp4", "127.0.0.1", nil}, | |
| } | |
| // TestDualStackUDPListener tests both single and double listen | |
| // to a test listener with various address families, different | |
| // listening address and same port. | |
| // | |
| // On DragonFly BSD, we expect the kernel version of node under test | |
| // to be greater than or equal to 4.4. | |
| func TestDualStackUDPListener(t *testing.T) { | |
| switch runtime.GOOS { | |
| case "plan9": | |
| t.Skipf("not supported on %s", runtime.GOOS) | |
| } | |
| if !supportsIPv4() || !supportsIPv6() { | |
| t.Skip("both IPv4 and IPv6 are required") | |
| } | |
| for _, tt := range dualStackUDPListenerTests { | |
| if !testableListenArgs(tt.network1, JoinHostPort(tt.address1, "0"), "") { | |
| t.Logf("skipping %s test", tt.network1+" "+tt.address1) | |
| continue | |
| } | |
| if !supportsIPv4map() && differentWildcardAddr(tt.address1, tt.address2) { | |
| tt.xerr = nil | |
| } | |
| var firstErr, secondErr error | |
| for i := 0; i < 5; i++ { | |
| cs, err := newDualStackPacketListener() | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| port := cs[0].port() | |
| for _, c := range cs { | |
| c.Close() | |
| } | |
| var c1 PacketConn | |
| c1, firstErr = ListenPacket(tt.network1, JoinHostPort(tt.address1, port)) | |
| if firstErr != nil { | |
| continue | |
| } | |
| if err := checkFirstListener(tt.network1, c1); err != nil { | |
| c1.Close() | |
| t.Fatal(err) | |
| } | |
| c2, err := ListenPacket(tt.network2, JoinHostPort(tt.address2, c1.(*UDPConn).port())) | |
| if err == nil { | |
| c2.Close() | |
| } | |
| if secondErr = checkDualStackSecondListener(tt.network2, tt.address2, err, tt.xerr); secondErr != nil { | |
| c1.Close() | |
| continue | |
| } | |
| c1.Close() | |
| break | |
| } | |
| if firstErr != nil { | |
| t.Error(firstErr) | |
| } | |
| if secondErr != nil { | |
| t.Error(secondErr) | |
| } | |
| } | |
| } | |
| func differentWildcardAddr(i, j string) bool { | |
| if (i == "" || i == "0.0.0.0" || i == "::ffff:0.0.0.0") && (j == "" || j == "0.0.0.0" || j == "::ffff:0.0.0.0") { | |
| return false | |
| } | |
| if i == "[::]" && j == "[::]" { | |
| return false | |
| } | |
| return true | |
| } | |
| func checkFirstListener(network string, ln any) error { | |
| switch network { | |
| case "tcp": | |
| fd := ln.(*TCPListener).fd | |
| if err := checkDualStackAddrFamily(fd); err != nil { | |
| return err | |
| } | |
| case "tcp4": | |
| fd := ln.(*TCPListener).fd | |
| if fd.family != syscall.AF_INET { | |
| return fmt.Errorf("%v got %v; want %v", fd.laddr, fd.family, syscall.AF_INET) | |
| } | |
| case "tcp6": | |
| fd := ln.(*TCPListener).fd | |
| if fd.family != syscall.AF_INET6 { | |
| return fmt.Errorf("%v got %v; want %v", fd.laddr, fd.family, syscall.AF_INET6) | |
| } | |
| case "udp": | |
| fd := ln.(*UDPConn).fd | |
| if err := checkDualStackAddrFamily(fd); err != nil { | |
| return err | |
| } | |
| case "udp4": | |
| fd := ln.(*UDPConn).fd | |
| if fd.family != syscall.AF_INET { | |
| return fmt.Errorf("%v got %v; want %v", fd.laddr, fd.family, syscall.AF_INET) | |
| } | |
| case "udp6": | |
| fd := ln.(*UDPConn).fd | |
| if fd.family != syscall.AF_INET6 { | |
| return fmt.Errorf("%v got %v; want %v", fd.laddr, fd.family, syscall.AF_INET6) | |
| } | |
| default: | |
| return UnknownNetworkError(network) | |
| } | |
| return nil | |
| } | |
| func checkSecondListener(network, address string, err error) error { | |
| switch network { | |
| case "tcp", "tcp4", "tcp6": | |
| if err == nil { | |
| return fmt.Errorf("%s should fail", network+" "+address) | |
| } | |
| case "udp", "udp4", "udp6": | |
| if err == nil { | |
| return fmt.Errorf("%s should fail", network+" "+address) | |
| } | |
| default: | |
| return UnknownNetworkError(network) | |
| } | |
| return nil | |
| } | |
| func checkDualStackSecondListener(network, address string, err, xerr error) error { | |
| switch network { | |
| case "tcp", "tcp4", "tcp6": | |
| if xerr == nil && err != nil || xerr != nil && err == nil { | |
| return fmt.Errorf("%s got %v; want %v", network+" "+address, err, xerr) | |
| } | |
| case "udp", "udp4", "udp6": | |
| if xerr == nil && err != nil || xerr != nil && err == nil { | |
| return fmt.Errorf("%s got %v; want %v", network+" "+address, err, xerr) | |
| } | |
| default: | |
| return UnknownNetworkError(network) | |
| } | |
| return nil | |
| } | |
| func checkDualStackAddrFamily(fd *netFD) error { | |
| switch a := fd.laddr.(type) { | |
| case *TCPAddr: | |
| // If a node under test supports both IPv6 capability | |
| // and IPv6 IPv4-mapping capability, we can assume | |
| // that the node listens on a wildcard address with an | |
| // AF_INET6 socket. | |
| if supportsIPv4map() && fd.laddr.(*TCPAddr).isWildcard() { | |
| if fd.family != syscall.AF_INET6 { | |
| return fmt.Errorf("Listen(%s, %v) returns %v; want %v", fd.net, fd.laddr, fd.family, syscall.AF_INET6) | |
| } | |
| } else { | |
| if fd.family != a.family() { | |
| return fmt.Errorf("Listen(%s, %v) returns %v; want %v", fd.net, fd.laddr, fd.family, a.family()) | |
| } | |
| } | |
| case *UDPAddr: | |
| // If a node under test supports both IPv6 capability | |
| // and IPv6 IPv4-mapping capability, we can assume | |
| // that the node listens on a wildcard address with an | |
| // AF_INET6 socket. | |
| if supportsIPv4map() && fd.laddr.(*UDPAddr).isWildcard() { | |
| if fd.family != syscall.AF_INET6 { | |
| return fmt.Errorf("ListenPacket(%s, %v) returns %v; want %v", fd.net, fd.laddr, fd.family, syscall.AF_INET6) | |
| } | |
| } else { | |
| if fd.family != a.family() { | |
| return fmt.Errorf("ListenPacket(%s, %v) returns %v; want %v", fd.net, fd.laddr, fd.family, a.family()) | |
| } | |
| } | |
| default: | |
| return fmt.Errorf("unexpected protocol address type: %T", a) | |
| } | |
| return nil | |
| } | |
| func TestWildWildcardListener(t *testing.T) { | |
| testenv.MustHaveExternalNetwork(t) | |
| switch runtime.GOOS { | |
| case "plan9": | |
| t.Skipf("not supported on %s", runtime.GOOS) | |
| } | |
| defer func() { | |
| if p := recover(); p != nil { | |
| t.Fatalf("panicked: %v", p) | |
| } | |
| }() | |
| if ln, err := Listen("tcp", ""); err == nil { | |
| ln.Close() | |
| } | |
| if ln, err := ListenPacket("udp", ""); err == nil { | |
| ln.Close() | |
| } | |
| if ln, err := ListenTCP("tcp", nil); err == nil { | |
| ln.Close() | |
| } | |
| if ln, err := ListenUDP("udp", nil); err == nil { | |
| ln.Close() | |
| } | |
| if ln, err := ListenIP("ip:icmp", nil); err == nil { | |
| ln.Close() | |
| } | |
| } | |
| var ipv4MulticastListenerTests = []struct { | |
| net string | |
| gaddr *UDPAddr // see RFC 4727 | |
| }{ | |
| {"udp", &UDPAddr{IP: IPv4(224, 0, 0, 254), Port: 12345}}, | |
| {"udp4", &UDPAddr{IP: IPv4(224, 0, 0, 254), Port: 12345}}, | |
| } | |
| // TestIPv4MulticastListener tests both single and double listen to a | |
| // test listener with same address family, same group address and same | |
| // port. | |
| func TestIPv4MulticastListener(t *testing.T) { | |
| testenv.MustHaveExternalNetwork(t) | |
| switch runtime.GOOS { | |
| case "android", "plan9": | |
| t.Skipf("not supported on %s", runtime.GOOS) | |
| } | |
| if !supportsIPv4() { | |
| t.Skip("IPv4 is not supported") | |
| } | |
| closer := func(cs []*UDPConn) { | |
| for _, c := range cs { | |
| if c != nil { | |
| c.Close() | |
| } | |
| } | |
| } | |
| for _, ifi := range []*Interface{loopbackInterface(), nil} { | |
| // Note that multicast interface assignment by system | |
| // is not recommended because it usually relies on | |
| // routing stuff for finding out an appropriate | |
| // nexthop containing both network and link layer | |
| // adjacencies. | |
| if ifi == nil || !*testIPv4 { | |
| continue | |
| } | |
| for _, tt := range ipv4MulticastListenerTests { | |
| var err error | |
| cs := make([]*UDPConn, 2) | |
| if cs[0], err = ListenMulticastUDP(tt.net, ifi, tt.gaddr); err != nil { | |
| t.Fatal(err) | |
| } | |
| if err := checkMulticastListener(cs[0], tt.gaddr.IP); err != nil { | |
| closer(cs) | |
| t.Fatal(err) | |
| } | |
| if cs[1], err = ListenMulticastUDP(tt.net, ifi, tt.gaddr); err != nil { | |
| closer(cs) | |
| t.Fatal(err) | |
| } | |
| if err := checkMulticastListener(cs[1], tt.gaddr.IP); err != nil { | |
| closer(cs) | |
| t.Fatal(err) | |
| } | |
| closer(cs) | |
| } | |
| } | |
| } | |
| var ipv6MulticastListenerTests = []struct { | |
| net string | |
| gaddr *UDPAddr // see RFC 4727 | |
| }{ | |
| {"udp", &UDPAddr{IP: ParseIP("ff01::114"), Port: 12345}}, | |
| {"udp", &UDPAddr{IP: ParseIP("ff02::114"), Port: 12345}}, | |
| {"udp", &UDPAddr{IP: ParseIP("ff04::114"), Port: 12345}}, | |
| {"udp", &UDPAddr{IP: ParseIP("ff05::114"), Port: 12345}}, | |
| {"udp", &UDPAddr{IP: ParseIP("ff08::114"), Port: 12345}}, | |
| {"udp", &UDPAddr{IP: ParseIP("ff0e::114"), Port: 12345}}, | |
| {"udp6", &UDPAddr{IP: ParseIP("ff01::114"), Port: 12345}}, | |
| {"udp6", &UDPAddr{IP: ParseIP("ff02::114"), Port: 12345}}, | |
| {"udp6", &UDPAddr{IP: ParseIP("ff04::114"), Port: 12345}}, | |
| {"udp6", &UDPAddr{IP: ParseIP("ff05::114"), Port: 12345}}, | |
| {"udp6", &UDPAddr{IP: ParseIP("ff08::114"), Port: 12345}}, | |
| {"udp6", &UDPAddr{IP: ParseIP("ff0e::114"), Port: 12345}}, | |
| } | |
| // TestIPv6MulticastListener tests both single and double listen to a | |
| // test listener with same address family, same group address and same | |
| // port. | |
| func TestIPv6MulticastListener(t *testing.T) { | |
| testenv.MustHaveExternalNetwork(t) | |
| switch runtime.GOOS { | |
| case "plan9": | |
| t.Skipf("not supported on %s", runtime.GOOS) | |
| } | |
| if !supportsIPv6() { | |
| t.Skip("IPv6 is not supported") | |
| } | |
| // On Windows, the test can be run by non-admin users. | |
| if runtime.GOOS != "windows" && os.Getuid() != 0 { | |
| t.Skip("must be root") | |
| } | |
| closer := func(cs []*UDPConn) { | |
| for _, c := range cs { | |
| if c != nil { | |
| c.Close() | |
| } | |
| } | |
| } | |
| for _, ifi := range []*Interface{loopbackInterface(), nil} { | |
| // Note that multicast interface assignment by system | |
| // is not recommended because it usually relies on | |
| // routing stuff for finding out an appropriate | |
| // nexthop containing both network and link layer | |
| // adjacencies. | |
| if ifi == nil && !*testIPv6 { | |
| continue | |
| } | |
| for _, tt := range ipv6MulticastListenerTests { | |
| var err error | |
| cs := make([]*UDPConn, 2) | |
| if cs[0], err = ListenMulticastUDP(tt.net, ifi, tt.gaddr); err != nil { | |
| t.Fatal(err) | |
| } | |
| if err := checkMulticastListener(cs[0], tt.gaddr.IP); err != nil { | |
| closer(cs) | |
| t.Fatal(err) | |
| } | |
| if cs[1], err = ListenMulticastUDP(tt.net, ifi, tt.gaddr); err != nil { | |
| closer(cs) | |
| t.Fatal(err) | |
| } | |
| if err := checkMulticastListener(cs[1], tt.gaddr.IP); err != nil { | |
| closer(cs) | |
| t.Fatal(err) | |
| } | |
| closer(cs) | |
| } | |
| } | |
| } | |
| func checkMulticastListener(c *UDPConn, ip IP) error { | |
| if ok, err := multicastRIBContains(ip); err != nil { | |
| return err | |
| } else if !ok { | |
| return fmt.Errorf("%s not found in multicast rib", ip.String()) | |
| } | |
| la := c.LocalAddr() | |
| if la, ok := la.(*UDPAddr); !ok || la.Port == 0 { | |
| return fmt.Errorf("got %v; want a proper address with non-zero port number", la) | |
| } | |
| return nil | |
| } | |
| func multicastRIBContains(ip IP) (bool, error) { | |
| switch runtime.GOOS { | |
| case "aix", "dragonfly", "netbsd", "openbsd", "plan9", "solaris", "illumos": | |
| return true, nil // not implemented yet | |
| case "linux": | |
| if runtime.GOARCH == "arm" || runtime.GOARCH == "alpha" { | |
| return true, nil // not implemented yet | |
| } | |
| } | |
| ift, err := Interfaces() | |
| if err != nil { | |
| return false, err | |
| } | |
| for _, ifi := range ift { | |
| ifmat, err := ifi.MulticastAddrs() | |
| if err != nil { | |
| return false, err | |
| } | |
| for _, ifma := range ifmat { | |
| if ifma.(*IPAddr).IP.Equal(ip) { | |
| return true, nil | |
| } | |
| } | |
| } | |
| return false, nil | |
| } | |
| // Issue 21856. | |
| func TestClosingListener(t *testing.T) { | |
| ln := newLocalListener(t, "tcp") | |
| addr := ln.Addr() | |
| go func() { | |
| for { | |
| c, err := ln.Accept() | |
| if err != nil { | |
| return | |
| } | |
| c.Close() | |
| } | |
| }() | |
| // Let the goroutine start. We don't sleep long: if the | |
| // goroutine doesn't start, the test will pass without really | |
| // testing anything, which is OK. | |
| time.Sleep(time.Millisecond) | |
| ln.Close() | |
| ln2, err := Listen("tcp", addr.String()) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| ln2.Close() | |
| } | |
| func TestListenConfigControl(t *testing.T) { | |
| switch runtime.GOOS { | |
| case "plan9": | |
| t.Skipf("not supported on %s", runtime.GOOS) | |
| } | |
| t.Run("StreamListen", func(t *testing.T) { | |
| for _, network := range []string{"tcp", "tcp4", "tcp6", "unix", "unixpacket"} { | |
| if !testableNetwork(network) { | |
| continue | |
| } | |
| ln := newLocalListener(t, network, &ListenConfig{Control: controlOnConnSetup}) | |
| ln.Close() | |
| } | |
| }) | |
| t.Run("PacketListen", func(t *testing.T) { | |
| for _, network := range []string{"udp", "udp4", "udp6", "unixgram"} { | |
| if !testableNetwork(network) { | |
| continue | |
| } | |
| c := newLocalPacketListener(t, network, &ListenConfig{Control: controlOnConnSetup}) | |
| c.Close() | |
| } | |
| }) | |
| } |