chore: merge wasip3 in wasmtime_wasi

Signed-off-by: Roman Volosatovs <[email protected]>

Author: rvolosatovs

ci/vendor-wit.sh

@@ -63,16 +63,7 @@ make_vendor "wasi-config" "config@f4d699b"
 
 make_vendor "wasi-keyvalue" "keyvalue@219ea36"
 
-make_vendor "wasi-clocks/src/p3" "clocks@[email protected]"
-
-make_vendor "wasi-random/src/p3" "random@[email protected]"
-
-make_vendor "wasi-sockets/src/p3" "
-    clocks@[email protected]
-    sockets@[email protected]
-"
-
-make_vendor "wasi-cli/src/p3" "
+make_vendor "wasi/src/p3" "
     cli@[email protected]
     clocks@[email protected]
     filesystem@[email protected]

crates/test-programs/src/bin/sockets_0_3_tcp_bind.rs

@@ -0,0 +1,179 @@
+use futures::{stream, try_join, SinkExt as _, StreamExt as _};
+use test_programs::p3::wasi::sockets::types::{
+    ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, TcpSocket,
+};
+use test_programs::p3::{sockets::attempt_random_port, wit_stream};
+use wit_bindgen_rt::async_support::StreamReader;
+
+struct Component;
+
+test_programs::p3::export!(Component);
+
+/// Bind a socket and let the system determine a port.
+fn test_tcp_bind_ephemeral_port(ip: IpAddress) {
+    let bind_addr = IpSocketAddress::new(ip, 0);
+
+    let sock = TcpSocket::new(ip.family());
+    sock.bind(bind_addr).unwrap();
+
+    let bound_addr = sock.local_address().unwrap();
+
+    assert_eq!(bind_addr.ip(), bound_addr.ip());
+    assert_ne!(bind_addr.port(), bound_addr.port());
+}
+
+/// Bind a socket on a specified port.
+fn test_tcp_bind_specific_port(ip: IpAddress) {
+    let sock = TcpSocket::new(ip.family());
+
+    let bind_addr = attempt_random_port(ip, |bind_addr| sock.bind(bind_addr)).unwrap();
+
+    let bound_addr = sock.local_address().unwrap();
+
+    assert_eq!(bind_addr.ip(), bound_addr.ip());
+    assert_eq!(bind_addr.port(), bound_addr.port());
+}
+
+/// Two sockets may not be actively bound to the same address at the same time.
+fn test_tcp_bind_addrinuse(ip: IpAddress) {
+    let bind_addr = IpSocketAddress::new(ip, 0);
+
+    let sock1 = TcpSocket::new(ip.family());
+    sock1.bind(bind_addr).unwrap();
+    sock1.listen().unwrap();
+
+    let bound_addr = sock1.local_address().unwrap();
+
+    let sock2 = TcpSocket::new(ip.family());
+    assert_eq!(sock2.bind(bound_addr), Err(ErrorCode::AddressInUse));
+}
+
+// The WASI runtime should set SO_REUSEADDR for us
+async fn test_tcp_bind_reuseaddr(ip: IpAddress) {
+    let client = TcpSocket::new(ip.family());
+
+    let bind_addr = {
+        let listener1 = TcpSocket::new(ip.family());
+
+        let bind_addr = attempt_random_port(ip, |bind_addr| listener1.bind(bind_addr)).unwrap();
+
+        let mut accept = listener1.listen().unwrap();
+
+        let connect_addr =
+            IpSocketAddress::new(IpAddress::new_loopback(ip.family()), bind_addr.port());
+        client.connect(connect_addr).unwrap();
+
+        let mut sock = accept.next().await.unwrap();
+        assert_eq!(sock.len(), 1);
+        let sock = sock.pop().unwrap();
+        let (mut data_tx, data_rx) = wit_stream::new();
+        sock.send(data_rx).unwrap();
+        data_tx.send(vec![0; 10]).await.unwrap();
+
+        bind_addr
+    };
+
+    {
+        let listener2 = TcpSocket::new(ip.family());
+
+        // If SO_REUSEADDR was configured correctly, the following lines shouldn't be
+        // affected by the TIME_WAIT state of the just closed `listener1` socket:
+        listener2.bind(bind_addr).unwrap();
+        listener2.listen().unwrap();
+    }
+
+    drop(client);
+}
+
+// Try binding to an address that is not configured on the system.
+fn test_tcp_bind_addrnotavail(ip: IpAddress) {
+    let bind_addr = IpSocketAddress::new(ip, 0);
+
+    let sock = TcpSocket::new(ip.family());
+
+    assert_eq!(sock.bind(bind_addr), Err(ErrorCode::AddressNotBindable));
+}
+
+/// Bind should validate the address family.
+fn test_tcp_bind_wrong_family(family: IpAddressFamily) {
+    let wrong_ip = match family {
+        IpAddressFamily::Ipv4 => IpAddress::IPV6_LOOPBACK,
+        IpAddressFamily::Ipv6 => IpAddress::IPV4_LOOPBACK,
+    };
+
+    let sock = TcpSocket::new(family);
+    let result = sock.bind(IpSocketAddress::new(wrong_ip, 0));
+
+    assert!(matches!(result, Err(ErrorCode::InvalidArgument)));
+}
+
+/// Bind only works on unicast addresses.
+fn test_tcp_bind_non_unicast() {
+    let ipv4_broadcast = IpSocketAddress::new(IpAddress::IPV4_BROADCAST, 0);
+    let ipv4_multicast = IpSocketAddress::new(IpAddress::Ipv4((224, 254, 0, 0)), 0);
+    let ipv6_multicast = IpSocketAddress::new(IpAddress::Ipv6((0xff00, 0, 0, 0, 0, 0, 0, 0)), 0);
+
+    let sock_v4 = TcpSocket::new(IpAddressFamily::Ipv4);
+    let sock_v6 = TcpSocket::new(IpAddressFamily::Ipv6);
+
+    assert!(matches!(
+        sock_v4.bind(ipv4_broadcast),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(
+        sock_v4.bind(ipv4_multicast),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(
+        sock_v6.bind(ipv6_multicast),
+        Err(ErrorCode::InvalidArgument)
+    ));
+}
+
+fn test_tcp_bind_dual_stack() {
+    let sock = TcpSocket::new(IpAddressFamily::Ipv6);
+    let addr = IpSocketAddress::new(IpAddress::IPV4_MAPPED_LOOPBACK, 0);
+
+    // Binding an IPv4-mapped-IPv6 address on a ipv6-only socket should fail:
+    assert!(matches!(sock.bind(addr), Err(ErrorCode::InvalidArgument)));
+}
+
+impl test_programs::p3::exports::wasi::cli::run::Guest for Component {
+    async fn run() -> Result<(), ()> {
+        const RESERVED_IPV4_ADDRESS: IpAddress = IpAddress::Ipv4((192, 0, 2, 0)); // Reserved for documentation and examples.
+        const RESERVED_IPV6_ADDRESS: IpAddress =
+            IpAddress::Ipv6((0x2001, 0x0db8, 0, 0, 0, 0, 0, 0)); // Reserved for documentation and examples.
+
+        test_tcp_bind_ephemeral_port(IpAddress::IPV4_LOOPBACK);
+        test_tcp_bind_ephemeral_port(IpAddress::IPV6_LOOPBACK);
+        test_tcp_bind_ephemeral_port(IpAddress::IPV4_UNSPECIFIED);
+        test_tcp_bind_ephemeral_port(IpAddress::IPV6_UNSPECIFIED);
+
+        test_tcp_bind_specific_port(IpAddress::IPV4_LOOPBACK);
+        test_tcp_bind_specific_port(IpAddress::IPV6_LOOPBACK);
+        test_tcp_bind_specific_port(IpAddress::IPV4_UNSPECIFIED);
+        test_tcp_bind_specific_port(IpAddress::IPV6_UNSPECIFIED);
+
+        test_tcp_bind_reuseaddr(IpAddress::IPV4_LOOPBACK).await;
+        test_tcp_bind_reuseaddr(IpAddress::IPV6_LOOPBACK).await;
+
+        test_tcp_bind_addrinuse(IpAddress::IPV4_LOOPBACK);
+        test_tcp_bind_addrinuse(IpAddress::IPV6_LOOPBACK);
+        test_tcp_bind_addrinuse(IpAddress::IPV4_UNSPECIFIED);
+        test_tcp_bind_addrinuse(IpAddress::IPV6_UNSPECIFIED);
+
+        test_tcp_bind_addrnotavail(RESERVED_IPV4_ADDRESS);
+        test_tcp_bind_addrnotavail(RESERVED_IPV6_ADDRESS);
+
+        test_tcp_bind_wrong_family(IpAddressFamily::Ipv4);
+        test_tcp_bind_wrong_family(IpAddressFamily::Ipv6);
+
+        test_tcp_bind_non_unicast();
+
+        test_tcp_bind_dual_stack();
+
+        Ok(())
+    }
+}
+
+fn main() {}

crates/wasi-sockets/src/p3/host/types/tcp.rs

@@ -137,14 +137,13 @@ where
                         || !socket_addr_check(remote_address, SocketAddrUse::TcpConnect).await =>
                 {
                     if let Some((sock, bound, ..)) = sock {
-                        Ok(Ok((sock, bound, Err(ErrorCode::AccessDenied))))
+                        Ok(Ok(Err((sock, bound, ErrorCode::AccessDenied))))
                     } else {
                         Ok(Err(ErrorCode::AccessDenied))
                     }
                 }
-                Ok(Some((sock, bound, family))) => {
-                    let res = connect(&sock, remote_address, family).await;
-                    Ok(Ok((sock, bound, res)))
+                Ok(Some((sock, .., family))) => {
+                    Ok(Ok(Ok(connect(sock, remote_address, family).await)))
                 }
                 Ok(None) => Ok(Err(ErrorCode::InvalidState)),
                 Err(err) => Err(err),
@@ -156,24 +155,28 @@ where
                     .table()
                     .get_mut(&mut socket)
                     .context("failed to get socket resource from table")?;
-                let (sock, bound, res) = match sock {
+                let sock = match sock {
                     Ok(sock) => sock,
                     Err(err) => return Ok(Err(err)),
                 };
                 ensure!(
                     matches!(socket.tcp_state, TcpState::Connecting),
                     "corrupted socket state"
                 );
-                match res {
-                    Ok(stream) => {
+                match sock {
+                    Ok(Ok(stream)) => {
                         socket.tcp_state = TcpState::Connected(stream);
                         Ok(Ok(()))
                     }
-                    Err(err) if bound => {
+                    Ok(Err(err)) => {
+                        socket.tcp_state = TcpState::Closed;
+                        Ok(Err(err))
+                    }
+                    Err((sock, bound, err)) if bound => {
                         socket.tcp_state = TcpState::Bound(sock);
                         Ok(Err(err))
                     }
-                    Err(err) => {
+                    Err((sock, bound, err)) => {
                         socket.tcp_state = TcpState::Default(sock);
                         Ok(Err(err))
                     }

crates/wasi-sockets/tests/p3.rs

@@ -108,3 +108,8 @@ foreach_sockets_0_3!(assert_test_exists);
 async fn sockets_0_3_ip_name_lookup() -> anyhow::Result<()> {
     run(SOCKETS_0_3_IP_NAME_LOOKUP_COMPONENT).await
 }
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn sockets_0_3_tcp_bind() -> anyhow::Result<()> {
+    run(SOCKETS_0_3_TCP_BIND_COMPONENT).await
+}

crates/wasi/Cargo.toml

@@ -54,10 +54,13 @@ windows-sys = { workspace = true }
 rustix = { workspace = true, features = ["event", "net"] }
 
 [features]
-default = [ "preview1"]
+default = [ "preview1", "p3"]
 preview1 = [
     "dep:wiggle",
 ]
+p3 = [
+    "wasmtime/component-model-async",
+]
 
 [[test]]
 name = "process_stdin"

crates/wasi/src/lib.rs

@@ -242,6 +242,8 @@ mod filesystem;
 mod host;
 mod ip_name_lookup;
 mod network;
+#[cfg(feature = "p3")]
+pub mod p3;
 pub mod pipe;
 mod poll;
 #[cfg(feature = "preview1")]