From b24f7825b161bf18def4bfe5d3b4d2d478b800fa Mon Sep 17 00:00:00 2001 From: Gwendal Simon Date: Fri, 20 Nov 2026 18:40:00 +0100 Subject: [PATCH] Refuse the peer requests the subscriber facade does not serve The subscriber facade dropped every request a peer opened: the session raised it and waited for an answer that never came, until the session ended. A relay that announces its namespaces with PUBLISH_NAMESPACE to each peer was left without the REQUEST_OK or REQUEST_ERROR that draft 18 section 6.2 (section 4.1 in drafts 22 and 23) requires. * moq_sub_tick now refuses the seven request kinds a subscriber does not serve, as the publisher facade's pub_refuse_unserved does: DOES_NOT_EXIST for SUBSCRIBE and TRACK_STATUS, NOT_SUPPORTED for PUBLISH_NAMESPACE, SUBSCRIBE_NAMESPACE, SUBSCRIBE_TRACKS, PUBLISH and FETCH (which the publisher serves). * A refusal the session cannot take yet is held, in arrival order, and sent on a later tick. The queue holds one entry per request the session can have open, sized at moq_sub_create. * The pending checks mirror pub_answer_pending. Sharing them between the two facades is left to a follow-up. * Tests: on drafts 18 and 22, one request of each kind gets exactly one refusal with the expected code; with a session limited to four actions, refusals are held after the first tick and sent on the next. Co-Authored-By: Claude Opus 5.5 --- core/src/facade/subscriber.c | 293 +++++++++++++++++++++++++- tests/CMakeLists.txt | 3 + tests/unit/test_subscriber_unserved.c | 254 ++++++++++++++++++++++ 3 files changed, 549 insertions(+), 1 deletion(-) create mode 100644 tests/unit/test_subscriber_unserved.c diff --git a/core/src/facade/subscriber.c b/core/src/facade/subscriber.c index ce05997d..da2c4071 100644 --- a/core/src/facade/subscriber.c +++ b/core/src/facade/subscriber.c @@ -152,6 +152,15 @@ typedef struct sub_group_end_entry { size_t chunk_seq; } sub_group_end_entry_t; +/* A refusal this subscriber owes a request the peer opened and nothing here + * serves (a relay's PUBLISH_NAMESPACE, for one), held while the session + * cannot take the answer. */ +typedef struct sub_owed_answer { + moq_event_kind_t kind; + uint64_t handle; + moq_request_error_t code; +} sub_owed_answer_t; + struct moq_subscriber { moq_session_t *session; moq_alloc_t alloc; @@ -164,6 +173,11 @@ struct moq_subscriber { bool closed; bool draining; + /* Refusals owed to unserved peer requests, in arrival order. */ + sub_owed_answer_t *owed; + size_t owed_count; + size_t owed_cap; + /* Byte budget for payload+properties rcbufs retained in the object and * fetch-object ring queues. Counts bytes currently in the rings only; the * one-deep pending slots are outside this gauge. Legacy profiles admit at @@ -1290,6 +1304,26 @@ _Static_assert(offsetof(moq_sub_cfg_t, max_fills) == s->surface_stream_terminals = true; } + /* One owed refusal per request the session can hold at once. */ + size_t owed_cap = 0; + const size_t request_caps[] = { + session->sub_cap, session->pub_cap, session->ann_cap, session->ns_sub_cap, + session->track_sub_cap, session->ts_cap, session->fetch_cap + }; + for (size_t i = 0; i < sizeof(request_caps) / sizeof(request_caps[0]); i++) { + if (request_caps[i] > SIZE_MAX - owed_cap) { moq_sub_destroy(s); return MOQ_ERR_LIMIT; } + owed_cap += request_caps[i]; + } + if (owed_cap > SIZE_MAX / sizeof(sub_owed_answer_t)) { moq_sub_destroy(s); return MOQ_ERR_LIMIT; } + if (owed_cap) { + s->owed = (sub_owed_answer_t *)alloc->alloc(owed_cap * sizeof(sub_owed_answer_t), alloc->ctx); + if (!s->owed) { + moq_sub_destroy(s); + return MOQ_ERR_NOMEM; + } + s->owed_cap = owed_cap; + } + *out = s; return MOQ_OK; } @@ -1334,6 +1368,8 @@ void moq_sub_destroy(moq_subscriber_t *sub) } moq_alloc_t alloc = sub->alloc; + if (sub->owed) + alloc.free(sub->owed, sub->owed_cap * sizeof(sub_owed_answer_t), alloc.ctx); if (sub->stream_terminals) alloc.free(sub->stream_terminals, sub->st_cap * sizeof(sub_stream_terminal_entry_t), alloc.ctx); @@ -1755,6 +1791,239 @@ static bool stream_finished_terminal(moq_subscriber_t *sub, moq_sub_track_t *t, return st_offer(sub, &st); } +/* -- Refusals owed to unserved peer requests ------------------------ + * + * The session raises a peer's request (a relay's PUBLISH_NAMESPACE, for one) + * and waits for an answer; nothing above a subscriber takes it, so each would + * stay unanswered until the session ends. The subscriber refuses them, as the + * publisher facade does for what it does not serve (pub_refuse_unserved), and + * holds a refusal the session cannot take yet. The checks mirror the + * publisher's pub_answer_pending, plus FETCH, which the publisher serves. */ + +/* Whether the request still awaits its answer (pure: the session is not + * advanced). */ +static bool sub_answer_pending(moq_subscriber_t *sub, const sub_owed_answer_t *a) +{ + moq_session_t *s = sub->session; + switch (a->kind) { + case MOQ_EVENT_SUBSCRIBE_REQUEST: { + int slot = sub_resolve_handle(s, (moq_subscription_t){a->handle}); + if (slot < 0) return false; + const moq_sub_entry_t *e = &s->subs[slot]; + return e->handle._opaque == a->handle && e->role == MOQ_SUB_ROLE_PUBLISHER && + e->state == MOQ_SUB_PENDING_PUBLISHER && !e->cancel_pending; + } + case MOQ_EVENT_PUBLISH_REQUEST: { + int slot = pub_resolve_handle(s, (moq_publication_t){a->handle}); + if (slot < 0) return false; + const moq_pub_entry_t *e = &s->publishes[slot]; + return e->handle._opaque == a->handle && e->role == MOQ_PUB_ROLE_SUBSCRIBER && + e->state == MOQ_PUB_PENDING_SUBSCRIBER && !e->done_pending; + } + case MOQ_EVENT_NAMESPACE_PUBLISHED: { + size_t slot = moq_handle_slot(a->handle); + if (moq_handle_pool_tag(a->handle) != MOQ_HANDLE_POOL_ANNOUNCEMENT || + moq_handle_session_tag(a->handle) != s->session_tag || slot >= s->ann_cap) + return false; + const moq_ann_entry_t *e = &s->announcements[slot]; + if (e->generation != moq_handle_generation(a->handle) || + e->handle._opaque != a->handle || e->role != MOQ_ANN_ROLE_RECEIVER || + e->state != MOQ_ANN_PENDING_RECEIVER) + return false; + return !s->profile->premature_fin_fails_request || + (!e->terminal_cause && !e->response_validated && + moq_request_lifetime_check_initial_response(&e->rs.lifetime, true) == MOQ_OK); + } + case MOQ_EVENT_NS_SUB_REQUEST: { + size_t slot = moq_handle_slot(a->handle); + if (moq_handle_pool_tag(a->handle) != MOQ_HANDLE_POOL_NAMESPACE_SUB || + moq_handle_session_tag(a->handle) != s->session_tag || slot >= s->ns_sub_cap) + return false; + const moq_ns_sub_entry_t *e = &s->ns_subs[slot]; + return e->generation == moq_handle_generation(a->handle) && + e->handle._opaque == a->handle && !e->local_subscriber && + e->state == MOQ_NS_SUB_PENDING_PUBLISHER && !e->terminal.cause; + } + case MOQ_EVENT_SUBSCRIBE_TRACKS_REQUEST: { + int slot = track_sub_resolve_handle(s, (moq_track_sub_handle_t){a->handle}); + if (slot < 0) return false; + const moq_track_sub_entry_t *e = &s->track_subs[slot]; + return e->handle._opaque == a->handle && e->role == MOQ_TRACK_SUB_ROLE_PUBLISHER && + e->state == MOQ_TRACK_SUB_PENDING_PUBLISHER; + } + case MOQ_EVENT_TRACK_STATUS_REQUEST: { + int slot = ts_resolve_handle(s, (moq_track_status_handle_t){a->handle}); + if (slot < 0) return false; + const moq_ts_entry_t *e = &s->track_statuses[slot]; + if (e->handle._opaque != a->handle || e->role != MOQ_TS_ROLE_PUBLISHER || + e->state != MOQ_TS_PENDING_PUBLISHER || e->goaway_sent) + return false; + return !s->profile->premature_fin_fails_request || + (!e->terminal_cause && !e->response_validated && + moq_request_lifetime_check_initial_response(&e->rs.lifetime, true) == MOQ_OK); + } + case MOQ_EVENT_FETCH_REQUEST: { + int slot = fetch_resolve_handle(s, (moq_fetch_t){a->handle}); + if (slot < 0) return false; + const moq_fetch_entry_t *e = &s->fetches[slot]; + return e->handle._opaque == a->handle && e->role == MOQ_FETCH_ROLE_PUBLISHER && + e->state == MOQ_FETCH_PENDING_PUBLISHER; + } + default: + return false; + } +} + +/* Drop every owed refusal whose request no longer awaits one, keeping the + * order of the rest. */ +static void sub_owed_prune(moq_subscriber_t *sub) +{ + size_t keep = 0; + for (size_t i = 0; i < sub->owed_count; i++) { + if (!sub_answer_pending(sub, &sub->owed[i])) continue; + if (keep != i) sub->owed[keep] = sub->owed[i]; + keep++; + } + sub->owed_count = keep; +} + +/* Answered, or the request is gone (a stale handle, or no longer awaiting an + * answer). WOULD_BLOCK and CLOSED are told apart by the callers. */ +static bool sub_answer_settled(moq_result_t rc) +{ + return rc == MOQ_OK || rc == MOQ_ERR_STALE_HANDLE || rc == MOQ_ERR_WRONG_STATE; +} + +static moq_result_t sub_answer_request(moq_subscriber_t *sub, const sub_owed_answer_t *a, + uint64_t now_us) +{ + moq_session_t *s = sub->session; + switch (a->kind) { + case MOQ_EVENT_SUBSCRIBE_REQUEST: { + moq_reject_subscribe_cfg_t rej; + moq_reject_subscribe_cfg_init(&rej); + rej.error_code = a->code; + return moq_session_reject_subscribe(s, (moq_subscription_t){ a->handle }, &rej, now_us); + } + case MOQ_EVENT_PUBLISH_REQUEST: { + moq_reject_publish_cfg_t rej; + moq_reject_publish_cfg_init(&rej); + rej.error_code = a->code; + return moq_session_reject_publish(s, (moq_publication_t){ a->handle }, &rej, now_us); + } + case MOQ_EVENT_NAMESPACE_PUBLISHED: { + moq_reject_namespace_cfg_t rej; + moq_reject_namespace_cfg_init(&rej); + rej.error_code = a->code; + return moq_session_reject_namespace(s, (moq_announcement_t){ a->handle }, &rej, now_us); + } + case MOQ_EVENT_NS_SUB_REQUEST: { + moq_reject_ns_sub_cfg_t rej; + moq_reject_ns_sub_cfg_init(&rej); + rej.error_code = a->code; + return moq_session_reject_ns_sub(s, (moq_ns_sub_handle_t){ a->handle }, &rej, now_us); + } + case MOQ_EVENT_SUBSCRIBE_TRACKS_REQUEST: { + moq_reject_subscribe_tracks_cfg_t rej; + moq_reject_subscribe_tracks_cfg_init(&rej); + rej.error_code = a->code; + return moq_session_reject_subscribe_tracks(s, (moq_track_sub_handle_t){ a->handle }, + &rej, now_us); + } + case MOQ_EVENT_TRACK_STATUS_REQUEST: { + moq_reject_track_status_cfg_t rej; + moq_reject_track_status_cfg_init(&rej); + rej.error_code = a->code; + return moq_session_reject_track_status(s, (moq_track_status_handle_t){ a->handle }, + &rej, now_us); + } + case MOQ_EVENT_FETCH_REQUEST: { + moq_reject_fetch_cfg_t rej; + moq_reject_fetch_cfg_init(&rej); + rej.error_code = a->code; + return moq_session_reject_fetch(s, (moq_fetch_t){ a->handle }, &rej, now_us); + } + default: + return MOQ_OK; + } +} + +/* Retry owed refusals in arrival order. Only WOULD_BLOCK keeps one; a refusal + * the session rejects outright is dropped and reported. */ +static moq_result_t sub_owed_drive(moq_subscriber_t *sub, uint64_t now_us) +{ + sub_owed_prune(sub); + size_t done = 0; + moq_result_t out = MOQ_OK; + while (done < sub->owed_count) { + /* Answering advances the session and may retire another request. */ + if (!sub_answer_pending(sub, &sub->owed[done])) { done++; continue; } + moq_result_t rc = sub_answer_request(sub, &sub->owed[done], now_us); + if (rc == MOQ_ERR_WOULD_BLOCK) { + if (!sub_answer_pending(sub, &sub->owed[done])) { done++; continue; } + if (out == MOQ_OK) out = rc; + break; + } + if (rc == MOQ_ERR_CLOSED) { done = sub->owed_count; out = rc; break; } + if (!sub_answer_settled(rc) && out == MOQ_OK) out = rc; + done++; + } + if (done > 0) { + memmove(sub->owed, sub->owed + done, (sub->owed_count - done) * sizeof(sub->owed[0])); + sub->owed_count -= done; + } + sub_owed_prune(sub); + return out; +} + +/* Refuse a request nothing here serves: now, or held behind earlier refusals + * (so they keep their order) or while the session cannot take it. */ +static moq_result_t sub_refuse_unserved(moq_subscriber_t *sub, const moq_event_t *ev, + uint64_t now_us) +{ + sub_owed_answer_t a = { .kind = ev->kind, .handle = 0, + .code = MOQ_REQUEST_ERROR_NOT_SUPPORTED }; + switch (ev->kind) { + case MOQ_EVENT_SUBSCRIBE_REQUEST: + a.handle = ev->u.subscribe_request.sub._opaque; + a.code = MOQ_REQUEST_ERROR_DOES_NOT_EXIST; + break; + case MOQ_EVENT_TRACK_STATUS_REQUEST: + a.handle = ev->u.track_status_request.handle._opaque; + a.code = MOQ_REQUEST_ERROR_DOES_NOT_EXIST; + break; + case MOQ_EVENT_PUBLISH_REQUEST: + a.handle = ev->u.publish_request.pub._opaque; + break; + case MOQ_EVENT_NAMESPACE_PUBLISHED: + a.handle = ev->u.namespace_published.ann._opaque; + break; + case MOQ_EVENT_NS_SUB_REQUEST: + a.handle = ev->u.ns_sub_request.handle._opaque; + break; + case MOQ_EVENT_SUBSCRIBE_TRACKS_REQUEST: + a.handle = ev->u.subscribe_tracks_request.handle._opaque; + break; + case MOQ_EVENT_FETCH_REQUEST: + a.handle = ev->u.fetch_request.fetch._opaque; + break; + default: + return MOQ_OK; + } + sub_owed_prune(sub); + if (!sub_answer_pending(sub, &a)) return MOQ_OK; + if (sub->owed_count == 0) { + moq_result_t rc = sub_answer_request(sub, &a, now_us); + if (rc != MOQ_ERR_WOULD_BLOCK) + return sub_answer_settled(rc) ? MOQ_OK : rc; + /* The failed attempt still advanced the session. */ + if (!sub_answer_pending(sub, &a)) return MOQ_OK; + } + if (sub->owed_count >= sub->owed_cap) return MOQ_ERR_INTERNAL; + sub->owed[sub->owed_count++] = a; + return MOQ_OK; +} + moq_result_t moq_sub_tick(moq_subscriber_t *sub, uint64_t now_us) { if (!sub) return MOQ_ERR_INVAL; @@ -1823,6 +2092,12 @@ moq_result_t moq_sub_tick(moq_subscriber_t *sub, uint64_t now_us) sub->has_pending_fli = false; } + /* Refusals already owed go first, in the order the requests came. One + * the session rejects outright is reported once the rest has progressed. */ + moq_result_t owed_rc = sub_owed_drive(sub, now_us); + if (owed_rc == MOQ_ERR_CLOSED) return owed_rc; + moq_result_t owed_err = owed_rc < 0 && owed_rc != MOQ_ERR_WOULD_BLOCK ? owed_rc : MOQ_OK; + moq_event_t ev; for (;;) { moq_result_t polled = exact_bytes @@ -2630,6 +2905,22 @@ moq_result_t moq_sub_tick(moq_subscriber_t *sub, uint64_t now_us) ev.u.closed.code); break; + /* Requests the peer opened: nothing above a subscriber serves them. */ + case MOQ_EVENT_SUBSCRIBE_REQUEST: + case MOQ_EVENT_PUBLISH_REQUEST: + case MOQ_EVENT_NAMESPACE_PUBLISHED: + case MOQ_EVENT_NS_SUB_REQUEST: + case MOQ_EVENT_SUBSCRIBE_TRACKS_REQUEST: + case MOQ_EVENT_TRACK_STATUS_REQUEST: + case MOQ_EVENT_FETCH_REQUEST: { + moq_result_t urc = sub_refuse_unserved(sub, &ev, now_us); + if (urc < 0) { + moq_event_cleanup(&ev); + return urc; + } + break; + } + default: break; } @@ -2646,7 +2937,7 @@ moq_result_t moq_sub_tick(moq_subscriber_t *sub, uint64_t now_us) sub->tracks[i].initial_result_error != MOQ_OK) return sub->tracks[i].initial_result_error; - return MOQ_OK; + return owed_err; } moq_result_t moq_sub_poll_object(moq_subscriber_t *sub, diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 5a89e1d2..83bf29d8 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1472,6 +1472,9 @@ if(TARGET moq::sim) add_executable(test_subscriber unit/test_subscriber.c) target_link_libraries(test_subscriber PRIVATE moq-core-test-internals moq::sim) add_test(NAME subscriber COMMAND test_subscriber) + add_executable(test_subscriber_unserved unit/test_subscriber_unserved.c) + target_link_libraries(test_subscriber_unserved PRIVATE moq-core-test-internals moq::sim) + add_test(NAME subscriber_unserved COMMAND test_subscriber_unserved) add_executable(test_subscriber_group_end unit/test_subscriber_group_end.c) target_link_libraries(test_subscriber_group_end PRIVATE moq-core-test-internals moq::sim) diff --git a/tests/unit/test_subscriber_unserved.c b/tests/unit/test_subscriber_unserved.c new file mode 100644 index 00000000..25a04935 --- /dev/null +++ b/tests/unit/test_subscriber_unserved.c @@ -0,0 +1,254 @@ +/* The subscriber facade refuses the requests a peer opens that nothing above + * it serves (a relay's PUBLISH_NAMESPACE, for one), so none stays unanswered + * until the session ends. Each gets REQUEST_ERROR: DOES_NOT_EXIST for a + * SUBSCRIBE or TRACK_STATUS, NOT_SUPPORTED otherwise, as the publisher facade + * answers them. A refusal the session cannot take yet is held and sent on a + * later tick. */ +#include +#include +#include "test_session_support.h" +#include +#include + +static int failures = 0; + +enum { K_NAMESPACE, K_SUBSCRIBE, K_TRACK_STATUS, K_NS_SUB, K_SUBSCRIBE_TRACKS, K_PUBLISH, K_FETCH, + K_COUNT }; +static const char *const k_names[K_COUNT] = { + "PUBLISH_NAMESPACE", "SUBSCRIBE", "TRACK_STATUS", "SUBSCRIBE_NAMESPACE", + "SUBSCRIBE_TRACKS", "PUBLISH", "FETCH" +}; + +typedef struct { + int count[K_COUNT]; + moq_request_error_t code[K_COUNT]; + int other_failures; /* a request answered with an unexpected kind */ +} answers_t; + +static void record(answers_t *a, int k, moq_request_error_t code) +{ + a->count[k]++; + a->code[k] = code; +} + +/* The relay side's answers: one error event per refused request. */ +static void collect(moq_session_t *relay, answers_t *a) +{ + moq_event_t ev; + while (moq_session_poll_events(relay, &ev, 1) == 1) { + switch (ev.kind) { + case MOQ_EVENT_NAMESPACE_REJECTED: + record(a, K_NAMESPACE, ev.u.namespace_rejected.error_code); break; + case MOQ_EVENT_SUBSCRIBE_ERROR: + record(a, K_SUBSCRIBE, ev.u.subscribe_error.error_code); break; + case MOQ_EVENT_TRACK_STATUS_ERROR: + record(a, K_TRACK_STATUS, ev.u.track_status_error.error_code); break; + case MOQ_EVENT_NS_SUB_ERROR: + record(a, K_NS_SUB, ev.u.ns_sub_error.error_code); break; + case MOQ_EVENT_SUBSCRIBE_TRACKS_ERROR: + record(a, K_SUBSCRIBE_TRACKS, ev.u.subscribe_tracks_error.error_code); break; + case MOQ_EVENT_PUBLISH_ERROR: + record(a, K_PUBLISH, ev.u.publish_error.error_code); break; + case MOQ_EVENT_FETCH_ERROR: + record(a, K_FETCH, ev.u.fetch_error.error_code); break; + case MOQ_EVENT_NAMESPACE_ACCEPTED: + case MOQ_EVENT_SUBSCRIBE_OK: + case MOQ_EVENT_TRACK_STATUS_OK: + case MOQ_EVENT_NS_SUB_OK: + case MOQ_EVENT_SUBSCRIBE_TRACKS_OK: + case MOQ_EVENT_PUBLISH_OK: + case MOQ_EVENT_FETCH_OK: + a->other_failures++; break; + default: + break; + } + moq_event_cleanup(&ev); + } +} + +static int answered(const answers_t *a) +{ + int n = 0; + for (int k = 0; k < K_COUNT; k++) n += a->count[k] > 0; + return n; +} + +static void drain(moq_session_t *s) +{ + moq_event_t ev; + while (moq_session_poll_events(s, &ev, 1) == 1) moq_event_cleanup(&ev); +} + +/* The relay (server) opens one request of each kind towards the subscriber + * (client). With step set, the pair runs after each request, so a session + * limited to a few actions can still open them all. */ +static void open_requests(moq_session_t *relay, uint64_t now, moq_simpair_t *step) +{ +#define STEP() do { if (step) moq_simpair_run_until_quiescent(step, 16, NULL); } while (0) + moq_bytes_t part = MOQ_BYTES_LITERAL("relay"); + moq_namespace_t ns = { &part, 1 }; + + moq_publish_namespace_cfg_t nc; moq_publish_namespace_cfg_init(&nc); + nc.track_namespace = ns; + moq_announcement_t ann; + MOQ_TEST_CHECK(moq_session_publish_namespace(relay, &nc, now, &ann) == MOQ_OK); + STEP(); + + moq_subscribe_cfg_t sc; moq_subscribe_cfg_init(&sc); + sc.track_namespace = ns; + sc.track_name = MOQ_BYTES_LITERAL("video"); + moq_subscription_t sub; + MOQ_TEST_CHECK(moq_session_subscribe(relay, &sc, now, &sub) == MOQ_OK); + STEP(); + + moq_track_status_cfg_t tc; moq_track_status_cfg_init(&tc); + tc.track_namespace = ns; + tc.track_name = MOQ_BYTES_LITERAL("video"); + moq_track_status_handle_t ts; + MOQ_TEST_CHECK(moq_session_track_status(relay, &tc, now, &ts) == MOQ_OK); + STEP(); + + moq_subscribe_namespace_cfg_t nsc; moq_subscribe_namespace_cfg_init(&nsc); + nsc.track_namespace_prefix = ns; + nsc.namespace_interest = MOQ_NAMESPACE_INTEREST_NAMESPACE_STATE; + moq_ns_sub_handle_t nsh; + MOQ_TEST_CHECK(moq_session_subscribe_namespace(relay, &nsc, now, &nsh) == MOQ_OK); + STEP(); + + moq_subscribe_tracks_cfg_t stc; moq_subscribe_tracks_cfg_init(&stc); + stc.track_namespace_prefix = ns; + moq_track_sub_handle_t sth; + MOQ_TEST_CHECK(moq_session_subscribe_tracks(relay, &stc, now, &sth) == MOQ_OK); + STEP(); + + moq_publish_cfg_t pc; moq_publish_cfg_init(&pc); + pc.track_namespace = ns; + pc.track_name = MOQ_BYTES_LITERAL("pushed"); + moq_publication_t pub; + MOQ_TEST_CHECK(moq_session_publish(relay, &pc, now, &pub) == MOQ_OK); + STEP(); + + moq_fetch_cfg_t fc; moq_fetch_cfg_init(&fc); + fc.track_namespace = ns; + fc.track_name = MOQ_BYTES_LITERAL("past"); + fc.end_group = 0; + fc.end_object = 9; + moq_fetch_t fetch; + MOQ_TEST_CHECK(moq_session_fetch(relay, &fc, now, &fetch) == MOQ_OK); + STEP(); +#undef STEP +} + +static void make_pair(test_alloc_state_t *as, moq_alloc_t *alloc, moq_version_t version, + uint32_t max_actions, moq_simpair_t **sp, moq_subscriber_t **sub) +{ + *as = (test_alloc_state_t){0}; + *alloc = test_allocator(as); + moq_simpair_cfg_t cfg = MOQ_SIMPAIR_CFG_INIT; + cfg.alloc = alloc; cfg.seed = 7; cfg.initial_now_us = 1000; + cfg.version = version; + cfg.max_actions = max_actions; + cfg.client_send_request_capacity = true; + cfg.client_initial_request_capacity = 32; + cfg.server_send_request_capacity = true; + cfg.server_initial_request_capacity = 32; + MOQ_TEST_CHECK(moq_simpair_create(&cfg, sp) == MOQ_OK); + moq_simpair_start(*sp); + moq_simpair_run_until_quiescent(*sp, 8, NULL); + drain(moq_simpair_client(*sp)); + drain(moq_simpair_server(*sp)); + moq_sub_cfg_t scfg; moq_sub_cfg_init(&scfg); + MOQ_TEST_CHECK(moq_sub_create(moq_simpair_client(*sp), alloc, &scfg, sub) == MOQ_OK); +} + +static void destroy_pair(test_alloc_state_t *as, moq_simpair_t *sp, moq_subscriber_t *sub) +{ + moq_sub_destroy(sub); + drain(moq_simpair_server(sp)); + drain(moq_simpair_client(sp)); + moq_simpair_destroy(sp); + MOQ_TEST_CHECK(as->balance == 0); +} + +static void check_codes(const answers_t *a, const char *label) +{ + for (int k = 0; k < K_COUNT; k++) { + moq_request_error_t want = (k == K_SUBSCRIBE || k == K_TRACK_STATUS) + ? MOQ_REQUEST_ERROR_DOES_NOT_EXIST : MOQ_REQUEST_ERROR_NOT_SUPPORTED; + if (a->count[k] != 1 || a->code[k] != want) { + fprintf(stderr, " %s: %s answered %d time(s), code %u (want 1, code %u)\n", label, + k_names[k], a->count[k], (unsigned)a->code[k], (unsigned)want); + failures++; + } + } + MOQ_TEST_CHECK(a->other_failures == 0); +} + +/* Every kind of peer request gets exactly one refusal, on drafts 18 and 22. */ +static void test_refuses_every_unserved_request(moq_version_t version, const char *label) +{ + test_alloc_state_t as; moq_alloc_t alloc; moq_simpair_t *sp; moq_subscriber_t *sub; + make_pair(&as, &alloc, version, 0, &sp, &sub); + moq_session_t *relay = moq_simpair_server(sp); + + open_requests(relay, moq_simpair_now_us(sp), NULL); + answers_t a = {0}; + for (int round = 0; round < 8 && answered(&a) < K_COUNT; round++) { + moq_simpair_run_until_quiescent(sp, 16, NULL); + MOQ_TEST_CHECK(moq_sub_tick(sub, moq_simpair_now_us(sp)) == MOQ_OK); + moq_simpair_run_until_quiescent(sp, 16, NULL); + collect(relay, &a); + } + check_codes(&a, label); + + destroy_pair(&as, sp, sub); + MOQ_TEST_PASS(label); +} + +/* With a session that can take only a few actions at a time, some refusals + * wait in the subscriber: they go out only on a later tick. After each tick + * the pair runs until quiet with no further tick, so whatever the session + * accepted has gone out by then; an answer that appears only after the next + * tick was held by the subscriber. Each request is still answered once. */ +static void test_held_refusals_are_retried(void) +{ + test_alloc_state_t as; moq_alloc_t alloc; moq_simpair_t *sp; moq_subscriber_t *sub; + make_pair(&as, &alloc, MOQ_VERSION_DRAFT_18, 4, &sp, &sub); + moq_session_t *relay = moq_simpair_server(sp); + + open_requests(relay, moq_simpair_now_us(sp), sp); + moq_simpair_run_until_quiescent(sp, 16, NULL); + answers_t a = {0}; + int ticks = 0, held_ticks = 0; + while (ticks < 32 && answered(&a) < K_COUNT) { + moq_result_t rc = moq_sub_tick(sub, moq_simpair_now_us(sp)); + MOQ_TEST_CHECK(rc == MOQ_OK || rc == MOQ_ERR_WOULD_BLOCK); + ticks++; + for (int i = 0; i < 8; i++) { + moq_simpair_run_until_quiescent(sp, 16, NULL); + collect(relay, &a); + } + /* Settled with no further tick, and still not all answered: the rest + * waits in the subscriber. */ + if (answered(&a) < K_COUNT) held_ticks++; + } + fprintf(stderr, " held_refusals_are_retried: %d tick(s), %d with refusals still held\n", + ticks, held_ticks); + check_codes(&a, "held_refusals_are_retried"); + if (held_ticks == 0) { + fprintf(stderr, " no refusal was held: the session took every refusal at once\n"); + failures++; + } + + destroy_pair(&as, sp, sub); + MOQ_TEST_PASS("held_refusals_are_retried"); +} + +int main(void) +{ + test_refuses_every_unserved_request(MOQ_VERSION_DRAFT_18, "refuses_every_unserved_request_d18"); + test_refuses_every_unserved_request(MOQ_VERSION_DRAFT_22, "refuses_every_unserved_request_d22"); + test_held_refusals_are_retried(); + fprintf(stderr, "subscriber_unserved: %d failure(s)\n", failures); + return failures ? 1 : 0; +}