net: implement wasip1 FileListener and FileConn

Implements net.FileListener and net.FileConn for wasip1.

net.FileListener can be used with a pre-opened socket. If the WASM
module knows the file descriptor, a listener can be constructed with:

    l, err := net.FileListener(os.NewFile(fd, ""))

If the WASM module does not know the file descriptor, but knows that at
least one of the preopens is a socket, it can find the file descriptor
and construct a listener like so:

    func findListener() (net.Listener, error) {
        // We start looking for pre-opened sockets at fd=3 because 0, 1,
        // and 2 are reserved for stdio. Pre-opened directories also
        // start at fd=3, so we skip fds that aren't sockets. Once we
        // reach EBADF we know there are no more pre-opens.
        for preopenFd := uintptr(3); ; preopenFd++ {
            l, err := net.FileListener(os.NewFile(preopenFd, ""))

            var se syscall.Errno
            switch errors.As(err, &se); se {
            case syscall.ENOTSOCK:
                continue
            case syscall.EBADF:
                err = nil
            }
            return l, err
        }
    }

A similar strategy can be used with net.FileConn and pre-opened
connection sockets.

The wasmtime runtime supports pre-opening listener sockets:

    $ wasmtime --tcplisten 127.0.0.1:8080 module.wasm

Change-Id: Iec6ae4ffa84b3753cce4f56a2817e150445db643
Reviewed-on: https://go-review.googlesource.com/c/go/+/493358
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
TryBot-Bypass: Dmitri Shuralyov <dmitshur@google.com>
Reviewed-by: Johan Brandhorst-Satzkorn <johan.brandhorst@gmail.com>
Auto-Submit: Johan Brandhorst-Satzkorn <johan.brandhorst@gmail.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>

5 files changed, 319 insertions, 56 deletions

