libgo/go/net/tcpsock_posix.go

   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 freebsd linux netbsd openbsd windows
   6
   7 // TCP sockets
   8
   9 package net
  10
  11 import (
  12         "io"
  13         "os"
  14         "syscall"
  15         "time"
  16 )
  17
  18 // BUG(rsc): On OpenBSD, listening on the "tcp" network does not listen for
  19 // both IPv4 and IPv6 connections. This is due to the fact that IPv4 traffic
  20 // will not be routed to an IPv6 socket - two separate sockets are required
  21 // if both AFs are to be supported. See inet6(4) on OpenBSD for details.
  22
  23 func sockaddrToTCP(sa syscall.Sockaddr) Addr {
  24         switch sa := sa.(type) {
  25         case *syscall.SockaddrInet4:
  26                 return &TCPAddr{sa.Addr[0:], sa.Port}
  27         case *syscall.SockaddrInet6:
  28                 return &TCPAddr{sa.Addr[0:], sa.Port}
  29         default:
  30                 if sa != nil {
  31                         // Diagnose when we will turn a non-nil sockaddr into a nil.
  32                         panic("unexpected type in sockaddrToTCP")
  33                 }
  34         }
  35         return nil
  36 }
  37
  38 func (a *TCPAddr) family() int {
  39         if a == nil || len(a.IP) <= IPv4len {
  40                 return syscall.AF_INET
  41         }
  42         if a.IP.To4() != nil {
  43                 return syscall.AF_INET
  44         }
  45         return syscall.AF_INET6
  46 }
  47
  48 func (a *TCPAddr) isWildcard() bool {
  49         if a == nil || a.IP == nil {
  50                 return true
  51         }
  52         return a.IP.IsUnspecified()
  53 }
  54
  55 func (a *TCPAddr) sockaddr(family int) (syscall.Sockaddr, error) {
  56         return ipToSockaddr(family, a.IP, a.Port)
  57 }
  58
  59 func (a *TCPAddr) toAddr() sockaddr {
  60         if a == nil { // nil *TCPAddr
  61                 return nil // nil interface
  62         }
  63         return a
  64 }
  65
  66 // TCPConn is an implementation of the Conn interface
  67 // for TCP network connections.
  68 type TCPConn struct {
  69         fd *netFD
  70 }
  71
  72 func newTCPConn(fd *netFD) *TCPConn {
  73         c := &TCPConn{fd}
  74         c.SetNoDelay(true)
  75         return c
  76 }
  77
  78 func (c *TCPConn) ok() bool { return c != nil && c.fd != nil }
  79
  80 // Implementation of the Conn interface - see Conn for documentation.
  81
  82 // Read implements the Conn Read method.
  83 func (c *TCPConn) Read(b []byte) (n int, err error) {
  84         if !c.ok() {
  85                 return 0, syscall.EINVAL
  86         }
  87         return c.fd.Read(b)
  88 }
  89
  90 // ReadFrom implements the io.ReaderFrom ReadFrom method.
  91 func (c *TCPConn) ReadFrom(r io.Reader) (int64, error) {
  92         if n, err, handled := sendFile(c.fd, r); handled {
  93                 return n, err
  94         }
  95         return genericReadFrom(c, r)
  96 }
  97
  98 // Write implements the Conn Write method.
  99 func (c *TCPConn) Write(b []byte) (n int, err error) {
 100         if !c.ok() {
 101                 return 0, syscall.EINVAL
 102         }
 103         return c.fd.Write(b)
 104 }
 105
 106 // Close closes the TCP connection.
 107 func (c *TCPConn) Close() error {
 108         if !c.ok() {
 109                 return syscall.EINVAL
 110         }
 111         return c.fd.Close()
 112 }
 113
 114 // CloseRead shuts down the reading side of the TCP connection.
 115 // Most callers should just use Close.
 116 func (c *TCPConn) CloseRead() error {
 117         if !c.ok() {
 118                 return syscall.EINVAL
 119         }
 120         return c.fd.CloseRead()
 121 }
 122
 123 // CloseWrite shuts down the writing side of the TCP connection.
 124 // Most callers should just use Close.
 125 func (c *TCPConn) CloseWrite() error {
 126         if !c.ok() {
 127                 return syscall.EINVAL
 128         }
 129         return c.fd.CloseWrite()
 130 }
 131
 132 // LocalAddr returns the local network address, a *TCPAddr.
 133 func (c *TCPConn) LocalAddr() Addr {
 134         if !c.ok() {
 135                 return nil
 136         }
 137         return c.fd.laddr
 138 }
 139
 140 // RemoteAddr returns the remote network address, a *TCPAddr.
 141 func (c *TCPConn) RemoteAddr() Addr {
 142         if !c.ok() {
 143                 return nil
 144         }
 145         return c.fd.raddr
 146 }
 147
 148 // SetDeadline implements the Conn SetDeadline method.
 149 func (c *TCPConn) SetDeadline(t time.Time) error {
 150         if !c.ok() {
 151                 return syscall.EINVAL
 152         }
 153         return setDeadline(c.fd, t)
 154 }
 155
 156 // SetReadDeadline implements the Conn SetReadDeadline method.
 157 func (c *TCPConn) SetReadDeadline(t time.Time) error {
 158         if !c.ok() {
 159                 return syscall.EINVAL
 160         }
 161         return setReadDeadline(c.fd, t)
 162 }
 163
 164 // SetWriteDeadline implements the Conn SetWriteDeadline method.
 165 func (c *TCPConn) SetWriteDeadline(t time.Time) error {
 166         if !c.ok() {
 167                 return syscall.EINVAL
 168         }
 169         return setWriteDeadline(c.fd, t)
 170 }
 171
 172 // SetReadBuffer sets the size of the operating system's
 173 // receive buffer associated with the connection.
 174 func (c *TCPConn) SetReadBuffer(bytes int) error {
 175         if !c.ok() {
 176                 return syscall.EINVAL
 177         }
 178         return setReadBuffer(c.fd, bytes)
 179 }
 180
 181 // SetWriteBuffer sets the size of the operating system's
 182 // transmit buffer associated with the connection.
 183 func (c *TCPConn) SetWriteBuffer(bytes int) error {
 184         if !c.ok() {
 185                 return syscall.EINVAL
 186         }
 187         return setWriteBuffer(c.fd, bytes)
 188 }
 189
 190 // SetLinger sets the behavior of Close() on a connection
 191 // which still has data waiting to be sent or to be acknowledged.
 192 //
 193 // If sec < 0 (the default), Close returns immediately and
 194 // the operating system finishes sending the data in the background.
 195 //
 196 // If sec == 0, Close returns immediately and the operating system
 197 // discards any unsent or unacknowledged data.
 198 //
 199 // If sec > 0, Close blocks for at most sec seconds waiting for
 200 // data to be sent and acknowledged.
 201 func (c *TCPConn) SetLinger(sec int) error {
 202         if !c.ok() {
 203                 return syscall.EINVAL
 204         }
 205         return setLinger(c.fd, sec)
 206 }
 207
 208 // SetKeepAlive sets whether the operating system should send
 209 // keepalive messages on the connection.
 210 func (c *TCPConn) SetKeepAlive(keepalive bool) error {
 211         if !c.ok() {
 212                 return syscall.EINVAL
 213         }
 214         return setKeepAlive(c.fd, keepalive)
 215 }
 216
 217 // SetNoDelay controls whether the operating system should delay
 218 // packet transmission in hopes of sending fewer packets
 219 // (Nagle's algorithm).  The default is true (no delay), meaning
 220 // that data is sent as soon as possible after a Write.
 221 func (c *TCPConn) SetNoDelay(noDelay bool) error {
 222         if !c.ok() {
 223                 return syscall.EINVAL
 224         }
 225         return setNoDelay(c.fd, noDelay)
 226 }
 227
 228 // File returns a copy of the underlying os.File, set to blocking mode.
 229 // It is the caller's responsibility to close f when finished.
 230 // Closing c does not affect f, and closing f does not affect c.
 231 func (c *TCPConn) File() (f *os.File, err error) { return c.fd.dup() }
 232
 233 // DialTCP connects to the remote address raddr on the network net,
 234 // which must be "tcp", "tcp4", or "tcp6".  If laddr is not nil, it is used
 235 // as the local address for the connection.
 236 func DialTCP(net string, laddr, raddr *TCPAddr) (*TCPConn, error) {
 237         if raddr == nil {
 238                 return nil, &OpError{"dial", net, nil, errMissingAddress}
 239         }
 240
 241         fd, err := internetSocket(net, laddr.toAddr(), raddr.toAddr(), syscall.SOCK_STREAM, 0, "dial", sockaddrToTCP)
 242
 243         // TCP has a rarely used mechanism called a 'simultaneous connection' in
 244         // which Dial("tcp", addr1, addr2) run on the machine at addr1 can
 245         // connect to a simultaneous Dial("tcp", addr2, addr1) run on the machine
 246         // at addr2, without either machine executing Listen.  If laddr == nil,
 247         // it means we want the kernel to pick an appropriate originating local
 248         // address.  Some Linux kernels cycle blindly through a fixed range of
 249         // local ports, regardless of destination port.  If a kernel happens to
 250         // pick local port 50001 as the source for a Dial("tcp", "", "localhost:50001"),
 251         // then the Dial will succeed, having simultaneously connected to itself.
 252         // This can only happen when we are letting the kernel pick a port (laddr == nil)
 253         // and when there is no listener for the destination address.
 254         // It's hard to argue this is anything other than a kernel bug.  If we
 255         // see this happen, rather than expose the buggy effect to users, we
 256         // close the fd and try again.  If it happens twice more, we relent and
 257         // use the result.  See also:
 258         //      http://golang.org/issue/2690
 259         //      http://stackoverflow.com/questions/4949858/
 260         for i := 0; i < 2 && err == nil && laddr == nil && selfConnect(fd); i++ {
 261                 fd.Close()
 262                 fd, err = internetSocket(net, laddr.toAddr(), raddr.toAddr(), syscall.SOCK_STREAM, 0, "dial", sockaddrToTCP)
 263         }
 264
 265         if err != nil {
 266                 return nil, err
 267         }
 268         return newTCPConn(fd), nil
 269 }
 270
 271 func selfConnect(fd *netFD) bool {
 272         // The socket constructor can return an fd with raddr nil under certain
 273         // unknown conditions. The errors in the calls there to Getpeername
 274         // are discarded, but we can't catch the problem there because those
 275         // calls are sometimes legally erroneous with a "socket not connected".
 276         // Since this code (selfConnect) is already trying to work around
 277         // a problem, we make sure if this happens we recognize trouble and
 278         // ask the DialTCP routine to try again.
 279         // TODO: try to understand what's really going on.
 280         if fd.laddr == nil || fd.raddr == nil {
 281                 return true
 282         }
 283         l := fd.laddr.(*TCPAddr)
 284         r := fd.raddr.(*TCPAddr)
 285         return l.Port == r.Port && l.IP.Equal(r.IP)
 286 }
 287
 288 // TCPListener is a TCP network listener.
 289 // Clients should typically use variables of type Listener
 290 // instead of assuming TCP.
 291 type TCPListener struct {
 292         fd *netFD
 293 }
 294
 295 // ListenTCP announces on the TCP address laddr and returns a TCP listener.
 296 // Net must be "tcp", "tcp4", or "tcp6".
 297 // If laddr has a port of 0, it means to listen on some available port.
 298 // The caller can use l.Addr() to retrieve the chosen address.
 299 func ListenTCP(net string, laddr *TCPAddr) (*TCPListener, error) {
 300         fd, err := internetSocket(net, laddr.toAddr(), nil, syscall.SOCK_STREAM, 0, "listen", sockaddrToTCP)
 301         if err != nil {
 302                 return nil, err
 303         }
 304         err = syscall.Listen(fd.sysfd, listenerBacklog)
 305         if err != nil {
 306                 closesocket(fd.sysfd)
 307                 return nil, &OpError{"listen", net, laddr, err}
 308         }
 309         l := new(TCPListener)
 310         l.fd = fd
 311         return l, nil
 312 }
 313
 314 // AcceptTCP accepts the next incoming call and returns the new connection
 315 // and the remote address.
 316 func (l *TCPListener) AcceptTCP() (c *TCPConn, err error) {
 317         if l == nil || l.fd == nil || l.fd.sysfd < 0 {
 318                 return nil, syscall.EINVAL
 319         }
 320         fd, err := l.fd.accept(sockaddrToTCP)
 321         if err != nil {
 322                 return nil, err
 323         }
 324         return newTCPConn(fd), nil
 325 }
 326
 327 // Accept implements the Accept method in the Listener interface;
 328 // it waits for the next call and returns a generic Conn.
 329 func (l *TCPListener) Accept() (c Conn, err error) {
 330         c1, err := l.AcceptTCP()
 331         if err != nil {
 332                 return nil, err
 333         }
 334         return c1, nil
 335 }
 336
 337 // Close stops listening on the TCP address.
 338 // Already Accepted connections are not closed.
 339 func (l *TCPListener) Close() error {
 340         if l == nil || l.fd == nil {
 341                 return syscall.EINVAL
 342         }
 343         return l.fd.Close()
 344 }
 345
 346 // Addr returns the listener's network address, a *TCPAddr.
 347 func (l *TCPListener) Addr() Addr { return l.fd.laddr }
 348
 349 // SetDeadline sets the deadline associated with the listener.
 350 // A zero time value disables the deadline.
 351 func (l *TCPListener) SetDeadline(t time.Time) error {
 352         if l == nil || l.fd == nil {
 353                 return syscall.EINVAL
 354         }
 355         return setDeadline(l.fd, t)
 356 }
 357
 358 // File returns a copy of the underlying os.File, set to blocking mode.
 359 // It is the caller's responsibility to close f when finished.
 360 // Closing l does not affect f, and closing f does not affect l.
 361 func (l *TCPListener) File() (f *os.File, err error) { return l.fd.dup() }