Switch to sys modules

Author: adamrk

src/net/mod.rs

@@ -12,9 +12,44 @@ use wasip3::sockets::types::{
     ErrorCode, IpAddressFamily, IpSocketAddress, Ipv4SocketAddress, Ipv6SocketAddress, TcpSocket,
 };
 
-mod tcp_listener;
-mod tcp_stream;
-mod udp;
+mod tcp_listener {
+    mod sys {
+        #[cfg(target_env = "p2")]
+        pub(super) mod p2;
+        #[cfg(target_env = "p3")]
+        pub(super) mod p3;
+    }
+    #[cfg(target_env = "p2")]
+    pub use sys::p2::*;
+    #[cfg(target_env = "p3")]
+    pub use sys::p3::*;
+}
+
+mod tcp_stream {
+    mod sys {
+        #[cfg(target_env = "p2")]
+        pub(super) mod p2;
+        #[cfg(target_env = "p3")]
+        pub(super) mod p3;
+    }
+    #[cfg(target_env = "p2")]
+    pub use sys::p2::*;
+    #[cfg(target_env = "p3")]
+    pub use sys::p3::*;
+}
+
+mod udp {
+    mod sys {
+        #[cfg(target_env = "p2")]
+        pub(super) mod p2;
+        #[cfg(target_env = "p3")]
+        pub(super) mod p3;
+    }
+    #[cfg(target_env = "p2")]
+    pub use sys::p2::*;
+    #[cfg(target_env = "p3")]
+    pub use sys::p3::*;
+}
 
 pub use tcp_listener::*;
 pub use tcp_stream::*;

src/net/tcp_listener.rs src/net/tcp_listener/sys/p2.rssrc/net/tcp_listener.rs renamed to src/net/tcp_listener/sys/p2.rs

@@ -1,17 +1,10 @@
-#[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, create_tcp_socket, sockaddr_from_wasi, sockaddr_to_wasi, to_io_err};
-#[cfg(target_env = "p2")]
+use crate::net::{TcpStream, create_tcp_socket, sockaddr_from_wasi, sockaddr_to_wasi, to_io_err};
 use crate::runtime::AsyncPollable;
 
 /// A TCP socket server, listening for connections.
@@ -20,8 +13,6 @@ 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,
 }
 
@@ -40,30 +31,18 @@ impl TcpListener {
         let socket = create_tcp_socket(family).map_err(to_io_err)?;
         let local_address = sockaddr_to_wasi(addr);
 
-        #[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)?;
+        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 })
-        }
-        #[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,
-            })
-        }
+        socket.start_listen().map_err(to_io_err)?;
+        pollable.wait_for().await;
+        socket.finish_listen().map_err(to_io_err)?;
+        Ok(Self { pollable, socket })
     }
 
     /// Returns the local socket address of this listener.
@@ -90,7 +69,6 @@ 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) {
@@ -99,14 +77,4 @@ 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))
-        })
-    }
 }

src/net/tcp_listener/sys/p3.rs

@@ -0,0 +1,71 @@
+use wasip3::{
+    sockets::types::{IpAddressFamily, TcpSocket},
+    wit_bindgen::StreamReader,
+};
+
+use crate::io;
+use crate::iter::AsyncIterator;
+use std::net::SocketAddr;
+
+use crate::net::{TcpStream, create_tcp_socket, sockaddr_from_wasi, sockaddr_to_wasi, to_io_err};
+
+/// A TCP socket server, listening for connections.
+#[derive(Debug)]
+pub struct TcpListener {
+    connections: StreamReader<TcpSocket>,
+    socket: TcpSocket,
+}
+
+impl TcpListener {
+    /// Creates a new TcpListener which will be bound to the specified address.
+    ///
+    /// The returned listener is ready for accepting connections.
+    pub async fn bind(addr: &str) -> io::Result<Self> {
+        let addr: SocketAddr = addr
+            .parse()
+            .map_err(|_| io::Error::other("failed to parse string to socket addr"))?;
+        let family = match addr {
+            SocketAddr::V4(_) => IpAddressFamily::Ipv4,
+            SocketAddr::V6(_) => IpAddressFamily::Ipv6,
+        };
+        let socket = create_tcp_socket(family).map_err(to_io_err)?;
+        let local_address = sockaddr_to_wasi(addr);
+
+        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> {
+        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.
+    pub fn incoming(&mut self) -> Incoming<'_> {
+        Incoming { listener: self }
+    }
+}
+
+/// An iterator that infinitely accepts connections on a TcpListener.
+#[derive(Debug)]
+pub struct Incoming<'a> {
+    listener: &'a mut TcpListener,
+}
+
+impl<'a> AsyncIterator for Incoming<'a> {
+    type Item = io::Result<TcpStream>;
+
+    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))
+        })
+    }
+}

