From 6bba2e9098d3cf1d460ae4d21e4590a228d7326e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 30 Oct 2026 06:43:22 -0700 Subject: [PATCH 1/4] chore(quest): claim quest/m1/c/consumer-cancel.md Quest-Claim: 6d53974572e07765 From 8d4cf9b2da390c562029e356056b482d876a9d19 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 30 Oct 2026 06:48:45 -0700 Subject: [PATCH 2/4] fix(moq-c): cancel every consumer before its subscription is accepted The catalog, raw track, datagram, and video/audio consumers awaited SUBSCRIBE_OK before watching their close signal, so a publisher that left the subscribe pending kept the task alive with no terminal callback after a cancel. Race the close against each consumer's setup, as the JSON consumers already do; the media consumer races its sibling-broadcast resolve too. Co-Authored-By: Claude Opus 5.5 --- quest/m1/c/README.md | 1 - quest/m1/c/consumer-cancel.md | 18 ---- rs/moq-c/src/consume.rs | 101 +++++++++++------- rs/moq-c/src/test.rs | 192 ++++++++++++++++++++++++++++++---- 4 files changed, 233 insertions(+), 79 deletions(-) delete mode 100644 quest/m1/c/consumer-cancel.md diff --git a/quest/m1/c/README.md b/quest/m1/c/README.md index 8c65a7e221e..3043818c8de 100644 --- a/quest/m1/c/README.md +++ b/quest/m1/c/README.md @@ -30,4 +30,3 @@ Public API: moq-c gains each m1 binding feature. Wire: none. ## Required - [API gaps](/quest/m1/c/api-gaps.md) - one malformed-epoch error code, an audio enabled query, and a relay hops test -- [Every consumer cancels while pending](/quest/m1/c/consumer-cancel.md) - catalog, raw, datagram, and media consumers end cleanly on cancel before their subscription is accepted diff --git a/quest/m1/c/consumer-cancel.md b/quest/m1/c/consumer-cancel.md deleted file mode 100644 index f49e10e4731..00000000000 --- a/quest/m1/c/consumer-cancel.md +++ /dev/null @@ -1,18 +0,0 @@ -# [S] Every moq-c consumer cancels while its subscription is pending - -## Goal - -Cancelling a hand-written moq-c catalog, raw track, datagram, or media -consumer ends it with a clean final callback even while it waits for its -subscription to be accepted, as the JSON consumers do since -[moq-dev/moq#7082](https://github.com/moq-dev/moq/pull/7082). - -## Plan - -Decided 2026-10-30 (maintainer, `/quest-plan`): the hand-written crate ships -at the cut and the [generated C line](/quest/m2/c/README.md) follows it, so -fix this bug for the release, but skip converting the consumer loops to kio -polling and changing the producers: the generated binding replaces both. - -Reuse #7082's `Consume::json_subscribe` pattern for the other consumers, with -a test per consumer that cancels an unanswered subscription. diff --git a/rs/moq-c/src/consume.rs b/rs/moq-c/src/consume.rs index 703a9020896..7fb01d28e8f 100644 --- a/rs/moq-c/src/consume.rs +++ b/rs/moq-c/src/consume.rs @@ -263,13 +263,14 @@ impl Consume { self.catalog_task.spawn( on_catalog, |state| &mut state.consume.catalog_task, - |close| async move { + |mut close| async move { driver .watch(async move { - let catalog = broadcast - .track(hang::catalog::Catalog::DEFAULT_NAME)? - .subscribe(hang::catalog::Catalog::default_subscription()) - .await?; + let subscription = hang::catalog::Catalog::default_subscription(); + let subscribe = Self::subscribe(&broadcast, hang::catalog::Catalog::DEFAULT_NAME, subscription); + let Some(catalog) = Self::until_closed(&mut close, subscribe).await? else { + return Ok(()); + }; Self::run_catalog(on_catalog, broadcast.clone(), origin, catalog.into(), close).await }) .await @@ -519,18 +520,20 @@ impl Consume { self.track_task.spawn( on_read, |state| &mut state.consume.track_task, - |close| async move { + |mut close| async move { driver .watch(async move { - let broadcast = resolve(broadcast, origin, reference).await?; - let track = broadcast - .track(&name)? - .subscribe( - moq_net::track::Subscription::default() - .with_priority(C::PRIORITY) - .with_max_delay(max_delay), - ) - .await?; + let subscription = moq_net::track::Subscription::default() + .with_priority(C::PRIORITY) + .with_max_delay(max_delay); + // Resolving a sibling broadcast can wait too, so the close races both steps. + let setup = async { + let broadcast = resolve(broadcast, origin, reference).await?; + Self::subscribe(&broadcast, &name, subscription).await + }; + let Some(track) = Self::until_closed(&mut close, setup).await? else { + return Ok(()); + }; let track = moq_mux::container::Consumer::new(track, container); Self::run_track(on_read, track, close).await }) @@ -607,6 +610,30 @@ impl Consume { Ok(()) } + /// Subscribe to `name`, waiting for SUBSCRIBE_OK. + async fn subscribe( + broadcast: &moq_net::broadcast::Consumer, + name: &str, + subscription: impl Into>, + ) -> Result { + Ok(broadcast.track(name)?.subscribe(subscription).await?) + } + + /// Run a consumer's `setup`, or return `None` once `close` fires first. + /// + /// A publisher can leave SUBSCRIBE_OK pending forever, so a cancel must not wait on it. + /// `close` is left unpolled once it fires, since a oneshot panics if polled again. + async fn until_closed( + close: &mut oneshot::Receiver<()>, + setup: impl Future>, + ) -> Result, Error> { + tokio::select! { + biased; + _ = close => Ok(None), + res = setup => res.map(Some), + } + } + /// Subscribe to a raw track by name, delivering each frame's payload as-is. /// /// No catalog lookup or container parsing. This is the moq-net primitive for @@ -628,14 +655,18 @@ impl Consume { let broadcast = context.broadcast.clone(); let name = name.to_string(); - let (task, close) = Task::new(on_frame); + let (task, mut close) = Task::new(on_frame); let control = RawControl::Pending(None); let id = self.raw_task.insert(RawTaskEntry { task, control })?; // `subscribe` blocks on SUBSCRIBE_OK, so run it inside the task. tokio::spawn(async move { let res = crate::ffi::run(driver.watch(async move { - let track = broadcast.track(&name)?.subscribe(subscription.clone()).await?.ordered(); + let subscribe = Self::subscribe(&broadcast, &name, subscription.clone()); + let Some(track) = Self::until_closed(&mut close, subscribe).await? else { + return Ok(()); + }; + let track = track.ordered(); let control = track.control(); Self::update_raw(&control, Self::raw_subscription(subscription))?; // Go live under the lock, so no later update lands before the pending one. @@ -799,10 +830,14 @@ impl Consume { self.datagram_task.spawn( on_datagram, |state| &mut state.consume.datagram_task, - |close| async move { + |mut close| async move { driver .watch(async move { - let track = broadcast.track(&name)?.subscribe(None).await?; + let Some(track) = + Self::until_closed(&mut close, Self::subscribe(&broadcast, &name, None)).await? + else { + return Ok(()); + }; Self::run_datagrams(on_datagram, track, close).await }) .await @@ -859,22 +894,6 @@ impl Consume { Ok(()) } - /// Subscribe a JSON consumer to `name`, or return `None` once `close` fires first. - /// - /// A publisher can leave SUBSCRIBE_OK pending forever, so a cancel must not wait on it. - async fn json_subscribe( - broadcast: &moq_net::broadcast::Consumer, - name: &str, - close: &mut oneshot::Receiver<()>, - ) -> Result, Error> { - let subscribe = broadcast.track(name)?.subscribe(None); - tokio::select! { - biased; - _ = close => Ok(None), - track = subscribe => Ok(Some(track?)), - } - } - /// Subscribe to a JSON snapshot track (lossy latest-value) by name. /// /// `on_value` is called with a value ID for each state, in order; a group superseded by a @@ -897,7 +916,9 @@ impl Consume { |mut close| async move { driver .watch(async move { - let Some(track) = Self::json_subscribe(&broadcast, &name, &mut close).await? else { + let Some(track) = + Self::until_closed(&mut close, Self::subscribe(&broadcast, &name, None)).await? + else { return Ok(()); }; let consumer = @@ -954,7 +975,9 @@ impl Consume { |mut close| async move { driver .watch(async move { - let Some(track) = Self::json_subscribe(&broadcast, &name, &mut close).await? else { + let Some(track) = + Self::until_closed(&mut close, Self::subscribe(&broadcast, &name, None)).await? + else { return Ok(()); }; let consumer = moq_json::stream::Consumer::::new(track, Default::default()); @@ -1008,7 +1031,9 @@ impl Consume { |mut close| async move { driver .watch(async move { - let Some(track) = Self::json_subscribe(&broadcast, &name, &mut close).await? else { + let Some(track) = + Self::until_closed(&mut close, Self::subscribe(&broadcast, &name, None)).await? + else { return Ok(()); }; let consumer = moq_json::window::Consumer::::new(track, Default::default()); diff --git a/rs/moq-c/src/test.rs b/rs/moq-c/src/test.rs index 54434728ffa..382f0fe6ddc 100644 --- a/rs/moq-c/src/test.rs +++ b/rs/moq-c/src/test.rs @@ -726,9 +726,10 @@ fn publish_catalog_config_invalid_broadcast() { assert!(unsafe { moq_publish_video_properties(0, &moq_video_properties::default()) } < 0); let audio_codec = "opus"; + let (audio_name, audio_codec) = ("audio", "opus"); let audio = moq_audio_config { - name: name.as_ptr() as *const c_char, - name_len: name.len(), + name: audio_name.as_ptr() as *const c_char, + name_len: audio_name.len(), label: std::ptr::null(), label_len: 0, codec: audio_codec.as_ptr() as *const c_char, @@ -2618,40 +2619,187 @@ fn json_window_refreshes_a_bounded_checkpoint() { /// Cancelling a JSON consumer whose subscription the publisher has not answered still delivers /// the terminal callback, for every JSON mode. -#[test] -fn json_cancel_while_subscribing() { - type Consumer = unsafe extern "C" fn(u32, *const c_char, usize, ffi::moq_status_callback, *mut c_void) -> i32; - let consumers: [(&[u8], Consumer); 3] = [ - (b"snapshot", moq_consume_json_snapshot), - (b"stream", moq_consume_json_stream), - (b"window", moq_consume_json_window), - ]; +/// Every consumer that subscribes by name, with its cancel. +type NamedConsumer = ( + &'static [u8], + fn(u32, &[u8], *mut c_void) -> i32, + extern "C" fn(u32) -> i32, +); + +const NAMED_CONSUMERS: [NamedConsumer; 5] = [ + ( + b"raw", + |consume, name, user_data| unsafe { + moq_consume_track( + consume, + name.as_ptr() as *const c_char, + name.len(), + std::ptr::null(), + Some(channel_callback), + user_data, + ) + }, + moq_consume_track_cancel, + ), + ( + b"datagrams", + |consume, name, user_data| unsafe { + moq_consume_datagrams( + consume, + name.as_ptr() as *const c_char, + name.len(), + Some(channel_callback), + user_data, + ) + }, + moq_consume_datagrams_cancel, + ), + ( + b"snapshot", + |consume, name, user_data| unsafe { + moq_consume_json_snapshot( + consume, + name.as_ptr() as *const c_char, + name.len(), + Some(channel_callback), + user_data, + ) + }, + moq_consume_json_cancel, + ), + ( + b"stream", + |consume, name, user_data| unsafe { + moq_consume_json_stream( + consume, + name.as_ptr() as *const c_char, + name.len(), + Some(channel_callback), + user_data, + ) + }, + moq_consume_json_cancel, + ), + ( + b"window", + |consume, name, user_data| unsafe { + moq_consume_json_window( + consume, + name.as_ptr() as *const c_char, + name.len(), + Some(channel_callback), + user_data, + ) + }, + moq_consume_json_cancel, + ), +]; +#[test] +fn named_consumers_cancel_while_subscribing() { let origin = id(moq_origin_create()); - let broadcast = publish_broadcast(origin, b"json-cancel-subscribing"); + let broadcast = publish_broadcast(origin, b"cancel-subscribing"); // Unknown tracks become requests, which leave each subscribe pending until answered. let request_cb = Callback::new(); let dynamic = id(unsafe { moq_publish_requests(broadcast, Some(channel_callback), request_cb.ptr) }); let consume = consume_local(broadcast); - for (name, consumer) in consumers { + for (name, consumer, cancel) in NAMED_CONSUMERS { let cb = Callback::new(); - let task = id(unsafe { - consumer( - consume, - name.as_ptr() as *const c_char, - name.len(), - Some(channel_callback), - cb.ptr, - ) - }); + let task = id(consumer(consume, name, cb.ptr)); + let request = id(request_cb.recv()); + + assert_eq!(cancel(task), 0); + assert_eq!(cb.recv_terminal(), 0, "a cancelled subscribe ends cleanly"); + assert_eq!(moq_track_request_free(request), 0); + } + + assert_eq!(moq_publish_requests_cancel(dynamic), 0); + assert_eq!(request_cb.recv_terminal(), 0); + assert_eq!(moq_consume_close(consume), 0); + assert_eq!(moq_publish_close(broadcast), 0); + assert_eq!(moq_origin_close(origin), 0); +} + +#[test] +fn catalog_cancel_while_subscribing() { + // A bare moq-net broadcast has no catalog track, so its subscribe waits on the handler. + let broadcast = moq_net::broadcast::Info::new().produce(); + let mut requests = broadcast.requests(); + let consume = i32::from(State::lock().consume.start(broadcast.consume(), None).unwrap()) as u32; + + let cb = Callback::new(); + let catalog = id(unsafe { moq_consume_catalog(consume, Some(channel_callback), cb.ptr) }); + let _unanswered = crate::ffi::RUNTIME.block_on(requests.requested_track()).unwrap(); + + assert_eq!(moq_consume_catalog_cancel(catalog), 0); + assert_eq!(cb.recv_terminal(), 0, "a cancelled subscribe ends cleanly"); + assert_eq!(moq_consume_close(consume), 0); +} + +#[test] +fn media_consumers_cancel_while_subscribing() { + let origin = id(moq_origin_create()); + let broadcast = publish_broadcast(origin, b"media-cancel-subscribing"); + + // Catalog renditions with no track behind them, so each media subscribe becomes a request. + let (video_name, video_codec) = ("video", "vp8"); + let video = moq_video_config { + preference: 0, + name: video_name.as_ptr() as *const c_char, + name_len: video_name.len(), + label: std::ptr::null(), + label_len: 0, + codec: video_codec.as_ptr() as *const c_char, + codec_len: video_codec.len(), + description: std::ptr::null(), + description_len: 0, + coded_width: 0, + coded_height: 0, + container: moq_container::default(), + }; + assert_eq!(unsafe { moq_publish_video_config(broadcast, &video) }, 0); + let (audio_name, audio_codec) = ("audio", "opus"); + let audio = moq_audio_config { + name: audio_name.as_ptr() as *const c_char, + name_len: audio_name.len(), + label: std::ptr::null(), + label_len: 0, + codec: audio_codec.as_ptr() as *const c_char, + codec_len: audio_codec.len(), + description: std::ptr::null(), + description_len: 0, + sample_rate: 48000, + channel_count: 2, + container: moq_container::default(), + }; + assert_eq!(unsafe { moq_publish_audio_config(broadcast, &audio) }, 0); + + let request_cb = Callback::new(); + let dynamic = id(unsafe { moq_publish_requests(broadcast, Some(channel_callback), request_cb.ptr) }); + let consume = consume_local(broadcast); + let catalog_cb = Callback::new(); + let catalog_task = id(unsafe { moq_consume_catalog(consume, Some(channel_callback), catalog_cb.ptr) }); + let catalog = id(catalog_cb.recv()); + + type Media = unsafe extern "C" fn(u32, u32, u64, ffi::moq_status_callback, *mut c_void) -> i32; + let consumers: [(Media, extern "C" fn(u32) -> i32); 2] = [ + (moq_consume_video, moq_consume_video_cancel), + (moq_consume_audio, moq_consume_audio_cancel), + ]; + for (consumer, cancel) in consumers { + let cb = Callback::new(); + let task = id(unsafe { consumer(catalog, 0, 0, Some(channel_callback), cb.ptr) }); let request = id(request_cb.recv()); - assert_eq!(moq_consume_json_cancel(task), 0); + assert_eq!(cancel(task), 0); assert_eq!(cb.recv_terminal(), 0, "a cancelled subscribe ends cleanly"); assert_eq!(moq_track_request_free(request), 0); } + assert_eq!(moq_consume_catalog_free(catalog), 0); + assert_eq!(moq_consume_catalog_cancel(catalog_task), 0); + assert_eq!(catalog_cb.recv_catalog_terminal(), 0); assert_eq!(moq_publish_requests_cancel(dynamic), 0); assert_eq!(request_cb.recv_terminal(), 0); assert_eq!(moq_consume_close(consume), 0); From fac1dcd9456214a115bd56f495f7648dfdbc4fdb Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 30 Oct 2026 06:54:45 -0700 Subject: [PATCH 3/4] fix(moq-c): keep the invalid-broadcast catalog test as it was Co-Authored-By: Claude Opus 5.5 --- rs/moq-c/src/test.rs | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/rs/moq-c/src/test.rs b/rs/moq-c/src/test.rs index 382f0fe6ddc..292acf51190 100644 --- a/rs/moq-c/src/test.rs +++ b/rs/moq-c/src/test.rs @@ -726,10 +726,9 @@ fn publish_catalog_config_invalid_broadcast() { assert!(unsafe { moq_publish_video_properties(0, &moq_video_properties::default()) } < 0); let audio_codec = "opus"; - let (audio_name, audio_codec) = ("audio", "opus"); let audio = moq_audio_config { - name: audio_name.as_ptr() as *const c_char, - name_len: audio_name.len(), + name: name.as_ptr() as *const c_char, + name_len: name.len(), label: std::ptr::null(), label_len: 0, codec: audio_codec.as_ptr() as *const c_char, @@ -2617,8 +2616,6 @@ fn json_window_refreshes_a_bounded_checkpoint() { assert_eq!(moq_origin_close(origin), 0); } -/// Cancelling a JSON consumer whose subscription the publisher has not answered still delivers -/// the terminal callback, for every JSON mode. /// Every consumer that subscribes by name, with its cancel. type NamedConsumer = ( &'static [u8], @@ -2695,6 +2692,8 @@ const NAMED_CONSUMERS: [NamedConsumer; 5] = [ ), ]; +/// Cancelling a consumer whose subscription the publisher has not answered still delivers the +/// terminal callback. #[test] fn named_consumers_cancel_while_subscribing() { let origin = id(moq_origin_create()); From dfdf13a7703036740daa0bbe5f27b78c654afa83 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sun, 1 Nov 2026 13:27:22 -0800 Subject: [PATCH 4/4] fix(moq-c): pass a moq_delay pointer in the media cancel test The main merge changed moq_consume_video/audio to take a *const moq_delay, so the test's function pointer type no longer matched. Co-Authored-By: Claude Opus 5.5 --- rs/moq-c/src/test.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rs/moq-c/src/test.rs b/rs/moq-c/src/test.rs index 51b9e465ad5..4206355b97d 100644 --- a/rs/moq-c/src/test.rs +++ b/rs/moq-c/src/test.rs @@ -2791,14 +2791,14 @@ fn media_consumers_cancel_while_subscribing() { let catalog_task = id(unsafe { moq_consume_catalog(consume, Some(channel_callback), catalog_cb.ptr) }); let catalog = id(catalog_cb.recv()); - type Media = unsafe extern "C" fn(u32, u32, u64, ffi::moq_status_callback, *mut c_void) -> i32; + type Media = unsafe extern "C" fn(u32, u32, *const moq_delay, ffi::moq_status_callback, *mut c_void) -> i32; let consumers: [(Media, extern "C" fn(u32) -> i32); 2] = [ (moq_consume_video, moq_consume_video_cancel), (moq_consume_audio, moq_consume_audio_cancel), ]; for (consumer, cancel) in consumers { let cb = Callback::new(); - let task = id(unsafe { consumer(catalog, 0, 0, Some(channel_callback), cb.ptr) }); + let task = id(unsafe { consumer(catalog, 0, std::ptr::null(), Some(channel_callback), cb.ptr) }); let request = id(request_cb.recv()); assert_eq!(cancel(task), 0);