1// Copyright 2009 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris windows
6
7package net
8
9import (
10	"context"
11	"io"
12	"os"
13	"syscall"
14)
15
16func sockaddrToTCP(sa syscall.Sockaddr) Addr {
17	switch sa := sa.(type) {
18	case *syscall.SockaddrInet4:
19		return &TCPAddr{IP: sa.Addr[0:], Port: sa.Port}
20	case *syscall.SockaddrInet6:
21		return &TCPAddr{IP: sa.Addr[0:], Port: sa.Port, Zone: zoneCache.name(int(sa.ZoneId))}
22	}
23	return nil
24}
25
26func (a *TCPAddr) family() int {
27	if a == nil || len(a.IP) <= IPv4len {
28		return syscall.AF_INET
29	}
30	if a.IP.To4() != nil {
31		return syscall.AF_INET
32	}
33	return syscall.AF_INET6
34}
35
36func (a *TCPAddr) sockaddr(family int) (syscall.Sockaddr, error) {
37	if a == nil {
38		return nil, nil
39	}
40	return ipToSockaddr(family, a.IP, a.Port, a.Zone)
41}
42
43func (a *TCPAddr) toLocal(net string) sockaddr {
44	return &TCPAddr{loopbackIP(net), a.Port, a.Zone}
45}
46
47func (c *TCPConn) readFrom(r io.Reader) (int64, error) {
48	if n, err, handled := sendFile(c.fd, r); handled {
49		return n, err
50	}
51	return genericReadFrom(c, r)
52}
53
54func dialTCP(ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error) {
55	if testHookDialTCP != nil {
56		return testHookDialTCP(ctx, net, laddr, raddr)
57	}
58	return doDialTCP(ctx, net, laddr, raddr)
59}
60
61func doDialTCP(ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error) {
62	fd, err := internetSocket(ctx, net, laddr, raddr, syscall.SOCK_STREAM, 0, "dial")
63
64	// TCP has a rarely used mechanism called a 'simultaneous connection' in
65	// which Dial("tcp", addr1, addr2) run on the machine at addr1 can
66	// connect to a simultaneous Dial("tcp", addr2, addr1) run on the machine
67	// at addr2, without either machine executing Listen. If laddr == nil,
68	// it means we want the kernel to pick an appropriate originating local
69	// address. Some Linux kernels cycle blindly through a fixed range of
70	// local ports, regardless of destination port. If a kernel happens to
71	// pick local port 50001 as the source for a Dial("tcp", "", "localhost:50001"),
72	// then the Dial will succeed, having simultaneously connected to itself.
73	// This can only happen when we are letting the kernel pick a port (laddr == nil)
74	// and when there is no listener for the destination address.
75	// It's hard to argue this is anything other than a kernel bug. If we
76	// see this happen, rather than expose the buggy effect to users, we
77	// close the fd and try again. If it happens twice more, we relent and
78	// use the result. See also:
79	//	https://golang.org/issue/2690
80	//	http://stackoverflow.com/questions/4949858/
81	//
82	// The opposite can also happen: if we ask the kernel to pick an appropriate
83	// originating local address, sometimes it picks one that is already in use.
84	// So if the error is EADDRNOTAVAIL, we have to try again too, just for
85	// a different reason.
86	//
87	// The kernel socket code is no doubt enjoying watching us squirm.
88	for i := 0; i < 2 && (laddr == nil || laddr.Port == 0) && (selfConnect(fd, err) || spuriousENOTAVAIL(err)); i++ {
89		if err == nil {
90			fd.Close()
91		}
92		fd, err = internetSocket(ctx, net, laddr, raddr, syscall.SOCK_STREAM, 0, "dial")
93	}
94
95	if err != nil {
96		return nil, err
97	}
98	return newTCPConn(fd), nil
99}
100
101func selfConnect(fd *netFD, err error) bool {
102	// If the connect failed, we clearly didn't connect to ourselves.
103	if err != nil {
104		return false
105	}
106
107	// The socket constructor can return an fd with raddr nil under certain
108	// unknown conditions. The errors in the calls there to Getpeername
109	// are discarded, but we can't catch the problem there because those
110	// calls are sometimes legally erroneous with a "socket not connected".
111	// Since this code (selfConnect) is already trying to work around
112	// a problem, we make sure if this happens we recognize trouble and
113	// ask the DialTCP routine to try again.
114	// TODO: try to understand what's really going on.
115	if fd.laddr == nil || fd.raddr == nil {
116		return true
117	}
118	l := fd.laddr.(*TCPAddr)
119	r := fd.raddr.(*TCPAddr)
120	return l.Port == r.Port && l.IP.Equal(r.IP)
121}
122
123func spuriousENOTAVAIL(err error) bool {
124	if op, ok := err.(*OpError); ok {
125		err = op.Err
126	}
127	if sys, ok := err.(*os.SyscallError); ok {
128		err = sys.Err
129	}
130	return err == syscall.EADDRNOTAVAIL
131}
132
133func (ln *TCPListener) ok() bool { return ln != nil && ln.fd != nil }
134
135func (ln *TCPListener) accept() (*TCPConn, error) {
136	fd, err := ln.fd.accept()
137	if err != nil {
138		return nil, err
139	}
140	return newTCPConn(fd), nil
141}
142
143func (ln *TCPListener) close() error {
144	return ln.fd.Close()
145}
146
147func (ln *TCPListener) file() (*os.File, error) {
148	f, err := ln.fd.dup()
149	if err != nil {
150		return nil, err
151	}
152	return f, nil
153}
154
155func listenTCP(ctx context.Context, network string, laddr *TCPAddr) (*TCPListener, error) {
156	fd, err := internetSocket(ctx, network, laddr, nil, syscall.SOCK_STREAM, 0, "listen")
157	if err != nil {
158		return nil, err
159	}
160	return &TCPListener{fd}, nil
161}
162