From c574773c88f9e78e8274c305969aa84e30165949 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 30 Oct 2026 05:09:20 -0700 Subject: [PATCH 1/2] chore(quest): claim quest/m2/setup-parse-once.md Quest-Claim: 50a5db016ec0e072 From 77369c834a133a48f92d33a51b7186672a79834b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 30 Oct 2026 05:48:31 -0700 Subject: [PATCH 2/2] refactor(net): parse a moq-transport SETUP's parameters once `decode_peer_setup` now returns a typed `SetupOptions` (path, token, implementation, declared `Peer`) and `accept_setup` builds its `PeerSetup` from it, so the server's pre-read and the uni loop share one parse. Co-Authored-By: Claude Opus 5.5 --- quest/m2/README.md | 1 - quest/m2/setup-parse-once.md | 13 ---- rs/moq-net/src/fuzz.rs | 4 +- rs/moq-net/src/ietf/session.rs | 123 ++++++++++++++++----------------- rs/moq-net/src/server.rs | 25 ++++--- 5 files changed, 74 insertions(+), 92 deletions(-) delete mode 100644 quest/m2/setup-parse-once.md diff --git a/quest/m2/README.md b/quest/m2/README.md index 4f4f2452b0a..b0b38f4955c 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -258,7 +258,6 @@ lite-07; bitrate enforcement is not part of this release. - [Lint override and deprecation audit](/quest/m2/audit-lints.md) - repeat the suppression and deprecation audit after the release ships, starting with clippy on the macOS and Windows targets - [Bound cmsg payload reads](/quest/m2/cmsg-decode-bound.md) - `CMsg::decode` refuses a short control message, and Tokio sockets keep the ECN mark - [Tenant matrix on both runtimes](/quest/m2/tenant-matrix.md) - tenant, mount, HTTP, normalization, and revalidation boundaries are tested on Tokio and io_uring -- [One typed SETUP parse](/quest/m2/setup-parse-once.md) - one function replaces three SETUP parameter parses - [Archive reads against a real store](/quest/m2/archive-store-bench.md) - LIST/GET counts and latency over track count - [A malformed track says so downstream](/quest/m2/malformed-track-status.md) - subscribers and bindings see a malformed track, not INTERNAL_ERROR - [Branch checks lint examples](/quest/m2/lint-examples.md) - `just check` runs clippy on the selected crates' examples diff --git a/quest/m2/setup-parse-once.md b/quest/m2/setup-parse-once.md deleted file mode 100644 index 6c28ba59380..00000000000 --- a/quest/m2/setup-parse-once.md +++ /dev/null @@ -1,13 +0,0 @@ -# [S] One typed SETUP parse - -## Goal - -One function turns SETUP parameters into path, token, implementation, and -`Peer` for every caller, replacing the three copies in -`rs/moq-net/src/server.rs` (legacy CLIENT_SETUP) and -`rs/moq-net/src/ietf/session.rs` (`accept_setup`, `decode_peer_setup`). - -## Plan - -- The legacy copy builds `Peer` by hand without cluster, auth, or epoch; - check whether that difference is intended before unifying. diff --git a/rs/moq-net/src/fuzz.rs b/rs/moq-net/src/fuzz.rs index 45c1f9efea5..5cb5ee2417f 100644 --- a/rs/moq-net/src/fuzz.rs +++ b/rs/moq-net/src/fuzz.rs @@ -730,9 +730,9 @@ where let outer = crate::Version::Ietf(version); if let Ok((message, _)) = T::decode_slice(data, outer) { let parameters = parameters(&message); - if ietf::decode_peer_setup(parameters.clone(), version, true).is_ok() { + if ietf::decode_peer_setup(parameters, version, true).is_ok() { assert!( - ietf::decode_peer_setup(parameters.clone(), version, false).is_ok(), + ietf::decode_peer_setup(parameters, version, false).is_ok(), "a server's Setup Options are refused from a client" ); } diff --git a/rs/moq-net/src/ietf/session.rs b/rs/moq-net/src/ietf/session.rs index e0467d3274a..961453ede74 100644 --- a/rs/moq-net/src/ietf/session.rs +++ b/rs/moq-net/src/ietf/session.rs @@ -485,17 +485,8 @@ pub struct PeerSetup { /// The SETUP's encoded size, counted once the session's stats are known. pub size: usize, - /// The request path the peer advertised, for URL-less transports. - pub path: Option, - - /// The credential the peer presented in its `AUTHORIZATION TOKEN` option. - pub token: Option, - - /// The implementation the peer advertised in its `IMPLEMENTATION` option. - pub implementation: Option, - - /// The Setup Options it declared (see [`cluster`] and [`solicit`]). - pub declared: peer::Peer, + /// What the SETUP's parameters say. + pub options: SetupOptions, /// Uni streams that arrived before the SETUP, type peeked but unread. The drafts say /// to buffer early data until the control streams arrive, so the session classifies @@ -546,70 +537,72 @@ pub async fn accept_setup(session: &mut Transport, version: Version) -> Result

