fd_windows.go

Documentation: net

     1  // Copyright 2010 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  package net
     6  
     7  import (
     8  	"context"
     9  	"internal/poll"
    10  	"os"
    11  	"runtime"
    12  	"syscall"
    13  	"unsafe"
    14  )
    15  
    16  const (
    17  	readSyscallName     = "wsarecv"
    18  	readFromSyscallName = "wsarecvfrom"
    19  	readMsgSyscallName  = "wsarecvmsg"
    20  	writeSyscallName    = "wsasend"
    21  	writeToSyscallName  = "wsasendto"
    22  	writeMsgSyscallName = "wsasendmsg"
    23  )
    24  
    25  // canUseConnectEx reports whether we can use the ConnectEx Windows API call
    26  // for the given network type.
    27  func canUseConnectEx(net string) bool {
    28  	switch net {
    29  	case "tcp", "tcp4", "tcp6":
    30  		return true
    31  	}
    32  	// ConnectEx windows API does not support connectionless sockets.
    33  	return false
    34  }
    35  
    36  func newFD(sysfd syscall.Handle, family, sotype int, net string) (*netFD, error) {
    37  	ret := &netFD{
    38  		pfd: poll.FD{
    39  			Sysfd:         sysfd,
    40  			IsStream:      sotype == syscall.SOCK_STREAM,
    41  			ZeroReadIsEOF: sotype != syscall.SOCK_DGRAM && sotype != syscall.SOCK_RAW,
    42  		},
    43  		family: family,
    44  		sotype: sotype,
    45  		net:    net,
    46  	}
    47  	return ret, nil
    48  }
    49  
    50  func (fd *netFD) init() error {
    51  	errcall, err := fd.pfd.Init(fd.net, true)
    52  	if errcall != "" {
    53  		err = wrapSyscallError(errcall, err)
    54  	}
    55  	return err
    56  }
    57  
    58  // Always returns nil for connected peer address result.
    59  func (fd *netFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (syscall.Sockaddr, error) {
    60  	// Do not need to call fd.writeLock here,
    61  	// because fd is not yet accessible to user,
    62  	// so no concurrent operations are possible.
    63  	if err := fd.init(); err != nil {
    64  		return nil, err
    65  	}
    66  	if deadline, ok := ctx.Deadline(); ok && !deadline.IsZero() {
    67  		fd.pfd.SetWriteDeadline(deadline)
    68  		defer fd.pfd.SetWriteDeadline(noDeadline)
    69  	}
    70  	if !canUseConnectEx(fd.net) {
    71  		err := connectFunc(fd.pfd.Sysfd, ra)
    72  		return nil, os.NewSyscallError("connect", err)
    73  	}
    74  	// ConnectEx windows API requires an unconnected, previously bound socket.
    75  	if la == nil {
    76  		switch ra.(type) {
    77  		case *syscall.SockaddrInet4:
    78  			la = &syscall.SockaddrInet4{}
    79  		case *syscall.SockaddrInet6:
    80  			la = &syscall.SockaddrInet6{}
    81  		default:
    82  			panic("unexpected type in connect")
    83  		}
    84  		if err := syscall.Bind(fd.pfd.Sysfd, la); err != nil {
    85  			return nil, os.NewSyscallError("bind", err)
    86  		}
    87  	}
    88  
    89  	// Wait for the goroutine converting context.Done into a write timeout
    90  	// to exist, otherwise our caller might cancel the context and
    91  	// cause fd.setWriteDeadline(aLongTimeAgo) to cancel a successful dial.
    92  	done := make(chan bool) // must be unbuffered
    93  	defer func() { done <- true }()
    94  	go func() {
    95  		select {
    96  		case <-ctx.Done():
    97  			// Force the runtime's poller to immediately give
    98  			// up waiting for writability.
    99  			fd.pfd.SetWriteDeadline(aLongTimeAgo)
   100  			<-done
   101  		case <-done:
   102  		}
   103  	}()
   104  
   105  	// Call ConnectEx API.
   106  	if err := fd.pfd.ConnectEx(ra); err != nil {
   107  		select {
   108  		case <-ctx.Done():
   109  			return nil, mapErr(ctx.Err())
   110  		default:
   111  			if _, ok := err.(syscall.Errno); ok {
   112  				err = os.NewSyscallError("connectex", err)
   113  			}
   114  			return nil, err
   115  		}
   116  	}
   117  	// Refresh socket properties.
   118  	return nil, os.NewSyscallError("setsockopt", syscall.Setsockopt(fd.pfd.Sysfd, syscall.SOL_SOCKET, syscall.SO_UPDATE_CONNECT_CONTEXT, (*byte)(unsafe.Pointer(&fd.pfd.Sysfd)), int32(unsafe.Sizeof(fd.pfd.Sysfd))))
   119  }
   120  
   121  func (c *conn) writeBuffers(v *Buffers) (int64, error) {
   122  	if !c.ok() {
   123  		return 0, syscall.EINVAL
   124  	}
   125  	n, err := c.fd.writeBuffers(v)
   126  	if err != nil {
   127  		return n, &OpError{Op: "wsasend", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
   128  	}
   129  	return n, nil
   130  }
   131  
   132  func (fd *netFD) writeBuffers(buf *Buffers) (int64, error) {
   133  	n, err := fd.pfd.Writev((*[][]byte)(buf))
   134  	runtime.KeepAlive(fd)
   135  	return n, wrapSyscallError("wsasend", err)
   136  }
   137  
   138  func (fd *netFD) accept() (*netFD, error) {
   139  	s, rawsa, rsan, errcall, err := fd.pfd.Accept(func() (syscall.Handle, error) {
   140  		return sysSocket(fd.family, fd.sotype, 0)
   141  	})
   142  
   143  	if err != nil {
   144  		if errcall != "" {
   145  			err = wrapSyscallError(errcall, err)
   146  		}
   147  		return nil, err
   148  	}
   149  
   150  	// Associate our new socket with IOCP.
   151  	netfd, err := newFD(s, fd.family, fd.sotype, fd.net)
   152  	if err != nil {
   153  		poll.CloseFunc(s)
   154  		return nil, err
   155  	}
   156  	if err := netfd.init(); err != nil {
   157  		fd.Close()
   158  		return nil, err
   159  	}
   160  
   161  	// Get local and peer addr out of AcceptEx buffer.
   162  	var lrsa, rrsa *syscall.RawSockaddrAny
   163  	var llen, rlen int32
   164  	syscall.GetAcceptExSockaddrs((*byte)(unsafe.Pointer(&rawsa[0])),
   165  		0, rsan, rsan, &lrsa, &llen, &rrsa, &rlen)
   166  	lsa, _ := lrsa.Sockaddr()
   167  	rsa, _ := rrsa.Sockaddr()
   168  
   169  	netfd.setAddr(netfd.addrFunc()(lsa), netfd.addrFunc()(rsa))
   170  	return netfd, nil
   171  }
   172  
   173  // Unimplemented functions.
   174  
   175  func (fd *netFD) dup() (*os.File, error) {
   176  	// TODO: Implement this
   177  	return nil, syscall.EWINDOWS
   178  }
   179
View as plain text