Udp

crates/test-programs/tests/wasi-sockets.rs

@@ -67,13 +67,33 @@ async fn run(name: &str) -> anyhow::Result<()> {
 }
 
 #[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn tcp_v4() {
- run("tcp_v4").await.unwrap();
+async fn tcp_sample_application() {
+ run("tcp_sample_application").await.unwrap();
 }
 
 #[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn tcp_v6() {
- run("tcp_v6").await.unwrap();
+async fn tcp_bind() {
+ run("tcp_bind").await.unwrap();
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn tcp_connect() {
+ run("tcp_connect").await.unwrap();
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn tcp_states() {
+ run("tcp_states").await.unwrap();
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn tcp_sockopts() {
+ run("tcp_sockopts").await.unwrap();
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn udp_sample_application() {
+ run("udp_sample_application").await.unwrap();
 }
 
 #[test_log::test(tokio::test(flavor = "multi_thread"))]

crates/test-programs/wasi-sockets-tests/src/bin/ip_name_lookup.rs

@@ -12,7 +12,7 @@ fn main() {
  assert!(addresses.resolve_next_address().is_ok());
 
  let result = ip_name_lookup::resolve_addresses(&network, "a.b<&>", None, false);
- assert!(matches!(result, Err(network::ErrorCode::InvalidName)));
+ assert!(matches!(result, Err(network::ErrorCode::InvalidArgument)));
 
  // Try resolving a valid address and ensure that it eventually terminates.
  // To help prevent this test from being flaky this additionally times out

crates/test-programs/wasi-sockets-tests/src/bin/tcp_bind.rs

@@ -0,0 +1,151 @@
+use wasi::sockets::network::{ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, Network};
+use wasi::sockets::tcp::TcpSocket;
+use wasi_sockets_tests::*;
+
+/// Bind a socket and let the system determine a port.
+fn test_tcp_bind_ephemeral_port(net: &Network, ip: IpAddress) {
+ let bind_addr = IpSocketAddress::new(ip, 0);
+
+ let sock = TcpSocket::new(ip.family()).unwrap();
+ sock.blocking_bind(net, 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(net: &Network, ip: IpAddress) {
+ const PORT: u16 = 54321;
+
+ let bind_addr = IpSocketAddress::new(ip, PORT);
+
+ let sock = TcpSocket::new(ip.family()).unwrap();
+ sock.blocking_bind(net, 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(net: &Network, ip: IpAddress) {
+ let bind_addr = IpSocketAddress::new(ip, 0);
+
+ let sock1 = TcpSocket::new(ip.family()).unwrap();
+ sock1.blocking_bind(net, bind_addr).unwrap();
+ sock1.blocking_listen().unwrap();
+
+ let bound_addr = sock1.local_address().unwrap();
+
+ let sock2 = TcpSocket::new(ip.family()).unwrap();
+ assert_eq!(
+ sock2.blocking_bind(net, bound_addr),
+ Err(ErrorCode::AddressInUse)
+ );
+}
+
+// Try binding to an address that is not configured on the system.
+fn test_tcp_bind_addrnotavail(net: &Network, ip: IpAddress) {
+ let bind_addr = IpSocketAddress::new(ip, 0);
+
+ let sock = TcpSocket::new(ip.family()).unwrap();
+
+ assert_eq!(
+ sock.blocking_bind(net, bind_addr),
+ Err(ErrorCode::AddressNotBindable)
+ );
+}
+
+/// Bind should validate the address family.
+fn test_tcp_bind_wrong_family(net: &Network, family: IpAddressFamily) {
+ let wrong_ip = match family {
+ IpAddressFamily::Ipv4 => IpAddress::IPV6_LOOPBACK,
+ IpAddressFamily::Ipv6 => IpAddress::IPV4_LOOPBACK,
+ };
+
+ let sock = TcpSocket::new(family).unwrap();
+ let result = sock.blocking_bind(net, IpSocketAddress::new(wrong_ip, 0));
+
+ assert!(matches!(result, Err(ErrorCode::InvalidArgument)));
+}
+
+/// Bind only works on unicast addresses.
+fn test_tcp_bind_non_unicast(net: &Network) {
+ 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).unwrap();
+ let sock_v6 = TcpSocket::new(IpAddressFamily::Ipv6).unwrap();
+
+ assert!(matches!(
+ sock_v4.blocking_bind(net, ipv4_broadcast),
+ Err(ErrorCode::InvalidArgument)
+ ));
+ assert!(matches!(
+ sock_v4.blocking_bind(net, ipv4_multicast),
+ Err(ErrorCode::InvalidArgument)
+ ));
+ assert!(matches!(
+ sock_v6.blocking_bind(net, ipv6_multicast),
+ Err(ErrorCode::InvalidArgument)
+ ));
+}
+
+fn test_tcp_bind_dual_stack(net: &Network) {
+ let sock = TcpSocket::new(IpAddressFamily::Ipv6).unwrap();
+ let addr = IpSocketAddress::new(IpAddress::IPV4_MAPPED_LOOPBACK, 0);
+
+ // Even on platforms that don't support dualstack sockets,
+ // setting ipv6_only to true (disabling dualstack mode) should work.
+ sock.set_ipv6_only(true).unwrap();
+
+ // Binding an IPv4-mapped-IPv6 address on a ipv6-only socket should fail:
+ assert!(matches!(
+ sock.blocking_bind(net, addr),
+ Err(ErrorCode::InvalidArgument)
+ ));
+
+ sock.set_ipv6_only(false).unwrap();
+
+ sock.blocking_bind(net, addr).unwrap();
+
+ let bound_addr = sock.local_address().unwrap();
+
+ assert_eq!(bound_addr.family(), IpAddressFamily::Ipv6);
+}
+
+fn main() {
+ 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.
+
+ let net = Network::default();
+
+ test_tcp_bind_ephemeral_port(&net, IpAddress::IPV4_LOOPBACK);
+ test_tcp_bind_ephemeral_port(&net, IpAddress::IPV6_LOOPBACK);
+ test_tcp_bind_ephemeral_port(&net, IpAddress::IPV4_UNSPECIFIED);
+ test_tcp_bind_ephemeral_port(&net, IpAddress::IPV6_UNSPECIFIED);
+
+ test_tcp_bind_specific_port(&net, IpAddress::IPV4_LOOPBACK);
+ test_tcp_bind_specific_port(&net, IpAddress::IPV6_LOOPBACK);
+ test_tcp_bind_specific_port(&net, IpAddress::IPV4_UNSPECIFIED);
+ test_tcp_bind_specific_port(&net, IpAddress::IPV6_UNSPECIFIED);
+
+ test_tcp_bind_addrinuse(&net, IpAddress::IPV4_LOOPBACK);
+ test_tcp_bind_addrinuse(&net, IpAddress::IPV6_LOOPBACK);
+ test_tcp_bind_addrinuse(&net, IpAddress::IPV4_UNSPECIFIED);
+ test_tcp_bind_addrinuse(&net, IpAddress::IPV6_UNSPECIFIED);
+
+ test_tcp_bind_addrnotavail(&net, RESERVED_IPV4_ADDRESS);
+ test_tcp_bind_addrnotavail(&net, RESERVED_IPV6_ADDRESS);
+
+ test_tcp_bind_wrong_family(&net, IpAddressFamily::Ipv4);
+ test_tcp_bind_wrong_family(&net, IpAddressFamily::Ipv6);
+
+ test_tcp_bind_non_unicast(&net);
+
+ test_tcp_bind_dual_stack(&net);
+}

crates/test-programs/wasi-sockets-tests/src/bin/tcp_connect.rs

@@ -0,0 +1,119 @@
+use wasi::sockets::network::{ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, Network};
+use wasi::sockets::tcp::TcpSocket;
+use wasi_sockets_tests::*;
+
+const SOME_PORT: u16 = 47; // If the tests pass, this will never actually be connected to.
+
+/// `0.0.0.0` / `::` is not a valid remote address in WASI.
+fn test_tcp_connect_unspec(net: &Network, family: IpAddressFamily) {
+ let addr = IpSocketAddress::new(IpAddress::new_unspecified(family), SOME_PORT);
+ let sock = TcpSocket::new(family).unwrap();
+
+ assert!(matches!(
+ sock.blocking_connect(net, addr),
+ Err(ErrorCode::InvalidArgument)
+ ));
+}
+
+/// 0 is not a valid remote port.
+fn test_tcp_connect_port_0(net: &Network, family: IpAddressFamily) {
+ let addr = IpSocketAddress::new(IpAddress::new_loopback(family), 0);
+ let sock = TcpSocket::new(family).unwrap();
+
+ assert!(matches!(
+ sock.blocking_connect(net, addr),
+ Err(ErrorCode::InvalidArgument)
+ ));
+}
+
+/// Bind should validate the address family.
+fn test_tcp_connect_wrong_family(net: &Network, family: IpAddressFamily) {
+ let wrong_ip = match family {
+ IpAddressFamily::Ipv4 => IpAddress::IPV6_LOOPBACK,
+ IpAddressFamily::Ipv6 => IpAddress::IPV4_LOOPBACK,
+ };
+ let remote_addr = IpSocketAddress::new(wrong_ip, SOME_PORT);
+
+ let sock = TcpSocket::new(family).unwrap();
+
+ assert!(matches!(
+ sock.blocking_connect(net, remote_addr),
+ Err(ErrorCode::InvalidArgument)
+ ));
+}
+
+/// Can only connect to unicast addresses.
+fn test_tcp_connect_non_unicast(net: &Network) {
+ let ipv4_broadcast = IpSocketAddress::new(IpAddress::IPV4_BROADCAST, SOME_PORT);
+ let ipv4_multicast = IpSocketAddress::new(IpAddress::Ipv4((224, 254, 0, 0)), SOME_PORT);
+ let ipv6_multicast =
+ IpSocketAddress::new(IpAddress::Ipv6((0xff00, 0, 0, 0, 0, 0, 0, 0)), SOME_PORT);
+
+ let sock_v4 = TcpSocket::new(IpAddressFamily::Ipv4).unwrap();
+ let sock_v6 = TcpSocket::new(IpAddressFamily::Ipv6).unwrap();
+
+ assert!(matches!(
+ sock_v4.blocking_connect(net, ipv4_broadcast),
+ Err(ErrorCode::InvalidArgument)
+ ));
+ assert!(matches!(
+ sock_v4.blocking_connect(net, ipv4_multicast),
+ Err(ErrorCode::InvalidArgument)
+ ));
+ assert!(matches!(
+ sock_v6.blocking_connect(net, ipv6_multicast),
+ Err(ErrorCode::InvalidArgument)
+ ));
+}
+
+fn test_tcp_connect_dual_stack(net: &Network) {
+ // Set-up:
+ let v4_listener = TcpSocket::new(IpAddressFamily::Ipv4).unwrap();
+ v4_listener
+ .blocking_bind(&net, IpSocketAddress::new(IpAddress::IPV4_LOOPBACK, 0))
+ .unwrap();
+ v4_listener.blocking_listen().unwrap();
+
+ let v4_listener_addr = v4_listener.local_address().unwrap();
+ let v6_listener_addr =
+ IpSocketAddress::new(IpAddress::IPV4_MAPPED_LOOPBACK, v4_listener_addr.port());
+
+ let v6_client = TcpSocket::new(IpAddressFamily::Ipv6).unwrap();
+
+ // Tests:
+
+ // Even on platforms that don't support dualstack sockets,
+ // setting ipv6_only to true (disabling dualstack mode) should work.
+ v6_client.set_ipv6_only(true).unwrap();
+
+ // Connecting to an IPv4-mapped-IPv6 address on an ipv6-only socket should fail:
+ assert!(matches!(
+ v6_client.blocking_connect(net, v6_listener_addr),
+ Err(ErrorCode::InvalidArgument)
+ ));
+
+ v6_client.set_ipv6_only(false).unwrap();
+
+ v6_client.blocking_connect(net, v6_listener_addr).unwrap();
+
+ let connected_addr = v6_client.local_address().unwrap();
+
+ assert_eq!(connected_addr.family(), IpAddressFamily::Ipv6);
+}
+
+fn main() {
+ let net = Network::default();
+
+ test_tcp_connect_unspec(&net, IpAddressFamily::Ipv4);
+ test_tcp_connect_unspec(&net, IpAddressFamily::Ipv6);
+
+ test_tcp_connect_port_0(&net, IpAddressFamily::Ipv4);
+ test_tcp_connect_port_0(&net, IpAddressFamily::Ipv6);
+
+ test_tcp_connect_wrong_family(&net, IpAddressFamily::Ipv4);
+ test_tcp_connect_wrong_family(&net, IpAddressFamily::Ipv6);
+
+ test_tcp_connect_non_unicast(&net);
+
+ test_tcp_connect_dual_stack(&net);
+}

crates/test-programs/wasi-sockets-tests/src/bin/tcp_sample_application.rs

@@ -0,0 +1,74 @@
+use wasi::sockets::network::{
+ IpAddressFamily, IpSocketAddress, Ipv4SocketAddress, Ipv6SocketAddress, Network,
+};
+use wasi::sockets::tcp::TcpSocket;
+use wasi_sockets_tests::*;
+
+fn test_sample_application(family: IpAddressFamily, bind_address: IpSocketAddress) {
+ let first_message = b"Hello, world!";
+ let second_message = b"Greetings, planet!";
+
+ let net = Network::default();
+ let listener = TcpSocket::new(family).unwrap();
+
+ listener.blocking_bind(&net, bind_address).unwrap();
+ listener.set_listen_backlog_size(32).unwrap();
+ listener.blocking_listen().unwrap();
+
+ let addr = listener.local_address().unwrap();
+
+ {
+ let client = TcpSocket::new(family).unwrap();
+ let (_client_input, client_output) = client.blocking_connect(&net, addr).unwrap();
+
+ client_output.blocking_write_util(&[]).unwrap();
+ client_output.blocking_write_util(first_message).unwrap();
+ }
+
+ {
+ let (_accepted, input, _output) = listener.accept().unwrap();
+
+ let empty_data = input.read(0).unwrap();
+ assert!(empty_data.is_empty());
+
+ let data = input.blocking_read(first_message.len() as u64).unwrap();
+
+ // Check that we sent and recieved our message!
+ assert_eq!(data, first_message); // Not guaranteed to work but should work in practice.
+ }
+
+ // Another client
+ {
+ let client = TcpSocket::new(family).unwrap();
+ let (_client_input, client_output) = client.blocking_connect(&net, addr).unwrap();
+
+ client_output.blocking_write_util(second_message).unwrap();
+ }
+
+ {
+ let (_accepted, input, _output) = listener.accept().unwrap();
+ let data = input.blocking_read(second_message.len() as u64).unwrap();
+
+ // Check that we sent and recieved our message!
+ assert_eq!(data, second_message); // Not guaranteed to work but should work in practice.
+ }
+}
+
+fn main() {
+ test_sample_application(
+ IpAddressFamily::Ipv4,
+ IpSocketAddress::Ipv4(Ipv4SocketAddress {
+ port: 0, // use any free port
+ address: (127, 0, 0, 1), // localhost
+ }),
+ );
+ test_sample_application(
+ IpAddressFamily::Ipv6,
+ IpSocketAddress::Ipv6(Ipv6SocketAddress {
+ port: 0, // use any free port
+ address: (0, 0, 0, 0, 0, 0, 0, 1), // localhost
+ flow_info: 0,
+ scope_id: 0,
+ }),
+ );
+}