Source file
src/net/listen_test.go
Documentation: net
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"},
}
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"},
}
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
network2, address2 string
xerr error
}{
{"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},
}
func TestDualStackTCPListener(t *testing.T) {
switch runtime.GOOS {
case "nacl", "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
network2, address2 string
xerr error
}{
{"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},
}
func TestDualStackUDPListener(t *testing.T) {
switch runtime.GOOS {
case "nacl", "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 interface{}) 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 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 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
}{
{"udp", &UDPAddr{IP: IPv4(224, 0, 0, 254), Port: 12345}},
{"udp4", &UDPAddr{IP: IPv4(224, 0, 0, 254), Port: 12345}},
}
func TestIPv4MulticastListener(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
switch runtime.GOOS {
case "android", "nacl", "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
case "solaris":
t.Skipf("not supported on solaris, see golang.org/issue/7399")
}
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} {
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
}{
{"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}},
}
func TestIPv6MulticastListener(t *testing.T) {
testenv.MustHaveExternalNetwork(t)
switch runtime.GOOS {
case "plan9":
t.Skipf("not supported on %s", runtime.GOOS)
case "solaris":
t.Skipf("not supported on solaris, see issue 7399")
}
if !supportsIPv6() {
t.Skip("IPv6 is not supported")
}
if 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} {
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 "dragonfly", "netbsd", "openbsd", "plan9", "solaris", "windows":
return true, nil
case "linux":
if runtime.GOARCH == "arm" || runtime.GOARCH == "alpha" {
return true, nil
}
}
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
}
func TestClosingListener(t *testing.T) {
ln, err := newLocalListener("tcp")
if err != nil {
t.Fatal(err)
}
addr := ln.Addr()
go func() {
for {
c, err := ln.Accept()
if err != nil {
return
}
c.Close()
}
}()
time.Sleep(time.Millisecond)
ln.Close()
ln2, err := Listen("tcp", addr.String())
if err != nil {
t.Fatal(err)
}
ln2.Close()
}
View as plain text