From 701d1ab638b23c24877fc41824add66232446676 Mon Sep 17 00:00:00 2001 From: Christopher Speller Date: Thu, 2 Feb 2017 09:32:00 -0500 Subject: Updating server dependancies (#5249) --- .../x/net/internal/netreflect/socket_test.go | 71 +---------- vendor/golang.org/x/net/internal/nettest/stack.go | 137 +++++++++++++++++---- 2 files changed, 121 insertions(+), 87 deletions(-) (limited to 'vendor/golang.org/x/net/internal') diff --git a/vendor/golang.org/x/net/internal/netreflect/socket_test.go b/vendor/golang.org/x/net/internal/netreflect/socket_test.go index 305665ac1..49b97ed54 100644 --- a/vendor/golang.org/x/net/internal/netreflect/socket_test.go +++ b/vendor/golang.org/x/net/internal/netreflect/socket_test.go @@ -5,76 +5,20 @@ package netreflect_test import ( - "fmt" - "io/ioutil" "net" "os" - "runtime" "testing" "golang.org/x/net/internal/netreflect" + "golang.org/x/net/internal/nettest" ) -func localPath() string { - f, err := ioutil.TempFile("", "netreflect") - if err != nil { - panic(err) - } - path := f.Name() - f.Close() - os.Remove(path) - return path -} - -func newLocalListener(network string) (net.Listener, error) { - switch network { - case "tcp": - if ln, err := net.Listen("tcp4", "127.0.0.1:0"); err == nil { - return ln, nil - } - return net.Listen("tcp6", "[::1]:0") - case "tcp4": - return net.Listen("tcp4", "127.0.0.1:0") - case "tcp6": - return net.Listen("tcp6", "[::1]:0") - case "unix", "unixpacket": - return net.Listen(network, localPath()) - } - return nil, fmt.Errorf("%s is not supported", network) -} - -func newLocalPacketListener(network string) (net.PacketConn, error) { - switch network { - case "udp": - if c, err := net.ListenPacket("udp4", "127.0.0.1:0"); err == nil { - return c, nil - } - return net.ListenPacket("udp6", "[::1]:0") - case "udp4": - return net.ListenPacket("udp4", "127.0.0.1:0") - case "udp6": - return net.ListenPacket("udp6", "[::1]:0") - case "unixgram": - return net.ListenPacket(network, localPath()) - } - return nil, fmt.Errorf("%s is not supported", network) -} - func TestSocketOf(t *testing.T) { for _, network := range []string{"tcp", "unix", "unixpacket"} { - switch runtime.GOOS { - case "darwin": - if network == "unixpacket" { - continue - } - case "nacl", "plan9": + if !nettest.TestableNetwork(network) { continue - case "windows": - if network == "unix" || network == "unixpacket" { - continue - } } - ln, err := newLocalListener(network) + ln, err := nettest.NewLocalListener(network) if err != nil { t.Error(err) continue @@ -101,15 +45,10 @@ func TestSocketOf(t *testing.T) { func TestPacketSocketOf(t *testing.T) { for _, network := range []string{"udp", "unixgram"} { - switch runtime.GOOS { - case "nacl", "plan9": + if !nettest.TestableNetwork(network) { continue - case "windows": - if network == "unixgram" { - continue - } } - c, err := newLocalPacketListener(network) + c, err := nettest.NewLocalPacketListener(network) if err != nil { t.Error(err) continue diff --git a/vendor/golang.org/x/net/internal/nettest/stack.go b/vendor/golang.org/x/net/internal/nettest/stack.go index 5ab95305d..cc92c035b 100644 --- a/vendor/golang.org/x/net/internal/nettest/stack.go +++ b/vendor/golang.org/x/net/internal/nettest/stack.go @@ -2,35 +2,40 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// Package nettest provides utilities for IP testing. +// Package nettest provides utilities for network testing. package nettest // import "golang.org/x/net/internal/nettest" -import "net" +import ( + "fmt" + "io/ioutil" + "net" + "os" + "runtime" +) -// SupportsIPv4 reports whether the platform supports IPv4 networking -// functionality. -func SupportsIPv4() bool { - ln, err := net.Listen("tcp4", "127.0.0.1:0") - if err != nil { - return false +var ( + supportsIPv4 bool + supportsIPv6 bool +) + +func init() { + if ln, err := net.Listen("tcp4", "127.0.0.1:0"); err == nil { + ln.Close() + supportsIPv4 = true + } + if ln, err := net.Listen("tcp6", "[::1]:0"); err == nil { + ln.Close() + supportsIPv6 = true } - ln.Close() - return true } +// SupportsIPv4 reports whether the platform supports IPv4 networking +// functionality. +func SupportsIPv4() bool { return supportsIPv4 } + // SupportsIPv6 reports whether the platform supports IPv6 networking // functionality. -func SupportsIPv6() bool { - if causesIPv6Crash() { - return false - } - ln, err := net.Listen("tcp6", "[::1]:0") - if err != nil { - return false - } - ln.Close() - return true -} +func SupportsIPv6() bool { return supportsIPv6 } // SupportsRawIPSocket reports whether the platform supports raw IP // sockets. @@ -50,3 +55,93 @@ func SupportsIPv6MulticastDeliveryOnLoopback() bool { func ProtocolNotSupported(err error) bool { return protocolNotSupported(err) } + +// TestableNetwork reports whether network is testable on the current +// platform configuration. +func TestableNetwork(network string) bool { + // This is based on logic from standard library's + // net/platform_test.go. + switch network { + case "unix", "unixgram": + switch runtime.GOOS { + case "android", "nacl", "plan9", "windows": + return false + } + if runtime.GOOS == "darwin" && (runtime.GOARCH == "arm" || runtime.GOARCH == "arm64") { + return false + } + case "unixpacket": + switch runtime.GOOS { + case "android", "darwin", "freebsd", "nacl", "plan9", "windows": + return false + } + } + return true +} + +// NewLocalListener returns a listener which listens to a loopback IP +// address or local file system path. +// Network must be "tcp", "tcp4", "tcp6", "unix" or "unixpacket". +func NewLocalListener(network string) (net.Listener, error) { + switch network { + case "tcp": + if supportsIPv4 { + if ln, err := net.Listen("tcp4", "127.0.0.1:0"); err == nil { + return ln, nil + } + } + if supportsIPv6 { + return net.Listen("tcp6", "[::1]:0") + } + case "tcp4": + if supportsIPv4 { + return net.Listen("tcp4", "127.0.0.1:0") + } + case "tcp6": + if supportsIPv6 { + return net.Listen("tcp6", "[::1]:0") + } + case "unix", "unixpacket": + return net.Listen(network, localPath()) + } + return nil, fmt.Errorf("%s is not supported", network) +} + +// NewLocalPacketListener returns a packet listener which listens to a +// loopback IP address or local file system path. +// Network must be "udp", "udp4", "udp6" or "unixgram". +func NewLocalPacketListener(network string) (net.PacketConn, error) { + switch network { + case "udp": + if supportsIPv4 { + if c, err := net.ListenPacket("udp4", "127.0.0.1:0"); err == nil { + return c, nil + } + } + if supportsIPv6 { + return net.ListenPacket("udp6", "[::1]:0") + } + case "udp4": + if supportsIPv4 { + return net.ListenPacket("udp4", "127.0.0.1:0") + } + case "udp6": + if supportsIPv6 { + return net.ListenPacket("udp6", "[::1]:0") + } + case "unixgram": + return net.ListenPacket(network, localPath()) + } + return nil, fmt.Errorf("%s is not supported", network) +} + +func localPath() string { + f, err := ioutil.TempFile("", "nettest") + if err != nil { + panic(err) + } + path := f.Name() + f.Close() + os.Remove(path) + return path +} -- cgit v1.2.3-1-g7c22