src/net/tcp_stream.rs src/net/tcp_stream/sys/p2.rssrc/net/tcp_stream.rs renamed to src/net/tcp_stream/sys/p2.rs

@@ -1,7 +1,6 @@
 use std::io::ErrorKind;
 use std::net::{SocketAddr, ToSocketAddrs};
 
-#[cfg(target_env = "p2")]
 use wasip2::{
     io::streams::{InputStream, OutputStream},
     sockets::{
@@ -11,16 +10,8 @@ use wasip2::{
     },
 };
 
-#[cfg(target_env = "p3")]
-use wasip3::sockets::types::{IpAddressFamily, IpSocketAddress, Ipv4SocketAddress, TcpSocket};
-#[cfg(target_env = "p3")]
-type InputStream = wasip3::wit_bindgen::StreamReader<u8>;
-#[cfg(target_env = "p3")]
-type OutputStream = wasip3::wit_bindgen::StreamWriter<u8>;
-
-use super::{create_tcp_socket, to_io_err};
 use crate::io::{self, AsyncInputStream, AsyncOutputStream};
-#[cfg(target_env = "p2")]
+use crate::net::{create_tcp_socket, to_io_err};
 use crate::runtime::AsyncPollable;
 
 /// A TCP stream between a local and a remote socket.
@@ -79,53 +70,36 @@ impl TcpStream {
             }
             SocketAddr::V6(_) => todo!("IPv6 not yet supported in `wstd::net::TcpStream`"),
         };
-        #[cfg(target_env = "p2")]
-        {
-            let network = instance_network();
-            socket
-                .start_connect(&network, remote_address)
-                .map_err(to_io_err)?;
-            let pollable = AsyncPollable::new(socket.subscribe());
-            pollable.wait_for().await;
-            let (input, output) = socket.finish_connect().map_err(to_io_err)?;
-            Ok(TcpStream::new(input, output, socket))
-        }
-        #[cfg(target_env = "p3")]
-        {
-            socket.connect(remote_address).await.map_err(to_io_err)?;
-            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))
-        }
+        let network = instance_network();
+        socket
+            .start_connect(&network, remote_address)
+            .map_err(to_io_err)?;
+        let pollable = AsyncPollable::new(socket.subscribe());
+        pollable.wait_for().await;
+        let (input, output) = socket.finish_connect().map_err(to_io_err)?;
+        Ok(TcpStream::new(input, output, socket))
     }
 
     /// Returns the socket address of the remote peer of this TCP connection.
     pub fn peer_addr(&self) -> io::Result<String> {
-        #[cfg(target_env = "p2")]
         let addr = self.socket.remote_address().map_err(to_io_err)?;
-        #[cfg(target_env = "p3")]
-        let addr = self.socket.get_remote_address().map_err(to_io_err)?;
         Ok(format!("{addr:?}"))
     }
 
     pub fn split(&mut self) -> (ReadHalf<'_>, WriteHalf<'_>) {
         (
             ReadHalf {
                 stream: &mut self.input,
-                #[cfg(target_env = "p2")]
                 socket: &self.socket,
             },
             WriteHalf {
                 stream: &mut self.output,
-                #[cfg(target_env = "p2")]
                 socket: &self.socket,
             },
         )
     }
 }
 
-#[cfg(target_env = "p2")]
 impl Drop for TcpStream {
     fn drop(&mut self) {
         let _ = self
@@ -160,11 +134,9 @@ impl io::AsyncWrite for TcpStream {
 
 pub struct ReadHalf<'a> {
     stream: &'a mut AsyncInputStream,
-    #[cfg(target_env = "p2")]
     socket: &'a TcpSocket,
 }
 
-#[cfg(target_env = "p2")]
 impl<'a> Drop for ReadHalf<'a> {
     fn drop(&mut self) {
         let _ = self
@@ -185,7 +157,6 @@ impl<'a> io::AsyncRead for ReadHalf<'a> {
 
 pub struct WriteHalf<'a> {
     stream: &'a mut AsyncOutputStream,
-    #[cfg(target_env = "p2")]
     socket: &'a TcpSocket,
 }
 
@@ -203,7 +174,6 @@ impl<'a> io::AsyncWrite for WriteHalf<'a> {
     }
 }
 
-#[cfg(target_env = "p2")]
 impl<'a> Drop for WriteHalf<'a> {
     fn drop(&mut self) {
         let _ = self