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  //go:build unix
     6  
     7  package net
     8  
     9  import (
    10  	"context"
    11  	"internal/poll"
    12  	"os"
    13  	"runtime"
    14  	"syscall"
    15  )
    16  
    17  const (
    18  	readSyscallName     = "read"
    19  	readFromSyscallName = "recvfrom"
    20  	readMsgSyscallName  = "recvmsg"
    21  	writeSyscallName    = "write"
    22  	writeToSyscallName  = "sendto"
    23  	writeMsgSyscallName = "sendmsg"
    24  )
    25  
    26  func newFD(sysfd, family, sotype int, net string) (*netFD, error) {
    27  	ret := &netFD{
    28  		pfd: poll.FD{
    29  			Sysfd:         sysfd,
    30  			IsStream:      sotype == syscall.SOCK_STREAM,
    31  			ZeroReadIsEOF: sotype != syscall.SOCK_DGRAM && sotype != syscall.SOCK_RAW,
    32  		},
    33  		family: family,
    34  		sotype: sotype,
    35  		net:    net,
    36  	}
    37  	return ret, nil
    38  }
    39  
    40  func (fd *netFD) init() error {
    41  	return fd.pfd.Init(fd.net, true)
    42  }
    43  
    44  func (fd *netFD) name() string {
    45  	var ls, rs string
    46  	if fd.laddr != nil {
    47  		ls = fd.laddr.String()
    48  	}
    49  	if fd.raddr != nil {
    50  		rs = fd.raddr.String()
    51  	}
    52  	return fd.net + ":" + ls + "->" + rs
    53  }
    54  
    55  func (fd *netFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (rsa syscall.Sockaddr, ret error) {
    56  	// Do not need to call fd.writeLock here,
    57  	// because fd is not yet accessible to user,
    58  	// so no concurrent operations are possible.
    59  	switch err := connectFunc(fd.pfd.Sysfd, ra); err {
    60  	case syscall.EINPROGRESS, syscall.EALREADY, syscall.EINTR:
    61  	case nil, syscall.EISCONN:
    62  		select {
    63  		case <-ctx.Done():
    64  			return nil, mapErr(ctx.Err())
    65  		default:
    66  		}
    67  		if err := fd.pfd.Init(fd.net, true); err != nil {
    68  			return nil, err
    69  		}
    70  		runtime.KeepAlive(fd)
    71  		return nil, nil
    72  	case syscall.EINVAL:
    73  		// On Solaris and illumos we can see EINVAL if the socket has
    74  		// already been accepted and closed by the server.  Treat this
    75  		// as a successful connection--writes to the socket will see
    76  		// EOF.  For details and a test case in C see
    77  		// https://golang.org/issue/6828.
    78  		if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" {
    79  			return nil, nil
    80  		}
    81  		fallthrough
    82  	default:
    83  		return nil, os.NewSyscallError("connect", err)
    84  	}
    85  	if err := fd.pfd.Init(fd.net, true); err != nil {
    86  		return nil, err
    87  	}
    88  	if deadline, hasDeadline := ctx.Deadline(); hasDeadline {
    89  		fd.pfd.SetWriteDeadline(deadline)
    90  		defer fd.pfd.SetWriteDeadline(noDeadline)
    91  	}
    92  
    93  	// Start the "interrupter" goroutine, if this context might be canceled.
    94  	//
    95  	// The interrupter goroutine waits for the context to be done and
    96  	// interrupts the dial (by altering the fd's write deadline, which
    97  	// wakes up waitWrite).
    98  	ctxDone := ctx.Done()
    99  	if ctxDone != nil {
   100  		// Wait for the interrupter goroutine to exit before returning
   101  		// from connect.
   102  		done := make(chan struct{})
   103  		interruptRes := make(chan error)
   104  		defer func() {
   105  			close(done)
   106  			if ctxErr := <-interruptRes; ctxErr != nil && ret == nil {
   107  				// The interrupter goroutine called SetWriteDeadline,
   108  				// but the connect code below had returned from
   109  				// waitWrite already and did a successful connect (ret
   110  				// == nil). Because we've now poisoned the connection
   111  				// by making it unwritable, don't return a successful
   112  				// dial. This was issue 16523.
   113  				ret = mapErr(ctxErr)
   114  				fd.Close() // prevent a leak
   115  			}
   116  		}()
   117  		go func() {
   118  			select {
   119  			case <-ctxDone:
   120  				// Force the runtime's poller to immediately give up
   121  				// waiting for writability, unblocking waitWrite
   122  				// below.
   123  				fd.pfd.SetWriteDeadline(aLongTimeAgo)
   124  				testHookCanceledDial()
   125  				interruptRes <- ctx.Err()
   126  			case <-done:
   127  				interruptRes <- nil
   128  			}
   129  		}()
   130  	}
   131  
   132  	for {
   133  		// Performing multiple connect system calls on a
   134  		// non-blocking socket under Unix variants does not
   135  		// necessarily result in earlier errors being
   136  		// returned. Instead, once runtime-integrated network
   137  		// poller tells us that the socket is ready, get the
   138  		// SO_ERROR socket option to see if the connection
   139  		// succeeded or failed. See issue 7474 for further
   140  		// details.
   141  		if err := fd.pfd.WaitWrite(); err != nil {
   142  			select {
   143  			case <-ctxDone:
   144  				return nil, mapErr(ctx.Err())
   145  			default:
   146  			}
   147  			return nil, err
   148  		}
   149  		nerr, err := getsockoptIntFunc(fd.pfd.Sysfd, syscall.SOL_SOCKET, syscall.SO_ERROR)
   150  		if err != nil {
   151  			return nil, os.NewSyscallError("getsockopt", err)
   152  		}
   153  		switch err := syscall.Errno(nerr); err {
   154  		case syscall.EINPROGRESS, syscall.EALREADY, syscall.EINTR:
   155  		case syscall.EISCONN:
   156  			return nil, nil
   157  		case syscall.Errno(0):
   158  			// The runtime poller can wake us up spuriously;
   159  			// see issues 14548 and 19289. Check that we are
   160  			// really connected; if not, wait again.
   161  			if rsa, err := syscall.Getpeername(fd.pfd.Sysfd); err == nil {
   162  				return rsa, nil
   163  			}
   164  		default:
   165  			return nil, os.NewSyscallError("connect", err)
   166  		}
   167  		runtime.KeepAlive(fd)
   168  	}
   169  }
   170  
   171  func (fd *netFD) accept() (netfd *netFD, err error) {
   172  	d, rsa, errcall, err := fd.pfd.Accept()
   173  	if err != nil {
   174  		if errcall != "" {
   175  			err = wrapSyscallError(errcall, err)
   176  		}
   177  		return nil, err
   178  	}
   179  
   180  	if netfd, err = newFD(d, fd.family, fd.sotype, fd.net); err != nil {
   181  		poll.CloseFunc(d)
   182  		return nil, err
   183  	}
   184  	if err = netfd.init(); err != nil {
   185  		netfd.Close()
   186  		return nil, err
   187  	}
   188  	lsa, _ := syscall.Getsockname(netfd.pfd.Sysfd)
   189  	netfd.setAddr(netfd.addrFunc()(lsa), netfd.addrFunc()(rsa))
   190  	return netfd, nil
   191  }
   192  
   193  // Defined in os package.
   194  func newUnixFile(fd int, name string) *os.File
   195  
   196  func (fd *netFD) dup() (f *os.File, err error) {
   197  	ns, call, err := fd.pfd.Dup()
   198  	if err != nil {
   199  		if call != "" {
   200  			err = os.NewSyscallError(call, err)
   201  		}
   202  		return nil, err
   203  	}
   204  
   205  	return newUnixFile(ns, fd.name()), nil
   206  }
   207
View as plain text