fd_wasip1.go

     1  // Copyright 2023 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 wasip1
     6  
     7  package net
     8  
     9  import (
    10  	"internal/poll"
    11  	"runtime"
    12  	"syscall"
    13  	"time"
    14  )
    15  
    16  const (
    17  	readSyscallName  = "fd_read"
    18  	writeSyscallName = "fd_write"
    19  )
    20  
    21  // Network file descriptor.
    22  type netFD struct {
    23  	pfd poll.FD
    24  
    25  	// immutable until Close
    26  	family      int
    27  	sotype      int
    28  	isConnected bool // handshake completed or use of association with peer
    29  	net         string
    30  	laddr       Addr
    31  	raddr       Addr
    32  
    33  	// The only networking available in WASI preview 1 is the ability to
    34  	// sock_accept on an pre-opened socket, and then fd_read, fd_write,
    35  	// fd_close, and sock_shutdown on the resulting connection. We
    36  	// intercept applicable netFD calls on this instance, and then pass
    37  	// the remainder of the netFD calls to fakeNetFD.
    38  	*fakeNetFD
    39  }
    40  
    41  func newFD(net string, sysfd int) *netFD {
    42  	return newPollFD(net, poll.FD{
    43  		Sysfd:         sysfd,
    44  		IsStream:      true,
    45  		ZeroReadIsEOF: true,
    46  	})
    47  }
    48  
    49  func newPollFD(net string, pfd poll.FD) *netFD {
    50  	var laddr Addr
    51  	var raddr Addr
    52  	// WASI preview 1 does not have functions like getsockname/getpeername,
    53  	// so we cannot get access to the underlying IP address used by connections.
    54  	//
    55  	// However, listeners created by FileListener are of type *TCPListener,
    56  	// which can be asserted by a Go program. The (*TCPListener).Addr method
    57  	// documents that the returned value will be of type *TCPAddr, we satisfy
    58  	// the documented behavior by creating addresses of the expected type here.
    59  	switch net {
    60  	case "tcp":
    61  		laddr = new(TCPAddr)
    62  		raddr = new(TCPAddr)
    63  	case "udp":
    64  		laddr = new(UDPAddr)
    65  		raddr = new(UDPAddr)
    66  	default:
    67  		laddr = unknownAddr{}
    68  		raddr = unknownAddr{}
    69  	}
    70  	return &netFD{
    71  		pfd:   pfd,
    72  		net:   net,
    73  		laddr: laddr,
    74  		raddr: raddr,
    75  	}
    76  }
    77  
    78  func (fd *netFD) init() error {
    79  	return fd.pfd.Init(fd.net, true)
    80  }
    81  
    82  func (fd *netFD) name() string {
    83  	return "unknown"
    84  }
    85  
    86  func (fd *netFD) accept() (netfd *netFD, err error) {
    87  	if fd.fakeNetFD != nil {
    88  		return fd.fakeNetFD.accept()
    89  	}
    90  	d, _, errcall, err := fd.pfd.Accept()
    91  	if err != nil {
    92  		if errcall != "" {
    93  			err = wrapSyscallError(errcall, err)
    94  		}
    95  		return nil, err
    96  	}
    97  	netfd = newFD("tcp", d)
    98  	if err = netfd.init(); err != nil {
    99  		netfd.Close()
   100  		return nil, err
   101  	}
   102  	return netfd, nil
   103  }
   104  
   105  func (fd *netFD) setAddr(laddr, raddr Addr) {
   106  	fd.laddr = laddr
   107  	fd.raddr = raddr
   108  	runtime.SetFinalizer(fd, (*netFD).Close)
   109  }
   110  
   111  func (fd *netFD) Close() error {
   112  	if fd.fakeNetFD != nil {
   113  		return fd.fakeNetFD.Close()
   114  	}
   115  	runtime.SetFinalizer(fd, nil)
   116  	return fd.pfd.Close()
   117  }
   118  
   119  func (fd *netFD) shutdown(how int) error {
   120  	if fd.fakeNetFD != nil {
   121  		return nil
   122  	}
   123  	err := fd.pfd.Shutdown(how)
   124  	runtime.KeepAlive(fd)
   125  	return wrapSyscallError("shutdown", err)
   126  }
   127  
   128  func (fd *netFD) closeRead() error {
   129  	if fd.fakeNetFD != nil {
   130  		return fd.fakeNetFD.closeRead()
   131  	}
   132  	return fd.shutdown(syscall.SHUT_RD)
   133  }
   134  
   135  func (fd *netFD) closeWrite() error {
   136  	if fd.fakeNetFD != nil {
   137  		return fd.fakeNetFD.closeWrite()
   138  	}
   139  	return fd.shutdown(syscall.SHUT_WR)
   140  }
   141  
   142  func (fd *netFD) Read(p []byte) (n int, err error) {
   143  	if fd.fakeNetFD != nil {
   144  		return fd.fakeNetFD.Read(p)
   145  	}
   146  	n, err = fd.pfd.Read(p)
   147  	runtime.KeepAlive(fd)
   148  	return n, wrapSyscallError(readSyscallName, err)
   149  }
   150  
   151  func (fd *netFD) Write(p []byte) (nn int, err error) {
   152  	if fd.fakeNetFD != nil {
   153  		return fd.fakeNetFD.Write(p)
   154  	}
   155  	nn, err = fd.pfd.Write(p)
   156  	runtime.KeepAlive(fd)
   157  	return nn, wrapSyscallError(writeSyscallName, err)
   158  }
   159  
   160  func (fd *netFD) SetDeadline(t time.Time) error {
   161  	if fd.fakeNetFD != nil {
   162  		return fd.fakeNetFD.SetDeadline(t)
   163  	}
   164  	return fd.pfd.SetDeadline(t)
   165  }
   166  
   167  func (fd *netFD) SetReadDeadline(t time.Time) error {
   168  	if fd.fakeNetFD != nil {
   169  		return fd.fakeNetFD.SetReadDeadline(t)
   170  	}
   171  	return fd.pfd.SetReadDeadline(t)
   172  }
   173  
   174  func (fd *netFD) SetWriteDeadline(t time.Time) error {
   175  	if fd.fakeNetFD != nil {
   176  		return fd.fakeNetFD.SetWriteDeadline(t)
   177  	}
   178  	return fd.pfd.SetWriteDeadline(t)
   179  }
   180  
   181  type unknownAddr struct{}
   182  
   183  func (unknownAddr) Network() string { return "unknown" }
   184  func (unknownAddr) String() string  { return "unknown" }
   185
View as plain text