1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
// Copyright 2015 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 (
"internal/testenv"
"os"
"os/exec"
"runtime"
"strconv"
"strings"
"testing"
)
var unixEnabledOnAIX bool
func init() {
if runtime.GOOS == "aix" {
// Unix network isn't properly working on AIX 7.2 with
// Technical Level < 2.
// The information is retrieved only once in this init()
// instead of everytime testableNetwork is called.
out, _ := exec.Command("oslevel", "-s").Output()
if len(out) >= len("7200-XX-ZZ-YYMM") { // AIX 7.2, Tech Level XX, Service Pack ZZ, date YYMM
aixVer := string(out[:4])
tl, _ := strconv.Atoi(string(out[5:7]))
unixEnabledOnAIX = aixVer > "7200" || (aixVer == "7200" && tl >= 2)
}
}
}
// testableNetwork reports whether network is testable on the current
// platform configuration.
func testableNetwork(network string) bool {
ss := strings.Split(network, ":")
switch ss[0] {
case "ip+nopriv":
case "ip", "ip4", "ip6":
switch runtime.GOOS {
case "plan9":
return false
default:
if os.Getuid() != 0 {
return false
}
}
case "unix", "unixgram":
switch runtime.GOOS {
case "android", "plan9", "windows":
return false
case "aix":
return unixEnabledOnAIX
}
// iOS does not support unix, unixgram.
if iOS() {
return false
}
case "unixpacket":
switch runtime.GOOS {
case "aix", "android", "darwin", "ios", "plan9", "windows":
return false
case "netbsd":
// It passes on amd64 at least. 386 fails (Issue 22927). arm is unknown.
if runtime.GOARCH == "386" {
return false
}
}
}
switch ss[0] {
case "tcp4", "udp4", "ip4":
if !supportsIPv4() {
return false
}
case "tcp6", "udp6", "ip6":
if !supportsIPv6() {
return false
}
}
return true
}
func iOS() bool {
return runtime.GOOS == "ios"
}
// testableAddress reports whether address of network is testable on
// the current platform configuration.
func testableAddress(network, address string) bool {
switch ss := strings.Split(network, ":"); ss[0] {
case "unix", "unixgram", "unixpacket":
// Abstract unix domain sockets, a Linux-ism.
if address[0] == '@' && runtime.GOOS != "linux" {
return false
}
}
return true
}
// testableListenArgs reports whether arguments are testable on the
// current platform configuration.
func testableListenArgs(network, address, client string) bool {
if !testableNetwork(network) || !testableAddress(network, address) {
return false
}
var err error
var addr Addr
switch ss := strings.Split(network, ":"); ss[0] {
case "tcp", "tcp4", "tcp6":
addr, err = ResolveTCPAddr("tcp", address)
case "udp", "udp4", "udp6":
addr, err = ResolveUDPAddr("udp", address)
case "ip", "ip4", "ip6":
addr, err = ResolveIPAddr("ip", address)
default:
return true
}
if err != nil {
return false
}
var ip IP
var wildcard bool
switch addr := addr.(type) {
case *TCPAddr:
ip = addr.IP
wildcard = addr.isWildcard()
case *UDPAddr:
ip = addr.IP
wildcard = addr.isWildcard()
case *IPAddr:
ip = addr.IP
wildcard = addr.isWildcard()
}
// Test wildcard IP addresses.
if wildcard && !testenv.HasExternalNetwork() {
return false
}
// Test functionality of IPv4 communication using AF_INET and
// IPv6 communication using AF_INET6 sockets.
if !supportsIPv4() && ip.To4() != nil {
return false
}
if !supportsIPv6() && ip.To16() != nil && ip.To4() == nil {
return false
}
cip := ParseIP(client)
if cip != nil {
if !supportsIPv4() && cip.To4() != nil {
return false
}
if !supportsIPv6() && cip.To16() != nil && cip.To4() == nil {
return false
}
}
// Test functionality of IPv4 communication using AF_INET6
// sockets.
if !supportsIPv4map() && supportsIPv4() && (network == "tcp" || network == "udp" || network == "ip") && wildcard {
// At this point, we prefer IPv4 when ip is nil.
// See favoriteAddrFamily for further information.
if ip.To16() != nil && ip.To4() == nil && cip.To4() != nil { // a pair of IPv6 server and IPv4 client
return false
}
if (ip.To4() != nil || ip == nil) && cip.To16() != nil && cip.To4() == nil { // a pair of IPv4 server and IPv6 client
return false
}
}
return true
}
func condFatalf(t *testing.T, network string, format string, args ...interface{}) {
t.Helper()
// A few APIs like File and Read/WriteMsg{UDP,IP} are not
// fully implemented yet on Plan 9 and Windows.
switch runtime.GOOS {
case "windows":
if network == "file+net" {
t.Logf(format, args...)
return
}
case "plan9":
t.Logf(format, args...)
return
}
t.Fatalf(format, args...)
}
|
