Implement net for WASIp3

Author: adamrk

examples/tcp_echo_server.rs

@@ -1,15 +1,15 @@
-#![cfg_attr(not(all(target_os = "wasi", target_env = "p2")), no_main)]
-#![cfg(all(target_os = "wasi", target_env = "p2"))]
+#![cfg_attr(not(target_os = "wasi"), no_main)]
+#![cfg(target_os = "wasi")]
 
 use wstd::io;
 use wstd::iter::AsyncIterator;
 use wstd::net::TcpListener;
 
 #[wstd::main]
 async fn main() -> io::Result<()> {
-    let mut listener = TcpListener::bind("127.0.0.1:8080").await?;
+    let mut listener = TcpListener::bind("127.0.0.1:0").await?;
     println!("Listening on {}", listener.local_addr()?);
-    println!("type `nc localhost 8080` to create a TCP client");
+    println!("type `nc localhost <PORT>` to create a TCP client");
 
     let mut incoming = listener.incoming();
     while let Some(stream) = incoming.next().await {

examples/tcp_stream_client.rs

@@ -1,5 +1,5 @@
-#![cfg_attr(not(all(target_os = "wasi", target_env = "p2")), no_main)]
-#![cfg(all(target_os = "wasi", target_env = "p2"))]
+#![cfg_attr(not(target_os = "wasi"), no_main)]
+#![cfg(target_os = "wasi")]
 
 use wstd::io::{self, AsyncRead, AsyncWrite};
 use wstd::net::TcpStream;

examples/udp_echo_server.rs

@@ -1,14 +1,14 @@
-#![cfg_attr(not(all(target_os = "wasi", target_env = "p2")), no_main)]
-#![cfg(all(target_os = "wasi", target_env = "p2"))]
+#![cfg_attr(not(target_os = "wasi"), no_main)]
+#![cfg(target_os = "wasi")]
 
 use wstd::io;
 use wstd::net::UdpSocket;
 
 #[wstd::main]
 async fn main() -> io::Result<()> {
-    let socket = UdpSocket::bind("127.0.0.1:8080").await?;
+    let socket = UdpSocket::bind("127.0.0.1:0").await?;
     println!("Listening on {}", socket.local_addr()?);
-    println!("type `nc -u localhost 8080` to create a UDP client");
+    println!("type `nc -u localhost <PORT>` to create a UDP client");
 
     let mut buf = vec![0; 65535];
     loop {

examples/udp_stream_client.rs

@@ -1,5 +1,5 @@
-#![cfg_attr(not(all(target_os = "wasi", target_env = "p2")), no_main)]
-#![cfg(all(target_os = "wasi", target_env = "p2"))]
+#![cfg_attr(not(target_os = "wasi"), no_main)]
+#![cfg(target_os = "wasi")]
 
 use wstd::io;
 use wstd::net::{UdpSocket, UdpStream};

src/lib.rs

@@ -62,7 +62,6 @@ pub mod future;
 pub mod http;
 pub mod io;
 pub mod iter;
-#[cfg(all(target_os = "wasi", target_env = "p2"))]
 pub mod net;
 pub mod rand;
 pub mod runtime;

src/net/mod.rs

@@ -1,7 +1,16 @@
 //! Async network abstractions.
 
 use std::io::{self, ErrorKind};
-use wasip2::sockets::network::{ErrorCode, IpSocketAddress, Ipv4SocketAddress};
+#[cfg(target_env = "p2")]
+use wasip2::sockets::{
+    network::{ErrorCode, IpSocketAddress, Ipv4SocketAddress, Ipv6SocketAddress},
+    tcp_create_socket::create_tcp_socket,
+    udp_create_socket::create_udp_socket,
+};
+#[cfg(target_env = "p3")]
+use wasip3::sockets::types::{
+    ErrorCode, IpAddressFamily, IpSocketAddress, Ipv4SocketAddress, Ipv6SocketAddress, TcpSocket,
+};
 
 mod tcp_listener;
 mod tcp_stream;
@@ -13,26 +22,39 @@ pub use udp::*;
 
 fn to_io_err(err: ErrorCode) -> io::Error {
     match err {
-        ErrorCode::Unknown => ErrorKind::Other.into(),
         ErrorCode::AccessDenied => ErrorKind::PermissionDenied.into(),
         ErrorCode::NotSupported => ErrorKind::Unsupported.into(),
         ErrorCode::InvalidArgument => ErrorKind::InvalidInput.into(),
         ErrorCode::OutOfMemory => ErrorKind::OutOfMemory.into(),
         ErrorCode::Timeout => ErrorKind::TimedOut.into(),
-        ErrorCode::WouldBlock => ErrorKind::WouldBlock.into(),
         ErrorCode::InvalidState => ErrorKind::InvalidData.into(),
         ErrorCode::AddressInUse => ErrorKind::AddrInUse.into(),
         ErrorCode::ConnectionRefused => ErrorKind::ConnectionRefused.into(),
         ErrorCode::ConnectionReset => ErrorKind::ConnectionReset.into(),
         ErrorCode::ConnectionAborted => ErrorKind::ConnectionAborted.into(),
-        ErrorCode::ConcurrencyConflict => ErrorKind::AlreadyExists.into(),
         ErrorCode::DatagramTooLarge => ErrorKind::InvalidInput.into(),
+
+        #[cfg(target_env = "p2")]
+        ErrorCode::Unknown => ErrorKind::Other.into(),
+        #[cfg(target_env = "p2")]
+        ErrorCode::WouldBlock => ErrorKind::WouldBlock.into(),
+        #[cfg(target_env = "p2")]
+        ErrorCode::ConcurrencyConflict => ErrorKind::AlreadyExists.into(),
+        #[cfg(target_env = "p2")]
         _ => ErrorKind::Other.into(),
+
+        #[cfg(target_env = "p3")]
+        ErrorCode::AddressNotBindable => ErrorKind::AddrNotAvailable.into(),
+        #[cfg(target_env = "p3")]
+        ErrorCode::RemoteUnreachable => ErrorKind::HostUnreachable.into(),
+        #[cfg(target_env = "p3")]
+        ErrorCode::ConnectionBroken => ErrorKind::BrokenPipe.into(),
+        #[cfg(target_env = "p3")]
+        ErrorCode::Other(s) => io::Error::other(s.unwrap_or_default()),
     }
 }
 
 fn sockaddr_from_wasi(addr: IpSocketAddress) -> std::net::SocketAddr {
-    use wasip2::sockets::network::Ipv6SocketAddress;
     match addr {
         IpSocketAddress::Ipv4(Ipv4SocketAddress { address, port }) => {
             std::net::SocketAddr::V4(std::net::SocketAddrV4::new(
@@ -58,7 +80,6 @@ fn sockaddr_from_wasi(addr: IpSocketAddress) -> std::net::SocketAddr {
 }
 
 fn sockaddr_to_wasi(addr: std::net::SocketAddr) -> IpSocketAddress {
-    use wasip2::sockets::network::Ipv6SocketAddress;
     match addr {
         std::net::SocketAddr::V4(addr) => {
             let ip = addr.ip().octets();
@@ -78,3 +99,17 @@ fn sockaddr_to_wasi(addr: std::net::SocketAddr) -> IpSocketAddress {
         }
     }
 }
+
+#[cfg(target_env = "p3")]
+fn create_tcp_socket(
+    family: IpAddressFamily,
+) -> Result<TcpSocket, wasip3::sockets::types::ErrorCode> {
+    TcpSocket::create(family)
+}
+
+#[cfg(target_env = "p3")]
+fn create_udp_socket(
+    family: IpAddressFamily,
+) -> Result<wasip3::sockets::types::UdpSocket, wasip3::sockets::types::ErrorCode> {
+    wasip3::sockets::types::UdpSocket::create(family)
+}

src/net/tcp_listener.rs

@@ -1,17 +1,27 @@
+#[cfg(target_env = "p2")]
 use wasip2::sockets::tcp::{IpAddressFamily, TcpSocket};
+#[cfg(target_env = "p3")]
+use wasip3::{
+    sockets::types::{IpAddressFamily, TcpSocket},
+    wit_bindgen::StreamReader,
+};
 
 use crate::io;
 use crate::iter::AsyncIterator;
 use std::net::SocketAddr;
 
-use super::{TcpStream, sockaddr_from_wasi, sockaddr_to_wasi, to_io_err};
+use super::{TcpStream, create_tcp_socket, sockaddr_from_wasi, sockaddr_to_wasi, to_io_err};
+#[cfg(target_env = "p2")]
 use crate::runtime::AsyncPollable;
 
 /// A TCP socket server, listening for connections.
 #[derive(Debug)]
 pub struct TcpListener {
     // Field order matters: must drop this child before parent below
+    #[cfg(target_env = "p2")]
     pollable: AsyncPollable,
+    #[cfg(target_env = "p3")]
+    connections: StreamReader<TcpSocket>,
     socket: TcpSocket,
 }
 
@@ -27,31 +37,42 @@ impl TcpListener {
             SocketAddr::V4(_) => IpAddressFamily::Ipv4,
             SocketAddr::V6(_) => IpAddressFamily::Ipv6,
         };
-        let socket =
-            wasip2::sockets::tcp_create_socket::create_tcp_socket(family).map_err(to_io_err)?;
-        let network = wasip2::sockets::instance_network::instance_network();
-
+        let socket = create_tcp_socket(family).map_err(to_io_err)?;
         let local_address = sockaddr_to_wasi(addr);
 
-        socket
-            .start_bind(&network, local_address)
-            .map_err(to_io_err)?;
-        let pollable = AsyncPollable::new(socket.subscribe());
-        pollable.wait_for().await;
-        socket.finish_bind().map_err(to_io_err)?;
+        #[cfg(target_env = "p2")]
+        {
+            let network = wasip2::sockets::instance_network::instance_network();
+            socket
+                .start_bind(&network, local_address)
+                .map_err(to_io_err)?;
+            let pollable = AsyncPollable::new(socket.subscribe());
+            pollable.wait_for().await;
+            socket.finish_bind().map_err(to_io_err)?;
 
-        socket.start_listen().map_err(to_io_err)?;
-        pollable.wait_for().await;
-        socket.finish_listen().map_err(to_io_err)?;
-        Ok(Self { pollable, socket })
+            socket.start_listen().map_err(to_io_err)?;
+            pollable.wait_for().await;
+            socket.finish_listen().map_err(to_io_err)?;
+            Ok(Self { pollable, socket })
+        }
+        #[cfg(target_env = "p3")]
+        {
+            socket.bind(local_address).map_err(to_io_err)?;
+            let connections = socket.listen().map_err(to_io_err)?;
+            Ok(Self {
+                connections,
+                socket,
+            })
+        }
     }
 
     /// Returns the local socket address of this listener.
     pub fn local_addr(&self) -> io::Result<std::net::SocketAddr> {
-        self.socket
-            .local_address()
-            .map_err(to_io_err)
-            .map(sockaddr_from_wasi)
+        #[cfg(target_env = "p2")]
+        let addr = self.socket.local_address();
+        #[cfg(target_env = "p3")]
+        let addr = self.socket.get_local_address();
+        addr.map_err(to_io_err).map(sockaddr_from_wasi)
     }
 
     /// Returns an iterator over the connections being received on this listener.
@@ -69,6 +90,7 @@ pub struct Incoming<'a> {
 impl<'a> AsyncIterator for Incoming<'a> {
     type Item = io::Result<TcpStream>;
 
+    #[cfg(target_env = "p2")]
     async fn next(&mut self) -> Option<Self::Item> {
         self.listener.pollable.wait_for().await;
         let (socket, input, output) = match self.listener.socket.accept().map_err(to_io_err) {
@@ -77,4 +99,14 @@ impl<'a> AsyncIterator for Incoming<'a> {
         };
         Some(Ok(TcpStream::new(input, output, socket)))
     }
+
+    #[cfg(target_env = "p3")]
+    async fn next(&mut self) -> Option<Self::Item> {
+        self.listener.connections.next().await.map(|socket| {
+            let (input, _receive_result) = socket.receive();
+            let (output, receiver) = wasip3::wit_stream::new();
+            let _send_result = socket.send(receiver);
+            Ok(TcpStream::new(input, output, socket))
+        })
+    }
 }