2012-01-13 06:11:45 +01:00
|
|
|
// 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.
|
|
|
|
|
|
|
|
package net
|
|
|
|
|
|
|
|
import (
|
2012-03-06 18:57:23 +01:00
|
|
|
"flag"
|
2012-03-30 23:27:11 +02:00
|
|
|
"fmt"
|
2012-11-21 08:03:38 +01:00
|
|
|
"io"
|
|
|
|
"os"
|
2012-03-06 18:57:23 +01:00
|
|
|
"regexp"
|
2012-01-13 06:11:45 +01:00
|
|
|
"runtime"
|
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
|
|
|
func newLocalListener(t *testing.T) Listener {
|
|
|
|
ln, err := Listen("tcp", "127.0.0.1:0")
|
|
|
|
if err != nil {
|
|
|
|
ln, err = Listen("tcp6", "[::1]:0")
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
return ln
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDialTimeout(t *testing.T) {
|
|
|
|
ln := newLocalListener(t)
|
|
|
|
defer ln.Close()
|
|
|
|
|
|
|
|
errc := make(chan error)
|
|
|
|
|
2012-03-02 17:38:43 +01:00
|
|
|
numConns := listenerBacklog + 10
|
2012-01-13 06:11:45 +01:00
|
|
|
|
|
|
|
// TODO(bradfitz): It's hard to test this in a portable
|
2012-03-30 23:27:11 +02:00
|
|
|
// way. This is unfortunate, but works for now.
|
2012-01-13 06:11:45 +01:00
|
|
|
switch runtime.GOOS {
|
|
|
|
case "linux":
|
|
|
|
// The kernel will start accepting TCP connections before userspace
|
|
|
|
// gets a chance to not accept them, so fire off a bunch to fill up
|
|
|
|
// the kernel's backlog. Then we test we get a failure after that.
|
|
|
|
for i := 0; i < numConns; i++ {
|
|
|
|
go func() {
|
|
|
|
_, err := DialTimeout("tcp", ln.Addr().String(), 200*time.Millisecond)
|
|
|
|
errc <- err
|
|
|
|
}()
|
|
|
|
}
|
2012-03-30 23:27:11 +02:00
|
|
|
case "darwin", "windows":
|
2012-01-13 06:11:45 +01:00
|
|
|
// At least OS X 10.7 seems to accept any number of
|
|
|
|
// connections, ignoring listen's backlog, so resort
|
|
|
|
// to connecting to a hopefully-dead 127/8 address.
|
2012-02-09 09:19:58 +01:00
|
|
|
// Same for windows.
|
2012-03-30 23:27:11 +02:00
|
|
|
//
|
|
|
|
// Use an IANA reserved port (49151) instead of 80, because
|
|
|
|
// on our 386 builder, this Dial succeeds, connecting
|
|
|
|
// to an IIS web server somewhere. The data center
|
|
|
|
// or VM or firewall must be stealing the TCP connection.
|
2012-11-21 08:03:38 +01:00
|
|
|
//
|
2012-03-30 23:27:11 +02:00
|
|
|
// IANA Service Name and Transport Protocol Port Number Registry
|
|
|
|
// <http://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xml>
|
2012-01-13 06:11:45 +01:00
|
|
|
go func() {
|
2012-03-30 23:27:11 +02:00
|
|
|
c, err := DialTimeout("tcp", "127.0.71.111:49151", 200*time.Millisecond)
|
|
|
|
if err == nil {
|
|
|
|
err = fmt.Errorf("unexpected: connected to %s!", c.RemoteAddr())
|
|
|
|
c.Close()
|
|
|
|
}
|
2012-01-13 06:11:45 +01:00
|
|
|
errc <- err
|
|
|
|
}()
|
|
|
|
default:
|
2012-02-09 09:19:58 +01:00
|
|
|
// TODO(bradfitz):
|
2012-03-02 17:38:43 +01:00
|
|
|
// OpenBSD may have a reject route to 127/8 except 127.0.0.1/32
|
|
|
|
// by default. FreeBSD likely works, but is untested.
|
|
|
|
// TODO(rsc):
|
|
|
|
// The timeout never happens on Windows. Why? Issue 3016.
|
2013-01-29 21:52:43 +01:00
|
|
|
t.Skipf("skipping test on %q; untested.", runtime.GOOS)
|
2012-01-13 06:11:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
connected := 0
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-time.After(15 * time.Second):
|
|
|
|
t.Fatal("too slow")
|
|
|
|
case err := <-errc:
|
|
|
|
if err == nil {
|
|
|
|
connected++
|
|
|
|
if connected == numConns {
|
|
|
|
t.Fatal("all connections connected; expected some to time out")
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
terr, ok := err.(timeout)
|
|
|
|
if !ok {
|
|
|
|
t.Fatalf("got error %q; want error with timeout interface", err)
|
|
|
|
}
|
|
|
|
if !terr.Timeout() {
|
|
|
|
t.Fatalf("got error %q; not a timeout", err)
|
|
|
|
}
|
|
|
|
// Pass. We saw a timeout error.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-03-02 17:38:43 +01:00
|
|
|
|
|
|
|
func TestSelfConnect(t *testing.T) {
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
// TODO(brainman): do not know why it hangs.
|
2013-01-29 21:52:43 +01:00
|
|
|
t.Skip("skipping known-broken test on windows")
|
2012-03-02 17:38:43 +01:00
|
|
|
}
|
|
|
|
// Test that Dial does not honor self-connects.
|
|
|
|
// See the comment in DialTCP.
|
|
|
|
|
|
|
|
// Find a port that would be used as a local address.
|
|
|
|
l, err := Listen("tcp", "127.0.0.1:0")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
c, err := Dial("tcp", l.Addr().String())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
addr := c.LocalAddr().String()
|
|
|
|
c.Close()
|
|
|
|
l.Close()
|
|
|
|
|
|
|
|
// Try to connect to that address repeatedly.
|
|
|
|
n := 100000
|
|
|
|
if testing.Short() {
|
|
|
|
n = 1000
|
|
|
|
}
|
|
|
|
switch runtime.GOOS {
|
2012-10-23 06:31:11 +02:00
|
|
|
case "darwin", "freebsd", "netbsd", "openbsd", "plan9", "solaris", "windows":
|
2012-03-02 17:38:43 +01:00
|
|
|
// Non-Linux systems take a long time to figure
|
|
|
|
// out that there is nothing listening on localhost.
|
|
|
|
n = 100
|
|
|
|
}
|
|
|
|
for i := 0; i < n; i++ {
|
|
|
|
c, err := Dial("tcp", addr)
|
|
|
|
if err == nil {
|
|
|
|
c.Close()
|
|
|
|
t.Errorf("#%d: Dial %q succeeded", i, addr)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-03-06 18:57:23 +01:00
|
|
|
|
|
|
|
var runErrorTest = flag.Bool("run_error_test", false, "let TestDialError check for dns errors")
|
|
|
|
|
|
|
|
type DialErrorTest struct {
|
|
|
|
Net string
|
|
|
|
Raddr string
|
|
|
|
Pattern string
|
|
|
|
}
|
|
|
|
|
|
|
|
var dialErrorTests = []DialErrorTest{
|
|
|
|
{
|
|
|
|
"datakit", "mh/astro/r70",
|
|
|
|
"dial datakit mh/astro/r70: unknown network datakit",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"tcp", "127.0.0.1:☺",
|
|
|
|
"dial tcp 127.0.0.1:☺: unknown port tcp/☺",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"tcp", "no-such-name.google.com.:80",
|
|
|
|
"dial tcp no-such-name.google.com.:80: lookup no-such-name.google.com.( on .*)?: no (.*)",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"tcp", "no-such-name.no-such-top-level-domain.:80",
|
|
|
|
"dial tcp no-such-name.no-such-top-level-domain.:80: lookup no-such-name.no-such-top-level-domain.( on .*)?: no (.*)",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"tcp", "no-such-name:80",
|
|
|
|
`dial tcp no-such-name:80: lookup no-such-name\.(.*\.)?( on .*)?: no (.*)`,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"tcp", "mh/astro/r70:http",
|
|
|
|
"dial tcp mh/astro/r70:http: lookup mh/astro/r70: invalid domain name",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"unix", "/etc/file-not-found",
|
|
|
|
"dial unix /etc/file-not-found: no such file or directory",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"unix", "/etc/",
|
|
|
|
"dial unix /etc/: (permission denied|socket operation on non-socket|connection refused)",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"unixpacket", "/etc/file-not-found",
|
|
|
|
"dial unixpacket /etc/file-not-found: no such file or directory",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"unixpacket", "/etc/",
|
|
|
|
"dial unixpacket /etc/: (permission denied|socket operation on non-socket|connection refused)",
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
var duplicateErrorPattern = `dial (.*) dial (.*)`
|
|
|
|
|
|
|
|
func TestDialError(t *testing.T) {
|
|
|
|
if !*runErrorTest {
|
|
|
|
t.Logf("test disabled; use -run_error_test to enable")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
for i, tt := range dialErrorTests {
|
|
|
|
c, err := Dial(tt.Net, tt.Raddr)
|
|
|
|
if c != nil {
|
|
|
|
c.Close()
|
|
|
|
}
|
|
|
|
if err == nil {
|
|
|
|
t.Errorf("#%d: nil error, want match for %#q", i, tt.Pattern)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
s := err.Error()
|
|
|
|
match, _ := regexp.MatchString(tt.Pattern, s)
|
|
|
|
if !match {
|
|
|
|
t.Errorf("#%d: %q, want match for %#q", i, s, tt.Pattern)
|
|
|
|
}
|
|
|
|
match, _ = regexp.MatchString(duplicateErrorPattern, s)
|
|
|
|
if match {
|
|
|
|
t.Errorf("#%d: %q, duplicate error return from Dial", i, s)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-11-21 08:03:38 +01:00
|
|
|
|
|
|
|
func TestDialTimeoutFDLeak(t *testing.T) {
|
|
|
|
if runtime.GOOS != "linux" {
|
|
|
|
// TODO(bradfitz): test on other platforms
|
2013-01-29 21:52:43 +01:00
|
|
|
t.Skipf("skipping test on %q", runtime.GOOS)
|
2012-11-21 08:03:38 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ln := newLocalListener(t)
|
|
|
|
defer ln.Close()
|
|
|
|
|
|
|
|
type connErr struct {
|
|
|
|
conn Conn
|
|
|
|
err error
|
|
|
|
}
|
|
|
|
dials := listenerBacklog + 100
|
2012-12-22 02:15:33 +01:00
|
|
|
// used to be listenerBacklog + 5, but was found to be unreliable, issue 4384.
|
|
|
|
maxGoodConnect := listenerBacklog + runtime.NumCPU()*10
|
2012-11-21 08:03:38 +01:00
|
|
|
resc := make(chan connErr)
|
|
|
|
for i := 0; i < dials; i++ {
|
|
|
|
go func() {
|
|
|
|
conn, err := DialTimeout("tcp", ln.Addr().String(), 500*time.Millisecond)
|
|
|
|
resc <- connErr{conn, err}
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
|
|
|
var firstErr string
|
|
|
|
var ngood int
|
|
|
|
var toClose []io.Closer
|
|
|
|
for i := 0; i < dials; i++ {
|
|
|
|
ce := <-resc
|
|
|
|
if ce.err == nil {
|
|
|
|
ngood++
|
|
|
|
if ngood > maxGoodConnect {
|
|
|
|
t.Errorf("%d good connects; expected at most %d", ngood, maxGoodConnect)
|
|
|
|
}
|
|
|
|
toClose = append(toClose, ce.conn)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
err := ce.err
|
|
|
|
if firstErr == "" {
|
|
|
|
firstErr = err.Error()
|
|
|
|
} else if err.Error() != firstErr {
|
|
|
|
t.Fatalf("inconsistent error messages: first was %q, then later %q", firstErr, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for _, c := range toClose {
|
|
|
|
c.Close()
|
|
|
|
}
|
|
|
|
for i := 0; i < 100; i++ {
|
|
|
|
if got := numFD(); got < dials {
|
|
|
|
// Test passes.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
time.Sleep(10 * time.Millisecond)
|
|
|
|
}
|
|
|
|
if got := numFD(); got >= dials {
|
|
|
|
t.Errorf("num fds after %d timeouts = %d; want <%d", dials, got, dials)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func numFD() int {
|
|
|
|
if runtime.GOOS == "linux" {
|
|
|
|
f, err := os.Open("/proc/self/fd")
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
defer f.Close()
|
|
|
|
names, err := f.Readdirnames(0)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
return len(names)
|
|
|
|
}
|
|
|
|
// All tests using this should be skipped anyway, but:
|
|
|
|
panic("numFDs not implemented on " + runtime.GOOS)
|
|
|
|
}
|