diff --git a/src/net/fd_wasip1.go b/src/net/fd_wasip1.go
new file mode 100644
index 0000000000..3f64ff4683
--- /dev/null
+++ b/src/net/fd_wasip1.go
@@ -0,0 +1,168 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build wasip1
+
+package net
+
+import (
+	"internal/poll"
+	"runtime"
+	"syscall"
+	"time"
+)
+
+const (
+	readSyscallName  = "fd_read"
+	writeSyscallName = "fd_write"
+)
+
+// Network file descriptor.
+type netFD struct {
+	pfd poll.FD
+
+	// immutable until Close
+	family      int
+	sotype      int
+	isConnected bool // handshake completed or use of association with peer
+	net         string
+	laddr       Addr
+	raddr       Addr
+
+	// The only networking available in WASI preview 1 is the ability to
+	// sock_accept on an pre-opened socket, and then fd_read, fd_write,
+	// fd_close, and sock_shutdown on the resulting connection. We
+	// intercept applicable netFD calls on this instance, and then pass
+	// the remainder of the netFD calls to fakeNetFD.
+	*fakeNetFD
+}
+
+func newFD(sysfd int) (*netFD, error) {
+	return newPollFD(poll.FD{
+		Sysfd:         sysfd,
+		IsStream:      true,
+		ZeroReadIsEOF: true,
+	})
+}
+
+func newPollFD(pfd poll.FD) (*netFD, error) {
+	ret := &netFD{
+		pfd:   pfd,
+		net:   "tcp",
+		laddr: unknownAddr{},
+		raddr: unknownAddr{},
+	}
+	return ret, nil
+}
+
+func (fd *netFD) init() error {
+	return fd.pfd.Init(fd.net, true)
+}
+
+func (fd *netFD) name() string {
+	return "unknown"
+}
+
+func (fd *netFD) accept() (netfd *netFD, err error) {
+	if fd.fakeNetFD != nil {
+		return fd.fakeNetFD.accept()
+	}
+	d, _, errcall, err := fd.pfd.Accept()
+	if err != nil {
+		if errcall != "" {
+			err = wrapSyscallError(errcall, err)
+		}
+		return nil, err
+	}
+	if netfd, err = newFD(d); err != nil {
+		poll.CloseFunc(d)
+		return nil, err
+	}
+	if err = netfd.init(); err != nil {
+		netfd.Close()
+		return nil, err
+	}
+	return netfd, nil
+}
+
+func (fd *netFD) setAddr(laddr, raddr Addr) {
+	fd.laddr = laddr
+	fd.raddr = raddr
+	runtime.SetFinalizer(fd, (*netFD).Close)
+}
+
+func (fd *netFD) Close() error {
+	if fd.fakeNetFD != nil {
+		return fd.fakeNetFD.Close()
+	}
+	runtime.SetFinalizer(fd, nil)
+	return fd.pfd.Close()
+}
+
+func (fd *netFD) shutdown(how int) error {
+	if fd.fakeNetFD != nil {
+		return nil
+	}
+	err := fd.pfd.Shutdown(how)
+	runtime.KeepAlive(fd)
+	return wrapSyscallError("shutdown", err)
+}
+
+func (fd *netFD) closeRead() error {
+	if fd.fakeNetFD != nil {
+		return fd.fakeNetFD.closeRead()
+	}
+	return fd.shutdown(syscall.SHUT_RD)
+}
+
+func (fd *netFD) closeWrite() error {
+	if fd.fakeNetFD != nil {
+		return fd.fakeNetFD.closeWrite()
+	}
+	return fd.shutdown(syscall.SHUT_WR)
+}
+
+func (fd *netFD) Read(p []byte) (n int, err error) {
+	if fd.fakeNetFD != nil {
+		return fd.fakeNetFD.Read(p)
+	}
+	n, err = fd.pfd.Read(p)
+	runtime.KeepAlive(fd)
+	return n, wrapSyscallError(readSyscallName, err)
+}
+
+func (fd *netFD) Write(p []byte) (nn int, err error) {
+	if fd.fakeNetFD != nil {
+		return fd.fakeNetFD.Write(p)
+	}
+	nn, err = fd.pfd.Write(p)
+	runtime.KeepAlive(fd)
+	return nn, wrapSyscallError(writeSyscallName, err)
+}
+
+func (fd *netFD) SetDeadline(t time.Time) error {
+	if fd.fakeNetFD != nil {
+		return fd.fakeNetFD.SetDeadline(t)
+	}
+	return fd.pfd.SetDeadline(t)
+}
+
+func (fd *netFD) SetReadDeadline(t time.Time) error {
+	if fd.fakeNetFD != nil {
+		return fd.fakeNetFD.SetReadDeadline(t)
+	}
+	return fd.pfd.SetReadDeadline(t)
+}
+
+func (fd *netFD) SetWriteDeadline(t time.Time) error {
+	if fd.fakeNetFD != nil {
+		return fd.fakeNetFD.SetWriteDeadline(t)
+	}
+	return fd.pfd.SetWriteDeadline(t)
+}
+
+type unknownAddr struct{}
+
+func (unknownAddr) Network() string { return "unknown" }
+func (unknownAddr) String() string  { return "unknown" }
diff --git a/src/net/file_stub.go b/src/net/file_stub.go
index 1299f0e67f..91df926a57 100644
--- a/src/net/file_stub.go
+++ b/src/net/file_stub.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (js && wasm) || wasip1
+//go:build js && wasm
 
 package net
 
