Add networking for target_os = "wasi"

With
* bytecodealliance/wasmtime#3711
* rust-lang/rust#93158
merged, mio can have limited support for networking for the
`wasm32-wasi` target.

Signed-off-by: Harald Hoyer <[email protected]>

Author: haraldh

src/net/mod.rs

@@ -28,7 +28,9 @@
 mod tcp;
 pub use self::tcp::{TcpListener, TcpStream};
 
+#[cfg(not(target_os = "wasi"))]
 mod udp;
+#[cfg(not(target_os = "wasi"))]
 pub use self::udp::UdpSocket;
 
 #[cfg(unix)]

src/net/tcp/listener.rs

@@ -1,13 +1,15 @@
 use std::net::{self, SocketAddr};
 #[cfg(unix)]
 use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
+#[cfg(target_os = "wasi")]
+use std::os::wasi::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
 #[cfg(windows)]
 use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket};
 use std::{fmt, io};
 
 use crate::io_source::IoSource;
 use crate::net::TcpStream;
-#[cfg(unix)]
+#[cfg(any(unix, target_os = "wasi"))]
 use crate::sys::tcp::set_reuseaddr;
 use crate::sys::tcp::{bind, listen, new_for_addr};
 use crate::{event, sys, Interest, Registry, Token};
@@ -54,7 +56,7 @@ impl TcpListener {
     /// 4. Calls `listen` on the socket to prepare it to receive new connections.
     pub fn bind(addr: SocketAddr) -> io::Result<TcpListener> {
         let socket = new_for_addr(addr)?;
-        #[cfg(unix)]
+        #[cfg(any(unix, target_os = "wasi"))]
         let listener = unsafe { TcpListener::from_raw_fd(socket) };
         #[cfg(windows)]
         let listener = unsafe { TcpListener::from_raw_socket(socket as _) };
@@ -215,3 +217,30 @@ impl FromRawSocket for TcpListener {
         TcpListener::from_std(FromRawSocket::from_raw_socket(socket))
     }
 }
+
+#[cfg(target_os = "wasi")]
+impl IntoRawFd for TcpListener {
+    fn into_raw_fd(self) -> RawFd {
+        self.inner.into_inner().into_raw_fd()
+    }
+}
+
+#[cfg(target_os = "wasi")]
+impl AsRawFd for TcpListener {
+    fn as_raw_fd(&self) -> RawFd {
+        self.inner.as_raw_fd()
+    }
+}
+
+#[cfg(target_os = "wasi")]
+impl FromRawFd for TcpListener {
+    /// Converts a `RawFd` to a `TcpListener`.
+    ///
+    /// # Notes
+    ///
+    /// The caller is responsible for ensuring that the socket is in
+    /// non-blocking mode.
+    unsafe fn from_raw_fd(fd: RawFd) -> TcpListener {
+        TcpListener::from_std(FromRawFd::from_raw_fd(fd))
+    }
+}

src/net/tcp/stream.rs

@@ -3,6 +3,8 @@ use std::io::{self, IoSlice, IoSliceMut, Read, Write};
 use std::net::{self, Shutdown, SocketAddr};
 #[cfg(unix)]
 use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
+#[cfg(target_os = "wasi")]
+use std::os::wasi::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
 #[cfg(windows)]
 use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket};
 
@@ -75,7 +77,7 @@ impl TcpStream {
     /// [read interest]: Interest::READABLE
     pub fn connect(addr: SocketAddr) -> io::Result<TcpStream> {
         let socket = new_for_addr(addr)?;
-        #[cfg(unix)]
+        #[cfg(any(unix, target_os = "wasi"))]
         let stream = unsafe { TcpStream::from_raw_fd(socket) };
         #[cfg(windows)]
         let stream = unsafe { TcpStream::from_raw_socket(socket as _) };
@@ -332,3 +334,30 @@ impl FromRawSocket for TcpStream {
         TcpStream::from_std(FromRawSocket::from_raw_socket(socket))
     }
 }
+
+#[cfg(target_os = "wasi")]
+impl IntoRawFd for TcpStream {
+    fn into_raw_fd(self) -> RawFd {
+        self.inner.into_inner().into_raw_fd()
+    }
+}
+
+#[cfg(target_os = "wasi")]
+impl AsRawFd for TcpStream {
+    fn as_raw_fd(&self) -> RawFd {
+        self.inner.as_raw_fd()
+    }
+}
+
+#[cfg(target_os = "wasi")]
+impl FromRawFd for TcpStream {
+    /// Converts a `RawFd` to a `TcpStream`.
+    ///
+    /// # Notes
+    ///
+    /// The caller is responsible for ensuring that the socket is in
+    /// non-blocking mode.
+    unsafe fn from_raw_fd(fd: RawFd) -> TcpStream {
+        TcpStream::from_std(FromRawFd::from_raw_fd(fd))
+    }
+}

src/sys/wasi/mod.rs

@@ -22,6 +22,12 @@ use std::time::Duration;
 
 use crate::{Interest, Token};
 
+cfg_net! {
+    mod net;
+
+    pub(crate) use net::tcp;
+}
+
 /// Unique id for use as `SelectorId`.
 #[cfg(debug_assertions)]
 static NEXT_ID: AtomicUsize = AtomicUsize::new(1);

src/sys/wasi/net.rs

@@ -0,0 +1,47 @@
+#![allow(dead_code)]
+
+use std::io;
+
+/// A lot of function are not support on Wasi, this function returns a
+/// consistent error when calling those functions.
+#[inline]
+fn unsupported() -> io::Error {
+    io::Error::new(io::ErrorKind::Other, "not supported on wasi")
+}
+
+pub(crate) mod tcp {
+    use std::io;
+    use std::net;
+
+    use super::unsupported;
+
+    pub type TcpSocket = wasi::Fd;
+
+    pub(crate) fn new_for_addr(_address: net::SocketAddr) -> io::Result<i32> {
+        Err(unsupported())
+    }
+
+    pub(crate) fn bind(_: &net::TcpListener, _: net::SocketAddr) -> io::Result<()> {
+        Err(unsupported())
+    }
+
+    pub(crate) fn connect(_: &net::TcpStream, _: net::SocketAddr) -> io::Result<net::TcpStream> {
+        Err(unsupported())
+    }
+
+    pub(crate) fn listen(_: &net::TcpListener, _: u32) -> io::Result<()> {
+        Err(unsupported())
+    }
+
+    pub(crate) fn set_reuseaddr(_: &net::TcpListener, _: bool) -> io::Result<()> {
+        Err(unsupported())
+    }
+
+    pub(crate) fn accept(
+        listener: &net::TcpListener,
+    ) -> io::Result<(net::TcpStream, net::SocketAddr)> {
+        let (stream, addr) = listener.accept()?;
+        stream.set_nonblocking(true)?;
+        Ok((stream, addr))
+    }
+}