feat: UdpSocket/UdpStream

examples/udp_echo_server.rs

@@ -0,0 +1,18 @@
+use wstd::io;
+use wstd::net::UdpSocket;
+
+#[wstd::main]
+async fn main() -> io::Result<()> {
+    let socket = UdpSocket::bind("127.0.0.1:8080").await?;
+    println!("Listening on {}", socket.local_addr()?);
+    println!("type `nc -u localhost 8080` to create a UDP client");
+
+    let mut buf = vec![0; 65535];
+    loop {
+        let (len, peer) = socket.recv_from(&mut buf).await?;
+        println!("Received {len} bytes from: {peer}");
+        // If the echo send fails, we can ignore it: one socket serves every
+        // peer here, so a failure for one must not end the loop for the rest.
+        let _ = socket.send_to(&buf[..len], peer).await;
+    }
+}

examples/udp_stream_client.rs

@@ -0,0 +1,42 @@
+use wstd::io;
+use wstd::net::{UdpSocket, UdpStream};
+
+async fn ping(stream: &UdpStream) -> io::Result<()> {
+    assert_eq!(stream.send(b"ping\n").await?, 5);
+
+    let mut reply = [0; 5];
+    let len = stream.recv(&mut reply).await?;
+    assert_eq!(&reply[..len], b"pong\n");
+
+    Ok(())
+}
+
+#[wstd::main]
+async fn main() -> io::Result<()> {
+    let mut args = std::env::args();
+
+    let _ = args.next();
+
+    let addr = args.next().ok_or_else(|| {
+        io::Error::new(
+            std::io::ErrorKind::InvalidInput,
+            "address argument required",
+        )
+    })?;
+
+    let stream = UdpStream::connect(addr).await?;
+    ping(&stream).await?;
+
+    let peer = stream.peer_addr()?;
+    drop(stream);
+
+    let local_addr = if peer.is_ipv4() {
+        "0.0.0.0:0"
+    } else {
+        "[::]:0"
+    };
+    let stream = UdpSocket::bind(local_addr).await?.connect(peer)?;
+    ping(&stream).await?;
+
+    Ok(())
+}

src/net/mod.rs

@@ -1,13 +1,15 @@
 //! Async network abstractions.
 
 use std::io::{self, ErrorKind};
-use wasip2::sockets::network::ErrorCode;
+use wasip2::sockets::network::{ErrorCode, IpSocketAddress, Ipv4SocketAddress};
 
 mod tcp_listener;
 mod tcp_stream;
+mod udp;
 
 pub use tcp_listener::*;
 pub use tcp_stream::*;
+pub use udp::*;
 
 fn to_io_err(err: ErrorCode) -> io::Error {
     match err {
@@ -24,6 +26,55 @@ fn to_io_err(err: ErrorCode) -> io::Error {
         ErrorCode::ConnectionReset => ErrorKind::ConnectionReset.into(),
         ErrorCode::ConnectionAborted => ErrorKind::ConnectionAborted.into(),
         ErrorCode::ConcurrencyConflict => ErrorKind::AlreadyExists.into(),
+        ErrorCode::DatagramTooLarge => ErrorKind::InvalidInput.into(),
         _ => ErrorKind::Other.into(),
     }
 }
+
+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(
+                std::net::Ipv4Addr::new(address.0, address.1, address.2, address.3),
+                port,
+            ))
+        }
+        IpSocketAddress::Ipv6(Ipv6SocketAddress {
+            address,
+            port,
+            flow_info,
+            scope_id,
+        }) => std::net::SocketAddr::V6(std::net::SocketAddrV6::new(
+            std::net::Ipv6Addr::new(
+                address.0, address.1, address.2, address.3, address.4, address.5, address.6,
+                address.7,
+            ),
+            port,
+            flow_info,
+            scope_id,
+        )),
+    }
+}
+
+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();
+            IpSocketAddress::Ipv4(Ipv4SocketAddress {
+                address: (ip[0], ip[1], ip[2], ip[3]),
+                port: addr.port(),
+            })
+        }
+        std::net::SocketAddr::V6(addr) => {
+            let ip = addr.ip().segments();
+            IpSocketAddress::Ipv6(Ipv6SocketAddress {
+                address: (ip[0], ip[1], ip[2], ip[3], ip[4], ip[5], ip[6], ip[7]),
+                port: addr.port(),
+                flow_info: addr.flowinfo(),
+                scope_id: addr.scope_id(),
+            })
+        }
+    }
+}

src/net/tcp_listener.rs

@@ -1,11 +1,10 @@
-use wasip2::sockets::network::Ipv4SocketAddress;
-use wasip2::sockets::tcp::{IpAddressFamily, IpSocketAddress, TcpSocket};
+use wasip2::sockets::tcp::{IpAddressFamily, TcpSocket};
 
 use crate::io;
 use crate::iter::AsyncIterator;
 use std::net::SocketAddr;
 
-use super::{TcpStream, to_io_err};
+use super::{TcpStream, sockaddr_from_wasi, sockaddr_to_wasi, to_io_err};
 use crate::runtime::AsyncPollable;
 
 /// A TCP socket server, listening for connections.
@@ -79,51 +78,3 @@ impl<'a> AsyncIterator for Incoming<'a> {
         Some(Ok(TcpStream::new(input, output, socket)))
     }
 }
-
-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(
-                std::net::Ipv4Addr::new(address.0, address.1, address.2, address.3),
-                port,
-            ))
-        }
-        IpSocketAddress::Ipv6(Ipv6SocketAddress {
-            address,
-            port,
-            flow_info,
-            scope_id,
-        }) => std::net::SocketAddr::V6(std::net::SocketAddrV6::new(
-            std::net::Ipv6Addr::new(
-                address.0, address.1, address.2, address.3, address.4, address.5, address.6,
-                address.7,
-            ),
-            port,
-            flow_info,
-            scope_id,
-        )),
-    }
-}
-
-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();
-            IpSocketAddress::Ipv4(Ipv4SocketAddress {
-                address: (ip[0], ip[1], ip[2], ip[3]),
-                port: addr.port(),
-            })
-        }
-        std::net::SocketAddr::V6(addr) => {
-            let ip = addr.ip().segments();
-            IpSocketAddress::Ipv6(Ipv6SocketAddress {
-                address: (ip[0], ip[1], ip[2], ip[3], ip[4], ip[5], ip[6], ip[7]),
-                port: addr.port(),
-                flow_info: addr.flowinfo(),
-                scope_id: addr.scope_id(),
-            })
-        }
-    }
-}