Update WASIp3 wasi:sockets WITs (#11422)

Brings in a few cosmetic changes to definitions to keep things up-to-date.

Closes bytecodealliance/wasip3-prototyping#242

Author: alexcrichton

ci/vendor-wit.sh

@@ -73,7 +73,7 @@ make_vendor "wasi/src/p3" "
     clocks@13d1c82@wit-0.3.0-draft
     filesystem@2007d36@wit-0.3.0-draft
     random@4e94663@wit-0.3.0-draft
-    sockets@e863ee2@wit-0.3.0-draft
+    sockets@bc1b8b1@wit-0.3.0-draft
 "
 
 rm -rf $cache_dir

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

@@ -14,22 +14,22 @@ test_programs::p3::export!(Component);
 fn test_tcp_bind_ephemeral_port(ip: IpAddress) {
     let bind_addr = IpSocketAddress::new(ip, 0);
 
-    let sock = TcpSocket::new(ip.family());
+    let sock = TcpSocket::create(ip.family()).unwrap();
     sock.bind(bind_addr).unwrap();
 
-    let bound_addr = sock.local_address().unwrap();
+    let bound_addr = sock.get_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 sock = TcpSocket::create(ip.family()).unwrap();
 
     let bind_addr = attempt_random_port(ip, |bind_addr| sock.bind(bind_addr)).unwrap();
 
-    let bound_addr = sock.local_address().unwrap();
+    let bound_addr = sock.get_local_address().unwrap();
 
     assert_eq!(bind_addr.ip(), bound_addr.ip());
     assert_eq!(bind_addr.port(), bound_addr.port());
@@ -39,22 +39,22 @@ fn test_tcp_bind_specific_port(ip: IpAddress) {
 fn test_tcp_bind_addrinuse(ip: IpAddress) {
     let bind_addr = IpSocketAddress::new(ip, 0);
 
-    let sock1 = TcpSocket::new(ip.family());
+    let sock1 = TcpSocket::create(ip.family()).unwrap();
     sock1.bind(bind_addr).unwrap();
     sock1.listen().unwrap();
 
-    let bound_addr = sock1.local_address().unwrap();
+    let bound_addr = sock1.get_local_address().unwrap();
 
-    let sock2 = TcpSocket::new(ip.family());
+    let sock2 = TcpSocket::create(ip.family()).unwrap();
     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 client = TcpSocket::create(ip.family()).unwrap();
 
     let bind_addr = {
-        let listener1 = TcpSocket::new(ip.family());
+        let listener1 = TcpSocket::create(ip.family()).unwrap();
 
         let bind_addr = attempt_random_port(ip, |bind_addr| listener1.bind(bind_addr)).unwrap();
 
@@ -97,7 +97,7 @@ async fn test_tcp_bind_reuseaddr(ip: IpAddress) {
     // time to see if we can reuse the address. This loop is bounded because it
     // should complete "quickly".
     for _ in 0..10 {
-        let listener2 = TcpSocket::new(ip.family());
+        let listener2 = TcpSocket::create(ip.family()).unwrap();
         if listener2.bind(bind_addr).is_ok() {
             listener2.listen().unwrap();
             return;
@@ -112,7 +112,7 @@ async fn test_tcp_bind_reuseaddr(ip: IpAddress) {
 fn test_tcp_bind_addrnotavail(ip: IpAddress) {
     let bind_addr = IpSocketAddress::new(ip, 0);
 
-    let sock = TcpSocket::new(ip.family());
+    let sock = TcpSocket::create(ip.family()).unwrap();
 
     assert_eq!(sock.bind(bind_addr), Err(ErrorCode::AddressNotBindable));
 }
@@ -124,7 +124,7 @@ fn test_tcp_bind_wrong_family(family: IpAddressFamily) {
         IpAddressFamily::Ipv6 => IpAddress::IPV4_LOOPBACK,
     };
 
-    let sock = TcpSocket::new(family);
+    let sock = TcpSocket::create(family).unwrap();
     let result = sock.bind(IpSocketAddress::new(wrong_ip, 0));
 
     assert!(matches!(result, Err(ErrorCode::InvalidArgument)));
@@ -136,8 +136,8 @@ fn test_tcp_bind_non_unicast() {
     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);
+    let sock_v4 = TcpSocket::create(IpAddressFamily::Ipv4).unwrap();
+    let sock_v6 = TcpSocket::create(IpAddressFamily::Ipv6).unwrap();
 
     assert!(matches!(
         sock_v4.bind(ipv4_broadcast),
@@ -154,7 +154,7 @@ fn test_tcp_bind_non_unicast() {
 }
 
 fn test_tcp_bind_dual_stack() {
-    let sock = TcpSocket::new(IpAddressFamily::Ipv6);
+    let sock = TcpSocket::create(IpAddressFamily::Ipv6).unwrap();
     let addr = IpSocketAddress::new(IpAddress::IPV4_MAPPED_LOOPBACK, 0);
 
     // Binding an IPv4-mapped-IPv6 address on a ipv6-only socket should fail:

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

@@ -12,15 +12,15 @@ const SOME_PORT: u16 = 47; // If the tests pass, this will never actually be con
 /// `0.0.0.0` / `::` is not a valid remote address in WASI.
 async fn test_tcp_connect_unspec(family: IpAddressFamily) {
     let addr = IpSocketAddress::new(IpAddress::new_unspecified(family), SOME_PORT);
-    let sock = TcpSocket::new(family);
+    let sock = TcpSocket::create(family).unwrap();
 
     assert_eq!(sock.connect(addr).await, Err(ErrorCode::InvalidArgument));
 }
 
 /// 0 is not a valid remote port.
 async fn test_tcp_connect_port_0(family: IpAddressFamily) {
     let addr = IpSocketAddress::new(IpAddress::new_loopback(family), 0);
-    let sock = TcpSocket::new(family);
+    let sock = TcpSocket::create(family).unwrap();
 
     assert_eq!(sock.connect(addr).await, Err(ErrorCode::InvalidArgument));
 }
@@ -33,7 +33,7 @@ async fn test_tcp_connect_wrong_family(family: IpAddressFamily) {
     };
     let remote_addr = IpSocketAddress::new(wrong_ip, SOME_PORT);
 
-    let sock = TcpSocket::new(family);
+    let sock = TcpSocket::create(family).unwrap();
 
     assert_eq!(
         sock.connect(remote_addr).await,
@@ -48,8 +48,8 @@ async fn test_tcp_connect_non_unicast() {
     let ipv6_multicast =
         IpSocketAddress::new(IpAddress::Ipv6((0xff00, 0, 0, 0, 0, 0, 0, 0)), SOME_PORT);
 
-    let sock_v4 = TcpSocket::new(IpAddressFamily::Ipv4);
-    let sock_v6 = TcpSocket::new(IpAddressFamily::Ipv6);
+    let sock_v4 = TcpSocket::create(IpAddressFamily::Ipv4).unwrap();
+    let sock_v6 = TcpSocket::create(IpAddressFamily::Ipv6).unwrap();
 
     assert_eq!(
         sock_v4.connect(ipv4_broadcast).await,
@@ -67,17 +67,17 @@ async fn test_tcp_connect_non_unicast() {
 
 async fn test_tcp_connect_dual_stack() {
     // Set-up:
-    let v4_listener = TcpSocket::new(IpAddressFamily::Ipv4);
+    let v4_listener = TcpSocket::create(IpAddressFamily::Ipv4).unwrap();
     v4_listener
         .bind(IpSocketAddress::new(IpAddress::IPV4_LOOPBACK, 0))
         .unwrap();
     v4_listener.listen().unwrap();
 
-    let v4_listener_addr = v4_listener.local_address().unwrap();
+    let v4_listener_addr = v4_listener.get_local_address().unwrap();
     let v6_listener_addr =
         IpSocketAddress::new(IpAddress::IPV4_MAPPED_LOOPBACK, v4_listener_addr.port());
 
-    let v6_client = TcpSocket::new(IpAddressFamily::Ipv6);
+    let v6_client = TcpSocket::create(IpAddressFamily::Ipv6).unwrap();
 
     // Tests:
 
@@ -99,14 +99,14 @@ async fn test_tcp_connect_explicit_bind(family: IpAddressFamily) {
 
     let (listener, mut accept) = {
         let bind_address = IpSocketAddress::new(ip, 0);
-        let listener = TcpSocket::new(family);
+        let listener = TcpSocket::create(family).unwrap();
         listener.bind(bind_address).unwrap();
         let accept = listener.listen().unwrap();
         (listener, accept)
     };
 
-    let listener_address = listener.local_address().unwrap();
-    let client = TcpSocket::new(family);
+    let listener_address = listener.get_local_address().unwrap();
+    let client = TcpSocket::create(family).unwrap();
 
     // Manually bind the client:
     client.bind(IpSocketAddress::new(ip, 0)).unwrap();

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

@@ -13,17 +13,17 @@ async fn test_tcp_sample_application(family: IpAddressFamily, bind_address: IpSo
     let first_message = b"Hello, world!";
     let second_message = b"Greetings, planet!";
 
-    let listener = TcpSocket::new(family);
+    let listener = TcpSocket::create(family).unwrap();
 
     listener.bind(bind_address).unwrap();
     listener.set_listen_backlog_size(32).unwrap();
     let mut accept = listener.listen().unwrap();
 
-    let addr = listener.local_address().unwrap();
+    let addr = listener.get_local_address().unwrap();
 
     join!(
         async {
-            let client = TcpSocket::new(family);
+            let client = TcpSocket::create(family).unwrap();
             client.connect(addr).await.unwrap();
             let (mut data_tx, data_rx) = wit_stream::new();
             join!(
@@ -54,7 +54,7 @@ async fn test_tcp_sample_application(family: IpAddressFamily, bind_address: IpSo
     // Another client
     join!(
         async {
-            let client = TcpSocket::new(family);
+            let client = TcpSocket::create(family).unwrap();
             client.connect(addr).await.unwrap();
             let (mut data_tx, data_rx) = wit_stream::new();
             join!(