A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
wasi: preserve accepted TCP peer addresses after reset (#14443)
Daniel Macoveia7b4f29596bf
diff --git a/.github/workflows/main.yml b/.github/workflows/main.ymlindex f702a216f4..b82d932598 100644--- a/.github/workflows/main.yml+++ b/.github/workflows/main.yml@@ -755,7 +755,7 @@ jobs:- uses: ./.github/actions/cargo-installwith:crate: cargo-fuzz- version: 0.13.1+ version: 0.13.2- uses: ./.github/actions/apt-get-installwith:packages: ocaml-nox ocamlbuild ocaml-findlib libzarith-ocaml-devdiff --git a/crates/wasi/src/p2/host/tcp.rs b/crates/wasi/src/p2/host/tcp.rsindex e73bdd5994..13d6dd1dfb 100644--- a/crates/wasi/src/p2/host/tcp.rs+++ b/crates/wasi/src/p2/host/tcp.rs@@ -154,7 +154,7 @@ impl crate::p2::host::tcp::tcp::HostTcpSocket for WasiSocketsCtxView<'_> {}fn remote_address(&mut self, this: Resource<TcpSocket>) -> SocketResult<IpSocketAddress> {- let socket = self.table.get(&this)?;+ let socket = self.table.get_mut(&this)?;Ok(socket.inner.remote_address()?.into())}diff --git a/crates/wasi/src/p3/sockets/host/types/tcp.rs b/crates/wasi/src/p3/sockets/host/types/tcp.rsindex 9cb165c6fa..9e54bda22e 100644--- a/crates/wasi/src/p3/sockets/host/types/tcp.rs+++ b/crates/wasi/src/p3/sockets/host/types/tcp.rs@@ -353,7 +353,7 @@ impl HostTcpSocket for WasiSocketsCtxView<'_> {}fn get_remote_address(&mut self, socket: Resource<TcpSocket>) -> SocketResult<IpSocketAddress> {- let sock = get_socket(self.table, &socket)?;+ let sock = get_socket_mut(self.table, &socket)?;Ok(sock.remote_address()?.into())}diff --git a/crates/wasi/src/sockets/tcp.rs b/crates/wasi/src/sockets/tcp.rsindex 7f3d4714ca..b2526d9897 100644--- a/crates/wasi/src/sockets/tcp.rs+++ b/crates/wasi/src/sockets/tcp.rs@@ -55,6 +55,9 @@ enum TcpState {/// A socket will not transition out of this state.Connected {stream: Arc<tokio::net::TcpStream>,+ /// Cached peer address, returned by `accept` or the first successful+ /// `peer_addr` query. The stream may no longer report it after a reset.+ peer: Option<SocketAddr>,receive_taken: bool,send_taken: bool,},@@ -63,9 +66,10 @@ enum TcpState {Closed(ErrorCode),}impl TcpState {- fn connected(stream: tokio::net::TcpStream) -> Self {+ fn connected(stream: tokio::net::TcpStream, peer: Option<SocketAddr>) -> Self {TcpState::Connected {stream: Arc::new(stream),+ peer,receive_taken: false,send_taken: false,}@@ -236,7 +240,7 @@ impl TcpSocket {match connect.unwrap_ready() {Ok(stream) => {- self.tcp_state = TcpState::connected(stream);+ self.tcp_state = TcpState::connected(stream, None);Poll::Ready(Ok(()))}Err(err) => {@@ -379,9 +383,16 @@ impl TcpSocket {}}- pub(crate) fn remote_address(&self) -> Result<SocketAddr, ErrorCode> {- match &self.tcp_state {- TcpState::Connected { stream, .. } => Ok(stream.peer_addr()?),+ pub(crate) fn remote_address(&mut self) -> Result<SocketAddr, ErrorCode> {+ match &mut self.tcp_state {+ TcpState::Connected {+ peer: Some(peer), ..+ } => Ok(*peer),+ TcpState::Connected { stream, peer, .. } => {+ let addr = stream.peer_addr()?;+ *peer = Some(addr);+ Ok(addr)+ }TcpState::Closed(err) => Err(*err),_ => Err(ErrorCode::InvalidState),}@@ -542,7 +553,7 @@ pub(crate) struct TcpListenStream {family: SocketAddressFamily,listener_options: NonInheritedOptions,permissions: SocketAddrCheck,- pending_accept: Option<MaybeReady<Result<tokio::net::TcpStream, ErrorCode>>>,+ pending_accept: Option<MaybeReady<Result<(tokio::net::TcpStream, SocketAddr), ErrorCode>>>,}impl TcpListenStream {pub(crate) fn poll_accept(&mut self, cx: &mut std::task::Context<'_>) -> Poll<TcpSocket> {@@ -550,9 +561,9 @@ impl TcpListenStream {let result = self.pending_accept.take().unwrap().unwrap_ready();Poll::Ready(TcpSocket {tcp_state: match result {- Ok(client) => {+ Ok((client, peer)) => {self.listener_options.apply(self.family, &client);- TcpState::connected(client)+ TcpState::connected(client, Some(peer))}Err(err) => TcpState::Closed(err),},@@ -578,7 +589,7 @@ impl TcpListenStream {.await.is_ok(){- return Ok(client);+ return Ok((client, addr));} else {reset(client);continue;@@ -893,3 +904,84 @@ fn clamp_keep_alive_count(value: u32) -> u32 {value.clamp(MIN_CNT, MAX_CNT)}++#[cfg(all(test, any(target_os = "linux", target_os = "macos")))]+mod tests {+ use super::*;+ use crate::WasiCtxBuilder;++ #[tokio::test]+ async fn accepted_remote_address_survives_reset() {+ let mut ctx = WasiCtxBuilder::new();+ ctx.inherit_network().allow_tcp(true);+ let ctx = ctx.build();+ let mut socket = TcpSocket::new(&ctx.sockets, SocketAddressFamily::Ipv4).unwrap();+ socket.bind("127.0.0.1:0".parse().unwrap()).await.unwrap();+ let mut listener = socket.listen().await.unwrap();++ let client = tokio::net::TcpStream::connect(socket.local_address().unwrap())+ .await+ .unwrap();+ let peer = client.local_addr().unwrap();++ // Complete the OS accept, but leave the result pending for poll_accept.+ poll_fn(|cx| listener.poll_ready(cx)).await;+ client.set_zero_linger().unwrap();+ drop(client);++ let mut accepted = poll_fn(|cx| listener.poll_accept(cx)).await;+ let mut input = accepted.take_receive_stream().unwrap();+ let mut byte = [0];+ let read = tokio::time::timeout(+ Duration::from_secs(5),+ poll_fn(|cx| input.poll_read(cx, &mut byte)),+ )+ .await+ .unwrap();+ assert!(matches!(read, Err(ErrorCode::ConnectionReset)));++ // The OS no longer answers getpeername, but accept already had the+ // address and the accepted socket must still report it.+ let TcpState::Connected { stream, .. } = &accepted.tcp_state else {+ panic!("expected an accepted connection");+ };+ assert!(stream.peer_addr().is_err());+ assert_eq!(accepted.remote_address().unwrap(), peer);+ }++ #[tokio::test]+ async fn connected_remote_address_survives_reset() {+ let mut ctx = WasiCtxBuilder::new();+ ctx.inherit_network().allow_tcp(true);+ let ctx = ctx.build();+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let peer = listener.local_addr().unwrap();++ let mut client = TcpSocket::new(&ctx.sockets, SocketAddressFamily::Ipv4).unwrap();+ client.start_connect(peer).unwrap();+ poll_fn(|cx| client.poll_finish_connect(cx)).await.unwrap();+ let (server, _) = listener.accept().await.unwrap();++ // Query the outgoing socket's peer while the connection is healthy.+ assert_eq!(client.remote_address().unwrap(), peer);+ server.set_zero_linger().unwrap();+ drop(server);++ let mut input = client.take_receive_stream().unwrap();+ let mut byte = [0];+ let read = tokio::time::timeout(+ Duration::from_secs(5),+ poll_fn(|cx| input.poll_read(cx, &mut byte)),+ )+ .await+ .unwrap();+ assert!(matches!(read, Err(ErrorCode::ConnectionReset)));++ // Subsequent queries must use the previously observed peer address.+ let TcpState::Connected { stream, .. } = &client.tcp_state else {+ panic!("expected an outgoing connection");+ };+ assert!(stream.peer_addr().is_err());+ assert_eq!(client.remote_address().unwrap(), peer);+ }+}