().await?; - let (params, _) = ietf::Parameters::decode_slice(&setup.parameters, version)?; - if session.address() == crate::transport::Address::Uri && params.get_bytes(ietf::ParameterBytes::Path).is_some() - { + let options = decode_peer_setup(&setup.parameters, version, false)?; + if session.address() == crate::transport::Address::Uri && options.path.is_some() { return Err(Error::ProtocolViolation); } - let path = match params.get_bytes(ietf::ParameterBytes::Path) { - Some(bytes) => Some( - std::str::from_utf8(bytes) - .map_err(|_| Error::Decode(crate::DecodeError::InvalidValue))? - .to_owned(), - ), - None => None, - }; - let token = super::token::from_setup(¶ms, version)?; - let implementation = - crate::setup::decode_implementation(params.get_bytes(ietf::ParameterBytes::Implementation))?; - let declared = peer_from_params(¶ms, version)?; return Ok(PeerSetup { stream: reader, size, - path, - token, - implementation, - declared, + options, early, }); } } -/// Parse the Setup Options we act on out of a raw SETUP parameter block, refusing any the -/// peer's role may not send. -pub(crate) fn decode_peer_setup( - parameters: bytes::Bytes, - version: Version, - client: bool, -) -> Result<(peer::Peer, Option), Error> { - let (params, _) = ietf::Parameters::decode_slice(¶meters, version)?; +/// What a peer's SETUP parameters say, parsed by [`decode_peer_setup`] for every caller. +pub struct SetupOptions { + /// The request path the peer advertised, for URL-less transports. + pub path: Option, + + /// The credential the peer presented in its `AUTHORIZATION TOKEN` option. + pub token: Option, + + /// The implementation the peer advertised in its `IMPLEMENTATION` option. + pub implementation: Option, + + /// The Setup Options it declared (see [`cluster`] and [`solicit`]). + pub declared: peer::Peer, +} + +/// Parse a peer's raw SETUP parameter block, refusing any option the peer's role may not +/// send. `client` is our role, so `true` means the block came from a server. +pub(crate) fn decode_peer_setup(parameters: &[u8], version: Version, client: bool) -> Result { + let (params, _) = ietf::Parameters::decode_slice(parameters, version)?; + let path = params.get_bytes(ietf::ParameterBytes::Path); // A server sends neither PATH nor AUTHORITY (draft-22 sections 9.1.1 and 9.1.2). - if client && params.get_bytes(ietf::ParameterBytes::Path).is_some() { + if client && path.is_some() { return Err(SessionError::InvalidPath.into()); } if client && params.get_bytes(ietf::ParameterBytes::Authority).is_some() { return Err(SessionError::InvalidAuthority.into()); } - // Nothing here uses the peer's token, but one that cannot be decoded still closes the - // session (draft-22 section 8.9). - super::token::from_setup(¶ms, version)?; - let implementation = crate::setup::decode_implementation(params.get_bytes(ietf::ParameterBytes::Implementation))?; - Ok((peer_from_params(¶ms, version)?, implementation)) -} + let path = match path { + Some(bytes) => Some( + std::str::from_utf8(bytes) + .map_err(|_| Error::Decode(crate::DecodeError::InvalidValue))? + .to_owned(), + ), + None => None, + }; -/// The Setup Options we act on, out of an already-decoded parameter block. One place, so -/// a future option reaches both the pre-read accept path and the uni loop. -fn peer_from_params(params: &ietf::Parameters, version: Version) -> Result { - Ok(peer::Peer { - cluster: cluster::peer_from_setup(params)?, - solicit: solicit::from_setup(params, version)?, - hidden: hidden::from_setup(params, version), - max_age: max_age::from_setup(params, version), - auth: auth::from_setup(params) == Some(true), - active_count: active_count::from_setup(params), - epoch: epoch::from_setup(params), - flate: super::flate::from_setup(params)?, + Ok(SetupOptions { + path, + // A token that cannot be decoded closes the session even where nothing uses it + // (draft-22 section 8.9). + token: super::token::from_setup(¶ms, version)?, + implementation: crate::setup::decode_implementation(params.get_bytes(ietf::ParameterBytes::Implementation))?, + declared: peer::Peer { + cluster: cluster::peer_from_setup(¶ms)?, + solicit: solicit::from_setup(¶ms, version)?, + hidden: hidden::from_setup(¶ms, version), + max_age: max_age::from_setup(¶ms, version), + auth: auth::from_setup(¶ms) == Some(true), + active_count: active_count::from_setup(¶ms), + epoch: epoch::from_setup(¶ms), + flate: super::flate::from_setup(¶ms)?, + }, }) } @@ -947,9 +940,9 @@ impl Uni { reader.set_priority(crate::priority::RECV_CONTROL); let msg = reader.decode::().await?; if let Some(peer_setup) = peer_setup { - let (declared, implementation) = decode_peer_setup(msg.parameters, version, client)?; - peer_setup.set(declared); - peer_setup.set_implementation(implementation); + let options = decode_peer_setup(&msg.parameters, version, client)?; + peer_setup.set(options.declared); + peer_setup.set_implementation(options.implementation); } // Monitor for GOAWAY after setup completes. @@ -1369,11 +1362,11 @@ mod tests { } params.encode_bytes(version).unwrap() }; - let (_, implementation) = decode_peer_setup(encode(Some(b"moq-net-rs/1")), version, true).unwrap(); - assert_eq!(implementation.as_deref(), Some("moq-net-rs/1")); - let (_, implementation) = decode_peer_setup(encode(None), version, true).unwrap(); - assert_eq!(implementation, None); - assert!(decode_peer_setup(encode(Some(&[0xff])), version, true).is_err()); + let options = decode_peer_setup(&encode(Some(b"moq-net-rs/1")), version, true).unwrap(); + assert_eq!(options.implementation.as_deref(), Some("moq-net-rs/1")); + let options = decode_peer_setup(&encode(None), version, true).unwrap(); + assert_eq!(options.implementation, None); + assert!(decode_peer_setup(&encode(Some(&[0xff])), version, true).is_err()); } #[moq_clock::test] diff --git a/rs/moq-net/src/server.rs b/rs/moq-net/src/server.rs index d18e3e2ab33..3486565706c 100644 --- a/rs/moq-net/src/server.rs +++ b/rs/moq-net/src/server.rs @@ -405,18 +405,19 @@ impl Server { version: ietf::Version, ) -> Result { let peer_setup = ietf::accept_setup(&mut session, version).await?; + let options = &peer_setup.options; Ok(Handshake { - path: peer_setup.path.clone(), + path: options.path.clone(), role: None, // A moq-transport peer only has an identity if it negotiated the MoQ // Cluster extension and declared a non-zero Hop ID. - origin: peer_setup.declared.cluster.hop.filter(|h| *h != crate::Hop::UNKNOWN), - token: peer_setup.token.clone(), - peer_implementation: peer_setup.implementation.clone(), + origin: options.declared.cluster.hop.filter(|h| *h != crate::Hop::UNKNOWN), + token: options.token.clone(), + peer_implementation: options.implementation.clone(), assigned_hop: crate::Hop::random(), // The client's SETUP already settled whether it offered MoQ Auth, so it is // negotiated exactly when we offer it too. - auth: crate::auth::Link::ietf(peer_setup.declared.auth && self.extensions.auth), + auth: crate::auth::Link::ietf(options.declared.auth && self.extensions.auth), inner: Some(RequestInner { server: self.clone(), runtime, @@ -509,7 +510,7 @@ impl PausedIetf { } = self; server.stats.control(stats::Message::Session, peer_setup.size, true); let (publish, subscribe) = server.stat_tagged_origins(); - let peer_implementation = setup::PeerImplementation::known(peer_setup.implementation); + let peer_implementation = setup::PeerImplementation::known(peer_setup.options.implementation); // The client's SETUP was read at the pause; hand the stream back // for GOAWAY. A server never advertises a path, hence `None`. @@ -530,7 +531,7 @@ impl PausedIetf { authority: None, token: None, peer_setup_stream: Some(peer_setup.stream), - peer_declared: Some(peer_setup.declared), + peer_declared: Some(peer_setup.options.declared), auth: auth.clone(), early_unis: peer_setup.early, extensions: server.extensions, @@ -1520,10 +1521,12 @@ mod tests { Version::Ietf(version), ), size: 0, - path: None, - token: None, - implementation: None, - declared: ietf::peer::Peer::default(), + options: ietf::SetupOptions { + path: None, + token: None, + implementation: None, + declared: ietf::peer::Peer::default(), + }, early: Vec::new(), }, }),