Network support for WASI preview 2

netdev.go

@@ -10,6 +10,7 @@ import (
 
 const (
 	_AF_INET       = 0x2
+	_AF_INET6      = 0xA
 	_SOCK_STREAM   = 0x1
 	_SOCK_DGRAM    = 0x2
 	_SOL_SOCKET    = 0x1

netdev_wasip2.go

@@ -0,0 +1,230 @@
+//go:build wasip2
+
+// L3/L4 network/transport layer implementation using WASI preview 2 sockets
+
+package net
+
+import (
+	"errors"
+	"fmt"
+	"net/netip"
+	"time"
+
+	instancenetwork "internal/wasi/sockets/v0.2.0/instance-network"
+	ipnamelookup "internal/wasi/sockets/v0.2.0/ip-name-lookup"
+	"internal/wasi/sockets/v0.2.0/network"
+)
+
+var errInvalidSocketFD = errors.New("wasip2: invalid socket fd")
+
+func tinygoToWasiAddr(ip netip.AddrPort) network.IPSocketAddress {
+	if ip.Addr().Is4() {
+		return network.IPSocketAddressIPv4(network.IPv4SocketAddress{
+			Port:    ip.Port(),
+			Address: ip.Addr().As4(),
+		})
+	}
+
+	if ip.Addr().Is6() {
+		as16 := ip.Addr().As16()
+		var as8uint16 [8]uint16
+		for i := 0; i < 8; i++ {
+			as8uint16[i] = uint16(as16[i*2])<<8 | uint16(as16[i*2+1])
+		}
+		return network.IPSocketAddressIPv6(network.IPv6SocketAddress{
+			Port:    ip.Port(),
+			Address: as8uint16,
+		})
+	}
+
+	return network.IPSocketAddressIPv4(network.IPv4SocketAddress{
+		Port: ip.Port(),
+	})
+}
+
+func wasiAddrToTinygo(addr network.IPSocketAddress) netip.AddrPort {
+	if addr4 := addr.IPv4(); addr4 != nil {
+		return netip.AddrPortFrom(netip.AddrFrom4(addr4.Address), addr4.Port)
+	}
+
+	if addr6 := addr.IPv6(); addr6 != nil {
+		var as16 [16]byte
+		for i := 0; i < 8; i++ {
+			as16[i*2] = byte(addr6.Address[i] >> 8)
+			as16[i*2+1] = byte(addr6.Address[i] & 0xFF)
+		}
+		return netip.AddrPortFrom(netip.AddrFrom16(as16), addr6.Port)
+	}
+
+	return netip.AddrPort{}
+}
+
+type wasip2Socket interface {
+	Recv(buf []byte, flags int, deadline time.Time) (int, error)
+	Send(buf []byte, flags int, deadline time.Time) (int, error)
+	Close() error
+	Listen(backlog int) error
+	Bind(globalNetwork instancenetwork.Network, ip network.IPSocketAddress) error
+	Connect(globalNetwork instancenetwork.Network, host string, ip network.IPSocketAddress) error
+	Accept() (wasip2Socket, *network.IPSocketAddress, error)
+}
+
+// wasip2Netdev is a netdev that uses WASI preview 2 sockets
+type wasip2Netdev struct {
+	fds    map[int]wasip2Socket
+	nextFd int
+	net    instancenetwork.Network
+}
+
+func init() {
+	useNetdev(&wasip2Netdev{
+		fds:    make(map[int]wasip2Socket),
+		nextFd: 0,
+		net:    instancenetwork.InstanceNetwork(),
+	})
+}
+
+func (n *wasip2Netdev) GetHostByName(name string) (netip.Addr, error) {
+	res := ipnamelookup.ResolveAddresses(n.net, name)
+
+	if res.IsErr() {
+		return netip.Addr{}, fmt.Errorf("failed to resolve address: %s", res.Err().String())
+	}
+
+	stream := res.OK()
+	pollable := stream.Subscribe()
+
+	for {
+		pollable.Block()
+		res := stream.ResolveNextAddress()
+
+		if res.IsErr() {
+			return netip.Addr{}, fmt.Errorf("failed to get resolved address: %s", res.Err().String())
+		}
+
+		if res.OK().None() {
+			return netip.Addr{}, errors.New("no addresses found")
+		}
+
+		// TODO: handle IPv6
+		if addr4 := res.OK().Some().IPv4(); addr4 != nil {
+			return netip.AddrFrom4(*addr4), nil
+		}
+	}
+}
+
+func (n *wasip2Netdev) Addr() (netip.Addr, error) {
+	return netip.Addr{}, errors.New("wasip2 TODO Addr")
+}
+
+func (n *wasip2Netdev) getNextFD() int {
+	n.nextFd++
+	return n.nextFd - 1
+}
+
+func (n *wasip2Netdev) Socket(domain int, stype int, protocol int) (sockfd int, _ error) {
+	af := network.IPAddressFamilyIPv4
+	if domain == _AF_INET6 {
+		af = network.IPAddressFamilyIPv6
+	}
+
+	var sock wasip2Socket
+	var err error
+
+	switch stype {
+	case _SOCK_STREAM:
+		sock, err = createTCPSocket(af)
+		if err != nil {
+			return -1, err
+		}
+	case _SOCK_DGRAM:
+		sock, err = createUDPSocket(af)
+		if err != nil {
+			return -1, err
+		}
+	default:
+		return -1, fmt.Errorf("wasip2: unsupported socket type %d", stype)
+	}
+
+	fd := n.getNextFD()
+	n.fds[fd] = sock
+
+	return fd, nil
+}
+
+func (n *wasip2Netdev) Bind(sockfd int, ip netip.AddrPort) error {
+	sock, ok := n.fds[sockfd]
+	if !ok {
+		return errInvalidSocketFD
+	}
+
+	return sock.Bind(n.net, tinygoToWasiAddr(ip))
+}
+
+func (n *wasip2Netdev) Connect(sockfd int, host string, ip netip.AddrPort) error {
+	sock, ok := n.fds[sockfd]
+	if !ok {
+		return errInvalidSocketFD
+	}
+
+	return sock.Connect(n.net, host, tinygoToWasiAddr(ip))
+}
+
+func (n *wasip2Netdev) Listen(sockfd int, backlog int) error {
+	sock, ok := n.fds[sockfd]
+	if !ok {
+		return errInvalidSocketFD
+	}
+
+	return sock.Listen(backlog)
+}
+
+func (n *wasip2Netdev) Accept(sockfd int) (int, netip.AddrPort, error) {
+	sock, ok := n.fds[sockfd]
+	if !ok {
+		return -1, netip.AddrPort{}, errInvalidSocketFD
+	}
+
+	newSock, raddr, err := sock.Accept()
+	if err != nil {
+		return -1, netip.AddrPort{}, fmt.Errorf("failed to accept connection: %s", err.Error())
+	}
+
+	fd := n.getNextFD()
+	n.fds[fd] = newSock
+
+	return fd, wasiAddrToTinygo(*raddr), nil
+}
+
+func (n *wasip2Netdev) Send(sockfd int, buf []byte, flags int, deadline time.Time) (int, error) {
+	sock, ok := n.fds[sockfd]
+	if !ok {
+		return -1, errInvalidSocketFD
+	}
+
+	return sock.Send(buf, flags, deadline)
+}
+
+func (n *wasip2Netdev) Recv(sockfd int, buf []byte, flags int, deadline time.Time) (int, error) {
+	sock, ok := n.fds[sockfd]
+	if !ok {
+		return -1, errInvalidSocketFD
+	}
+
+	return sock.Recv(buf, flags, deadline)
+}
+
+func (n *wasip2Netdev) Close(sockfd int) error {
+	sock, ok := n.fds[sockfd]
+	if !ok {
+		return errInvalidSocketFD
+	}
+
+	delete(n.fds, sockfd)
+
+	return sock.Close()
+}
+
+func (n *wasip2Netdev) SetSockOpt(sockfd int, level int, opt int, value interface{}) error {
+	return errors.New("wasip2 TODO set socket option")
+}