Skip to content

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.yml
index f702a216f4..b82d932598 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -755,7 +755,7 @@ jobs:
- uses: ./.github/actions/cargo-install
with:
crate: cargo-fuzz
- version: 0.13.1
+ version: 0.13.2
- uses: ./.github/actions/apt-get-install
with:
packages: ocaml-nox ocamlbuild ocaml-findlib libzarith-ocaml-dev
diff --git a/crates/wasi/src/p2/host/tcp.rs b/crates/wasi/src/p2/host/tcp.rs
index 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.rs
index 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.rs
index 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);
+ }
+}