anemo: allow separate max_frame_size for requests and responses (#71)

* anemo: allow separate max_frame_size for requests and responses

Adds `max_request_frame_size` and `max_response_frame_size` Config
options. Each falls back to `max_frame_size` when unset, preserving
existing behavior.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix rustdoc intra-doc link to public Config fields

Rename the private accessors (`max_request_frame_size`,
`max_response_frame_size`) to `request_frame_size` /
`response_frame_size` so the public field names referenced in the
`max_frame_size` doc comment resolve to the public fields rather than
the private methods.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: aschran

crates/anemo/src/config.rs

@@ -91,12 +91,26 @@ pub struct Config {
 
     /// Set the maximum frame size in bytes.
     ///
-    /// This controls the maximum size of a request or response.
+    /// This controls the maximum size of a request or response. Acts as the default
+    /// for both directions when [`Config::max_request_frame_size`] or
+    /// [`Config::max_response_frame_size`] are not set.
     ///
     /// If unspecified, there will be no limit.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub max_frame_size: Option<usize>,
 
+    /// Set the maximum frame size in bytes for request messages.
+    ///
+    /// If unspecified, falls back to [`Config::max_frame_size`].
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_request_frame_size: Option<usize>,
+
+    /// Set the maximum frame size in bytes for response messages.
+    ///
+    /// If unspecified, falls back to [`Config::max_frame_size`].
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_response_frame_size: Option<usize>,
+
     /// Set a timeout, in milliseconds, for all inbound requests.
     ///
     /// When an inbound timeout is hit when processing a request a Response is sent to the
@@ -271,8 +285,12 @@ impl Config {
             .unwrap_or(PEER_EVENT_BROADCAST_CHANNEL_CAPACITY)
     }
 
-    pub(crate) fn max_frame_size(&self) -> Option<usize> {
-        self.max_frame_size
+    pub(crate) fn request_frame_size(&self) -> Option<usize> {
+        self.max_request_frame_size.or(self.max_frame_size)
+    }
+
+    pub(crate) fn response_frame_size(&self) -> Option<usize> {
+        self.max_response_frame_size.or(self.max_frame_size)
     }
 
     pub(crate) fn inbound_request_timeout(&self) -> Option<Duration> {

crates/anemo/src/network/peer.rs

@@ -1,5 +1,7 @@
 use super::{
-    wire::{network_message_frame_codec, read_response, write_request},
+    wire::{
+        read_response, request_message_frame_codec, response_message_frame_codec, write_request,
+    },
     OutboundRequestLayer,
 };
 use crate::{connection::Connection, Config, PeerId, Request, Response, Result};
@@ -50,9 +52,9 @@ impl Peer {
     async fn do_rpc(&self, request: Request<Bytes>) -> Result<Response<Bytes>> {
         let (send_stream, recv_stream) = self.connection.open_bi().await?;
         let mut send_stream =
-            FramedWrite::new(send_stream, network_message_frame_codec(&self.config));
+            FramedWrite::new(send_stream, request_message_frame_codec(&self.config));
         let mut recv_stream =
-            FramedRead::new(recv_stream, network_message_frame_codec(&self.config));
+            FramedRead::new(recv_stream, response_message_frame_codec(&self.config));
 
         //
         // Write Request

crates/anemo/src/network/request_handler.rs

@@ -1,6 +1,8 @@
 use super::wire::MessageFrameCodec;
 use super::{
-    wire::{network_message_frame_codec, read_request, write_response},
+    wire::{
+        read_request, request_message_frame_codec, response_message_frame_codec, write_response,
+    },
     ActivePeers,
 };
 use crate::{
@@ -137,8 +139,8 @@ impl BiStreamRequestHandler {
         Self {
             connection,
             service,
-            send_stream: FramedWrite::new(send_stream, network_message_frame_codec(config)),
-            recv_stream: FramedRead::new(recv_stream, network_message_frame_codec(config)),
+            send_stream: FramedWrite::new(send_stream, response_message_frame_codec(config)),
+            recv_stream: FramedRead::new(recv_stream, request_message_frame_codec(config)),
         }
     }
 

crates/anemo/src/network/tests.rs

@@ -1,4 +1,4 @@
-use crate::{types::PeerEvent, Network, NetworkRef, Request, Response, Result};
+use crate::{types::PeerEvent, Config, Network, NetworkRef, Request, Response, Result};
 use bytes::{Buf, BufMut, Bytes, BytesMut};
 use futures::FutureExt;
 use std::{convert::Infallible, time::Duration};
@@ -868,3 +868,104 @@ async fn network_ref_via_extension() -> Result<()> {
 
     Ok(())
 }
+
+fn build_network_with_config(config: Config) -> Result<Network> {
+    let network = Network::bind("localhost:0")
+        .random_private_key()
+        .server_name("test")
+        .config(config)
+        .start(echo_service())?;
+
+    trace!(
+        address =% network.local_addr(),
+        peer_id =% network.peer_id(),
+        "starting network"
+    );
+
+    Ok(network)
+}
+
+#[tokio::test]
+async fn server_max_request_frame_size_rejects_large_requests() -> Result<()> {
+    let _guard = crate::init_tracing_for_testing();
+
+    let server = build_network_with_config(Config {
+        max_request_frame_size: Some(128),
+        ..Default::default()
+    })?;
+    let client = build_network()?;
+
+    let peer = client.connect(server.local_addr()).await?;
+
+    // Request body within the server's request limit succeeds.
+    let small = vec![0u8; 32];
+    let response = client.rpc(peer, Request::new(small.clone().into())).await?;
+    assert_eq!(response.into_body().as_ref(), small.as_slice());
+
+    // Request body exceeding the server's request limit is rejected by the server,
+    // and the client sees the RPC fail.
+    let big = vec![0u8; 4096];
+    client
+        .rpc(peer, Request::new(big.into()))
+        .await
+        .unwrap_err();
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn client_max_response_frame_size_rejects_large_responses() -> Result<()> {
+    let _guard = crate::init_tracing_for_testing();
+
+    let server = build_network()?;
+    let client = build_network_with_config(Config {
+        max_response_frame_size: Some(128),
+        ..Default::default()
+    })?;
+
+    let peer = client.connect(server.local_addr()).await?;
+
+    // Response body within the client's response limit succeeds.
+    let small = vec![0u8; 32];
+    let response = client.rpc(peer, Request::new(small.clone().into())).await?;
+    assert_eq!(response.into_body().as_ref(), small.as_slice());
+
+    // The echoed response exceeds the client's response limit. The request itself
+    // is still within the (default) request limit, so it leaves the client and the
+    // server processes it; the failure happens when the client tries to decode the
+    // response.
+    let big = vec![0u8; 4096];
+    client
+        .rpc(peer, Request::new(big.into()))
+        .await
+        .unwrap_err();
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn max_frame_size_falls_back_for_both_directions() -> Result<()> {
+    let _guard = crate::init_tracing_for_testing();
+
+    // Setting only the legacy `max_frame_size` should constrain both directions,
+    // matching pre-existing behavior.
+    let server = build_network_with_config(Config {
+        max_frame_size: Some(128),
+        ..Default::default()
+    })?;
+    let client = build_network()?;
+
+    let peer = client.connect(server.local_addr()).await?;
+
+    let small = vec![0u8; 32];
+    let response = client.rpc(peer, Request::new(small.clone().into())).await?;
+    assert_eq!(response.into_body().as_ref(), small.as_slice());
+
+    let big = vec![0u8; 4096];
+    client
+        .rpc(peer, Request::new(big.into()))
+        .await
+        .unwrap_err();
+
+    Ok(())
+}

crates/anemo/src/network/wire.rs

@@ -122,10 +122,19 @@ impl Encoder<Bytes> for MessageFrameCodec {
     }
 }
 
-/// Returns a fully configured message frame codec for writing/reading
-/// serialized frames to/from a socket.
-pub(crate) fn network_message_frame_codec(config: &Config) -> MessageFrameCodec {
-    let max_frame_length = config.max_frame_size().unwrap_or(DEFAULT_MAX_FRAME_LENGTH);
+/// Returns a message frame codec sized for request messages.
+pub(crate) fn request_message_frame_codec(config: &Config) -> MessageFrameCodec {
+    let max_frame_length = config
+        .request_frame_size()
+        .unwrap_or(DEFAULT_MAX_FRAME_LENGTH);
+    MessageFrameCodec::new(max_frame_length)
+}
+
+/// Returns a message frame codec sized for response messages.
+pub(crate) fn response_message_frame_codec(config: &Config) -> MessageFrameCodec {
+    let max_frame_length = config
+        .response_frame_size()
+        .unwrap_or(DEFAULT_MAX_FRAME_LENGTH);
     MessageFrameCodec::new(max_frame_length)
 }