A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
wasi-sockets: Align stream tests with current P3 spec (#12600)
Dave Bakker3621d3e3d85a
diff --git a/crates/test-programs/src/bin/p3_sockets_tcp_streams.rs b/crates/test-programs/src/bin/p3_sockets_tcp_streams.rsindex 3aaef7a7fc..9b6b401575 100644--- a/crates/test-programs/src/bin/p3_sockets_tcp_streams.rs+++ b/crates/test-programs/src/bin/p3_sockets_tcp_streams.rs@@ -2,113 +2,197 @@ use futures::join;use std::pin::pin;use std::task::{Context, Poll, Waker};use test_programs::p3::wasi::sockets::types::{- IpAddress, IpAddressFamily, IpSocketAddress, TcpSocket,+ ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, TcpSocket,};use test_programs::p3::wit_stream;use test_programs::sockets::supports_ipv6;-use wit_bindgen::StreamResult;+use wit_bindgen::{FutureReader, StreamReader, StreamResult, StreamWriter};struct Component;test_programs::p3::export!(Component);-/// InputStream::read should return `StreamError::Closed` after the connection has been shut down by the server.-async fn test_tcp_input_stream_should_be_closed_by_remote_shutdown(family: IpAddressFamily) {- setup(family, |server, client| async move {- drop(server);-- let (mut client_rx, client_fut) = client.receive();+/// Test basic functionality.+async fn test_tcp_ping_pong(family: IpAddressFamily) {+ setup(family, |mut server, mut client| async move {+ {+ let rest = server.send_stream.write_all(b"ping".into()).await;+ assert!(rest.is_empty());+ }+ {+ let (status, buf) = client.receive_stream.read(Vec::with_capacity(4)).await;+ assert_eq!(status, StreamResult::Complete(4));+ assert_eq!(buf, b"ping");+ }+ {+ let rest = client.send_stream.write_all(b"pong".into()).await;+ assert!(rest.is_empty());+ }+ {+ let (status, buf) = server.receive_stream.read(Vec::with_capacity(4)).await;+ assert_eq!(status, StreamResult::Complete(4));+ assert_eq!(buf, b"pong");+ }+ })+ .await;+}- // The input stream should immediately signal StreamError::Closed.- // Notably, it should _not_ return an empty list (the wasi-io equivalent of EWOULDBLOCK)- // See: https://github.com/bytecodealliance/wasmtime/pull/8968+/// The stream and future returned by `receive` should complete/resolve after+/// the connection has been shut down by the remote.+async fn test_tcp_receive_stream_should_be_dropped_by_remote_shutdown(family: IpAddressFamily) {+ setup(family, |server, mut client| async move {+ drop(server);// Wait for the shutdown signal to reach the client:- assert!(client_rx.next().await.is_none());- assert_eq!(client_fut.await, Ok(()));+ let (stream_result, data) = client.receive_stream.read(Vec::with_capacity(1)).await;+ assert_eq!(data.len(), 0);+ assert_eq!(stream_result, StreamResult::Dropped);+ assert_eq!(client.receive_result.await, Ok(()));}).await;}-/// InputStream::read should return `StreamError::Closed` after the connection has been shut down locally.-async fn test_tcp_input_stream_should_be_closed_by_local_shutdown(family: IpAddressFamily) {- setup(family, |server, client| async move {- let (mut server_tx, server_rx) = wit_stream::new();- join!(- async {- server.send(server_rx).await.unwrap();- },- async {- // On Linux, `recv` continues to work even after `shutdown(sock, SHUT_RD)`- // has been called. To properly test that this behavior doesn't happen in- // WASI, we make sure there's some data to read by the client:- let rest = server_tx.write_all(b"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.".into()).await;- assert!(rest.is_empty());- drop(server_tx);- },- );+/// The future returned by `receive` should resolve once the companion stream+/// has been dropped. Regardless of whether there was still data pending.+async fn test_tcp_receive_future_should_resolve_when_stream_dropped(family: IpAddressFamily) {+ setup(family, |mut server, client| async move {+ {+ let rest = server.send_stream.write_all(b"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.".into()).await;+ assert!(rest.is_empty());+ }+ {+ let Connection { mut receive_stream, receive_result, .. } = client;- let (client_rx, client_fut) = client.receive();+ // Wait for the data to be ready:+ receive_stream.next().await.unwrap();+ drop(receive_stream);- // Shut down socket locally:- drop(client_rx);- // Wait for the shutdown signal to reach the client:- assert_eq!(client_fut.await, Ok(()));+ // Dropping the stream should've caused the future to resolve even+ // though there was still data pending:+ assert_eq!(receive_result.await, Ok(()));+ }}).await;}-/// StreamWriter should return `StreamError::Closed` after the connection has been locally shut down for sending.-async fn test_tcp_output_stream_should_be_closed_by_local_shutdown(family: IpAddressFamily) {+/// The future returned by `send` should resolve after the input stream is dropped.+async fn test_tcp_send_future_should_resolve_when_stream_dropped(family: IpAddressFamily) {setup(family, |_server, client| async move {- let (client_tx, client_rx) = wit_stream::new();- join!(- async {- client.send(client_rx).await.unwrap();- },- async {- // TODO: Verify if send on the stream should return an error- //assert!(client_tx.send(b"Hi!".into()).await.is_err());- drop(client_tx);+ let Connection {+ send_stream,+ send_result,+ ..+ } = client;+ drop(send_stream);+ assert_eq!(send_result.await, Ok(()));+ })+ .await;+}++/// `send` should drop the input stream when the connection is shut down by the remote.+async fn test_tcp_send_drops_stream_when_remote_shutdown(family: IpAddressFamily) {+ setup(family, |server, mut client| async move {+ drop(server);++ // Give it a few tries for the shutdown signal to reach the client:+ loop {+ let stream_result = client.send_stream.write(b"undeliverable".into()).await.0;+ if stream_result == StreamResult::Dropped {+ break;}- );+ }++ _ = client.send_result.await;+ })+ .await;+}++/// `receive` may be called successfully at most once.+async fn test_tcp_receive_once(family: IpAddressFamily) {+ setup(family, |mut server, client| async move {+ // Give the client some potential data to _hopefully never_ read.+ {+ let rest = server.send_stream.write_all(b"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.".into()).await;+ assert!(rest.is_empty());+ }++ // FYI, the first call to `receive` is part of the `setup` code, so every+ // `receive` in here should fail.+ for _ in 0..3 {+ let (mut reader, future) = client.socket.receive();++ let (stream_result, data) = reader.read(Vec::with_capacity(10)).await;+ assert_eq!(data.len(), 0);+ assert_eq!(stream_result, StreamResult::Dropped);+ assert_eq!(future.await, Err(ErrorCode::InvalidState));+ }+ })+ .await;+}++/// `send` may be called successfully at most once.+async fn test_tcp_send_once(family: IpAddressFamily) {+ setup(family, |_server, client| async move {+ // FYI, the first call to `send` is part of the `setup` code, so every+ // `send` in here should fail.+ for _ in 0..3 {+ let (mut writer, send_rx) = wit_stream::new();+ let future = client.socket.send(send_rx);++ const DATA: &[u8] = b"undeliverable";+ let (stream_result, rest) = writer.write(DATA.into()).await;+ assert_eq!(rest.into_vec(), DATA);+ assert_eq!(stream_result, StreamResult::Dropped);+ assert_eq!(future.await, Err(ErrorCode::InvalidState));+ }}).await;}-/// Calling `shutdown` while the StreamWriter is in the middle of a background write should not cause that write to be lost.-async fn test_tcp_shutdown_should_not_lose_data(family: IpAddressFamily) {+/// The streams and futures returned by `send` and `receive` should remain+/// operational even after the socket that spawned them has been dropped.+async fn test_tcp_stream_lifetimes(family: IpAddressFamily) {setup(family, |server, client| async move {- // Minimize the local send buffer:- client.set_send_buffer_size(1024).unwrap();- let small_buffer_size = client.get_send_buffer_size().unwrap();+ let Connection {+ socket: server_socket,+ send_stream: mut server_send_stream,+ receive_stream: server_receive_stream,+ send_result: server_send_result,+ receive_result: server_receive_result,+ } = server;+ let Connection {+ socket: client_socket,+ send_stream: mut client_send_stream,+ receive_stream: client_receive_stream,+ send_result: client_send_result,+ receive_result: client_receive_result,+ } = client;- // Create a significantly bigger buffer, so that we can be pretty sure the `write` won't finish immediately:- let big_buffer_size = 100 * small_buffer_size;- assert!(big_buffer_size > small_buffer_size);- let outgoing_data = vec![0; big_buffer_size as usize];+ // Drop the parent sockets:+ drop(server_socket);+ drop(client_socket);- // Submit the oversized buffer and immediately initiate the shutdown:- let (mut client_tx, client_rx) = wit_stream::new();- join!(- async {- client.send(client_rx).await.unwrap();- },- async {- let ret = client_tx.write_all(outgoing_data.clone()).await;- assert!(ret.is_empty());- drop(client_tx);- },- async {- // The peer should receive _all_ data:- let (server_rx, server_fut) = server.receive();- let incoming_data = server_rx.collect().await;- assert_eq!(- outgoing_data, incoming_data,- "Received data should match the sent data"- );- server_fut.await.unwrap();- },- );+ {+ let rest = server_send_stream.write_all(b"ping".into()).await;+ assert!(rest.is_empty());+ drop(server_send_stream);+ assert_eq!(server_send_result.await, Ok(()));+ }+ {+ let data = client_receive_stream.collect().await;+ assert_eq!(data, b"ping");+ assert_eq!(client_receive_result.await, Ok(()));+ }+ {+ let rest = client_send_stream.write_all(b"pong".into()).await;+ assert!(rest.is_empty());+ drop(client_send_stream);+ assert_eq!(client_send_result.await, Ok(()));+ }+ {+ let data = server_receive_stream.collect().await;+ assert_eq!(data, b"pong");+ assert_eq!(server_receive_result.await, Ok(()));+ }}).await;}@@ -125,31 +209,26 @@ async fn test_tcp_read_cancellation(family: IpAddressFamily) {*slot = i as u8;}- setup(family, |server, client| async move {+ setup(family, |mut server, mut client| async move {// Minimize the local send buffer:- client.set_send_buffer_size(1024).unwrap();+ client.socket.set_send_buffer_size(1024).unwrap();- let (mut client_tx, client_rx) = wit_stream::new();join!(- async {- client.send(client_rx).await.unwrap();- },async {for _ in 0..CHUNKS {- let ret = client_tx.write_all(data.to_vec()).await;+ let ret = client.send_stream.write_all(data.to_vec()).await;assert!(ret.is_empty());}- drop(client_tx);+ drop(client.send_stream);},async {let mut buf = Vec::with_capacity(1024);- let (mut server_rx, server_fut) = server.receive();let mut i = 0_usize;let mut consecutive_zero_length_reads = 0;loop {assert!(buf.is_empty());let (status, b) = {- let mut fut = pin!(server_rx.read(buf));+ let mut fut = pin!(server.receive_stream.read(buf));let mut cx = Context::from_waker(Waker::noop());match fut.as_mut().poll(&mut cx) {Poll::Ready(pair) => pair,@@ -171,12 +250,12 @@ async fn test_tcp_read_cancellation(family: IpAddressFamily) {StreamResult::Cancelled => {assert!(consecutive_zero_length_reads < 10);consecutive_zero_length_reads += 1;- server_rx.read(Vec::new()).await;+ server.receive_stream.read(Vec::new()).await;}}}assert_eq!(i, CHUNKS * 256);- server_fut.await.unwrap();+ server.receive_result.await.unwrap();},);})@@ -185,17 +264,27 @@ async fn test_tcp_read_cancellation(family: IpAddressFamily) {impl test_programs::p3::exports::wasi::cli::run::Guest for Component {async fn run() -> Result<(), ()> {- test_tcp_input_stream_should_be_closed_by_remote_shutdown(IpAddressFamily::Ipv4).await;- test_tcp_input_stream_should_be_closed_by_local_shutdown(IpAddressFamily::Ipv4).await;- test_tcp_output_stream_should_be_closed_by_local_shutdown(IpAddressFamily::Ipv4).await;- test_tcp_shutdown_should_not_lose_data(IpAddressFamily::Ipv4).await;+ test_tcp_ping_pong(IpAddressFamily::Ipv4).await;+ test_tcp_receive_stream_should_be_dropped_by_remote_shutdown(IpAddressFamily::Ipv4).await;+ test_tcp_receive_future_should_resolve_when_stream_dropped(IpAddressFamily::Ipv4).await;+ test_tcp_send_future_should_resolve_when_stream_dropped(IpAddressFamily::Ipv4).await;+ test_tcp_send_drops_stream_when_remote_shutdown(IpAddressFamily::Ipv4).await;+ test_tcp_receive_once(IpAddressFamily::Ipv4).await;+ test_tcp_send_once(IpAddressFamily::Ipv4).await;+ test_tcp_stream_lifetimes(IpAddressFamily::Ipv4).await;test_tcp_read_cancellation(IpAddressFamily::Ipv4).await;if supports_ipv6() {- test_tcp_input_stream_should_be_closed_by_remote_shutdown(IpAddressFamily::Ipv6).await;- test_tcp_input_stream_should_be_closed_by_local_shutdown(IpAddressFamily::Ipv6).await;- test_tcp_output_stream_should_be_closed_by_local_shutdown(IpAddressFamily::Ipv6).await;- test_tcp_shutdown_should_not_lose_data(IpAddressFamily::Ipv6).await;+ test_tcp_ping_pong(IpAddressFamily::Ipv6).await;+ test_tcp_receive_stream_should_be_dropped_by_remote_shutdown(IpAddressFamily::Ipv6)+ .await;+ test_tcp_receive_future_should_resolve_when_stream_dropped(IpAddressFamily::Ipv6).await;+ test_tcp_send_future_should_resolve_when_stream_dropped(IpAddressFamily::Ipv6).await;+ test_tcp_send_drops_stream_when_remote_shutdown(IpAddressFamily::Ipv6).await;+ test_tcp_receive_once(IpAddressFamily::Ipv6).await;+ test_tcp_send_once(IpAddressFamily::Ipv6).await;+ test_tcp_stream_lifetimes(IpAddressFamily::Ipv6).await;+ test_tcp_read_cancellation(IpAddressFamily::Ipv6).await;}Ok(())}@@ -203,10 +292,32 @@ impl test_programs::p3::exports::wasi::cli::run::Guest for Component {fn main() {}+struct Connection {+ socket: TcpSocket,+ receive_stream: StreamReader<u8>,+ receive_result: FutureReader<Result<(), ErrorCode>>,+ send_stream: StreamWriter<u8>,+ send_result: FutureReader<Result<(), ErrorCode>>,+}+impl Connection {+ fn new(socket: TcpSocket) -> Self {+ let (send_stream, send_rx) = wit_stream::new();+ let send_result = socket.send(send_rx);+ let (receive_stream, receive_result) = socket.receive();+ Self {+ socket,+ receive_stream,+ receive_result,+ send_stream,+ send_result,+ }+ }+}+/// Set up a connected pair of socketsasync fn setup<Fut: Future<Output = ()>>(family: IpAddressFamily,- body: impl FnOnce(TcpSocket, TcpSocket) -> Fut,+ body: impl FnOnce(Connection, Connection) -> Fut,) {let bind_address = IpSocketAddress::new(IpAddress::new_loopback(family), 0);let listener = TcpSocket::create(family).unwrap();@@ -220,5 +331,10 @@ async fn setup<Fut: Future<Output = ()>>(},async { accept.next().await.unwrap() },);- body(accepted_socket, client_socket).await;++ body(+ Connection::new(accepted_socket),+ Connection::new(client_socket),+ )+ .await;}diff --git a/crates/wasi/src/p2/tcp.rs b/crates/wasi/src/p2/tcp.rsindex 67edf98ba8..15f93f1e77 100644--- a/crates/wasi/src/p2/tcp.rs+++ b/crates/wasi/src/p2/tcp.rs@@ -15,11 +15,9 @@ use wasmtime::Result;impl TcpSocket {pub(crate) fn p2_streams(&mut self) -> SocketResult<(DynInputStream, DynOutputStream)> {- let client = self.tcp_stream_arc()?;- let reader = Arc::new(Mutex::new(TcpReader::new(client.clone())));- let writer = Arc::new(Mutex::new(TcpWriter::new(client.clone())));+ let reader = Arc::new(Mutex::new(TcpReader::new(self.take_receive_stream()?)));+ let writer = Arc::new(Mutex::new(TcpWriter::new(self.take_send_stream()?)));self.set_p2_streaming_state(P2TcpStreamingState {- stream: client.clone(),reader: reader.clone(),writer: writer.clone(),})?;@@ -30,7 +28,6 @@ impl TcpSocket {}pub(crate) struct P2TcpStreamingState {- pub(crate) stream: Arc<tokio::net::TcpStream>,reader: Arc<Mutex<TcpReader>>,writer: Arc<Mutex<TcpWriter>>,}diff --git a/crates/wasi/src/p3/bindings.rs b/crates/wasi/src/p3/bindings.rsindex cc589e2f3c..a20a32750e 100644--- a/crates/wasi/src/p3/bindings.rs+++ b/crates/wasi/src/p3/bindings.rs@@ -87,7 +87,7 @@ mod generated {"wasi:filesystem/types.[method]descriptor.read-directory": store | tracing,"wasi:sockets/types.[method]tcp-socket.bind": async | tracing | trappable,"wasi:sockets/types.[method]tcp-socket.listen": store | tracing | trappable,- "wasi:sockets/types.[method]tcp-socket.send": store | tracing,+ "wasi:sockets/types.[method]tcp-socket.send": store | tracing | trappable,"wasi:sockets/types.[method]tcp-socket.receive": store | tracing | trappable,"wasi:sockets/types.[method]udp-socket.bind": async | tracing | trappable,"wasi:sockets/types.[method]udp-socket.connect": async | tracing | trappable,diff --git a/crates/wasi/src/p3/sockets/host/types/tcp.rs b/crates/wasi/src/p3/sockets/host/types/tcp.rsindex a8815fd55b..0a080c3499 100644--- a/crates/wasi/src/p3/sockets/host/types/tcp.rs+++ b/crates/wasi/src/p3/sockets/host/types/tcp.rs@@ -226,6 +226,9 @@ impl<D> StreamConsumer<D> for SendStreamConsumer {Poll::Pending => return Poll::Pending,}}+ Err(err) if err.kind() == std::io::ErrorKind::BrokenPipe => {+ break 'result Ok(());+ }Err(err) => break 'result Err(err.into()),}}@@ -286,12 +289,11 @@ impl HostTcpSocketWithStore for WasiSockets {mut store: Access<'_, T, Self>,socket: Resource<TcpSocket>,mut data: StreamReader<u8>,- ) -> FutureReader<Result<(), ErrorCode>> {- let (result_tx, result_rx) = oneshot::channel();- match get_socket(store.get().table, &socket)- .and_then(|sock| sock.tcp_stream_arc().map(Arc::clone).map_err(Into::into))- {+ ) -> wasmtime::Result<FutureReader<Result<(), ErrorCode>>> {+ let socket = get_socket_mut(store.get().table, &socket)?;+ match socket.take_send_stream() {Ok(stream) => {+ let (result_tx, result_rx) = oneshot::channel();data.pipe(&mut store,SendStreamConsumer {@@ -299,13 +301,15 @@ impl HostTcpSocketWithStore for WasiSockets {result: Some(result_tx),},);+ Ok(FutureReader::new(&mut store, result_rx))}Err(err) => {data.close(&mut store);- let _ = result_tx.send(Err(err.downcast().unwrap_or(ErrorCode::Unknown)));+ Ok(FutureReader::new(&mut store, async {+ wasmtime::error::Ok(Err(err.into()))+ }))}}- FutureReader::new(&mut store, result_rx)}fn receive<T: 'static>(@@ -313,9 +317,8 @@ impl HostTcpSocketWithStore for WasiSockets {socket: Resource<TcpSocket>,) -> wasmtime::Result<(StreamReader<u8>, FutureReader<Result<(), ErrorCode>>)> {let socket = get_socket_mut(store.get().table, &socket)?;- match socket.start_receive() {- Some(stream) => {- let stream = Arc::clone(stream);+ match socket.take_receive_stream() {+ Ok(stream) => {let (result_tx, result_rx) = oneshot::channel();Ok((StreamReader::new(@@ -328,11 +331,9 @@ impl HostTcpSocketWithStore for WasiSockets {FutureReader::new(&mut store, result_rx),))}- None => Ok((+ Err(err) => Ok((StreamReader::new(&mut store, iter::empty()),- FutureReader::new(&mut store, async {- wasmtime::error::Ok(Err(ErrorCode::InvalidState))- }),+ FutureReader::new(&mut store, async { wasmtime::error::Ok(Err(err.into())) }),)),}}diff --git a/crates/wasi/src/sockets/tcp.rs b/crates/wasi/src/sockets/tcp.rsindex d31e464078..2dc7fff55c 100644--- a/crates/wasi/src/sockets/tcp.rs+++ b/crates/wasi/src/sockets/tcp.rs@@ -87,20 +87,12 @@ enum TcpState {/// This is created either via `finish_connect` or for freshly accepted/// sockets from a TCP listener.///- /// From here a socket can transition to `Receiving` or `P2Streaming`.- Connected(Arc<tokio::net::TcpStream>),-- /// A connection has been established and `receive` has been called.- ///- /// A socket will not transition out of this state.- #[cfg(feature = "p3")]- Receiving(Arc<tokio::net::TcpStream>),-- /// This is a WASIp2-bound socket which stores some extra state for- /// read/write streams to handle TCP shutdown.- ////// A socket will not transition out of this state.- P2Streaming(Box<P2TcpStreamingState>),+ Connected {+ stream: Arc<tokio::net::TcpStream>,+ taken_streams: TakenStreams,+ p2_state: Option<P2TcpStreamingState>,+ },/// This is not actually a socket but a deferred error.///@@ -112,7 +104,18 @@ enum TcpState {/// The socket is closed and no more operations can be performed.Closed,}-+impl TcpState {+ fn connected(stream: tokio::net::TcpStream) -> Self {+ TcpState::Connected {+ stream: Arc::new(stream),+ taken_streams: TakenStreams {+ receive: false,+ send: false,+ },+ p2_state: None,+ }+ }+}impl Debug for TcpState {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {match self {@@ -125,15 +128,17 @@ impl Debug for TcpState {Self::ConnectReady(..) => f.debug_tuple("ConnectReady").finish(),Self::Connected { .. } => f.debug_tuple("Connected").finish(),#[cfg(feature = "p3")]- Self::Receiving { .. } => f.debug_tuple("Receiving").finish(),- Self::P2Streaming(_) => f.debug_tuple("P2Streaming").finish(),- #[cfg(feature = "p3")]Self::Error(..) => f.debug_tuple("Error").finish(),Self::Closed => write!(f, "Closed"),}}}+struct TakenStreams {+ receive: bool,+ send: bool,+}+/// A host TCP socket, plus associated bookkeeping.pub struct TcpSocket {/// The current state in the bind/listen/accept/connect progression.@@ -218,10 +223,7 @@ impl TcpSocket {_ => err,})?;options.apply(family, &client);- Ok(Self::from_state(- TcpState::Connected(Arc::new(client)),- family,- ))+ Ok(Self::from_state(TcpState::connected(client), family))}/// Create a `TcpSocket` from an existing socket.@@ -240,11 +242,8 @@ impl TcpSocket {| TcpState::BindStarted(socket)| TcpState::Bound(socket)| TcpState::ListenStarted(socket) => Ok(socket.as_socketlike_view()),- TcpState::Connected(stream) => Ok(stream.as_socketlike_view()),- #[cfg(feature = "p3")]- TcpState::Receiving(stream) => Ok(stream.as_socketlike_view()),+ TcpState::Connected { stream, .. } => Ok(stream.as_socketlike_view()),TcpState::Listening { listener, .. } => Ok(listener.as_socketlike_view()),- TcpState::P2Streaming(state) => Ok(state.stream.as_socketlike_view()),TcpState::Connecting(..) | TcpState::ConnectReady(_) | TcpState::Closed => {Err(ErrorCode::InvalidState)}@@ -371,7 +370,7 @@ impl TcpSocket {}match result {Ok(stream) => {- self.tcp_state = TcpState::Connected(Arc::new(stream));+ self.tcp_state = TcpState::connected(stream);Ok(())}Err(err) => {@@ -509,27 +508,10 @@ impl TcpSocket {Ok(Some(Self::new_accept(result, &self.options, self.family)?))}- #[cfg(feature = "p3")]- pub(crate) fn start_receive(&mut self) -> Option<&Arc<tokio::net::TcpStream>> {- match mem::replace(&mut self.tcp_state, TcpState::Closed) {- TcpState::Connected(stream) => {- self.tcp_state = TcpState::Receiving(stream);- Some(self.tcp_stream_arc().unwrap())- }- prev => {- self.tcp_state = prev;- None- }- }- }-pub(crate) fn local_address(&self) -> Result<SocketAddr, ErrorCode> {match &self.tcp_state {TcpState::Bound(socket) => Ok(socket.local_addr()?),- TcpState::Connected(stream) => Ok(stream.local_addr()?),- #[cfg(feature = "p3")]- TcpState::Receiving(stream) => Ok(stream.local_addr()?),- TcpState::P2Streaming(state) => Ok(state.stream.local_addr()?),+ TcpState::Connected { stream, .. } => Ok(stream.local_addr()?),TcpState::Listening { listener, .. } => Ok(listener.local_addr()?),#[cfg(feature = "p3")]TcpState::Error(err) => Err(err.into()),@@ -538,9 +520,12 @@ impl TcpSocket {}pub(crate) fn remote_address(&self) -> Result<SocketAddr, ErrorCode> {- let stream = self.tcp_stream_arc()?;- let addr = stream.peer_addr()?;- Ok(addr)+ match &self.tcp_state {+ TcpState::Connected { stream, .. } => Ok(stream.peer_addr()?),+ #[cfg(feature = "p3")]+ TcpState::Error(err) => Err(err.into()),+ _ => Err(ErrorCode::InvalidState),+ }}pub(crate) fn is_listening(&self) -> bool {@@ -695,21 +680,43 @@ impl TcpSocket {}}- pub(crate) fn tcp_stream_arc(&self) -> Result<&Arc<tokio::net::TcpStream>, ErrorCode> {- match &self.tcp_state {- TcpState::Connected(socket) => Ok(socket),- #[cfg(feature = "p3")]- TcpState::Receiving(socket) => Ok(socket),- TcpState::P2Streaming(state) => Ok(&state.stream),+ pub(crate) fn take_receive_stream(&mut self) -> Result<Arc<tokio::net::TcpStream>, ErrorCode> {+ self.take_stream(|s| &mut s.receive)+ }++ pub(crate) fn take_send_stream(&mut self) -> Result<Arc<tokio::net::TcpStream>, ErrorCode> {+ self.take_stream(|s| &mut s.send)+ }++ fn take_stream(+ &mut self,+ direction: impl FnOnce(&mut TakenStreams) -> &mut bool,+ ) -> Result<Arc<tokio::net::TcpStream>, ErrorCode> {+ match &mut self.tcp_state {+ TcpState::Connected {+ stream,+ taken_streams,+ ..+ } => {+ let taken = direction(taken_streams);+ if *taken {+ return Err(ErrorCode::InvalidState);+ }+ *taken = true;+ Ok(stream.clone())+ }#[cfg(feature = "p3")]- TcpState::Error(err) => Err(err.into()),+ TcpState::Error(err) => Err((&*err).into()),_ => Err(ErrorCode::InvalidState),}}pub(crate) fn p2_streaming_state(&self) -> Result<&P2TcpStreamingState, ErrorCode> {match &self.tcp_state {- TcpState::P2Streaming(state) => Ok(state),+ TcpState::Connected {+ p2_state: Some(state),+ ..+ } => Ok(state),#[cfg(feature = "p3")]TcpState::Error(err) => Err(err.into()),_ => Err(ErrorCode::InvalidState),@@ -720,11 +727,12 @@ impl TcpSocket {&mut self,state: P2TcpStreamingState,) -> Result<(), ErrorCode> {- if !matches!(self.tcp_state, TcpState::Connected(_)) {- return Err(ErrorCode::InvalidState);+ if let TcpState::Connected { p2_state, .. } = &mut self.tcp_state {+ *p2_state = Some(state);+ Ok(())+ } else {+ Err(ErrorCode::InvalidState)}- self.tcp_state = TcpState::P2Streaming(Box::new(state));- Ok(())}/// Used for `Pollable` in the WASIp2 implementation this awaits the socket@@ -745,11 +753,10 @@ impl TcpSocket {| TcpState::Listening {pending_accept: Some(_),..- }- | TcpState::P2Streaming(_) => {}+ } => {}#[cfg(feature = "p3")]- TcpState::Receiving(_) | TcpState::Error(_) => {}+ TcpState::Error(_) => {}TcpState::Connecting(Some(future)) => {self.tcp_state = TcpState::ConnectReady(future.as_mut().await);