diff --git a/codex-rs/realtime-webrtc/src/client.rs b/codex-rs/realtime-webrtc/src/client.rs index 98e467ff05..3073ca4dd2 100644 --- a/codex-rs/realtime-webrtc/src/client.rs +++ b/codex-rs/realtime-webrtc/src/client.rs @@ -4,20 +4,17 @@ use std::collections::HashMap; use std::ffi::OsString; use std::time::Duration; -use anyhow::Context; use anyhow::Result; use anyhow::ensure; use codex_install_context::CodexPackageLayout; use codex_utils_pty::ProcessHandle; use codex_utils_pty::SpawnedProcess; -use tokio::sync::mpsc; use tokio::sync::oneshot; use tokio::time::timeout; -use crate::MAX_FRAME_BYTES; use crate::Message; -use crate::decode_frame; use crate::encode_frame; +use crate::message_reader::MessageReader; const DEADLINE: Duration = Duration::from_secs(/*secs*/ 5); @@ -25,7 +22,7 @@ const DEADLINE: Duration = Duration::from_secs(/*secs*/ 5); /// A successful handshake establishes compatibility only, not an active audio session. pub struct VoiceHost { process: ProcessHandle, - output: mpsc::Receiver>, + output: MessageReader, exit: oneshot::Receiver, } @@ -60,7 +57,7 @@ impl VoiceHost { drop(stderr_rx); // Drain and discard diagnostics rather than logging untyped child output. let mut host = Self { process: session, - output: stdout_rx, + output: MessageReader::new(stdout_rx), exit: exit_rx, }; host.exchange( @@ -92,23 +89,9 @@ impl VoiceHost { .send(encode_frame(&request)?) .await .map_err(|_| anyhow::anyhow!("voice helper input closed"))?; - let mut frame = Vec::new(); - loop { - let chunk = self - .output - .recv() - .await - .context("voice helper output closed")?; - ensure!( - frame.len() + chunk.len() <= MAX_FRAME_BYTES + 4, - "voice helper output exceeds limit" - ); - frame.extend(chunk); - if let Some(response) = decode_frame(&frame)? { - ensure!(response == expected, "unexpected voice helper response"); - return Ok(()); - } - } + let response = self.output.next().await?; + ensure!(response == expected, "unexpected voice helper response"); + Ok(()) }) .await? } diff --git a/codex-rs/realtime-webrtc/src/lib.rs b/codex-rs/realtime-webrtc/src/lib.rs index dcbe7b49d2..281808152b 100644 --- a/codex-rs/realtime-webrtc/src/lib.rs +++ b/codex-rs/realtime-webrtc/src/lib.rs @@ -1,4 +1,5 @@ mod client; +mod message_reader; mod protocol; pub use client::VoiceHost; diff --git a/codex-rs/realtime-webrtc/src/message_reader.rs b/codex-rs/realtime-webrtc/src/message_reader.rs new file mode 100644 index 0000000000..aaa45f8d7a --- /dev/null +++ b/codex-rs/realtime-webrtc/src/message_reader.rs @@ -0,0 +1,61 @@ +//! Read bounded helper frames independently of pipe chunks; cancellation retains partial input. + +use std::io; + +use tokio::sync::mpsc; + +use crate::Message; +use crate::decode_frame; + +// Matches the maximum read in codex_utils_pty's pipe output reader. Retain at most +// one such chunk and one bounded partial frame, never a queue of decoded messages. +const MAX_CHUNK_BYTES: usize = 8_192; + +pub(crate) struct MessageReader { + output: mpsc::Receiver>, + pending: std::vec::IntoIter, + frame: Vec, +} + +impl MessageReader { + pub(crate) fn new(output: mpsc::Receiver>) -> Self { + Self { + output, + pending: Vec::new().into_iter(), + frame: Vec::new(), + } + } + + pub(crate) async fn next(&mut self) -> io::Result { + loop { + let target = if let [a, b, c, d, ..] = self.frame.as_slice() { + // Validate the header before consuming or allocating its payload. + decode_frame(&self.frame)?; + u32::from_be_bytes([*a, *b, *c, *d]) as usize + 4 + } else { + 4 + }; + while self.frame.len() < target { + if self.pending.len() == 0 { + let chunk = self.output.recv().await.ok_or_else(|| { + io::Error::new(io::ErrorKind::UnexpectedEof, "voice helper output closed") + })?; + if chunk.is_empty() || chunk.len() > MAX_CHUNK_BYTES { + return Err(io::Error::other("invalid voice helper output chunk")); + } + self.pending = chunk.into_iter(); + } + self.frame + .extend(self.pending.by_ref().take(target - self.frame.len())); + } + if let Some(message) = decode_frame(&self.frame)? { + self.frame.clear(); + return Ok(message); + } + } + } +} + +#[cfg(test)] +#[path = "message_reader_tests.rs"] +mod tests; diff --git a/codex-rs/realtime-webrtc/src/message_reader_tests.rs b/codex-rs/realtime-webrtc/src/message_reader_tests.rs new file mode 100644 index 0000000000..e21e756a23 --- /dev/null +++ b/codex-rs/realtime-webrtc/src/message_reader_tests.rs @@ -0,0 +1,144 @@ +//! Exercise real frame decoding across pipe boundaries, cancellation, and invalid input. + +use std::future::Future; +use std::io; +use std::task::Context; +use std::task::Poll; +use std::task::Waker; + +use pretty_assertions::assert_eq; +use tokio::sync::mpsc; + +use super::MAX_CHUNK_BYTES; +use super::MessageReader; +use crate::MAX_FRAME_BYTES; +use crate::Message; +use crate::encode_frame; + +#[tokio::test] +async fn reads_fragmented_and_coalesced_messages() -> io::Result<()> { + let expected = [ + Message::Hello { + protocol: 1, + build_commit: "test-build".into(), + }, + Message::Ready {}, + Message::Close {}, + Message::Closed {}, + ]; + let frames = expected + .iter() + .map(encode_frame) + .collect::>>()? + .concat(); + // Every split exercises both a partial frame and multiple messages in a chunk. + for split in 1..frames.len() { + let (sender, receiver) = mpsc::channel(/*buffer*/ 2); + sender.try_send(frames[..split].to_vec()).unwrap(); + sender.try_send(frames[split..].to_vec()).unwrap(); + drop(sender); + let mut reader = MessageReader::new(receiver); + let mut actual = Vec::new(); + for _ in &expected { + actual.push(reader.next().await?); + } + assert_eq!(actual, expected); + assert_eq!( + reader.next().await.unwrap_err().kind(), + io::ErrorKind::UnexpectedEof + ); + } + Ok(()) +} + +#[tokio::test] +async fn cancelled_read_preserves_each_partial_header_and_payload() -> io::Result<()> { + let expected = Message::Hello { + protocol: 1, + build_commit: "test-build".into(), + }; + let frame = encode_frame(&expected)?; + for split in 1..frame.len() { + let (sender, receiver) = mpsc::channel(/*buffer*/ 1); + sender.try_send(frame[..split].to_vec()).unwrap(); + let mut reader = MessageReader::new(receiver); + { + let mut read = std::pin::pin!(reader.next()); + assert!(matches!( + read.as_mut().poll(&mut Context::from_waker(Waker::noop())), + Poll::Pending + )); + } + sender.try_send(frame[split..].to_vec()).unwrap(); + assert_eq!(reader.next().await?, expected); + } + Ok(()) +} + +#[tokio::test] +async fn rejects_oversized_headers_without_waiting_for_payload() { + for length in [MAX_FRAME_BYTES as u32 + 1, u32::MAX] { + let (sender, receiver) = mpsc::channel(/*buffer*/ 1); + sender.try_send(length.to_be_bytes().to_vec()).unwrap(); + let mut reader = MessageReader::new(receiver); + let mut read = std::pin::pin!(reader.next()); + assert!(matches!( + read.as_mut().poll(&mut Context::from_waker(Waker::noop())), + Poll::Ready(Err(_)) + )); + } +} + +#[tokio::test] +async fn rejects_truncation_at_every_byte_boundary() -> io::Result<()> { + let frame = encode_frame(&Message::Ready {})?; + for end in 0..frame.len() { + let (sender, receiver) = mpsc::channel(/*buffer*/ 1); + if end > 0 { + sender.try_send(frame[..end].to_vec()).unwrap(); + } + drop(sender); + assert_eq!( + MessageReader::new(receiver) + .next() + .await + .unwrap_err() + .kind(), + io::ErrorKind::UnexpectedEof + ); + } + Ok(()) +} + +#[tokio::test] +async fn rejects_malformed_input_without_echoing_payload() { + let secret = b"sensitive-invalid-json"; + let mut invalid = (secret.len() as u32).to_be_bytes().to_vec(); + invalid.extend(secret); + let (sender, receiver) = mpsc::channel(/*buffer*/ 1); + sender.try_send(invalid).unwrap(); + assert_eq!( + MessageReader::new(receiver) + .next() + .await + .unwrap_err() + .to_string(), + "invalid voice frame" + ); +} + +#[tokio::test] +async fn rejects_chunks_outside_the_pipe_read_bound() { + for chunk in [vec![], vec![0; MAX_CHUNK_BYTES + 1]] { + let (sender, receiver) = mpsc::channel(/*buffer*/ 1); + sender.try_send(chunk).unwrap(); + assert_eq!( + MessageReader::new(receiver) + .next() + .await + .unwrap_err() + .to_string(), + "invalid voice helper output chunk" + ); + } +}