diff --git a/src/net/file_wasip1.go b/src/net/file_wasip1.go
new file mode 100644
index 0000000000..95fd5403a6
--- /dev/null
+++ b/src/net/file_wasip1.go
@@ -0,0 +1,62 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build wasip1
+
+package net
+
+import (
+	"os"
+	"syscall"
+	_ "unsafe" // for go:linkname
+)
+
+func fileListener(f *os.File) (Listener, error) {
+	fd, err := newFileFD(f)
+	if err != nil {
+		return nil, err
+	}
+	return &TCPListener{fd: fd}, nil
+}
+
+func fileConn(f *os.File) (Conn, error) {
+	fd, err := newFileFD(f)
+	if err != nil {
+		return nil, err
+	}
+	return &TCPConn{conn{fd: fd}}, nil
+}
+
+func filePacketConn(f *os.File) (PacketConn, error) { return nil, syscall.ENOPROTOOPT }
+
+func newFileFD(f *os.File) (fd *netFD, err error) {
+	pfd := f.PollFD().Copy()
+	defer func() {
+		if err != nil {
+			pfd.Close()
+		}
+	}()
+	filetype, err := fd_fdstat_get_type(pfd.Sysfd)
+	if err != nil {
+		return nil, err
+	}
+	if filetype != syscall.FILETYPE_SOCKET_STREAM {
+		return nil, syscall.ENOTSOCK
+	}
+	fd, err = newPollFD(pfd)
+	if err != nil {
+		return nil, err
+	}
+	if err := fd.init(); err != nil {
+		return nil, err
+	}
+	return fd, nil
+}
+
+// This helper is implemented in the syscall package. It means we don't have
+// to redefine the fd_fdstat_get host import or the fdstat struct it
+// populates.
+//
+//go:linkname fd_fdstat_get_type syscall.fd_fdstat_get_type
+func fd_fdstat_get_type(fd int) (uint8, error)
diff --git a/src/net/net_fake.go b/src/net/net_fake.go
index 8e801d15d1..a816213f8d 100644
--- a/src/net/net_fake.go
+++ b/src/net/net_fake.go
@@ -10,7 +10,6 @@ package net
 
 import (
 	"context"
-	"internal/poll"
 	"io"
 	"os"
 	"sync"
@@ -33,61 +32,64 @@ func nextPort() int {
 	return portCounter
 }
 
-// Network file descriptor.
-type netFD struct {
+type fakeNetFD struct {
+	listener bool
+	laddr    Addr
 	r        *bufferedPipe
 	w        *bufferedPipe
 	incoming chan *netFD
 
 	closedMu sync.Mutex
 	closed   bool
-
-	// immutable until Close
-	listener bool
-	family   int
-	sotype   int
-	net      string
-	laddr    Addr
-	raddr    Addr
-
-	// unused
-	pfd         poll.FD
-	isConnected bool // handshake completed or use of association with peer
 }
 
 // socket returns a network file descriptor that is ready for
 // asynchronous I/O using the network poller.
 func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, ctrlCtxFn func(context.Context, string, string, syscall.RawConn) error) (*netFD, error) {
 	fd := &netFD{family: family, sotype: sotype, net: net}
+	if laddr != nil && raddr == nil {
+		return fakelistener(fd, laddr)
+	}
+	fd2 := &netFD{family: family, sotype: sotype, net: net}
+	return fakeconn(fd, fd2, raddr)
+}
 
-	if laddr != nil && raddr == nil { // listener
-		l := laddr.(*TCPAddr)
-		fd.laddr = &TCPAddr{
-			IP:   l.IP,
-			Port: nextPort(),
-			Zone: l.Zone,
-		}
-		fd.listener = true
-		fd.incoming = make(chan *netFD, 1024)
-		listenersMu.Lock()
-		listeners[fd.laddr.(*TCPAddr).String()] = fd
-		listenersMu.Unlock()
-		return fd, nil
+func fakelistener(fd *netFD, laddr sockaddr) (*netFD, error) {
+	l := laddr.(*TCPAddr)
+	fd.laddr = &TCPAddr{
+		IP:   l.IP,
+		Port: nextPort(),
+		Zone: l.Zone,
+	}
+	fd.fakeNetFD = &fakeNetFD{
+		listener: true,
+		laddr:    fd.laddr,
+		incoming: make(chan *netFD, 1024),
 	}
+	listenersMu.Lock()
+	listeners[fd.laddr.(*TCPAddr).String()] = fd
+	listenersMu.Unlock()
+	return fd, nil
+}
 
+func fakeconn(fd *netFD, fd2 *netFD, raddr sockaddr) (*netFD, error) {
 	fd.laddr = &TCPAddr{
 		IP:   IPv4(127, 0, 0, 1),
 		Port: nextPort(),
 	}
 	fd.raddr = raddr
-	fd.r = newBufferedPipe(65536)
-	fd.w = newBufferedPipe(65536)
 
-	fd2 := &netFD{family: fd.family, sotype: sotype, net: net}
+	fd.fakeNetFD = &fakeNetFD{
+		r: newBufferedPipe(65536),
+		w: newBufferedPipe(65536),
+	}
+	fd2.fakeNetFD = &fakeNetFD{
+		r: fd.fakeNetFD.w,
+		w: fd.fakeNetFD.r,
+	}
+
 	fd2.laddr = fd.raddr
 	fd2.raddr = fd.laddr
-	fd2.r = fd.w
-	fd2.w = fd.r
 	listenersMu.Lock()
 	l, ok := listeners[fd.raddr.(*TCPAddr).String()]
 	if !ok {
@@ -100,15 +102,15 @@ func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only
 	return fd, nil
 }
 
-func (fd *netFD) Read(p []byte) (n int, err error) {
+func (fd *fakeNetFD) Read(p []byte) (n int, err error) {
 	return fd.r.Read(p)
 }
 
-func (fd *netFD) Write(p []byte) (nn int, err error) {
+func (fd *fakeNetFD) Write(p []byte) (nn int, err error) {
 	return fd.w.Write(p)
 }
 
-func (fd *netFD) Close() error {
+func (fd *fakeNetFD) Close() error {
 	fd.closedMu.Lock()
 	if fd.closed {
 		fd.closedMu.Unlock()
@@ -131,17 +133,17 @@ func (fd *netFD) Close() error {
 	return nil
 }
 
-func (fd *netFD) closeRead() error {
+func (fd *fakeNetFD) closeRead() error {
 	fd.r.Close()
 	return nil
 }
 
-func (fd *netFD) closeWrite() error {
+func (fd *fakeNetFD) closeWrite() error {
 	fd.w.Close()
 	return nil
 }
 
-func (fd *netFD) accept() (*netFD, error) {
+func (fd *fakeNetFD) accept() (*netFD, error) {
 	c, ok := <-fd.incoming
 	if !ok {
 		return nil, syscall.EINVAL
@@ -149,18 +151,18 @@ func (fd *netFD) accept() (*netFD, error) {
 	return c, nil
 }
 
-func (fd *netFD) SetDeadline(t time.Time) error {
+func (fd *fakeNetFD) SetDeadline(t time.Time) error {
 	fd.r.SetReadDeadline(t)
 	fd.w.SetWriteDeadline(t)
 	return nil
 }
 
-func (fd *netFD) SetReadDeadline(t time.Time) error {
+func (fd *fakeNetFD) SetReadDeadline(t time.Time) error {
 	fd.r.SetReadDeadline(t)
 	return nil
 }
 
-func (fd *netFD) SetWriteDeadline(t time.Time) error {
+func (fd *fakeNetFD) SetWriteDeadline(t time.Time) error {
 	fd.w.SetWriteDeadline(t)
 	return nil
 }
@@ -265,55 +267,59 @@ func sysSocket(family, sotype, proto int) (int, error) {
 	return 0, syscall.ENOSYS
 }
 
-func (fd *netFD) readFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
+func (fd *fakeNetFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (syscall.Sockaddr, error) {
+	return nil, syscall.ENOSYS
+}
+
+func (fd *fakeNetFD) readFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
 	return 0, nil, syscall.ENOSYS
 
 }
-func (fd *netFD) readFromInet4(p []byte, sa *syscall.SockaddrInet4) (n int, err error) {
+func (fd *fakeNetFD) readFromInet4(p []byte, sa *syscall.SockaddrInet4) (n int, err error) {
 	return 0, syscall.ENOSYS
 }
 
-func (fd *netFD) readFromInet6(p []byte, sa *syscall.SockaddrInet6) (n int, err error) {
+func (fd *fakeNetFD) readFromInet6(p []byte, sa *syscall.SockaddrInet6) (n int, err error) {
 	return 0, syscall.ENOSYS
 }
 
-func (fd *netFD) readMsg(p []byte, oob []byte, flags int) (n, oobn, retflags int, sa syscall.Sockaddr, err error) {
+func (fd *fakeNetFD) readMsg(p []byte, oob []byte, flags int) (n, oobn, retflags int, sa syscall.Sockaddr, err error) {
 	return 0, 0, 0, nil, syscall.ENOSYS
 }
 
-func (fd *netFD) readMsgInet4(p []byte, oob []byte, flags int, sa *syscall.SockaddrInet4) (n, oobn, retflags int, err error) {
+func (fd *fakeNetFD) readMsgInet4(p []byte, oob []byte, flags int, sa *syscall.SockaddrInet4) (n, oobn, retflags int, err error) {
 	return 0, 0, 0, syscall.ENOSYS
 }
 
-func (fd *netFD) readMsgInet6(p []byte, oob []byte, flags int, sa *syscall.SockaddrInet6) (n, oobn, retflags int, err error) {
+func (fd *fakeNetFD) readMsgInet6(p []byte, oob []byte, flags int, sa *syscall.SockaddrInet6) (n, oobn, retflags int, err error) {
 	return 0, 0, 0, syscall.ENOSYS
 }
 
-func (fd *netFD) writeMsgInet4(p []byte, oob []byte, sa *syscall.SockaddrInet4) (n int, oobn int, err error) {
+func (fd *fakeNetFD) writeMsgInet4(p []byte, oob []byte, sa *syscall.SockaddrInet4) (n int, oobn int, err error) {
 	return 0, 0, syscall.ENOSYS
 }
 
-func (fd *netFD) writeMsgInet6(p []byte, oob []byte, sa *syscall.SockaddrInet6) (n int, oobn int, err error) {
+func (fd *fakeNetFD) writeMsgInet6(p []byte, oob []byte, sa *syscall.SockaddrInet6) (n int, oobn int, err error) {
 	return 0, 0, syscall.ENOSYS
 }
 
-func (fd *netFD) writeTo(p []byte, sa syscall.Sockaddr) (n int, err error) {
+func (fd *fakeNetFD) writeTo(p []byte, sa syscall.Sockaddr) (n int, err error) {
 	return 0, syscall.ENOSYS
 }
 
-func (fd *netFD) writeToInet4(p []byte, sa *syscall.SockaddrInet4) (n int, err error) {
+func (fd *fakeNetFD) writeToInet4(p []byte, sa *syscall.SockaddrInet4) (n int, err error) {
 	return 0, syscall.ENOSYS
 }
 
-func (fd *netFD) writeToInet6(p []byte, sa *syscall.SockaddrInet6) (n int, err error) {
+func (fd *fakeNetFD) writeToInet6(p []byte, sa *syscall.SockaddrInet6) (n int, err error) {
 	return 0, syscall.ENOSYS
 }
 
-func (fd *netFD) writeMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oobn int, err error) {
+func (fd *fakeNetFD) writeMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oobn int, err error) {
 	return 0, 0, syscall.ENOSYS
 }
 
-func (fd *netFD) dup() (f *os.File, err error) {
+func (fd *fakeNetFD) dup() (f *os.File, err error) {
 	return nil, syscall.ENOSYS
 }
 
diff --git a/src/net/net_fake_js.go b/src/net/net_fake_js.go
new file mode 100644
index 0000000000..1fc0b50b7d
--- /dev/null
+++ b/src/net/net_fake_js.go
@@ -0,0 +1,27 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Fake networking for js/wasm. It is intended to allow tests of other package to pass.
+
+//go:build js && wasm
+
+package net
+
+import "internal/poll"
+
+// Network file descriptor.
+type netFD struct {
+	*fakeNetFD
+
+	// immutable until Close
+	family int
+	sotype int
+	net    string
+	laddr  Addr
+	raddr  Addr
+
+	// unused
+	pfd         poll.FD
+	isConnected bool // handshake completed or use of association with peer
+}