fix(proto): floor negative echo lengths

crates/irtt-client/src/async_client.rs

@@ -246,7 +246,7 @@ impl AsyncClient {
             machine,
             schedule: None,
             remote,
-            recv_buffer: vec![0_u8; recv_buffer_size(false, None)?],
+            recv_buffer: vec![0_u8; recv_buffer_size(false, None)],
             applied_traffic_class: None,
             prepared_open: Some(prepared_open),
             prepared_probe: None,
@@ -820,12 +820,7 @@ impl AsyncClient {
                 return Err(Box::new(PreparedAsyncOpenFailure { primary, machine }));
             }
         };
-        let recv_buffer_len = match recv_buffer_size(self.machine.has_hmac(), Some(negotiated)) {
-            Ok(size) => size,
-            Err(primary) => {
-                return Err(Box::new(PreparedAsyncOpenFailure { primary, machine }));
-            }
-        };
+        let recv_buffer_len = recv_buffer_size(self.machine.has_hmac(), Some(negotiated));
         let negotiated_traffic_class = match u8::try_from(negotiated.params.dscp) {
             Ok(traffic_class) => traffic_class,
             Err(_) => {

crates/irtt-client/src/client.rs

@@ -131,7 +131,7 @@ impl Client {
             schedule: None,
             socket,
             remote,
-            recv_buffer: vec![0_u8; recv_buffer_size(false, None)?],
+            recv_buffer: vec![0_u8; recv_buffer_size(false, None)],
             applied_traffic_class: None,
             #[cfg(test)]
             test_hooks: ClientTestHooks::default(),
@@ -530,10 +530,7 @@ impl Client {
             Ok(schedule) => schedule,
             Err(primary) => return Err(Box::new(PreparedClientOpenFailure { primary, machine })),
         };
-        let recv_buffer_len = match recv_buffer_size(self.runtime.has_hmac(), Some(negotiated)) {
-            Ok(size) => size,
-            Err(primary) => return Err(Box::new(PreparedClientOpenFailure { primary, machine })),
-        };
+        let recv_buffer_len = recv_buffer_size(self.runtime.has_hmac(), Some(negotiated));
         #[cfg(test)]
         let recv_buffer_len = self
             .test_hooks

crates/irtt-client/src/client/tests/support.rs

@@ -1,8 +1,8 @@
 use super::*;
+pub(crate) use irtt_proto::echo_packet_len;
 use irtt_proto::{
-    echo_packet_len as checked_echo_packet_len, encode_echo_reply, encode_open_reply,
-    flags::FLAG_OPEN, flags::FLAG_REPLY, layout::PacketLayout, Clock, EchoReply, OpenReply,
-    ReceivedStats, StampAt,
+    encode_echo_reply, encode_open_reply, flags::FLAG_OPEN, flags::FLAG_REPLY,
+    layout::PacketLayout, Clock, EchoReply, OpenReply, ReceivedStats, StampAt,
 };
 use std::{
     net::UdpSocket,
@@ -72,11 +72,6 @@ pub(super) fn open_reply(
     .unwrap()
 }
 
-pub(crate) fn echo_packet_len(hmac: bool, params: &Params) -> usize {
-    checked_echo_packet_len(hmac, params)
-        .expect("test params must have a non-negative packet length")
-}
-
 pub(super) fn echo_reply_packet(
     token: u64,
     seq: u32,

crates/irtt-client/src/session/machine.rs

@@ -235,7 +235,6 @@ impl SessionMachine {
                 | irtt_proto::ProtoError::VarintOverflow
                 | irtt_proto::ProtoError::InvalidUtf8
                 | irtt_proto::ProtoError::InvalidEnum { .. }
-                | irtt_proto::ProtoError::NegativePacketLength { .. }
                 | irtt_proto::ProtoError::ParameterLengthTooLarge { .. }
                 | irtt_proto::ProtoError::MalformedParams),
             ) => Err(ClientError::Protocol(error)),
@@ -824,16 +823,13 @@ impl SessionMachine {
     }
 }
 
-pub(crate) fn recv_buffer_size(
-    has_hmac: bool,
-    negotiated: Option<&NegotiatedParams>,
-) -> Result<usize, ClientError> {
-    Ok(match negotiated {
-        Some(negotiated) => echo_packet_len(has_hmac, &negotiated.params)?
+pub(crate) fn recv_buffer_size(has_hmac: bool, negotiated: Option<&NegotiatedParams>) -> usize {
+    match negotiated {
+        Some(negotiated) => echo_packet_len(has_hmac, &negotiated.params)
             .saturating_add(1)
             .max(MIN_RECV_BUFFER_SIZE),
         None => MIN_RECV_BUFFER_SIZE,
-    })
+    }
 }
 
 pub(crate) fn params_from_config(config: &ClientConfig) -> Result<Params, ClientError> {

crates/irtt-client/tests/support/mod.rs

@@ -12,12 +12,13 @@ use std::{
 
 use irtt_client::{Client, ClientConfig, ClientEvent, NegotiatedParams, OpenOutcome, SocketConfig};
 use irtt_proto::{
-    compute_hmac_in_place, decode_request, echo_packet_len, encode_echo_reply, encode_open_reply,
-    flags, verify_packet_hmac, Clock, DecodedRequest, DecodedRequestKind, EchoReply, OpenReply,
+    compute_hmac_in_place, decode_request, encode_echo_reply, encode_open_reply, flags,
+    verify_packet_hmac, Clock, DecodedRequest, DecodedRequestKind, EchoReply, OpenReply,
     PacketLayout, Params, ProtoError, ReceivedStats, ServerFill, StampAt, TimestampFields,
     HMAC_SIZE, MAGIC, PROTOCOL_VERSION,
 };
 
+pub(super) use irtt_proto::echo_packet_len as test_echo_packet_len;
 pub use real_irtt::RealIrtServer;
 
 const HMAC_OFFSET: usize = 4;
@@ -533,11 +534,6 @@ fn open_reply(flags: u8, token: u64, params: &Params, hmac_key: Option<&[u8]>) -
     .unwrap()
 }
 
-pub(super) fn test_echo_packet_len(hmac: bool, params: &Params) -> usize {
-    echo_packet_len(hmac, params)
-        .expect("managed runner test params must have a non-negative packet length")
-}
-
 fn echo_reply_packet(
     token: u64,
     seq: u32,