From fada5e2968ffb3114e2d6732873e3b1a524c2be4 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 20 Oct 2026 09:37:36 -0700 Subject: [PATCH 1/2] fix(net): strip properties from status datagrams a newer draft can't carry A draft 14 to 16 status datagram (END_OF_GROUP, END_OF_TRACK) with properties was dropped when relayed to a draft-17+ subscriber, since draft 17+ forbids properties beside a non-Normal status and the encode failed. Strip the properties instead and forward the status, as stream status objects already do. The codec's rule moves into `carries_properties` so encode, decode, and egress share it. Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/src/ietf/datagram.rs | 14 +++-- rs/moq-net/src/ietf/publisher.rs | 12 +++- rs/moq-net/src/ietf/subscriber.rs | 93 +++++++++++++++++++++++++++++++ 3 files changed, 112 insertions(+), 7 deletions(-) diff --git a/rs/moq-net/src/ietf/datagram.rs b/rs/moq-net/src/ietf/datagram.rs index 008d7e931f4..4036dabb524 100644 --- a/rs/moq-net/src/ietf/datagram.rs +++ b/rs/moq-net/src/ietf/datagram.rs @@ -58,6 +58,12 @@ impl ObjectDatagram { } } +/// Whether `version` lets a datagram of Object Status `status` carry properties: from +/// draft-17 on, only a Normal Object may. +pub(super) fn carries_properties(status: u64, version: Version) -> bool { + status == 0 || matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16) +} + impl Encode for ObjectDatagram { fn encode(&self, w: &mut Encoder<'_>, version: Version) -> Result<(), EncodeError> { let mut kind = 0; @@ -99,9 +105,7 @@ impl Encode for ObjectDatagram { match &self.body { DatagramBody::Status(status) => { - // Draft-17 on: only a Normal Object may carry Properties. - let legacy = matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16); - if !legacy && *status != 0 && self.properties.is_some() { + if self.properties.is_some() && !carries_properties(*status, version) { return Err(EncodeError::InvalidState); } w.varint(*status)? @@ -146,9 +150,7 @@ impl Decode for ObjectDatagram { let body = match kind & flag::STATUS != 0 { true => { let status = r.varint()?; - // Draft-17 on: only a Normal Object may carry Properties. - let legacy = matches!(version, Version::Draft14 | Version::Draft15 | Version::Draft16); - if !legacy && status != 0 && properties.is_some() { + if properties.is_some() && !carries_properties(status, version) { return Err(DecodeError::InvalidValue); } if !r.is_empty() { diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index 14da04d6b7d..8fca9ee1d04 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -4413,7 +4413,17 @@ impl TrackServe { tracing::debug!(sequence, "dropping a datagram status this draft cannot carry"); continue; } - let properties = match super::object::write(&wire.properties, self.version, self.timescale) { + // A status keeps its meaning without the properties this draft forbids + // beside it, as a stream's status object does. + let stripped = Default::default(); + let forwarded = match wire + .status + .is_some_and(|status| !super::datagram::carries_properties(status, self.version)) + { + true => &stripped, + false => &wire.properties, + }; + let properties = match super::object::write(forwarded, self.version, self.timescale) { Ok(properties) => properties, Err(err) => { tracing::debug!(%err, sequence, "dropping a datagram whose properties cannot be forwarded"); diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index 499c3453c8c..9e56d3e1591 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -12842,6 +12842,99 @@ mod stitch_tests { } } + /// A status datagram's properties are stripped, not the datagram dropped, where the + /// egress draft forbids them beside a non-Normal status. + #[moq_clock::test] + async fn passthrough_strips_status_datagram_properties_a_draft_forbids() { + for ingress in [Version::Draft14, Version::Draft15, Version::Draft16] { + let egresses = [ + Version::Draft14, + Version::Draft16, + Version::Draft17, + Version::Draft18, + Version::Draft22, + ]; + let pairs = egresses + .into_iter() + .flat_map(|egress| [END_OF_GROUP, END_OF_TRACK].map(|status| (egress, status))); + for (egress, status) in pairs { + let origin = crate::origin::Config::new(crate::Hop::new(2).unwrap()).produce(); + let broadcast = origin.publish("room", crate::origin::Route::default()).unwrap(); + let track = broadcast.create_track("video", None).unwrap(); + let mut h = Harness::with_timescale(Fill::Done, vec![], None); + h.subscriber.version = ingress; + h.subscriber.state.lock().subscribes.get_mut(&REQUEST).unwrap().producer = Some(track.clone()); + let mut properties = Vec::new(); + let mut encoder = Encoder::new(&mut properties, ingress.into()); + encoder.varint(0x80u64).unwrap(); + encoder.varint(96_000u64).unwrap(); + let datagram = ietf::ObjectDatagram { + track_alias: ALIAS, + group_id: SEQUENCE, + object_id: Some(5), + publisher_priority: Some(200), + end_of_group: false, + properties: Some(properties), + body: ietf::DatagramBody::Status(status), + }; + h.subscriber + .recv_datagram(datagram.encode_bytes(ingress).unwrap()) + .unwrap(); + track.finish().unwrap(); + let mut downstream = ScriptedSession::per_stream(vec![vec![]]).with_datagrams(65535); + let peer = peer::PeerSetup::default(); + peer.set(peer::Peer::default()); + let publisher = crate::ietf::Publisher::new( + crate::time::sim(), + downstream.clone(), + origin.consume(), + Control::new(None, false), + None, + peer, + egress, + ); + let subscribe = ietf::Subscribe { + max_age: None, + new_group: None, + request_id: RequestId(3), + track_namespace: Path::new("room"), + track_name: "video".into(), + subscriber_priority: 128, + group_order: ietf::GroupOrder::Ascending, + filter: Filter::Unfiltered, + fill: None, + properties_wanted: true, + forward: true, + rendezvous: false, + range_filters: false, + authorization_token: None, + epoch: None, + }; + let mut body = Vec::new(); + subscribe + .encode_msg(&mut Encoder::new(&mut body, egress.into()), egress) + .unwrap(); + let stream = Stream::open(&mut downstream, egress).await.unwrap(); + publisher + .handle_stream(ietf::Subscribe::ID, ietf::Body(body.into()), stream, false) + .unwrap() + .await; + let sent = downstream.log.datagrams.lock().unwrap(); + let context = format!("{ingress} to {egress}, status {status}"); + let [bytes] = sent.as_slice() else { + panic!("{context}: sent {} datagrams", sent.len()); + }; + let (actual, _) = ietf::ObjectDatagram::decode_slice(bytes, egress).unwrap(); + let carried = matches!(egress, Version::Draft14 | Version::Draft15 | Version::Draft16); + assert_eq!( + (actual.object_id, actual.body, actual.properties.is_some()), + (Some(5), ietf::DatagramBody::Status(status), carried), + "{context}" + ); + } + } + } + #[moq_clock::test] async fn passthrough_translates_mutable_property_encodings() { for ingress in [Version::Draft14, Version::Draft15, Version::Draft17, Version::Draft22] { From e6db818fd94c6cd0ff32200e71b1616dda5d380b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 20 Oct 2026 09:54:00 -0700 Subject: [PATCH 2/2] test(net): relay status datagrams to every draft Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/src/ietf/subscriber.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index 9e56d3e1591..b0793bd0f0f 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -12849,9 +12849,13 @@ mod stitch_tests { for ingress in [Version::Draft14, Version::Draft15, Version::Draft16] { let egresses = [ Version::Draft14, + Version::Draft15, Version::Draft16, Version::Draft17, Version::Draft18, + Version::Draft19, + Version::Draft20, + Version::Draft21, Version::Draft22, ]; let pairs = egresses