libgo/go/net/fd_unix.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 aix darwin dragonfly freebsd hurd linux nacl netbsd openbsd solaris
   6
   7 package net
   8
   9 import (
  10         "context"
  11         "internal/poll"
  12         "os"
  13         "runtime"
  14         "syscall"
  15         "time"
  16 )
  17
  18 // Network file descriptor.
  19 type netFD struct {
  20         pfd poll.FD
  21
  22         // immutable until Close
  23         family      int
  24         sotype      int
  25         isConnected bool // handshake completed or use of association with peer
  26         net         string
  27         laddr       Addr
  28         raddr       Addr
  29 }
  30
  31 func newFD(sysfd, family, sotype int, net string) (*netFD, error) {
  32         ret := &netFD{
  33                 pfd: poll.FD{
  34                         Sysfd:         sysfd,
  35                         IsStream:      sotype == syscall.SOCK_STREAM,
  36                         ZeroReadIsEOF: sotype != syscall.SOCK_DGRAM && sotype != syscall.SOCK_RAW,
  37                 },
  38                 family: family,
  39                 sotype: sotype,
  40                 net:    net,
  41         }
  42         return ret, nil
  43 }
  44
  45 func (fd *netFD) init() error {
  46         return fd.pfd.Init(fd.net, true)
  47 }
  48
  49 func (fd *netFD) setAddr(laddr, raddr Addr) {
  50         fd.laddr = laddr
  51         fd.raddr = raddr
  52         runtime.SetFinalizer(fd, (*netFD).Close)
  53 }
  54
  55 func (fd *netFD) name() string {
  56         var ls, rs string
  57         if fd.laddr != nil {
  58                 ls = fd.laddr.String()
  59         }
  60         if fd.raddr != nil {
  61                 rs = fd.raddr.String()
  62         }
  63         return fd.net + ":" + ls + "->" + rs
  64 }
  65
  66 func (fd *netFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (rsa syscall.Sockaddr, ret error) {
  67         // Do not need to call fd.writeLock here,
  68         // because fd is not yet accessible to user,
  69         // so no concurrent operations are possible.
  70         switch err := connectFunc(fd.pfd.Sysfd, ra); err {
  71         case syscall.EINPROGRESS, syscall.EALREADY, syscall.EINTR:
  72         case nil, syscall.EISCONN:
  73                 select {
  74                 case <-ctx.Done():
  75                         return nil, mapErr(ctx.Err())
  76                 default:
  77                 }
  78                 if err := fd.pfd.Init(fd.net, true); err != nil {
  79                         return nil, err
  80                 }
  81                 runtime.KeepAlive(fd)
  82                 return nil, nil
  83         case syscall.EINVAL:
  84                 // On Solaris and illumos we can see EINVAL if the socket has
  85                 // already been accepted and closed by the server.  Treat this
  86                 // as a successful connection--writes to the socket will see
  87                 // EOF.  For details and a test case in C see
  88                 // https://golang.org/issue/6828.
  89                 if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" {
  90                         return nil, nil
  91                 }
  92                 fallthrough
  93         default:
  94                 return nil, os.NewSyscallError("connect", err)
  95         }
  96         if err := fd.pfd.Init(fd.net, true); err != nil {
  97                 return nil, err
  98         }
  99         if deadline, _ := ctx.Deadline(); !deadline.IsZero() {
 100                 fd.pfd.SetWriteDeadline(deadline)
 101                 defer fd.pfd.SetWriteDeadline(noDeadline)
 102         }
 103
 104         // Start the "interrupter" goroutine, if this context might be canceled.
 105         // (The background context cannot)
 106         //
 107         // The interrupter goroutine waits for the context to be done and
 108         // interrupts the dial (by altering the fd's write deadline, which
 109         // wakes up waitWrite).
 110         if ctx != context.Background() {
 111                 // Wait for the interrupter goroutine to exit before returning
 112                 // from connect.
 113                 done := make(chan struct{})
 114                 interruptRes := make(chan error)
 115                 defer func() {
 116                         close(done)
 117                         if ctxErr := <-interruptRes; ctxErr != nil && ret == nil {
 118                                 // The interrupter goroutine called SetWriteDeadline,
 119                                 // but the connect code below had returned from
 120                                 // waitWrite already and did a successful connect (ret
 121                                 // == nil). Because we've now poisoned the connection
 122                                 // by making it unwritable, don't return a successful
 123                                 // dial. This was issue 16523.
 124                                 ret = mapErr(ctxErr)
 125                                 fd.Close() // prevent a leak
 126                         }
 127                 }()
 128                 go func() {
 129                         select {
 130                         case <-ctx.Done():
 131                                 // Force the runtime's poller to immediately give up
 132                                 // waiting for writability, unblocking waitWrite
 133                                 // below.
 134                                 fd.pfd.SetWriteDeadline(aLongTimeAgo)
 135                                 testHookCanceledDial()
 136                                 interruptRes <- ctx.Err()
 137                         case <-done:
 138                                 interruptRes <- nil
 139                         }
 140                 }()
 141         }
 142
 143         for {
 144                 // Performing multiple connect system calls on a
 145                 // non-blocking socket under Unix variants does not
 146                 // necessarily result in earlier errors being
 147                 // returned. Instead, once runtime-integrated network
 148                 // poller tells us that the socket is ready, get the
 149                 // SO_ERROR socket option to see if the connection
 150                 // succeeded or failed. See issue 7474 for further
 151                 // details.
 152                 if err := fd.pfd.WaitWrite(); err != nil {
 153                         select {
 154                         case <-ctx.Done():
 155                                 return nil, mapErr(ctx.Err())
 156                         default:
 157                         }
 158                         return nil, err
 159                 }
 160                 nerr, err := getsockoptIntFunc(fd.pfd.Sysfd, syscall.SOL_SOCKET, syscall.SO_ERROR)
 161                 if err != nil {
 162                         return nil, os.NewSyscallError("getsockopt", err)
 163                 }
 164                 switch err := syscall.Errno(nerr); err {
 165                 case syscall.EINPROGRESS, syscall.EALREADY, syscall.EINTR:
 166                 case syscall.EISCONN:
 167                         return nil, nil
 168                 case syscall.Errno(0):
 169                         // The runtime poller can wake us up spuriously;
 170                         // see issues 14548 and 19289. Check that we are
 171                         // really connected; if not, wait again.
 172                         if rsa, err := syscall.Getpeername(fd.pfd.Sysfd); err == nil {
 173                                 return rsa, nil
 174                         }
 175                 default:
 176                         return nil, os.NewSyscallError("connect", err)
 177                 }
 178                 runtime.KeepAlive(fd)
 179         }
 180 }
 181
 182 func (fd *netFD) Close() error {
 183         runtime.SetFinalizer(fd, nil)
 184         return fd.pfd.Close()
 185 }
 186
 187 func (fd *netFD) shutdown(how int) error {
 188         err := fd.pfd.Shutdown(how)
 189         runtime.KeepAlive(fd)
 190         return wrapSyscallError("shutdown", err)
 191 }
 192
 193 func (fd *netFD) closeRead() error {
 194         return fd.shutdown(syscall.SHUT_RD)
 195 }
 196
 197 func (fd *netFD) closeWrite() error {
 198         return fd.shutdown(syscall.SHUT_WR)
 199 }
 200
 201 func (fd *netFD) Read(p []byte) (n int, err error) {
 202         n, err = fd.pfd.Read(p)
 203         runtime.KeepAlive(fd)
 204         return n, wrapSyscallError("read", err)
 205 }
 206
 207 func (fd *netFD) readFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
 208         n, sa, err = fd.pfd.ReadFrom(p)
 209         runtime.KeepAlive(fd)
 210         return n, sa, wrapSyscallError("recvfrom", err)
 211 }
 212
 213 func (fd *netFD) readMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.Sockaddr, err error) {
 214         n, oobn, flags, sa, err = fd.pfd.ReadMsg(p, oob)
 215         runtime.KeepAlive(fd)
 216         return n, oobn, flags, sa, wrapSyscallError("recvmsg", err)
 217 }
 218
 219 func (fd *netFD) Write(p []byte) (nn int, err error) {
 220         nn, err = fd.pfd.Write(p)
 221         runtime.KeepAlive(fd)
 222         return nn, wrapSyscallError("write", err)
 223 }
 224
 225 func (fd *netFD) writeTo(p []byte, sa syscall.Sockaddr) (n int, err error) {
 226         n, err = fd.pfd.WriteTo(p, sa)
 227         runtime.KeepAlive(fd)
 228         return n, wrapSyscallError("sendto", err)
 229 }
 230
 231 func (fd *netFD) writeMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oobn int, err error) {
 232         n, oobn, err = fd.pfd.WriteMsg(p, oob, sa)
 233         runtime.KeepAlive(fd)
 234         return n, oobn, wrapSyscallError("sendmsg", err)
 235 }
 236
 237 func (fd *netFD) accept() (netfd *netFD, err error) {
 238         d, rsa, errcall, err := fd.pfd.Accept()
 239         if err != nil {
 240                 if errcall != "" {
 241                         err = wrapSyscallError(errcall, err)
 242                 }
 243                 return nil, err
 244         }
 245
 246         if netfd, err = newFD(d, fd.family, fd.sotype, fd.net); err != nil {
 247                 poll.CloseFunc(d)
 248                 return nil, err
 249         }
 250         if err = netfd.init(); err != nil {
 251                 fd.Close()
 252                 return nil, err
 253         }
 254         lsa, _ := syscall.Getsockname(netfd.pfd.Sysfd)
 255         netfd.setAddr(netfd.addrFunc()(lsa), netfd.addrFunc()(rsa))
 256         return netfd, nil
 257 }
 258
 259 func (fd *netFD) dup() (f *os.File, err error) {
 260         ns, call, err := fd.pfd.Dup()
 261         if err != nil {
 262                 if call != "" {
 263                         err = os.NewSyscallError(call, err)
 264                 }
 265                 return nil, err
 266         }
 267
 268         return os.NewFile(uintptr(ns), fd.name()), nil
 269 }
 270
 271 func (fd *netFD) SetDeadline(t time.Time) error {
 272         return fd.pfd.SetDeadline(t)
 273 }
 274
 275 func (fd *netFD) SetReadDeadline(t time.Time) error {
 276         return fd.pfd.SetReadDeadline(t)
 277 }
 278
 279 func (fd *netFD) SetWriteDeadline(t time.Time) error {
 280         return fd.pfd.SetWriteDeadline(t)
 281 }