From 1b2eb89ef1d9c77193e4d54497c6df2077f4f2be Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 19 Oct 2026 13:07:31 -0700 Subject: [PATCH 1/8] chore: claim GOAWAY stream coverage quest From 78318b1135476cc696b2605e46bf023fd9c6437c Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 19 Oct 2026 13:31:21 -0700 Subject: [PATCH 2/8] fix(net): validate GOAWAY across IETF request streams Co-Authored-By: GPT-6.1-Sol --- js/net/src/auth_session.ts | 9 +- js/net/src/ietf/adapter.ts | 132 +++++++++-------- js/net/src/ietf/auth.ts | 12 +- js/net/src/ietf/connection.ts | 68 +++++---- js/net/src/ietf/goaway.test.ts | 185 +++++++++++++++++++++++ js/net/src/ietf/publisher.ts | 86 +++++++++-- js/net/src/ietf/request_stream.test.ts | 42 ++++-- js/net/src/ietf/request_stream.ts | 60 ++++++-- js/net/src/ietf/subscriber.ts | 28 ++-- js/net/src/lite/auth.ts | 4 + rs/moq-net/benches/auth.rs | 105 ++++++------- rs/moq-net/src/ietf/adapter.rs | 68 ++++++--- rs/moq-net/src/ietf/auth.rs | 36 ++--- rs/moq-net/src/ietf/control.rs | 43 +++++- rs/moq-net/src/ietf/publisher.rs | 184 +++++++++++++++++++---- rs/moq-net/src/ietf/request_stream.rs | 141 +++++++++++++++++- rs/moq-net/src/ietf/session.rs | 196 ++++++++++++++++--------- rs/moq-net/src/ietf/subscriber.rs | 151 ++++++++++++++----- 18 files changed, 1185 insertions(+), 365 deletions(-) diff --git a/js/net/src/auth_session.ts b/js/net/src/auth_session.ts index daeb0afcccd..46cde30367b 100644 --- a/js/net/src/auth_session.ts +++ b/js/net/src/auth_session.ts @@ -38,6 +38,8 @@ export interface AuthWire { read(stream: Stream): Promise; /** The token the peer presents on a stream it opened. */ accept(stream: Stream): Promise; + /** Wait for the presenter to withdraw while validating follow-up messages. */ + withdrawn(stream: Stream): Promise; /** Tell the presenter a grant. Throws {@link Unsupported} when this wire cannot represent it. */ grant(stream: Stream, grant: WireGrant): Promise; /** Refuse or revoke the presenter's token. */ @@ -172,11 +174,8 @@ class IssuedGrant implements Issued { this.#stream = stream; this.#wire = wire; // The presenter withdraws by closing or cancelling its side. - this.closed = stream.reader - .done() - .then((done) => { - if (!done) throw new ProtocolViolation("additional message on an AUTH stream"); - }) + this.closed = wire + .withdrawn(stream) .then( () => null, (err: unknown) => (err instanceof StreamError && err.code === StreamCode.Cancel ? null : error(err)), diff --git a/js/net/src/ietf/adapter.ts b/js/net/src/ietf/adapter.ts index 1d4bb8b3af2..856134e6522 100644 --- a/js/net/src/ietf/adapter.ts +++ b/js/net/src/ietf/adapter.ts @@ -1,4 +1,4 @@ -import { Once } from "@moq/signals"; +import { Once, race } from "@moq/signals"; import { Mutex } from "async-mutex"; import type { Drain } from "../connection/goaway.ts"; import { error, ProtocolViolation, SessionCode, SessionError } from "../error.ts"; @@ -465,76 +465,84 @@ export class ControlStreamAdapter implements Session { void this.#acceptNativeBidis(); } - for (;;) { - const done = await this.#reader.done(); - if (done) { - cause = new ProtocolViolation("control stream closed"); - break; - } + const read = async () => { + for (;;) { + const done = await this.#reader.done(); + if (done) { + throw new ProtocolViolation("control stream closed"); + } - const typeId = await this.#reader.u53(); - const size = await this.#reader.u16(); - const body = await this.#reader.read(size); + const typeId = await this.#reader.u53(); + const size = await this.#reader.u16(); + const body = await this.#reader.read(size); - const classified = await this.#classify(typeId, body); + const classified = await this.#classify(typeId, body); - if (classified.route === Route.GoAway) { - // The session keeps serving: a GOAWAY asks us to migrate, not to stop reading. - const msg = await GoAway.decodeBody(body, this.version); - if (this.goaway.peek() !== undefined) throw new ProtocolViolation("duplicate GOAWAY"); - // A client may leave, but only the server may name where to go. - if (!this.client && msg.newSessionUri !== "") { - throw new ProtocolViolation("client GOAWAY must not name a redirect"); + if (classified.route === Route.GoAway) { + // The session keeps serving: a GOAWAY asks us to migrate, not to stop reading. + const msg = await GoAway.decodeBody(body, this.version); + if (this.goaway.peek() !== undefined) throw new ProtocolViolation("duplicate GOAWAY"); + // A client may leave, but only the server may name where to go. + if (!this.client && msg.newSessionUri !== "") { + throw new ProtocolViolation("client GOAWAY must not name a redirect"); + } + this.goaway.set(msg.drain()); + continue; } - this.goaway.set(msg.drain()); - continue; - } - if (classified.route === Route.Update) { - this.spendRequest(classified.ownRequestId); - // An update whose request is gone, or rides a stream of its own like draft 16's - // SUBSCRIBE_NAMESPACE, is still owed its one answer. Draft 14 answers no update. - if ( - !this.#pushMessage(classified.requestId, typeId, size, body) && - this.version !== Version.DRAFT_14 - ) { - void this.#refuseUpdate(classified.ownRequestId); + if (classified.route === Route.Update) { + this.spendRequest(classified.ownRequestId); + // An update whose request is gone, or rides a stream of its own like draft 16's + // SUBSCRIBE_NAMESPACE, is still owed its one answer. Draft 14 answers no update. + if ( + !this.#pushMessage(classified.requestId, typeId, size, body) && + this.version !== Version.DRAFT_14 + ) { + void this.#refuseUpdate(classified.ownRequestId); + } + continue; } - continue; - } - const { route, requestId } = classified; - if ((route === Route.Response || route === Route.ErrorResponse) && this.#updates.delete(requestId)) - continue; - - switch (route) { - case Route.NewRequest: - this.#admitHeld(requestId); - this.#newRequest(typeId, size, body, requestId); - break; - case Route.Response: - this.#pushMessage(requestId, typeId, size, body); - break; - case Route.ErrorResponse: - this.#pushMessage(requestId, typeId, size, body); - this.#closeStream(requestId); - break; - case Route.CloseStream: - this.#closeStream(requestId); - break; - case Route.FollowUp: - this.#pushMessage(requestId, typeId, size, body); - break; - case Route.MaxRequestId: - this.#maxRequestId = requestId; - for (const resolve of this.#maxRequestIdResolves) resolve(); - this.#maxRequestIdResolves.clear(); - break; + const { route, requestId } = classified; + if ((route === Route.Response || route === Route.ErrorResponse) && this.#updates.delete(requestId)) + continue; + + switch (route) { + case Route.NewRequest: + this.#admitHeld(requestId); + this.#newRequest(typeId, size, body, requestId); + break; + case Route.Response: + this.#pushMessage(requestId, typeId, size, body); + break; + case Route.ErrorResponse: + this.#pushMessage(requestId, typeId, size, body); + this.#closeStream(requestId); + break; + case Route.CloseStream: + this.#closeStream(requestId); + break; + case Route.FollowUp: + this.#pushMessage(requestId, typeId, size, body); + break; + case Route.MaxRequestId: + this.#maxRequestId = requestId; + for (const resolve of this.#maxRequestIdResolves) resolve(); + this.#maxRequestIdResolves.clear(); + break; + } } - } + }; + const stopped = this.#writer.closed.then(() => { + throw new ProtocolViolation("control stream stopped"); + }); + await race([read(), stopped]); } catch (err: unknown) { - cause = error(err); - throw err; + cause = + err instanceof ProtocolViolation || err instanceof RequestWindowError + ? err + : new ProtocolViolation(error(err).message, { cause: err }); + throw cause; } finally { this.close(cause); } diff --git a/js/net/src/ietf/auth.ts b/js/net/src/ietf/auth.ts index 13c42ddb0e8..5168588a1fb 100644 --- a/js/net/src/ietf/auth.ts +++ b/js/net/src/ietf/auth.ts @@ -1,12 +1,13 @@ import { Unsupported } from "../auth.ts"; import type { AuthWire, WireGrant, WireReply } from "../auth_session.ts"; -import { SessionCode, SessionError } from "../error.ts"; +import { ProtocolViolation, SessionCode, SessionError } from "../error.ts"; import * as Path from "../path.ts"; import type { Reader, Stream, Writer } from "../stream.ts"; import type { Session } from "./adapter.ts"; import * as Message from "./message.ts"; import * as Namespace from "./namespace.ts"; import { SetupOption, type SetupOptions } from "./parameters.ts"; +import { nextMessage } from "./request_stream.ts"; import { type IetfVersion, Version } from "./version.ts"; /** @@ -233,8 +234,8 @@ export class IetfAuthWire implements AuthWire { } async read(stream: Stream): Promise { - if (await stream.reader.done()) return undefined; - const id = await stream.reader.u53(); + const id = await nextMessage(stream.reader, this.#version, this.#session.client); + if (id === undefined) return undefined; switch (id) { case AuthOk.id: { const ok = await AuthOk.decode(stream.reader, this.#version); @@ -256,6 +257,11 @@ export class IetfAuthWire implements AuthWire { return msg.token; } + async withdrawn(stream: Stream): Promise { + if ((await nextMessage(stream.reader, this.#version, this.#session.client)) !== undefined) + throw new ProtocolViolation("additional message on an AUTH stream"); + } + async grant(stream: Stream, grant: WireGrant): Promise { await new AuthOk(grant.publish, grant.subscribe, grant.expires).encode(stream.writer, this.#version); } diff --git a/js/net/src/ietf/connection.ts b/js/net/src/ietf/connection.ts index 3fe648cd664..9349f687257 100644 --- a/js/net/src/ietf/connection.ts +++ b/js/net/src/ietf/connection.ts @@ -1,5 +1,5 @@ import { Nano, Second } from "@moq/clock"; -import { type Getter, Once, Signal } from "@moq/signals"; +import { type Getter, Once, race, Signal } from "@moq/signals"; import type * as announce from "../announced.ts"; import type * as Auth from "../auth.ts"; import { AuthSession } from "../auth_session.ts"; @@ -185,8 +185,11 @@ export class Connection implements Established { this.#close({ closeCode: err.code, reason: err.message }); return; } - console.error("adapter error", err); - this.#close(); + this.#violated( + err instanceof ProtocolViolation + ? err + : new ProtocolViolation("control stream failed", { cause: err }), + ); }); } @@ -615,33 +618,46 @@ export class Connection implements Established { */ async #runGoAway(controlStream: Stream, version: IetfVersion) { try { - for (;;) { - const done = await controlStream.reader.done(); - if (done) return; + const read = async () => { + for (;;) { + const done = await controlStream.reader.done(); + if (done) throw new ProtocolViolation("control stream closed"); - const msg = await this.#readGoAway(controlStream, version).catch((err: unknown) => { - throw malformed(err, "setup stream message"); - }); - if (this.#goaway.peek() !== undefined) throw new ProtocolViolation("duplicate GOAWAY"); - // A client may leave, but only the server may name where to go. - if (!this.#client && msg.newSessionUri !== "") { - throw new ProtocolViolation("client GOAWAY must not name a redirect"); - } - // Draft-18's Request ID names our IDs: even when we are the client, odd for a server. - // It is required here, on the control stream. - if (version === Version.DRAFT_18 && msg.requestId === undefined) { - throw new ProtocolViolation("draft-18 GOAWAY on the control stream lacks a Request ID"); - } - if (msg.requestId !== undefined && msg.requestId % 2n !== (this.#client ? 0n : 1n)) { - throw new ProtocolViolation("GOAWAY Request ID has the wrong parity", { - code: SessionCode.InvalidRequestId, + const msg = await this.#readGoAway(controlStream, version).catch((err: unknown) => { + throw malformed(err, "setup stream message"); }); + if (this.#goaway.peek() !== undefined) throw new ProtocolViolation("duplicate GOAWAY"); + // A client may leave, but only the server may name where to go. + if (!this.#client && msg.newSessionUri !== "") { + throw new ProtocolViolation("client GOAWAY must not name a redirect"); + } + // Draft-18's Request ID names our IDs: even when we are the client, odd for a server. + // It is required here, on the control stream. + if (version === Version.DRAFT_18 && msg.requestId === undefined) { + throw new ProtocolViolation("draft-18 GOAWAY on the control stream lacks a Request ID"); + } + if (msg.requestId !== undefined && msg.requestId % 2n !== (this.#client ? 0n : 1n)) { + throw new ProtocolViolation("GOAWAY Request ID has the wrong parity", { + code: SessionCode.InvalidRequestId, + }); + } + // Reject bytes already behind GOAWAY before a caller can close on the drain. + if (controlStream.reader.tryDecode((c) => c.u8()) !== undefined) + throw new ProtocolViolation("message after control stream GOAWAY"); + this.#goaway.set(msg.drain()); } - this.#goaway.set(msg.drain()); - } + }; + const stopped = controlStream.writer.closed.then(() => { + throw new ProtocolViolation("control stream stopped"); + }); + await race([read(), stopped]); } catch (err) { - if (err instanceof ProtocolViolation) this.#violated(err); - else if (!this.#closed) console.error("error reading setup stream", err); + if (!this.#closed) + this.#violated( + err instanceof ProtocolViolation + ? err + : new ProtocolViolation("control stream failed", { cause: err }), + ); } finally { this.#close(); } diff --git a/js/net/src/ietf/goaway.test.ts b/js/net/src/ietf/goaway.test.ts index 8faf99c372c..c29361a511a 100644 --- a/js/net/src/ietf/goaway.test.ts +++ b/js/net/src/ietf/goaway.test.ts @@ -1,10 +1,18 @@ import { expect, test } from "bun:test"; import { Milli } from "@moq/clock"; +import { SessionCode, StreamCode, StreamError } from "../error.ts"; import { createMockTransportPair } from "../mock.ts"; +import { Producer as OriginProducer } from "../origin.ts"; +import * as Path from "../path.ts"; import { Stream } from "../stream.ts"; import { wireOf } from "../wire.ts"; +import { NativeSession } from "./adapter.ts"; +import { AuthMessage, AuthOk, IetfAuthWire } from "./auth.ts"; import { Connection } from "./connection.ts"; import { GoAway } from "./goaway.ts"; +import { PublishNamespace } from "./publish_namespace.ts"; +import { RequestOk } from "./request.ts"; +import { SubscribeNamespace, SubscribeNamespaceEntry } from "./subscribe_namespace.ts"; import { ALPN, Version } from "./version.ts"; // Draft-17+ carry GOAWAY on the setup stream, with the peer's deadline. The session keeps @@ -80,3 +88,180 @@ test("a zero GOAWAY timeout reads as no deadline", async () => { const msg = new GoAway({ newSessionUri: "https://relay.example/next", timeout: 0n }); expect(msg.drain()).toEqual({ uri: "https://relay.example/next", timeout: undefined }); }); + +for (const [version, alpn] of [ + [Version.DRAFT_15, ALPN.DRAFT_15], + [Version.DRAFT_17, ALPN.DRAFT_17], + [Version.DRAFT_18, ALPN.DRAFT_18], + [Version.DRAFT_21, ALPN.DRAFT_21], + [Version.DRAFT_22, ALPN.DRAFT_22], +] as const) { + for (const end of ["FIN", "reset", "STOP_SENDING"] as const) { + test(`${alpn} control stream ${end} is a protocol violation`, async () => { + const pair = createMockTransportPair(alpn); + const control = await Stream.open(pair.client, { version }); + const peer = await Stream.accept(pair.server, version); + if (!peer) throw new Error("no control stream"); + const connection = new Connection({ + url: new URL("https://relay.example/"), + quic: pair.client, + control, + maxRequestId: 100n, + version, + client: true, + }); + try { + if (end === "reset") peer.writer.reset(new StreamError(StreamCode.Cancel)); + else if (end === "STOP_SENDING") peer.reader.stop(new StreamError(StreamCode.Cancel)); + else peer.writer.close(); + expect((await pair.server.closed).closeCode).toBe(SessionCode.ProtocolViolation); + } finally { + connection.abort(); + } + }); + } +} + +for (const [version, alpn] of [ + [Version.DRAFT_18, ALPN.DRAFT_18], + [Version.DRAFT_21, ALPN.DRAFT_21], +] as const) { + test(`${alpn} rejects queued duplicate GOAWAYs before exposing a drain`, async () => { + const pair = createMockTransportPair(alpn); + const control = await Stream.open(pair.client, { version }); + const peer = await Stream.accept(pair.server, version); + if (!peer) throw new Error("no control stream"); + const connection = new Connection({ + url: new URL("https://relay.example/"), + quic: pair.client, + control, + maxRequestId: 100n, + version, + client: true, + }); + // A caller may close immediately on a redirect, so the protocol error must win. + void wireOf(connection).goaway.then(() => connection.abort()); + const frame = version === Version.DRAFT_18 ? [0x10, 0, 3, 0, 0, 0] : [0x10, 0, 2, 0, 0]; + try { + await peer.writer.write(new Uint8Array([...frame, ...frame])); + expect((await pair.server.closed).closeCode).toBe(SessionCode.ProtocolViolation); + expect(wireOf(connection).goaway.peek()).toBeUndefined(); + } finally { + connection.abort(); + } + }); +} + +for (const [version, alpn] of [ + [Version.DRAFT_18, ALPN.DRAFT_18], + [Version.DRAFT_22, ALPN.DRAFT_22], +] as const) { + test(`${alpn} AUTH replies handle GOAWAY across grants`, async () => { + const pair = createMockTransportPair(alpn); + const wire = new IetfAuthWire(new NativeSession(pair.client, version, true)); + const stream = await wire.present(new Uint8Array()); + const peer = await Stream.accept(pair.server, version); + if (!peer) throw new Error("no AUTH stream"); + try { + await peer.writer.u53(GoAway.id); + await new GoAway({ newSessionUri: "" }).encode(peer.writer, version); + await new AuthOk(new Path.Patterns(), new Path.Patterns()).encode(peer.writer, version); + expect(await wire.read(stream)).toEqual({ + grant: { publish: new Path.Patterns(), subscribe: new Path.Patterns(), expires: undefined }, + }); + await peer.writer.u53(GoAway.id); + await new GoAway({ newSessionUri: "" }).encode(peer.writer, version); + await expect(wire.read(stream)).rejects.toThrow("second GOAWAY"); + } finally { + pair.client.close(); + } + }); + + test(`${alpn} an AUTH presenter can send GOAWAY before withdrawing`, async () => { + const pair = createMockTransportPair(alpn); + const wire = new IetfAuthWire(new NativeSession(pair.client, version, true)); + const stream = await Stream.open(pair.client, { version }); + const peer = await Stream.accept(pair.server, version); + if (!peer) throw new Error("no AUTH stream"); + try { + await new AuthMessage(1n, new Uint8Array()).encode(peer.writer, version); + expect(await stream.reader.u53()).toBe(AuthMessage.id); + await wire.accept(stream); + const withdrawn = wire.withdrawn(stream); + await peer.writer.u53(GoAway.id); + await new GoAway({ newSessionUri: "" }).encode(peer.writer, version); + peer.writer.close(); + await withdrawn; + } finally { + pair.client.close(); + } + }); +} + +for (const [version, alpn] of [ + [Version.DRAFT_18, ALPN.DRAFT_18], + [Version.DRAFT_22, ALPN.DRAFT_22], +] as const) { + test(`${alpn} namespace discovery reads GOAWAY before its response and between entries`, async () => { + const pair = createMockTransportPair(alpn); + const control = await Stream.open(pair.client, { version }); + await Stream.accept(pair.server, version); + const connection = new Connection({ + url: new URL("https://relay.example/"), + quic: pair.client, + control, + maxRequestId: 100n, + version, + client: true, + }); + const announced = connection.announced(); + try { + const request = await Stream.accept(pair.server, version); + if (!request) throw new Error("no namespace subscription"); + expect(await request.reader.u53()).toBe(SubscribeNamespace.id); + await SubscribeNamespace.decode(request.reader, version); + await request.writer.u53(GoAway.id); + await new GoAway({ newSessionUri: "" }).encode(request.writer, version); + await request.writer.u53(RequestOk.id); + await new RequestOk({ requestId: undefined }).encode(request.writer, version); + await request.writer.u53(SubscribeNamespaceEntry.id); + await new SubscribeNamespaceEntry({ suffix: Path.from("room") }).encode(request.writer, version); + expect((await announced.next())?.prefix).toBe(Path.from("room")); + await request.writer.write(Uint8Array.of(0x10, 0, 2, 0, 0)); + expect((await pair.server.closed).closeCode).toBe(SessionCode.ProtocolViolation); + } finally { + announced.close(); + connection.abort(); + } + }); + + test(`${alpn} an idle advertisement still rejects a second GOAWAY`, async () => { + const pair = createMockTransportPair(alpn); + const control = await Stream.open(pair.server, { version }); + await Stream.accept(pair.client, version); + const origin = new OriginProducer(); + origin.createBroadcast(Path.from("room")).announce(); + const connection = new Connection({ + url: new URL("https://relay.example/"), + quic: pair.server, + control, + maxRequestId: 100n, + version, + client: false, + publish: origin.consume(), + }); + try { + const request = await Stream.accept(pair.client, version); + if (!request) throw new Error("no advertisement"); + expect(await request.reader.u53()).toBe(PublishNamespace.id); + await PublishNamespace.decode(request.reader, version); + await request.writer.u53(RequestOk.id); + await new RequestOk({ requestId: undefined }).encode(request.writer, version); + await request.writer.write(Uint8Array.of(0x10, 0, 2, 0, 0, 0x10, 0, 2, 0, 0)); + expect((await pair.client.closed).closeCode).toBe(SessionCode.ProtocolViolation); + } finally { + connection.abort(); + origin.close(); + } + }); +} diff --git a/js/net/src/ietf/publisher.ts b/js/net/src/ietf/publisher.ts index 54a049c7ace..8aabe07259f 100644 --- a/js/net/src/ietf/publisher.ts +++ b/js/net/src/ietf/publisher.ts @@ -54,7 +54,15 @@ import { PublishNamespaceUpdate, } from "./publish_namespace.ts"; import { RequestError, RequestOk } from "./request.ts"; -import { cancelled, finCancels, malformed, namespaceUpdate, nextMessage, refuseReserved } from "./request_stream.ts"; +import { + cancelled, + ended, + finCancels, + malformed, + namespaceUpdate, + nextMessage, + refuseReserved, +} from "./request_stream.ts"; import { GroupOrder, type Subscribe, SubscribeError, SubscribeOk, SubscribeUpdate } from "./subscribe.ts"; import { type SubscribeNamespace, @@ -153,7 +161,15 @@ type Refused = "never" | number; type Answer = "held" | "dropped" | Refused; /** The open PUBLISH_NAMESPACE request per advertised path. */ -type Requests = Map; +type Request = { + path: Path.Valid; + requestId: bigint; + stream: Stream; + auth?: Auth; + reply?: Promise; + updating?: boolean; +}; +type Requests = Map; /** What one announce loop knows about the peer, keyed the way that loop names namespaces. */ interface Namespaces { @@ -596,12 +612,13 @@ export class Publisher { unsubscribe = resolve; }); const legacy = version === Version.DRAFT_14 || version === Version.DRAFT_15 || version === Version.DRAFT_16; - const goaway = { client: this.#session.client, seen: false }; const updates = (async () => { for (;;) { - const type = await nextMessage(stream.reader, version, goaway).catch((err: unknown) => { - throw malformed(err, "subscription message"); - }); + const type = await nextMessage(stream.reader, version, this.#session.client).catch( + (err: unknown) => { + throw malformed(err, "subscription message"); + }, + ); if (type === undefined) { if (legacy || finCancels(version)) return; return stream.writer.closed; @@ -1209,9 +1226,8 @@ export class Publisher { }; const ending = cancelled(stream, version); - const goaway = { client: this.#session.client, seen: false }; const readUpdate = () => - namespaceUpdate(stream.reader, version, goaway).then( + namespaceUpdate(stream.reader, version, this.#session.client).then( (update) => ({ update }), (err) => ({ error: error(err) }), ); @@ -1679,7 +1695,8 @@ export class Publisher { await msg.encode(stream.writer, this.#session.version); // Read response (RequestOk and PublishNamespaceOk share 0x07) - const respTypeId = await stream.reader.u53(); + const respTypeId = await nextMessage(stream.reader, this.#session.version, this.#session.client); + if (respTypeId === undefined) throw new Error("advertisement ended before its response"); if (respTypeId === RequestError.id) { const err = await RequestError.decode(stream.reader, this.#session.version); const why = requestReason( @@ -1705,11 +1722,19 @@ export class Publisher { })(), ); - if (answer === "held" && request) requests.set(path, { path, requestId, stream: request, auth }); + if (answer === "held" && request) { + const held: Request = { path, requestId, stream: request, auth }; + requests.set(path, held); + if (this.#session.version >= Version.DRAFT_18) held.reply = this.#readAdvertisement(held); + } return answer; } catch (err: unknown) { // The peer never answered the advertisement: a control timeout, not late content. const e = err instanceof TimeoutError ? controlTimeout(err) : error(err); + if (e instanceof ProtocolViolation) { + this.#quic.close({ closeCode: e.code, reason: e.message }); + this.#session.close(); + } console.warn(`announce failed: broadcast=${path} error=${reason(e)}`); request?.abort(e); return e instanceof NoStreamCredit || (e instanceof StreamError && e.code === StreamCode.ControlTimeout) @@ -1718,6 +1743,26 @@ export class Publisher { } } + // Keep reading while an advertisement is idle, so GOAWAY validation never waits for an update. + #readAdvertisement(request: Request): Promise { + const reply = nextMessage(request.stream.reader, this.#session.version, this.#session.client) + .then((type) => { + if (type !== undefined && !request.updating) + throw new ProtocolViolation("unexpected message on an idle advertisement"); + return type; + }) + .catch((err: unknown) => { + if (err instanceof ProtocolViolation) { + this.#quic.close({ closeCode: err.code, reason: err.message }); + this.#session.close(); + } + throw err; + }); + // A later update consumes the result; failures are acted on as soon as they arrive. + void reply.catch(() => undefined); + return reply; + } + /** * Check a REQUEST_OK answering a PUBLISH_NAMESPACE. ACTIVE_COUNT only answers * SUBSCRIBE_NAMESPACE (MoQ Active Count), and the session closes over it here, with the @@ -1769,10 +1814,12 @@ export class Publisher { answer = await withTimeout( (async (): Promise => { const { writer, reader } = request.stream; + request.updating = true; await writer.u53(PublishNamespaceUpdate.id); await new PublishNamespaceUpdate({ requestId, update, token }).encode(writer, version); - const typeId = await reader.u53(); + const typeId = await (request.reply ?? nextMessage(reader, version, this.#session.client)); + if (typeId === undefined) throw new Error("advertisement ended before its update response"); if (typeId === RequestError.id) { const err = await RequestError.decode(reader, version); const why = requestReason(err.errorCode, err.reasonPhrase, "publish_namespace", version); @@ -1783,6 +1830,8 @@ export class Publisher { throw new Error(`unexpected answer to the update: typeId=0x${typeId.toString(16)}`); } this.#answered(await RequestOk.decode(reader, version)); + request.updating = false; + if (version >= Version.DRAFT_18) request.reply = this.#readAdvertisement(request); return "held"; })(), ADVERTISE_TIMEOUT, @@ -1790,6 +1839,10 @@ export class Publisher { ); } catch (err: unknown) { const e = err instanceof TimeoutError ? controlTimeout(err) : error(err); + if (e instanceof ProtocolViolation) { + this.#quic.close({ closeCode: e.code, reason: e.message }); + this.#session.close(); + } console.warn(`publish_namespace update failed: broadcast=${path} error=${reason(e)}`); requests.delete(path); request.stream.abort(e); @@ -1864,7 +1917,16 @@ export class Publisher { // nothing, and lets go of the broadcast and track lookups. const hold = new AbortController(); const cancel = new StreamError(StreamCode.Cancel, { message: "cancel" }); - void cancelled(stream, version).then(() => hold.abort(cancel)); + void ended(stream, version, this.#session.client).then( + () => hold.abort(cancel), + (err) => { + if (err instanceof ProtocolViolation) { + this.#quic.close({ closeCode: err.code, reason: err.message }); + this.#session.close(); + } + hold.abort(cancel); + }, + ); // A grant that narrows abandons the lookup, and resets an answer the transport has // not taken yet rather than delivering it. diff --git a/js/net/src/ietf/request_stream.test.ts b/js/net/src/ietf/request_stream.test.ts index d5c9bb166ba..184e6028e50 100644 --- a/js/net/src/ietf/request_stream.test.ts +++ b/js/net/src/ietf/request_stream.test.ts @@ -2,8 +2,8 @@ import { expect, test } from "bun:test"; import { ProtocolViolation } from "../error.ts"; import { Reader } from "../stream.ts"; import * as Varint from "../varint.ts"; -import { namespaceUpdate } from "./request_stream.ts"; -import { Version } from "./version.ts"; +import { namespaceUpdate, nextMessage } from "./request_stream.ts"; +import { Version, versionName } from "./version.ts"; test("an oversized or truncated namespace update type is a protocol violation", async () => { // Both drafts use leading-ones varints. @@ -13,9 +13,7 @@ test("an oversized or truncated namespace update type is a protocol violation", const truncated = Uint8Array.of(0x80); for (const bytes of [oversized, truncated]) { const reader = new Reader(undefined, bytes, version); - await expect(namespaceUpdate(reader, version, { client: false, seen: false })).rejects.toBeInstanceOf( - ProtocolViolation, - ); + await expect(namespaceUpdate(reader, version, false)).rejects.toBeInstanceOf(ProtocolViolation); } } }); @@ -24,9 +22,7 @@ test("namespace update framing refuses duplicate prefix parameters", async () => for (const version of [Version.DRAFT_18, Version.DRAFT_21]) { const body = [2, 2, 0x34, 1, 1, 97, 0, 1, 1, 98]; const reader = new Reader(undefined, Uint8Array.from([2, 0, body.length, ...body]), version); - await expect(namespaceUpdate(reader, version, { client: false, seen: false })).rejects.toBeInstanceOf( - ProtocolViolation, - ); + await expect(namespaceUpdate(reader, version, false)).rejects.toBeInstanceOf(ProtocolViolation); } }); @@ -34,9 +30,37 @@ test("a repeated namespace update token is a request refusal", async () => { for (const version of [Version.DRAFT_18, Version.DRAFT_21]) { const body = [2, 2, 3, 3, 3, 0, 170, 0, 3, 3, 0, 170]; const reader = new Reader(undefined, Uint8Array.from([2, 0, body.length, ...body]), version); - expect(await namespaceUpdate(reader, version, { client: false, seen: false })).toEqual({ + expect(await namespaceUpdate(reader, version, false)).toEqual({ requestId: 2n, refused: "malformed_auth_token", }); } }); + +for (const version of [Version.DRAFT_18, Version.DRAFT_19, Version.DRAFT_21, Version.DRAFT_22]) { + test(`${versionName(version)} keeps GOAWAY state across request response phases`, async () => { + // GOAWAY, an empty REQUEST_OK, and another GOAWAY on the same stream. + const reader = new Reader(undefined, Uint8Array.of(0x10, 0, 2, 0, 0, 7, 0, 0, 0x10, 0, 2, 0, 0), version); + expect(await nextMessage(reader, version, true)).toBe(7); + expect(await reader.u16()).toBe(0); + await expect(nextMessage(reader, version, true)).rejects.toBeInstanceOf(ProtocolViolation); + }); + + test(`${versionName(version)} keeps separate request streams' GOAWAY state`, async () => { + for (let n = 0; n < 2; n++) { + const reader = new Reader(undefined, Uint8Array.of(0x10, 0, 2, 0, 0, 7, 0, 0), version); + expect(await nextMessage(reader, version, false)).toBe(7); + } + }); +} + +test("request message parsing preserves a transport session failure", async () => { + const failed = Object.assign(new Error("session closed"), { source: "session" }); + const input = new ReadableStream({ + start(controller) { + controller.error(failed); + }, + }); + const reader = new Reader(input, undefined, Version.DRAFT_22); + await expect(nextMessage(reader, Version.DRAFT_22, true)).rejects.toBe(failed); +}); diff --git a/js/net/src/ietf/request_stream.ts b/js/net/src/ietf/request_stream.ts index 1e799eb76e2..b3e554886a9 100644 --- a/js/net/src/ietf/request_stream.ts +++ b/js/net/src/ietf/request_stream.ts @@ -46,7 +46,10 @@ export async function refuseReserved(stream: Stream, version: IetfVersion): Prom * may name a new session. * @internal */ -export type GoAways = { client: boolean; seen: boolean }; +type GoAways = { client: boolean; seen: boolean }; + +// One reader spans the initial response and later updates on the same request. +const goaways = new WeakMap(); /** * Read the type of a request stream's next message, or undefined once the peer finishes. @@ -54,21 +57,41 @@ export type GoAways = { client: boolean; seen: boolean }; * or a client's naming a new session, is a protocol violation. * @internal */ -export async function nextMessage(reader: Reader, version: IetfVersion, goaway: GoAways): Promise { - for (;;) { - if (await reader.done()) return undefined; - const type = await reader.u53(); - if (type !== GoAway.id || version < Version.DRAFT_18) return type; - if (goaway.seen) throw new ProtocolViolation("second GOAWAY on a request stream"); - goaway.seen = true; - // Draft-18's Request ID belongs on the control stream only. - const msg = await GoAway.decode(reader, version); - if (msg.requestId !== undefined) throw new ProtocolViolation("request stream GOAWAY carries a Request ID"); - if (!goaway.client && msg.newSessionUri !== "") - throw new ProtocolViolation("client GOAWAY names a new session"); +export async function nextMessage(reader: Reader, version: IetfVersion, client: boolean): Promise { + let goaway = goaways.get(reader); + if (!goaway) { + goaway = { client, seen: false }; + goaways.set(reader, goaway); + } + try { + for (;;) { + if (await reader.done()) return undefined; + const type = await reader.u53(); + if (type !== GoAway.id || version < Version.DRAFT_18) return type; + if (goaway.seen) throw new ProtocolViolation("second GOAWAY on a request stream"); + goaway.seen = true; + // Draft-18's Request ID belongs on the control stream only. + const msg = await GoAway.decode(reader, version); + if (msg.requestId !== undefined) throw new ProtocolViolation("request stream GOAWAY carries a Request ID"); + if (!goaway.client && msg.newSessionUri !== "") + throw new ProtocolViolation("client GOAWAY names a new session"); + } + } catch (err) { + throw malformed(err, "request stream message"); } } +/** Wait for a request's FIN or reset while still validating its GOAWAY messages. @internal */ +export async function ended(stream: Stream, version: IetfVersion, client: boolean): Promise { + if (version <= Version.DRAFT_16) return cancelled(stream, version); + const read = (async () => { + if ((await nextMessage(stream.reader, version, client)) !== undefined) + throw new ProtocolViolation("unexpected request stream message"); + if (!finCancels(version)) await stream.writer.closed; + })(); + await race([read, stream.writer.closed]); +} + /** * Read one whole namespace update without abandoning a partial frame. * @internal @@ -76,11 +99,11 @@ export async function nextMessage(reader: Reader, version: IetfVersion, goaway: export async function namespaceUpdate( reader: Reader, version: IetfVersion, - goaway: GoAways, + client: boolean, ): Promise<{ requestId: bigint; prefix?: Path.Valid; refused?: RequestCondition } | undefined> { try { // Inside the normalization, so an oversized or truncated type is malformed too. - const type = await nextMessage(reader, version, goaway); + const type = await nextMessage(reader, version, client); if (type === undefined) return undefined; if (type !== 0x02) throw new ProtocolViolation("expected namespace REQUEST_UPDATE"); return await Message.decode(reader, async (body) => { @@ -111,6 +134,11 @@ export async function namespaceUpdate( * @internal */ export function malformed(err: unknown, what: string): unknown { - if (err instanceof ProtocolViolation || err instanceof StreamError) return err; + if ( + err instanceof ProtocolViolation || + err instanceof StreamError || + (typeof err === "object" && err !== null && "source" in err && err.source === "session") + ) + return err; return new ProtocolViolation(`malformed ${what}`, { cause: err }); } diff --git a/js/net/src/ietf/subscriber.ts b/js/net/src/ietf/subscriber.ts index 6e670b57434..7a161a403ce 100644 --- a/js/net/src/ietf/subscriber.ts +++ b/js/net/src/ietf/subscriber.ts @@ -62,7 +62,7 @@ import { PublishNamespaceUpdate, } from "./publish_namespace.ts"; import { RequestError, RequestOk } from "./request.ts"; -import { finCancels, refuseReserved } from "./request_stream.ts"; +import { finCancels, nextMessage, refuseReserved } from "./request_stream.ts"; import { joinFilter, Subscribe, SubscribeError, SubscribeOk, SubscribeUpdate, Unsubscribe } from "./subscribe.ts"; import { PublishBlocked, @@ -514,7 +514,8 @@ export class Subscriber { // Resolves to how many NAMESPACEs make up the initial set (MoQ Active Count). const response = (async () => { - const respTypeId = await stream.reader.u53(); + const respTypeId = await nextMessage(stream.reader, version, this.#session.client); + if (respTypeId === undefined) throw new Error("namespace stream ended before its response"); if (respTypeId === RequestOk.id) { const ok = await RequestOk.decode(stream.reader, version); // A count the negotiation did not promise, or a missing one it did, is @@ -547,14 +548,13 @@ export class Subscriber { for (;;) { if (initial === 0) announced.synced(); - const done = await stream.reader.done(); - if (done) { + const msgType = await nextMessage(stream.reader, version, this.#session.client); + if (msgType === undefined) { if (initial > 0) throw new ProtocolViolation("namespace stream ended inside the initial set"); break; } - const msgType = await stream.reader.u53(); // The counted initial set is NAMESPACEs only, so anything else cuts it short. if (initial > 0 && msgType !== SubscribeNamespaceEntry.id) { throw new ProtocolViolation(`message 0x${msgType.toString(16)} inside the initial set`); @@ -625,6 +625,7 @@ export class Subscriber { throw err; } } catch (err: unknown) { + if (err instanceof ProtocolViolation) this.#violated(err); const e = error(err); console.warn(`subscribe_namespace error: ${reason(e)}`); @@ -763,6 +764,7 @@ export class Subscriber { } console.debug(`subscribe ok: id=${requestId} broadcast=${broadcast} track=${request.name}`); } catch (err) { + if (err instanceof ProtocolViolation) this.#violated(err); // A control request that timed out is not late content, so it carries its own code. // Local abandonment must commit without yielding after the demand check. const e = err === abandoned ? abandoned : await sessionCause(this.#quic, err); @@ -877,6 +879,7 @@ export class Subscriber { stream.close(); console.debug(`subscribe close: id=${requestId} broadcast=${broadcast} track=${request.name}`); } catch (err) { + if (err instanceof ProtocolViolation) this.#violated(err); const e = await sessionCause(this.#quic, err); producer.close(this.#localClose ? undefined : e); stream.abort(e); @@ -911,8 +914,8 @@ export class Subscriber { // further answer is owed. let refused = false; for (;;) { - if (await stream.reader.done()) throw new ProtocolViolation("subscribe stream ended without PUBLISH_DONE"); - const typeId = await stream.reader.u53(); + const typeId = await nextMessage(stream.reader, version, this.#session.client); + if (typeId === undefined) throw new ProtocolViolation("subscribe stream ended without PUBLISH_DONE"); if (typeId === PublishDone.id) break; const answer = (typeId === RequestOk.id || typeId === RequestError.id) && !refused && unanswered.peek() > 0; if (!answer) throw new ProtocolViolation(`unexpected message on a subscription: 0x${typeId.toString(16)}`); @@ -1080,7 +1083,8 @@ export class Subscriber { if (state.cancelled) throw new Error("subscribe cancelled while it was being sent"); console.debug(`subscribe written: id=${requestId} broadcast=${broadcast} track=${request.name}`); - const respTypeId = await state.stream.reader.u53(); + const respTypeId = await nextMessage(state.stream.reader, version, this.#session.client); + if (respTypeId === undefined) throw new Error("subscription ended before its response"); if (respTypeId !== SubscribeOk.id) { let reasonPhrase = "unknown error"; try { @@ -1246,13 +1250,15 @@ export class Subscriber { ) : undefined; for (;;) { - if (await (stopped !== undefined ? race([stream.reader.done(), stopped]) : stream.reader.done())) { + const typeId = await (stopped !== undefined + ? race([nextMessage(stream.reader, version, this.#session.client), stopped.then(() => undefined)]) + : nextMessage(stream.reader, version, this.#session.client)); + if (typeId === undefined) { if (!finCancels(version)) await stopped; stream.reader.stop(new StreamError(StreamCode.Cancel)); break; } - const typeId = await stream.reader.u53(); // Drafts 14-15 have no update for an advertisement, so a SUBSCRIBE_UPDATE the // adapter routed here is refused and changes nothing. Draft 14 answers no update; // draft 15 names the update's own Request ID, which the adapter already spent. @@ -1414,6 +1420,7 @@ export class Subscriber { // The control message establishing this alias can arrive after the data stream. subscription = await this.#aliases.get(group.trackAlias); } catch (err: unknown) { + if (err instanceof ProtocolViolation) this.#violated(err); const e = await sessionCause(this.#quic, err); // Ours: we cancelled the subscription and the publisher has not stopped yet. // Anything else on this alias is the publisher sending data for a track it never @@ -1511,6 +1518,7 @@ export class Subscriber { // A group with no objects still exists. open().close(); } catch (err: unknown) { + if (err instanceof ProtocolViolation) this.#violated(err); const e = await sessionCause(this.#quic, err); // The compact form names the subgroup by its first Object ID, so a nonzero one is // subgroup N: stop the stream before any group exists for it. diff --git a/js/net/src/lite/auth.ts b/js/net/src/lite/auth.ts index 3e53e3d1a13..273f84c3f26 100644 --- a/js/net/src/lite/auth.ts +++ b/js/net/src/lite/auth.ts @@ -220,6 +220,10 @@ export class LiteAuthWire implements AuthWire { return msg.token; } + async withdrawn(stream: Stream): Promise { + if (!(await stream.reader.done())) throw new ProtocolViolation("additional message on an AUTH stream"); + } + async grant(stream: Stream, grant: WireGrant): Promise { await new AuthOk(grant.publish, grant.subscribe, grant.expires).encode(stream.writer, this.#version); } diff --git a/rs/moq-net/benches/auth.rs b/rs/moq-net/benches/auth.rs index 359227297fc..8e50688df4c 100644 --- a/rs/moq-net/benches/auth.rs +++ b/rs/moq-net/benches/auth.rs @@ -5,7 +5,8 @@ //! //! `renewal` times swapping the auth of every announced route on one origin, until //! the session that presented both auths has renewed each announcement and its peer -//! accepted every token. It sweeps the routes and the sessions publishing that origin: +//! accepted every token. `renewal_one` changes one route while the others remain idle. +//! Both sweep the routes and the sessions publishing that origin: //! the others carry no auth for those routes, so their cost is waking on a change that //! sends nothing. @@ -152,58 +153,62 @@ fn renewal(c: &mut Criterion) { .enable_all() .build() .unwrap(); - let mut group = c.benchmark_group("auth/renewal"); - group.sample_size(10); - group.warm_up_time(Duration::from_millis(100)); - group.measurement_time(Duration::from_millis(300)); - for sessions in [1, 16, 64] { - for routes in [1, 16, 128] { - group.throughput(Throughput::Elements(routes as u64)); - group.bench_with_input( - BenchmarkId::new(sessions.to_string(), routes), - &(sessions, routes), - |b, &(sessions, routes)| { - let _guard = runtime.enter(); - // No hold, so an iteration times the renewal rather than the origin batching it. - let mut config = origin::Config::new(Hop::new(2).unwrap()); - config.update_hold = Duration::ZERO; - let (origin, driver) = origin::Producer::new(config); - harness::spawn(driver); - let mut publishers = runtime.block_on(join_all((0..sessions).map(|_| publisher(&origin)))); - let (session, _, requests) = &mut publishers[0]; - let handle = session.auth(); - let auths = - runtime.block_on(async { [handle.add("a").await.unwrap(), handle.add("b").await.unwrap()] }); - let broadcasts: Vec<_> = (0..routes) - .map(|route| origin.create_broadcast(format!("room/{route}").as_str()).unwrap()) - .collect(); - let mut swap = |auth: &auth::Auth| { - for broadcast in &broadcasts { - broadcast - .announce(origin::Route::default().with_auth(auth.clone())) - .unwrap(); - } - runtime.block_on(async { - let mut issued = Vec::with_capacity(routes); - for _ in 0..routes { - issued.push(requests.next().await.unwrap().accept(auth::Grant::all())); + for (name, single) in [("auth/renewal", false), ("auth/renewal_one", true)] { + let mut group = c.benchmark_group(name); + group.sample_size(10); + group.warm_up_time(Duration::from_millis(100)); + group.measurement_time(Duration::from_millis(300)); + for sessions in [1, 16, 64] { + for routes in [1, 16, 128] { + let touched = if single { 1 } else { routes }; + group.throughput(Throughput::Elements(touched as u64)); + group.bench_with_input( + BenchmarkId::new(sessions.to_string(), routes), + &(sessions, routes), + |b, &(sessions, routes)| { + let _guard = runtime.enter(); + // No hold, so an iteration times the renewal rather than the origin batching it. + let mut config = origin::Config::new(Hop::new(2).unwrap()); + config.update_hold = Duration::ZERO; + let (origin, driver) = origin::Producer::new(config); + harness::spawn(driver); + let mut publishers = runtime.block_on(join_all((0..sessions).map(|_| publisher(&origin)))); + let (session, _, requests) = &mut publishers[0]; + let handle = session.auth(); + let auths = runtime + .block_on(async { [handle.add("a").await.unwrap(), handle.add("b").await.unwrap()] }); + let broadcasts: Vec<_> = (0..routes) + .map(|route| origin.create_broadcast(format!("room/{route}").as_str()).unwrap()) + .collect(); + let mut swap = |auth: &auth::Auth, touched: usize| { + for broadcast in broadcasts.iter().take(touched) { + broadcast + .announce(origin::Route::default().with_auth(auth.clone())) + .unwrap(); } - issued - }) - }; - // Each round's grants replace the last round's, which drop once their - // renewals are accepted. - let mut _held = swap(&auths[0]); - let mut next = 1; - b.iter(|| { - _held = swap(&auths[next]); - next ^= 1; - }); - }, - ); + runtime.block_on(async { + let mut issued = Vec::with_capacity(touched); + for _ in 0..touched { + issued.push(requests.next().await.unwrap().accept(auth::Grant::all())); + } + issued + }) + }; + // Each round's grants replace the last round's, which drop once their + // renewals are accepted. + let mut held = swap(&auths[0], routes); + let mut next = 1; + b.iter(|| { + let replacements = swap(&auths[next], touched); + drop(held.splice(..touched, replacements)); + next ^= 1; + }); + }, + ); + } } + group.finish(); } - group.finish(); } criterion_group!(benches, admission, renewal); diff --git a/rs/moq-net/src/ietf/adapter.rs b/rs/moq-net/src/ietf/adapter.rs index 2bf51eac65b..8f1f0b64536 100644 --- a/rs/moq-net/src/ietf/adapter.rs +++ b/rs/moq-net/src/ietf/adapter.rs @@ -47,12 +47,6 @@ impl Queue { true } - /// Dequeue the next message, waiting while the queue is open and empty. - /// Returns `None` once the queue is closed and drained. - async fn pop(&self) -> Option { - kio::wait(|waiter| self.poll_pop(waiter)).await - } - /// Poll for the next message; ready with `None` once closed and drained. fn poll_pop(&self, waiter: &kio::Waiter) -> Poll> { self.0 @@ -66,7 +60,7 @@ impl Queue { .map(|mut state| state.messages.pop_front()) } - /// Stop future pushes; buffered messages still drain, then `pop` returns `None`. + /// Stop future pushes; buffered messages still drain, then `poll_pop` returns `None`. fn close(&self) { self.0.lock().closed = true; } @@ -878,11 +872,23 @@ impl ControlStreamAdapter { /// Writer task: drains the queue and writes to the control stream. async fn run_write(&self, mut writer: Writer) -> Result<(), Error> { - while let Some(msg) = self.shared.control.pop().await { - let mut buf = std::io::Cursor::new(msg); - writer.write_all(&mut buf).await?; + loop { + let message = kio::wait(|waiter| { + if writer.poll_closed(&mut waiter.context()).is_ready() { + return Poll::Ready(Err(Error::ProtocolViolation)); + } + self.shared.control.poll_pop(waiter).map(Ok) + }) + .await?; + let Some(message) = message else { + return Ok(()); + }; + let mut buf = std::io::Cursor::new(message); + writer + .write_all(&mut buf) + .await + .map_err(super::session::control_stream_error)?; } - Ok(()) } /// Dispatcher loop that reads control stream messages and routes them. @@ -892,12 +898,20 @@ impl ControlStreamAdapter { goaway: crate::goaway::Protocol, ) -> Result<(), Error> { loop { - let type_id = match reader.varint_maybe().await? { + let type_id = match reader + .varint_maybe() + .await + .map_err(super::session::control_stream_error)? + { Some(id) => id, - None => return Ok(()), + None => return Err(Error::ProtocolViolation), }; - let body = reader.decode::().await?.0; + let body = reader + .decode::() + .await + .map_err(super::session::control_stream_error)? + .0; // Reconstruct raw message bytes: [type_id][size][body] let raw = encode_raw(type_id, &body, self.version); @@ -1442,7 +1456,7 @@ mod tests { shared .open_incoming(target_id, Bytes::from_static(b"request"), None) .unwrap(); - let (_, mut recv) = shared.incoming.pop().await.unwrap(); + let (_, mut recv) = kio::wait(|waiter| shared.incoming.poll_pop(waiter)).await.unwrap(); assert_eq!( recv.read_chunk(usize::MAX).await.unwrap(), Some(Bytes::from_static(b"request")) @@ -1575,7 +1589,7 @@ mod tests { let n = stream.write(b"hello").await.unwrap(); assert_eq!(n, 5); - let data = control.pop().await.unwrap(); + let data = kio::wait(|waiter| control.poll_pop(waiter)).await.unwrap(); assert_eq!(data, &b"hello"[..]); } @@ -1636,7 +1650,7 @@ mod tests { .open_incoming(request_id, encode_msg(&msg, version), None) .unwrap(); - let (_, mut recv) = shared.incoming.pop().await.unwrap(); + let (_, mut recv) = kio::wait(|waiter| shared.incoming.poll_pop(waiter)).await.unwrap(); // Drain the advertisement the stream opened with, so both halves are quiescent // and a later read only sees what the terminal message routes. @@ -1938,6 +1952,26 @@ mod tests { (adapter, Reader::new(recv, VERSION), writer, log) } + #[moq_clock::test] + async fn a_legacy_control_stream_fin_or_reset_is_a_protocol_violation() { + use crate::lite::test_transport::{DeadStreamSession, ScriptedSession}; + for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + let mut session = ScriptedSession::eof(Vec::new()); + let stream = crate::coding::Stream::open(&mut session, version).await.unwrap(); + let adapter = ControlStreamAdapter::new(session, Control::new(None, true), version); + let (_handle, protocol) = crate::goaway::Handle::new(false); + let err = adapter.run(stream.reader, stream.writer, protocol).await.unwrap_err(); + assert!(matches!(err, Error::ProtocolViolation), "{version:?}: {err:?}"); + + let mut session = DeadStreamSession::bis(0); + let stream = crate::coding::Stream::open(&mut session, version).await.unwrap(); + let adapter = ControlStreamAdapter::new(session, Control::new(None, true), version); + let (_handle, protocol) = crate::goaway::Handle::new(false); + let err = adapter.run(stream.reader, stream.writer, protocol).await.unwrap_err(); + assert!(matches!(err, Error::ProtocolViolation), "{version:?}: {err:?}"); + } + } + /// A request ID at the MAX_REQUEST_ID we advertised closes the session with the /// draft's TOO_MANY_REQUESTS, before the request is queued. #[moq_clock::test] diff --git a/rs/moq-net/src/ietf/auth.rs b/rs/moq-net/src/ietf/auth.rs index 0cceeaed4bd..97591fb5e32 100644 --- a/rs/moq-net/src/ietf/auth.rs +++ b/rs/moq-net/src/ietf/auth.rs @@ -328,14 +328,15 @@ impl Present { } let mut answered = false; + let mut messages = super::request_stream::Messages::new(self.session.clone(), self.control.client()); loop { enum Next { Withdrawn, - Reply(Result, Error>), + Reply(Result, Error>), } let next = { - let mut read = std::pin::pin!(read_message(&mut stream)); + let mut read = std::pin::pin!(messages.next(&mut stream.reader)); kio::wait(|waiter| { if self.handle.poll_withdrawn(self.id, waiter).is_ready() { return Poll::Ready(Next::Withdrawn); @@ -348,7 +349,7 @@ impl Present { let (id, body) = match next { // Resetting our side is what tells the peer. Next::Withdrawn => return Error::Cancel, - Next::Reply(Ok(Some(msg))) => msg, + Next::Reply(Ok(Some(super::request_stream::Framed(id, body)))) => (id, body), // The peer ended the grant without revoking it. Next::Reply(Ok(None)) if answered => return Error::Cancel, // A peer that closes before answering could not tell us anything. @@ -409,18 +410,6 @@ fn decode_reply(body: &super::Body, version: Version) -> Result( - stream: &mut Stream, -) -> Result, Error> { - let Some(id) = stream.reader.varint_maybe().await? else { - return Ok(None); - }; - let body: super::Body = stream.reader.decode().await?; - Ok(Some((id, body))) -} - /// Answers the peer's Auth requests: the app's verdict when it took the requests, /// otherwise the default grant for the connection's own credential. #[derive(Clone)] @@ -440,6 +429,7 @@ impl Serve { msg: Auth, version: Version, ) -> Result<(), Error> { + let mut goaways = super::request_stream::GoAways::new(msg.request_id.0 % 2 == 1); let serving = Serving::new(self.handle.clone()); let issue = &serving.issue; let mut default = None; @@ -463,7 +453,16 @@ impl Serve { None => default = Some(crate::auth::DefaultGrant::new(self.handle.clone(), self.peer_grant)), } - let err = match serve_issue(&self.runtime, issue, default.as_mut(), &mut stream, version).await { + let err = match serve_issue( + &self.runtime, + issue, + default.as_mut(), + &mut stream, + version, + &mut goaways, + ) + .await + { Ok(()) => Error::Cancel, Err(err) => { match &err { @@ -498,6 +497,7 @@ async fn serve_issue( mut default: Option<&mut crate::auth::DefaultGrant>, stream: &mut Stream, version: Version, + goaways: &mut super::request_stream::GoAways, ) -> Result<(), Error> { enum Next { Withdrawn(Result<(), Error>), @@ -507,8 +507,8 @@ async fn serve_issue( loop { let next = kio::wait(|waiter| { let mut cx = std::task::Context::from_waker(waiter.waker()); - if let Poll::Ready(res) = stream.reader.poll_read_chunk(&mut cx, 1).map(|res| { - res.and_then(|chunk| match chunk { + if let Poll::Ready(res) = goaways.poll_next(&mut stream.reader, &mut cx).map(|res| { + res.and_then(|message| match message { None => Ok(()), Some(_) => Err(Error::ProtocolViolation), }) diff --git a/rs/moq-net/src/ietf/control.rs b/rs/moq-net/src/ietf/control.rs index be873ada8c5..af3900a188a 100644 --- a/rs/moq-net/src/ietf/control.rs +++ b/rs/moq-net/src/ietf/control.rs @@ -86,6 +86,8 @@ struct ControlState { modern: Spent, /// The most runs `modern` may hold. Forgetting one would make its IDs usable again. history: u64, + /// A draft-18 GOAWAY has frozen admission of new peer requests. + going_away: bool, } /// The MAX_REQUEST_ID window we grant the peer. @@ -132,6 +134,7 @@ impl Control { // The peer takes the other parity: a client's IDs are even, a server's odd. modern: Spent::new(u64::from(client)), history: crate::session::Limits::default().requests(), + going_away: false, }), } } @@ -166,6 +169,17 @@ impl Control { self } + /// Freeze draft-18 admission and name the first peer ID beyond those already admitted. + pub fn goaway(&self) -> Result { + let mut state = self.state.lock(); + let next = state.modern.next; + if next >= 1 << 62 { + return Err(SessionError::Internal.into()); + } + state.going_away = true; + Ok(RequestId(next)) + } + pub fn max_request_id(&self, max: RequestId) { // Mutating through the guard wakes any `next_request_id` waiting on the limit. self.state.lock().request_id_max = Some(max); @@ -191,7 +205,11 @@ impl Control { return Err(SessionError::Internal.into()); } modern.spend(id.0); - return Ok(None); + return if state.going_away { + Err(Error::GoingAway) + } else { + Ok(None) + }; }; if id.0 >= incoming.max { tracing::warn!(id = %id, max = incoming.max, live = incoming.live, "peer exceeded MAX_REQUEST_ID"); @@ -302,6 +320,29 @@ impl Drop for RequestPermit { mod tests { use super::*; + #[test] + fn goaway_freezes_request_admission_at_current_progress() { + for client in [false, true] { + let control = Control::new(None, client); + let first = u64::from(client); + assert_eq!(control.goaway().unwrap(), RequestId(first)); + assert!(matches!(control.accept(RequestId(first)), Err(Error::GoingAway))); + + let control = Control::new(None, client); + control.accept(RequestId(first)).unwrap(); + control.accept(RequestId(first + 4)).unwrap(); + assert_eq!(control.goaway().unwrap(), RequestId(first + 6)); + // Cross-stream reordering may deliver an older ID after GOAWAY too. + for id in [first + 2, first + 6, first + 8] { + assert!(matches!(control.accept(RequestId(id)), Err(Error::GoingAway))); + } + assert!(matches!( + control.accept(RequestId(first)), + Err(Error::Session(SessionError::InvalidRequestId)) + )); + } + } + fn granted(control: &Control) -> Option { match control.poll_grant(&kio::Waiter::noop()) { Poll::Ready(max) => Some(max.0), diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index cb6e373261d..f1806eb7bfa 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -397,11 +397,12 @@ impl Target { fn poll_closed( &mut self, finished: &mut bool, + goaways: &mut super::request_stream::Messages, version: Version, cx: &mut std::task::Context<'_>, ) -> Poll> { match self.stream() { - Some(stream) => super::request_stream::poll_cancel(stream, finished, version, cx), + Some(stream) => super::request_stream::poll_cancel(stream, finished, goaways, version, cx), None => Poll::Pending, } } @@ -410,7 +411,7 @@ impl Target { fn poll_event( &mut self, finished: &mut bool, - goaways: &mut super::request_stream::GoAways, + goaways: &mut super::request_stream::Messages, version: Version, cx: &mut std::task::Context<'_>, ) -> Poll { @@ -420,7 +421,9 @@ impl Target { version, Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 ) { - return self.poll_closed(finished, version, cx).map(NamespaceEvent::Closed); + return self + .poll_closed(finished, goaways, version, cx) + .map(NamespaceEvent::Closed); } let Some(stream) = self.stream() else { return Poll::Pending; @@ -1101,6 +1104,7 @@ where }; let mut request_finished = false; + let mut goaways = super::request_stream::Messages::new(self.session.clone(), self.control.client()); // A token-authorized subscription is held to its own grant, which ends it when the // grant lapses, is revoked, or stops covering it. Every subscription is gated so it // ends once what the peer granted us stops covering it, and a limit-authorized one @@ -1339,6 +1343,7 @@ where if super::request_stream::poll_cancel( &mut stream, &mut request_finished, + &mut goaways, self.version, &mut cx, ) @@ -1446,7 +1451,7 @@ where // carry no Request ID, so they must go out in the order the updates arrived. The stash is // a FIFO bounded by MAX_REQUEST_UPDATES (counting the one being verified). let mut renewal = request_update::Renewal::::default(); - let mut goaways = super::request_stream::GoAways::new(self.control.client()); + let mut goaways = super::request_stream::Messages::new(self.session.clone(), self.control.client()); // What one turn of the loop resolved to. enum Turn { @@ -1506,8 +1511,12 @@ where use super::request_stream::{Next, Update}; while !*finished { match stream.reader.poll_decode_maybe::>(&mut cx) { - Poll::Ready(Ok(Some(Next::Message(update)))) => { + Poll::Ready(Ok(Some(Next::Message(mut update)))) => { if let Err(err) = self.control.accept(update.request_id) { + if matches!(err, Error::GoingAway) { + update.refused = Some(err); + return Poll::Ready(Turn::Update(update)); + } session.clone().close( super::error::to_session_code(&crate::SessionError::from(&err)), "invalid request ID", @@ -1643,6 +1652,7 @@ where // side admits is verified. let refused = match update.refused { Some(Error::Decode(err)) => Some((super::token::reason(&err), Error::Decode(err))), + Some(Error::GoingAway) => Some(("going away", Error::GoingAway)), Some(err) => Some(("REQUEST_UPDATE parameters not supported", err)), None if update.authorization_token.is_some() && request_grant.is_none() @@ -2387,9 +2397,12 @@ where let group = { let mut read = std::pin::pin!(read_fetch(&track, start.group, start.object, until, priority)); let mut finished = false; + let mut messages = super::request_stream::Messages::new(self.session.clone(), self.control.client()); kio::wait(|waiter| { let mut cx = waiter.context(); - if super::request_stream::poll_cancel(&mut stream, &mut finished, self.version, &mut cx).is_ready() { + if super::request_stream::poll_cancel(&mut stream, &mut finished, &mut messages, self.version, &mut cx) + .is_ready() + { return Poll::Ready(None); } if gate.poll_denied(waiter).is_ready() || lapsed(waiter) { @@ -2621,13 +2634,16 @@ where let joined = { let mut pending = false; let mut finished = false; + let mut messages = super::request_stream::Messages::new(self.session.clone(), self.control.client()); let mut deadline = crate::time::Deadline::after(&self.runtime, Duration::from_secs(10)); kio::wait(|waiter| { let mut cx = waiter.context(); // The request reader is what the subscriber FINs or resets. The writer // on a draft-14-16 virtual stream reports closed immediately, which is // not a cancellation. - if super::request_stream::poll_cancel(stream, &mut finished, self.version, &mut cx).is_ready() { + if super::request_stream::poll_cancel(stream, &mut finished, &mut messages, self.version, &mut cx) + .is_ready() + { return Poll::Ready(Err(Error::Cancel)); } let joins = self.joins.poll(waiter, |joins| match joins.get(&subscribe_id) { @@ -2742,9 +2758,12 @@ where let info = { let query = track.query(); let mut finished = false; + let mut messages = super::request_stream::Messages::new(self.session.clone(), self.control.client()); kio::wait(|waiter| { let mut cx = waiter.context(); - if super::request_stream::poll_cancel(&mut stream, &mut finished, self.version, &mut cx).is_ready() { + if super::request_stream::poll_cancel(&mut stream, &mut finished, &mut messages, self.version, &mut cx) + .is_ready() + { return Poll::Ready(None); } if gate.poll_denied(waiter).is_ready() { @@ -2937,6 +2956,7 @@ where target, watched, requests, + woken, updates, .. } = ns; @@ -3014,6 +3034,14 @@ where .await?; } } + // Register an idle reader too: GOAWAY can arrive without an update in flight. + if !matches!( + self.version, + Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 + ) && requests.contains_key(suffix) + { + woken.suffixes.lock().unwrap().push(suffix.clone()); + } // The peer can reject a fresh PUBLISH_NAMESPACE or an update, which leaves // no request behind. Record what it actually holds, so a later route change // retries instead of believing the namespace is already advertised. @@ -3099,7 +3127,8 @@ where // Bounded for the same reason the open is: a peer that takes the stream and answers // nothing would park this loop forever, and every withdrawal queued behind it. - let Some((type_id, body)) = self.read_response(&mut request).await? else { + let mut messages = super::request_stream::Messages::new(self.session.clone(), self.control.client()); + let Some((type_id, body)) = self.read_response(&mut request, &mut messages).await? else { tracing::debug!(broadcast = %self.origin.absolute(path), "no answer to the advertisement"); return Ok(Refused::No); }; @@ -3140,6 +3169,7 @@ where requests.insert( suffix, NamespaceRequest { + messages, path: path.clone(), request_id, stream: request, @@ -3287,6 +3317,7 @@ where inflight: &mut VecDeque<(crate::time::Instant, crate::PathOwned)>, woken: &Arc, now: crate::time::Instant, + version: Version, cx: &mut std::task::Context<'_>, ) -> Poll<(crate::PathOwned, Result)> { // Registered before the take, so a wake landing between them is not lost. @@ -3296,18 +3327,27 @@ where let Some(request) = requests.get_mut(&suffix) else { continue; }; - if request.pending.is_none() { + if request.pending.is_none() + && matches!( + version, + Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 + ) { continue; } let waker = request.waker.get_or_insert_with(|| woken.waker(suffix.clone())).clone(); if let Poll::Ready(answer) = request - .stream - .reader - .poll_decode_maybe(&mut std::task::Context::from_waker(&waker)) + .messages + .poll_next(&mut request.stream.reader, &mut std::task::Context::from_waker(&waker)) { // The rest stay woken for the next pass. woken.suffixes.lock().unwrap().append(&mut suffixes); - let answer = answer.map(|answer| answer.map_or(Answer::Ended, Answer::Message)); + let answer = answer.and_then(|answer| { + if answer.is_some() && request.pending.is_none() { + return Err(request.messages.failed(Error::UnexpectedMessage)); + } + Ok(answer.map_or(Answer::Ended, Answer::Message)) + }); + woken.suffixes.lock().unwrap().push(suffix.clone()); return Poll::Ready((suffix, answer)); } } @@ -3446,10 +3486,13 @@ where /// behavior seen a step later: a stream the peer accepts and never answers on holds the /// loop just as effectively as one it never grants. Giving up records nothing, so the /// namespace stays outstanding and the retry re-offers it. - async fn read_response(&self, request: &mut Stream) -> Result, Error> { + async fn read_response( + &self, + request: &mut Stream, + messages: &mut super::request_stream::Messages, + ) -> Result, Error> { let mut read = std::pin::pin!(async { - let type_id = request.reader.varint().await?; - let body: ietf::Body = request.reader.decode().await?; + let super::request_stream::Framed(type_id, body) = messages.message(&mut request.reader).await?; Ok::<_, Error>((type_id, body)) }); let mut timeout = crate::time::Deadline::after(&self.runtime, ADVERTISE_TIMEOUT); @@ -3754,7 +3797,7 @@ where initial: Vec, ) -> Result<(), Error> { let mut finished = false; - let mut goaways = super::request_stream::GoAways::new(self.control.client()); + let mut goaways = super::request_stream::Messages::new(self.session.clone(), self.control.client()); let _withdrawing = self.withdrawal.register(); if self.withdrawal.poll(&kio::Waiter::noop()).is_ready() { return Ok(()); @@ -3825,7 +3868,9 @@ where // Each update in flight is answered on its own stream, so many renew at // once and none holds up the announcements behind it. let now = self.runtime.now(); - if let Poll::Ready((suffix, answer)) = Self::poll_answer(requests, inflight, woken, now, &mut cx) { + if let Poll::Ready((suffix, answer)) = + Self::poll_answer(requests, inflight, woken, now, self.version, &mut cx) + { return Poll::Ready(NamespaceEvent::Answered(suffix, answer)); } // The front is now the earliest update still waiting. @@ -3858,13 +3903,17 @@ where // Only a solicited loop has a stream to close, and its request task closes the // session over a protocol violation. NamespaceEvent::Closed(res) => break res, - NamespaceEvent::Request(update) => { + NamespaceEvent::Request(mut update) => { if let Err(err) = self.control.accept(update.request_id) { - self.session.clone().close( - super::error::to_session_code(&crate::SessionError::from(&err)), - "invalid request ID", - ); - break Err(err); + if matches!(err, Error::GoingAway) { + update.refused = Some(err); + } else { + self.session.clone().close( + super::error::to_session_code(&crate::SessionError::from(&err)), + "invalid request ID", + ); + break Err(err); + } } let refusal = update .refused @@ -5080,6 +5129,7 @@ struct NamespaceRequest { path: crate::PathOwned, request_id: RequestId, stream: Stream, + messages: super::request_stream::Messages, /// The auth the peer holds the request under: the one it opened with, or the one /// its last update carried. Held, so the credential stays presented while it does. auth: Option, @@ -6044,6 +6094,90 @@ mod serve_tests { use crate::lite::test_transport::{Log, ScriptedSession, Sent, SinkSession}; use crate::model::ProduceTest; + #[moq_clock::test] + async fn idle_advertisements_keep_reading_goaways() { + let version = Version::Draft21; + let mut session = ScriptedSession::new(vec![0x10, 0, 2, 0, 0]); + let stream = Stream::open(&mut session, version).await.unwrap(); + let suffix: crate::PathOwned = "room".into(); + let mut requests = HashMap::new(); + requests.insert( + suffix.clone(), + NamespaceRequest { + path: suffix.clone(), + request_id: RequestId(0), + stream, + messages: super::super::request_stream::Messages::new(session.clone(), true), + auth: None, + queued: false, + pending: None, + waker: None, + }, + ); + let woken = Arc::new(Woken::default()); + woken.suffixes.lock().unwrap().push(suffix.clone()); + let mut inflight = VecDeque::new(); + let runtime = crate::time::sim(); + let mut cx = std::task::Context::from_waker(std::task::Waker::noop()); + assert!( + Publisher::::poll_answer( + &mut requests, + &mut inflight, + &woken, + runtime.now(), + version, + &mut cx + ) + .is_pending() + ); + assert!(session.log.closes().is_empty()); + session.push(&[0x10, 0, 2, 0, 0]); + woken.suffixes.lock().unwrap().push(suffix); + assert!(matches!( + Publisher::::poll_answer( + &mut requests, + &mut inflight, + &woken, + runtime.now(), + version, + &mut cx + ), + Poll::Ready((_, Err(Error::ProtocolViolation))) + )); + assert_eq!(session.log.closes()[0].0, 0x03); + } + + #[moq_clock::test] + async fn an_update_after_draft18_goaway_is_refused_without_closing_the_session() { + let version = Version::Draft18; + let h = serve(version); + h.publisher.control.accept(RequestId(0)).unwrap(); + assert_eq!(h.publisher.control.goaway().unwrap(), RequestId(2)); + // REQUEST_UPDATE, Request ID 2, no parameters. + let mut session = ScriptedSession::new(vec![0x02, 0, 2, 2, 0]); + let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut serving = TrackServe::new( + h.session.clone(), + h.track.subscribe(None), + RequestId(0), + version, + ServeRange::default(), + None, + ); + let served = h + .publisher + .run_subscription(&mut stream, &mut serving, &mut false, async {}, None) + .await; + assert!(matches!(served, Some(Served::UpdateFailed(_))), "{served:?}"); + assert!(h.log.closes().is_empty()); + let written = session.log.writes.lock().unwrap().clone(); + let mut bytes = bytes::Bytes::from(written); + let super::super::request_stream::Framed(id, body) = + crate::coding::decode_buf(&mut bytes, version, super::super::request_stream::Framed::decode).unwrap(); + assert_eq!(id, ietf::RequestError::ID); + assert_eq!(body.message::(version).unwrap().error_code, 0x06); + } + fn occurrences(log: &Log, needle: &[u8]) -> usize { let writes = log.writes.lock().unwrap(); writes.windows(needle.len()).filter(|window| *window == needle).count() diff --git a/rs/moq-net/src/ietf/request_stream.rs b/rs/moq-net/src/ietf/request_stream.rs index b2d7c4ee898..f279bc2e540 100644 --- a/rs/moq-net/src/ietf/request_stream.rs +++ b/rs/moq-net/src/ietf/request_stream.rs @@ -17,13 +17,14 @@ pub(super) fn fin_cancels(version: Version) -> bool { pub(super) fn poll_cancel( stream: &mut Stream, finished: &mut bool, + messages: &mut Messages, version: Version, cx: &mut Context<'_>, ) -> Poll> { if !*finished { let closed = match version { Version::Draft14 | Version::Draft15 | Version::Draft16 => poll_legacy_end(stream, version, cx), - _ => stream.reader.poll_closed(cx), + _ => messages.poll_end(&mut stream.reader, cx), }; match closed { Poll::Ready(Ok(())) if !fin_cancels(version) => *finished = true, @@ -204,6 +205,84 @@ impl GoAways { } Ok(()) } + pub fn poll_next( + &mut self, + reader: &mut crate::coding::Reader, + cx: &mut Context<'_>, + ) -> Poll, Error>> { + loop { + match ready!(reader.poll_decode_maybe::>(cx))? { + Some(Next::GoAway { redirect }) => self.receive(redirect)?, + Some(Next::Message(message)) => return Poll::Ready(Ok(Some(message))), + None => return Poll::Ready(Ok(None)), + } + } + } +} + +/// The messages on one request stream, keeping GOAWAY validation across response phases. +pub(super) struct Messages { + session: S, + goaways: GoAways, +} + +impl Messages { + pub fn new(session: S, client: bool) -> Self { + Self { + session, + goaways: GoAways::new(client), + } + } + + pub fn failed(&mut self, err: Error) -> Error { + if super::subscriber::is_protocol_violation(&err) { + self.session.close( + super::error::to_session_code(&crate::SessionError::from(&err)), + &err.to_string(), + ); + } + err + } + + pub fn receive(&mut self, redirect: bool) -> Result<(), Error> { + self.goaways.receive(redirect).map_err(|err| self.failed(err)) + } + + /// Read complete frames, consuming at most one GOAWAY without ending the request. + pub fn poll_next( + &mut self, + reader: &mut crate::coding::Reader, + cx: &mut Context<'_>, + ) -> Poll, Error>> { + self.goaways.poll_next(reader, cx).map_err(|err| self.failed(err)) + } + + pub async fn next( + &mut self, + reader: &mut crate::coding::Reader, + ) -> Result, Error> { + std::future::poll_fn(|cx| self.poll_next(reader, cx)).await + } + + pub async fn message( + &mut self, + reader: &mut crate::coding::Reader, + ) -> Result { + self.next(reader) + .await? + .ok_or_else(|| self.failed(Error::ProtocolViolation)) + } + + pub fn poll_end( + &mut self, + reader: &mut crate::coding::Reader, + cx: &mut Context<'_>, + ) -> Poll> { + match ready!(self.poll_next(reader, cx))? { + None => Poll::Ready(Ok(())), + Some(_) => Poll::Ready(Err(self.failed(Error::UnexpectedMessage))), + } + } } /// Refuse a modern request with its complete REQUEST_ERROR, then finish the response. @@ -224,7 +303,8 @@ pub(super) struct Update { /// The first Request ID: the update's own on drafts 14-16, which their answer names. pub(super) request_id: super::RequestId, pub(super) priority: Option, - /// Why the update is refused, which fails the subscription: [`Error::Unsupported`], a + /// Why the update is refused, which fails the subscription: [`Error::GoingAway`], + /// [`Error::Unsupported`], a /// [`DecodeError::MalformedAuthToken`] for tokens that repeat, or a /// [`DecodeError::MultipleAuthTokens`] for more than one token. pub(super) refused: Option, @@ -396,6 +476,60 @@ impl Decode for NamespaceUpdate { mod tests { use super::*; + #[moq_clock::test] + async fn request_messages_keep_goaway_state_across_response_phases() { + use crate::lite::test_transport::ScriptedSession; + for version in [Version::Draft18, Version::Draft19, Version::Draft21, Version::Draft22] { + // GOAWAY, REQUEST_OK, then another GOAWAY on the same stream. + let script = vec![0x10, 0, 2, 0, 0, 0x07, 0, 0, 0x10, 0, 2, 0, 0]; + let mut session = ScriptedSession::eof(script); + let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut messages = Messages::new(session.clone(), true); + assert_eq!(messages.message(&mut stream.reader).await.unwrap().0, 0x07); + assert!(matches!( + messages.message(&mut stream.reader).await, + Err(Error::ProtocolViolation) + )); + assert_eq!(session.log.closes()[0].0, 0x03, "{version}"); + } + } + + #[moq_clock::test] + async fn a_goaway_does_not_cancel_a_pending_request() { + use crate::lite::test_transport::ScriptedSession; + for version in [Version::Draft18, Version::Draft21, Version::Draft22] { + let mut session = ScriptedSession::new(vec![0x10, 0, 2, 0, 0]); + let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut messages = Messages::new(session.clone(), false); + let mut finished = false; + assert!( + futures::poll!(std::future::poll_fn(|cx| poll_cancel( + &mut stream, + &mut finished, + &mut messages, + version, + cx, + ))) + .is_pending(), + "{version}" + ); + assert!(session.log.closes().is_empty()); + // A second GOAWAY is still session-fatal while the response is pending. + session.push(&[0x10, 0, 2, 0, 0]); + assert!(matches!( + futures::poll!(std::future::poll_fn(|cx| poll_cancel( + &mut stream, + &mut finished, + &mut messages, + version, + cx, + ))), + Poll::Ready(Err(Error::ProtocolViolation)) + )); + assert_eq!(session.log.closes()[0].0, 0x03); + } + } + /// On drafts 14-16 an update aimed at a request that applies none, such as a FETCH or /// SUBSCRIBE_NAMESPACE, keeps the request open. Drafts 15 and 16 refuse it with a /// REQUEST_ERROR naming the update, and a later cancellation still ends the request. @@ -415,10 +549,12 @@ mod tests { let mut session = ScriptedSession::new(update); let mut stream = Stream::open(&mut session, version).await.unwrap(); let mut finished = false; + let mut messages = Messages::new(session.clone(), false); let polled = futures::poll!(std::future::poll_fn(|cx| poll_cancel( &mut stream, &mut finished, + &mut messages, version, cx ))); @@ -440,6 +576,7 @@ mod tests { let polled = futures::poll!(std::future::poll_fn(|cx| poll_cancel( &mut stream, &mut finished, + &mut messages, version, cx ))); diff --git a/rs/moq-net/src/ietf/session.rs b/rs/moq-net/src/ietf/session.rs index dab78786fa1..6b79e944810 100644 --- a/rs/moq-net/src/ietf/session.rs +++ b/rs/moq-net/src/ietf/session.rs @@ -389,37 +389,24 @@ where res } _ => { - // Send SETUP and keep the stream alive: it is also our GOAWAY channel. - let setup = { - let runtime = runtime.clone(); - let session = session.clone(); - let goaway = goaway.clone(); - let extensions = crate::setup::Extensions { + let control = Control::new(None, client).with_history(limits.requests()); + // Send SETUP and retain its writer for the session's lifetime. + let setup = run_setup( + runtime.clone(), + session.clone(), + version, + path, + authority, + self_origin, + cost, + crate::setup::Extensions { auth: extensions.auth && auth.supported(), ..extensions - }; - async move { - if let Err(err) = run_setup( - runtime, - session, - version, - client, - path, - authority, - self_origin, - cost, - extensions, - goaway, - ) - .await - { - tracing::warn!(%err, "setup send error"); - } - std::future::pending::<()>().await; - } - }; + }, + goaway.clone(), + control.clone(), + ); - let control = Control::new(None, client).with_history(limits.requests()); // Only the dialing side fails loud on a publication outside its grant: a // server's publish origin is everything the peer may read, not what it // intends to push. @@ -579,8 +566,8 @@ where if let Poll::Ready(err) = waiter.poll_future(enforce.as_mut()) { return Poll::Ready(Err(err)); } - if waiter.poll_future(setup.as_mut()).is_ready() { - return Poll::Ready(Ok(())); + if let Poll::Ready(result) = waiter.poll_future(setup.as_mut()) { + return Poll::Ready(result); } if task_set.poll(waiter).is_ready() { return Poll::Ready(Ok(())); @@ -783,13 +770,13 @@ async fn run_setup( runtime: crate::time::Deadlines, mut session: S, version: Version, - client: bool, path: Option, authority: Option, self_origin: Hop, cost: Option, extensions: crate::setup::Extensions, goaway: crate::goaway::Protocol, + control: Control, ) -> Result<(), Error> { let outer_version = crate::Version::Ietf(version); @@ -819,7 +806,10 @@ async fn run_setup( request_update::into_setup(&mut parameters, version); let parameters = parameters.encode_bytes(version)?; - writer.encode(&setup::Setup { parameters }).await?; + writer + .encode(&setup::Setup { parameters }) + .await + .map_err(control_stream_error)?; // Hold the writer alive until the session closes, sending a GOAWAY if the // drain trigger fires meanwhile. The trigger resolves `None` when the session @@ -828,29 +818,42 @@ async fn run_setup( let payload = kio::wait(|waiter| { let mut cx = waiter.context(); if session.poll_closed(&mut cx).is_ready() { - return std::task::Poll::Ready(None); + return std::task::Poll::Ready(Ok(None)); + } + if writer.poll_closed(&mut cx).is_ready() { + return std::task::Poll::Ready(Err(Error::ProtocolViolation)); } - goaway.poll_triggered(waiter) + goaway.poll_triggered(waiter).map(Ok) }) - .await; + .await?; if let Some(payload) = payload { let timeout_ms = payload.timeout.map(|d| d.as_millis() as u64).unwrap_or(0); let msg = ietf::GoAway { new_session_uri: std::borrow::Cow::Borrowed(payload.uri.as_ref()), timeout: timeout_ms, - // We track no per-request progress, so name the receiver's first Request ID: a - // client's are even and a server's odd, so a client sends 1 and a server 0. - request_id: Some(ietf::RequestId(u64::from(client))), + request_id: (version == Version::Draft18).then(|| control.goaway()).transpose()?, }; // Frame as [type_id varint][size u16][body], the same shape as the // control-stream messages this channel otherwise carries. let mut writer = writer.with_version(version); - writer.encode_message(&msg).await?; + writer.encode_message(&msg).await.map_err(control_stream_error)?; - crate::goaway::enforce(&runtime, &mut session, payload.timeout).await; - session.closed().await; + let mut draining = std::pin::pin!(async { + crate::goaway::enforce(&runtime, &mut session, payload.timeout).await; + session.closed().await; + }); + kio::wait(|waiter| { + if waiter.poll_future(draining.as_mut()).is_ready() { + return std::task::Poll::Ready(Ok(())); + } + if writer.poll_closed(&mut waiter.context()).is_ready() { + return std::task::Poll::Ready(Err(Error::ProtocolViolation)); + } + std::task::Poll::Pending + }) + .await?; writer.finish().ok(); } else { writer.finish().ok(); @@ -1321,7 +1324,27 @@ impl Bidi { | auth::Auth::ID ) { let request_id = RequestId::decode(&mut data.decoder(version), version)?; - publisher.control.accept(request_id)?; + match publisher.control.accept(request_id) { + Err(Error::GoingAway) => { + return super::request_stream::reject( + stream, + ietf::RequestError { + request_id: None, + error_code: super::error::request::to_code( + &Error::GoingAway, + super::error::request::Kind::Subscribe, + version, + ), + reason_phrase: "going away".into(), + retry_interval: 0, + }, + ) + .await; + } + result => { + result?; + } + } } match id { // Draft-16 moved SUBSCRIBE_NAMESPACE to its own stream, past the control stream @@ -1365,25 +1388,25 @@ impl Bidi { } } -/// Monitor the peer's SETUP stream for a GOAWAY, surfacing it through -/// [`crate::Session::goaway`], then hold the stream until it FINs. -/// -/// Fails only when the peer broke the protocol, which closes the session: an unknown or -/// malformed message, a second GOAWAY, or a draft-18 Request ID of the wrong parity. The -/// stream failing on its own, such as a reset, leaves the session up. +/// Monitor the peer's SETUP stream for GOAWAY until the session closes. +/// A FIN or reset of this control stream is a protocol violation. async fn run_goaway( reader: Reader, version: Version, client: bool, goaway: crate::goaway::Protocol, ) -> Result<(), Error> { - match read_goaways(reader, version, client, goaway).await { - Err(err) if is_protocol_violation(&err) => Err(err), - Err(err) => { - tracing::debug!(%err, "SETUP stream failed"); - Ok(()) - } - Ok(()) => Ok(()), + read_goaways(reader, version, client, goaway) + .await + .map_err(control_stream_error) +} + +/// A control stream cannot end independently of its session. +pub(super) fn control_stream_error(err: Error) -> Error { + if is_protocol_violation(&err) || matches!(err, Error::Session(_) | Error::Encode(_)) { + err + } else { + Error::ProtocolViolation } } @@ -1437,7 +1460,7 @@ async fn read_goaways( timeout, })?; } - Ok(()) + Err(Error::ProtocolViolation) } /// Closes the auth handle when the session driver ends without finishing, releasing @@ -3138,10 +3161,11 @@ mod tests { /// The session code a client closes with after reading `stream` as the server's SETUP /// stream, or `None` while the session stays up. - async fn client_reads_setup_stream(version: Version, stream: Vec) -> Option { + async fn client_reads_setup_stream(version: Version, stream: Vec, fin: bool) -> Option { let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()).with_incoming_unis(vec![stream]); - // The peer FINs its stream after the script, so a message it cuts short is malformed. - session.close(crate::lite::test_transport::Close::Fin); + if fin { + session.close(crate::lite::test_transport::Close::Fin); + } let (_, result) = drive_unis(version, session, None, None).await; result.map(|result| SessionError::from(&result.expect_err("the loop ended without an error"))) } @@ -3156,7 +3180,7 @@ mod tests { ] { let mut params = ietf::Parameters::default(); params.set_bytes(param, b"a".to_vec()); - let closed = client_reads_setup_stream(version, setup_stream(version, params, &[])).await; + let closed = client_reads_setup_stream(version, setup_stream(version, params, &[]), false).await; assert_eq!(closed, Some(expected), "{version:?}"); } } @@ -3176,7 +3200,7 @@ mod tests { ] { let mut params = ietf::Parameters::default(); params.set_bytes(ietf::ParameterBytes::AuthorizationToken, token.to_vec()); - let closed = client_reads_setup_stream(version, setup_stream(version, params, &[])).await; + let closed = client_reads_setup_stream(version, setup_stream(version, params, &[]), false).await; assert_eq!(closed, expected, "{version:?} {token:?}"); } } @@ -3224,12 +3248,39 @@ mod tests { ), ] { let stream = setup_stream(version, ietf::Parameters::default(), after); - let closed = client_reads_setup_stream(version, stream).await; + let closed = client_reads_setup_stream(version, stream, why == "a body cut short by FIN").await; assert_eq!(closed, expected, "{version:?}: {why}"); } } } + #[moq_clock::test] + async fn a_control_stream_fin_or_reset_is_a_protocol_violation() { + use crate::lite::test_transport::{Close, DeadStreamSession, ScriptedSession}; + use crate::transport::poll::Session as _; + for version in [Version::Draft17, Version::Draft18, Version::Draft21, Version::Draft22] { + let session = ScriptedSession::new(Vec::new()).with_incoming_unis(vec![setup_stream( + version, + ietf::Parameters::default(), + &[], + )]); + session.close(Close::Fin); + let (_, result) = drive_unis(version, session, None, None).await; + assert!( + matches!(result, Some(Err(ref err)) if SessionError::from(err) == SessionError::ProtocolViolation), + "{version:?}: {result:?}" + ); + + let mut session = DeadStreamSession::unis(1); + let recv = session.accept_uni().await.unwrap(); + let (_handle, protocol) = crate::goaway::Handle::new(false); + let err = run_goaway(Reader::new(recv, version), version, true, protocol) + .await + .unwrap_err(); + assert_eq!(SessionError::from(&err), SessionError::ProtocolViolation, "{version:?}"); + } + } + /// A second GOAWAY arriving with the first closes the session before the first surfaces, /// so an application leaving over it cannot close first, without our code. #[moq_clock::test] @@ -3318,37 +3369,40 @@ mod tests { (None, Some(SessionError::ProtocolViolation)), ] { let stream = setup_stream(VERSION, ietf::Parameters::default(), &goaway(VERSION, request_id)); - let closed = client_reads_setup_stream(VERSION, stream).await; + let closed = client_reads_setup_stream(VERSION, stream, false).await; assert_eq!(closed, expected, "Request ID {request_id:?}"); } } - /// We send a draft-18 GOAWAY naming the receiver's first Request ID: odd from a client, - /// even from a server, so a strict peer does not close over its parity. + /// Draft-18 GOAWAY carries the admission cutoff, preserving the peer's parity. #[moq_clock::test] - async fn our_draft18_goaway_names_the_receivers_parity() { + async fn our_draft18_goaway_names_the_admitted_request_cutoff() { const VERSION: Version = Version::Draft18; for client in [false, true] { let session = crate::lite::test_transport::ScriptedSession::new(Vec::new()); let log = session.log.clone(); + let control = Control::new(None, client); + let first = u64::from(client); + control.accept(RequestId(first)).unwrap(); + control.accept(RequestId(first + 4)).unwrap(); let (handle, goaway_protocol) = crate::goaway::Handle::new(!client); - let _setup = moq_clock::sim::spawn(run_setup( + let mut setup = std::pin::pin!(run_setup( crate::time::sim(), session, VERSION, - client, None, None, Hop::new(1).unwrap(), None, Default::default(), goaway_protocol, + control.clone(), )); handle.producer().send(crate::goaway::Goaway::new()).unwrap(); - moq_clock::sleep(std::time::Duration::from_millis(1)).await; - - let sent = goaway(VERSION, Some(u64::from(client))); + assert!(futures::poll!(setup.as_mut()).is_pending()); + let sent = goaway(VERSION, Some(first + 6)); assert_eq!(occurrences(&log, &sent), 1, "client={client}"); + assert!(matches!(control.accept(RequestId(first + 6)), Err(Error::GoingAway))); } } diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index 3c9b053c66e..fe72f70afa0 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -1088,8 +1088,8 @@ where tracing::debug!(%prefix, "subscribe_namespace sent"); // Read response - let type_id = stream.reader.varint().await?; - let body: ietf::Body = stream.reader.decode().await?; + let mut messages = super::request_stream::Messages::new(self.session.clone(), self.control.client()); + let super::request_stream::Framed(type_id, body) = messages.message(&mut stream.reader).await?; let mut data = body.decoder(self.version); let count = match type_id { @@ -1139,7 +1139,14 @@ where // This is what moq-lite already does, where the equivalent map is a local whose // guards drop. let res = self - .run_namespace_entries(&mut stream, &prefix, &peer, &mut live, Initial { initial, snapshot }) + .run_namespace_entries( + &mut stream, + &prefix, + &peer, + &mut live, + Initial { initial, snapshot }, + &mut messages, + ) .await; for path in live { let _ = self.stop_announce(path, false); @@ -1159,19 +1166,19 @@ where peer: &cluster::Peer, live: &mut std::collections::HashSet, mut initial: Initial, + messages: &mut super::request_stream::Messages, ) -> Result<(), Error> { loop { // Every counted NAMESPACE is in the origin by now, dropped ones included. if initial.initial == 0 { initial.snapshot = None; } - let type_id = match stream.reader.varint_maybe().await? { - Some(id) => id, + let super::request_stream::Framed(type_id, body) = match messages.next(&mut stream.reader).await? { + Some(message) => message, // A stream ending inside the counted set cut it short. None if initial.initial > 0 => return Err(Error::ProtocolViolation), None => break, }; - let body: ietf::Body = stream.reader.decode().await?; let mut data = body.decoder(self.version); match type_id { @@ -1608,6 +1615,7 @@ where // does, and the caller's guard ends it when the old grant does. Messages behind a // pending verdict wait in `renewal`, handled in order once it resolves. let mut renewal = request_update::Renewal::<(u64, ietf::Body)>::default(); + let mut messages = super::request_stream::Messages::new(self.session.clone(), self.control.client()); // Draft-19+ only: the peer finished its send direction, which does not withdraw the // advertisement there, so stop reading and keep watching the writer. let mut finished = false; @@ -1647,10 +1655,7 @@ where // Keep reading while a verdict is pending, so a withdrawal still ends the // announce: a buffered update must not mask a later terminal. if !finished { - return match stream - .reader - .poll_decode_maybe::(&mut cx) - { + return match messages.poll_next(&mut stream.reader, &mut cx) { Poll::Ready(Ok(Some(super::request_stream::Framed(id, body)))) => { Poll::Ready(Turn::Message(id, body)) } @@ -1671,7 +1676,18 @@ where // Its request ID is spent on arrival, so one dropped with the queue stays spent. if self.version != Version::Draft16 { let update_id = ietf::RequestId::decode(&mut body.decoder(self.version), self.version)?; - self.spend(update_id)?; + if let Err(err) = self.spend(update_id) { + if matches!(err, Error::GoingAway) { + return Ok(Withdraw::Cancel( + update_id, + crate::auth::Refusal { + error: err, + reason: "going away".to_string(), + }, + )); + } + return Err(err); + } spent.insert(update_id); } // Decoded on arrival too, so a session-fatal update still closes the session @@ -1771,8 +1787,20 @@ where // adapter already spent it when it routed the update here, and a queued one was // spent when it arrived. let update_id = ietf::RequestId::decode(&mut body.decoder(self.version), self.version)?; - if self.version != Version::Draft16 && !spent.remove(&update_id) { - self.spend(update_id)?; + if self.version != Version::Draft16 + && !spent.remove(&update_id) + && let Err(err) = self.spend(update_id) + { + if matches!(err, Error::GoingAway) { + return Ok(Withdraw::Cancel( + update_id, + crate::auth::Refusal { + error: err, + reason: "going away".to_string(), + }, + )); + } + return Err(err); } let msg = match ietf::PublishNamespaceUpdate::decode_msg(&mut data, self.version) { // A token refusal rejects the update, which withdraws the advertisement as @@ -1966,6 +1994,9 @@ where /// Spend a peer's request ID, closing the session on one it already used. fn spend(&self, id: RequestId) -> Result<(), Error> { if let Err(err) = self.control.accept(id) { + if matches!(err, Error::GoingAway) { + return Err(err); + } self.session.clone().close( super::error::to_session_code(&crate::SessionError::from(&err)), "invalid request ID", @@ -2708,9 +2739,10 @@ where Gone, } + let mut messages = super::request_stream::Messages::new(self.session.clone(), self.control.client()); let mut retired = false; let setup = { - let mut response = std::pin::pin!(self.read_subscribe_response(&mut stream)); + let mut response = std::pin::pin!(self.read_subscribe_response(&mut stream, &mut messages)); loop { let setup = kio::wait(|waiter| { let response = waiter.poll_future(response.as_mut()); @@ -2979,7 +3011,12 @@ where // Nobody subscribing at all (only fetches asked) needs no subscription. let mut subscribed = track.subscription().is_some(); let idle = { - let mut done = std::pin::pin!(Self::read_publish_done(&mut stream.reader, self.version, &unanswered)); + let mut done = std::pin::pin!(Self::read_publish_done( + &mut stream.reader, + self.version, + &unanswered, + &mut messages + )); loop { let end = kio::wait(|waiter| { if gate.poll_denied(waiter).is_ready() { @@ -3272,17 +3309,15 @@ where reader: &mut Reader, version: Version, unanswered: &AtomicU64, + messages: &mut super::request_stream::Messages, ) -> Result { // A refused update is followed by PUBLISH_DONE, which ends the subscription. Its // count stays, so no further update goes out meanwhile, and no answer is owed. let mut refused = false; loop { - let type_id = match reader.varint_maybe().await? { - Some(type_id) => type_id, - None => return Err(Error::ProtocolViolation), - }; + let super::request_stream::Framed(type_id, body) = messages.message(reader).await?; if type_id == ietf::PublishDone::ID { - let msg: ietf::PublishDone = reader.decode().await?; + let msg: ietf::PublishDone = body.message(version)?; tracing::debug!(message = ?msg, "received publish done"); msg.end(version)?; return Ok(msg.stream_count); @@ -3292,7 +3327,6 @@ where if !answer { return Err(Error::UnexpectedMessage); } - let body: ietf::Body = reader.decode().await?; let mut data = body.decoder(version); match type_id { ietf::RequestOk::ID => { @@ -3510,8 +3544,9 @@ where }) .map(drop) }; + let mut messages = super::request_stream::Messages::new(self.session.clone(), self.control.client()); let accepted = { - let mut response = std::pin::pin!(self.read_fetch_response(&mut stream)); + let mut response = std::pin::pin!(self.read_fetch_response(&mut stream, &mut messages)); kio::wait(|waiter| { if cancelled(waiter).is_ready() { return Poll::Ready(false); @@ -3524,7 +3559,32 @@ where }; if accepted { // The request stays open while the subscription still needs its fill. - kio::wait(cancelled).await; + let mut finished = false; + let mut failed = false; + kio::wait(|waiter| { + if !finished { + let mut cx = waiter.context(); + let ended = match self.version { + Version::Draft14 | Version::Draft15 | Version::Draft16 => { + super::request_stream::poll_legacy_end(&mut stream, self.version, &mut cx) + } + _ => messages.poll_end(&mut stream.reader, &mut cx), + }; + match ended { + Poll::Ready(Ok(())) => finished = true, + Poll::Ready(Err(_)) => { + failed = true; + return Poll::Ready(()); + } + Poll::Pending => {} + } + } + cancelled(waiter) + }) + .await; + if failed { + settle_join_live(&fill, live); + } } else { settle_join_live(&fill, live); } @@ -3534,9 +3594,12 @@ where /// `true` when the publisher answered FETCH_OK. A FETCH_ERROR / REQUEST_ERROR is a /// refusal, not a session error: the live subscription continues. - async fn read_fetch_response(&self, stream: &mut Stream) -> Result { - let type_id = stream.reader.varint().await?; - let body: ietf::Body = stream.reader.decode().await?; + async fn read_fetch_response( + &self, + stream: &mut Stream, + messages: &mut super::request_stream::Messages, + ) -> Result { + let super::request_stream::Framed(type_id, body) = messages.message(&mut stream.reader).await?; let mut data = body.decoder(self.version); match type_id { @@ -3556,10 +3619,13 @@ where } } - async fn read_subscribe_response(&self, stream: &mut Stream) -> Result, Error> { + async fn read_subscribe_response( + &self, + stream: &mut Stream, + messages: &mut super::request_stream::Messages, + ) -> Result, Error> { // Read type_id + size + body from the stream - let type_id = stream.reader.varint().await?; - let body: ietf::Body = stream.reader.decode().await?; + let super::request_stream::Framed(type_id, body) = messages.message(&mut stream.reader).await?; let mut data = body.decoder(self.version); match type_id { @@ -3717,8 +3783,8 @@ where /// Read the answer to a TRACK_STATUS: TRACK_STATUS_OK, or the publisher's refusal as an /// error. async fn read_track_status_response(&self, stream: &mut Stream) -> Result { - let type_id = stream.reader.varint().await?; - let body: ietf::Body = stream.reader.decode().await?; + let mut messages = super::request_stream::Messages::new(self.session.clone(), self.control.client()); + let super::request_stream::Framed(type_id, body) = messages.message(&mut stream.reader).await?; let mut data = body.decoder(self.version); let code = match type_id { @@ -4762,11 +4828,12 @@ where Ok::<_, Error>(()) } .await; + let mut messages = super::request_stream::Messages::new(self.session.clone(), self.control.client()); let mut retired = false; let res = match res { Err(err) => Some(Err(err)), Ok(()) => { - let mut response = std::pin::pin!(self.read_group_fetch_response(&mut stream)); + let mut response = std::pin::pin!(self.read_group_fetch_response(&mut stream, &mut messages)); kio::wait(|waiter| { let response = waiter.poll_future(response.as_mut()); if let Poll::Ready(Err(err)) = response { @@ -4897,7 +4964,7 @@ where Version::Draft14 | Version::Draft15 | Version::Draft16 => { super::request_stream::poll_legacy_end(&mut stream, self.version, &mut cx) } - _ => stream.reader.poll_closed(&mut cx), + _ => messages.poll_end(&mut stream.reader, &mut cx), }; match closed { Poll::Ready(Err(err)) => return Poll::Ready(Some(err)), @@ -4957,9 +5024,12 @@ where } /// Read the answer to a group FETCH: FETCH_OK, or the publisher's refusal as an error. - async fn read_group_fetch_response(&self, stream: &mut Stream) -> Result { - let type_id = stream.reader.varint().await?; - let body: ietf::Body = stream.reader.decode().await?; + async fn read_group_fetch_response( + &self, + stream: &mut Stream, + messages: &mut super::request_stream::Messages, + ) -> Result { + let super::request_stream::Framed(type_id, body) = messages.message(&mut stream.reader).await?; let mut data = body.decoder(self.version); match type_id { @@ -5544,8 +5614,13 @@ mod tests { let mut session = ScriptedSession::eof(responses); let (_, recv) = session.open_bi(Default::default()).await.unwrap(); let mut reader = Reader::new(recv, Version::Draft19); - let result = - Subscriber::::read_publish_done(&mut reader, Version::Draft19, &AtomicU64::new(0)).await; + let result = Subscriber::::read_publish_done( + &mut reader, + Version::Draft19, + &AtomicU64::new(0), + &mut crate::ietf::request_stream::Messages::new(session.clone(), true), + ) + .await; if clean { assert_eq!(result.unwrap(), 0); } else { From 5fc9ec4001ee6c840492d5be5a6efd537d305d6e Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Mon, 19 Oct 2026 13:35:57 -0700 Subject: [PATCH 3/8] fix(net): preserve GOAWAY state through subscription completion Co-Authored-By: GPT-6.1-Sol --- rs/moq-net/src/ietf/publisher.rs | 208 +++++++++++++++++++++++-------- 1 file changed, 156 insertions(+), 52 deletions(-) diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index f1806eb7bfa..b360d1429b0 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -1317,6 +1317,7 @@ where &mut stream, &mut track_serve, &mut request_finished, + &mut goaways, fill, request_grant.clone(), ) @@ -1434,6 +1435,7 @@ where stream: &mut Stream, serve: &mut TrackServe, finished: &mut bool, + goaways: &mut super::request_stream::Messages, fill: impl std::future::Future, request_grant: Option, ) -> Option { @@ -1451,7 +1453,6 @@ where // carry no Request ID, so they must go out in the order the updates arrived. The stash is // a FIFO bounded by MAX_REQUEST_UPDATES (counting the one being verified). let mut renewal = request_update::Renewal::::default(); - let mut goaways = super::request_stream::Messages::new(self.session.clone(), self.control.client()); // What one turn of the loop resolved to. enum Turn { @@ -6156,6 +6157,7 @@ mod serve_tests { // REQUEST_UPDATE, Request ID 2, no parameters. let mut session = ScriptedSession::new(vec![0x02, 0, 2, 2, 0]); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -6166,7 +6168,7 @@ mod serve_tests { ); let served = h .publisher - .run_subscription(&mut stream, &mut serving, &mut false, async {}, None) + .run_subscription(&mut stream, &mut serving, &mut false, &mut goaways, async {}, None) .await; assert!(matches!(served, Some(Served::UpdateFailed(_))), "{served:?}"); assert!(h.log.closes().is_empty()); @@ -6178,6 +6180,56 @@ mod serve_tests { assert_eq!(body.message::(version).unwrap().error_code, 0x06); } + #[moq_clock::test] + async fn a_subscription_keeps_its_goaway_count_until_the_final_marker() { + for version in [Version::Draft18, Version::Draft22] { + let h = serve(version); + let mut session = ScriptedSession::new(vec![0x10, 0, 2, 0, 0]); + let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut serving = TrackServe::new( + h.session.clone(), + h.track.subscribe(None), + RequestId(0), + version, + ServeRange::default(), + None, + ); + let mut finished = false; + let mut goaways = super::super::request_stream::Messages::new(h.session.clone(), false); + { + let run = h.publisher.run_subscription( + &mut stream, + &mut serving, + &mut finished, + &mut goaways, + async {}, + None, + ); + let mut run = std::pin::pin!(run); + assert!(futures::poll!(run.as_mut()).is_pending()); + h.track.finish().unwrap(); + assert!(matches!(run.await, Some(Served::Track(Ok(())))), "{version}"); + } + // The same reader now watches cancellation while the final marker waits for credit. + session.push(&[0x10, 0, 2, 0, 0]); + let mut cx = std::task::Context::from_waker(std::task::Waker::noop()); + assert!( + matches!( + super::super::request_stream::poll_cancel( + &mut stream, + &mut finished, + &mut goaways, + version, + &mut cx + ), + Poll::Ready(Err(Error::ProtocolViolation)) + ), + "{version}" + ); + assert_eq!(h.log.closes()[0].0, 0x03, "{version}"); + } + } + fn occurrences(log: &Log, needle: &[u8]) -> usize { let writes = log.writes.lock().unwrap(); writes.windows(needle.len()).filter(|window| *window == needle).count() @@ -6246,6 +6298,8 @@ mod serve_tests { let h = serve(version); let mut session = ScriptedSession::per_stream_eof(vec![vec![]]); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = + super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -6255,11 +6309,14 @@ mod serve_tests { None, ); let mut finished = false; - let mut run = - std::pin::pin!( - h.publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None,) - ); + let mut run = std::pin::pin!(h.publisher.run_subscription( + &mut stream, + &mut serving, + &mut finished, + &mut goaways, + async {}, + None, + )); assert_eq!( futures::poll!(run.as_mut()).is_ready(), super::super::request_stream::fin_cancels(version), @@ -6292,6 +6349,8 @@ mod serve_tests { let h = serve(version); let mut session = ScriptedSession::per_stream_reset(vec![vec![]]); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = + super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -6301,9 +6360,9 @@ mod serve_tests { None, ); let mut finished = false; - let run = h - .publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None); + let run = + h.publisher + .run_subscription(&mut stream, &mut serving, &mut finished, &mut goaways, async {}, None); assert!(futures::poll!(std::pin::pin!(run)).is_ready(), "{version}"); } } @@ -6377,6 +6436,7 @@ mod serve_tests { let h = serve(version); let mut session = ScriptedSession::per_stream(vec![vec![0x02, 0, 4, 2, 1, 0x20, 10, 0x02, 0, 2, 4, 0]]); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -6386,11 +6446,14 @@ mod serve_tests { None, ); let mut finished = false; - let mut run = - std::pin::pin!( - h.publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None,) - ); + let mut run = std::pin::pin!(h.publisher.run_subscription( + &mut stream, + &mut serving, + &mut finished, + &mut goaways, + async {}, + None, + )); assert!(futures::poll!(run.as_mut()).is_pending()); assert_eq!(h.track.subscription().unwrap().priority, 245); assert_eq!(occurrences(&session.log, &[0x07, 0, 1, 0]), 2); @@ -6408,6 +6471,7 @@ mod serve_tests { // subscription's stream past it. let queue = PriorityQueue::default(); let _other = queue.insert(Priority::new(100, 1, 0)); + let mut goaways = super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -6418,11 +6482,14 @@ mod serve_tests { ) .ranked(queue); let mut finished = false; - let mut run = - std::pin::pin!( - h.publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None,) - ); + let mut run = std::pin::pin!(h.publisher.run_subscription( + &mut stream, + &mut serving, + &mut finished, + &mut goaways, + async {}, + None, + )); // An unfinished group keeps its stream open. let mut group = h.track.create_group(group::Info { sequence: 0 }).unwrap(); @@ -6448,6 +6515,7 @@ mod serve_tests { // FORWARD=0 asks to pause delivery, which this publisher does not support. let mut session = ScriptedSession::per_stream(vec![vec![0x02, 0, 4, 2, 1, 0x10, 0]]); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -6459,7 +6527,7 @@ mod serve_tests { let mut finished = false; let served = h .publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None) + .run_subscription(&mut stream, &mut serving, &mut finished, &mut goaways, async {}, None) .await; assert!( matches!(served, Some(Served::UpdateFailed(Error::Unsupported))), @@ -6674,6 +6742,7 @@ mod serve_tests { let h = serve(version); let mut session = ScriptedSession::per_stream(vec![vec![]]); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -6686,7 +6755,7 @@ mod serve_tests { let mut finished = false; let served = h .publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None) + .run_subscription(&mut stream, &mut serving, &mut finished, &mut goaways, async {}, None) .await .expect("the track's error ends the subscription"); assert!(matches!(served, Served::Track(Err(Error::Unsupported))), "{served:?}"); @@ -6831,6 +6900,8 @@ mod serve_tests { let h = serve(version); let mut session = ScriptedSession::new(legacy_update(version, 10, true)); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = + super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -6840,11 +6911,14 @@ mod serve_tests { None, ); let mut finished = false; - let mut run = - std::pin::pin!( - h.publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None,) - ); + let mut run = std::pin::pin!(h.publisher.run_subscription( + &mut stream, + &mut serving, + &mut finished, + &mut goaways, + async {}, + None, + )); assert!(futures::poll!(run.as_mut()).is_pending(), "{version}: update ended it"); assert_eq!(h.track.subscription().unwrap().priority, 245, "{version}"); @@ -6874,6 +6948,8 @@ mod serve_tests { let h = serve(version); let mut session = ScriptedSession::new(legacy_update(version, 10, false)); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = + super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -6885,7 +6961,7 @@ mod serve_tests { let mut finished = false; let served = h .publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None) + .run_subscription(&mut stream, &mut serving, &mut finished, &mut goaways, async {}, None) .await; assert!( matches!(served, Some(Served::UpdateFailed(Error::Unsupported))), @@ -6996,6 +7072,8 @@ mod serve_tests { ); let mut session = ScriptedSession::new(new_group_update(version, 10, 9)); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = + super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -7005,11 +7083,14 @@ mod serve_tests { None, ); let mut finished = false; - let mut run = - std::pin::pin!( - h.publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None) - ); + let mut run = std::pin::pin!(h.publisher.run_subscription( + &mut stream, + &mut serving, + &mut finished, + &mut goaways, + async {}, + None + )); assert!(futures::poll!(run.as_mut()).is_pending(), "{version}: update ended it"); assert_eq!(h.track.new_group(), Some(NewGroup { value: 9, first: 0 }), "{version}"); // Draft 16 names the update it answers; later drafts answer on its own stream. @@ -7035,6 +7116,8 @@ mod serve_tests { let mut session = ScriptedSession::new([new_group_update(version, 10, 9), new_group_update(version, 12, 0)].concat()); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = + super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -7044,11 +7127,14 @@ mod serve_tests { None, ); let mut finished = false; - let mut run = - std::pin::pin!( - h.publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None) - ); + let mut run = std::pin::pin!(h.publisher.run_subscription( + &mut stream, + &mut serving, + &mut finished, + &mut goaways, + async {}, + None + )); assert!( futures::poll!(run.as_mut()).is_pending(), "{version}: an update ended it" @@ -7065,6 +7151,8 @@ mod serve_tests { let h = serve(version); let mut session = ScriptedSession::new(new_group_update(version, 10, 9)); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = + super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -7076,7 +7164,7 @@ mod serve_tests { let mut finished = false; let served = h .publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None) + .run_subscription(&mut stream, &mut serving, &mut finished, &mut goaways, async {}, None) .await; assert!( matches!(served, Some(Served::UpdateFailed(Error::Unsupported))), @@ -7146,6 +7234,8 @@ mod serve_tests { let h = serve(version); let mut session = ScriptedSession::per_stream(vec![update_with_tokens(version, &[token])]); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = + super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -7157,7 +7247,7 @@ mod serve_tests { let mut finished = false; let served = h .publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None) + .run_subscription(&mut stream, &mut serving, &mut finished, &mut goaways, async {}, None) .await; assert!( matches!(served, Some(Served::Track(Err(_)) | Served::UpdateFailed(_))), @@ -7240,6 +7330,8 @@ mod serve_tests { let h = serve(version); let mut session = ScriptedSession::per_stream(vec![update_with_tokens(version, &tokens)]); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = + super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -7249,11 +7341,14 @@ mod serve_tests { None, ); let mut finished = false; - let mut run = - std::pin::pin!( - h.publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None) - ); + let mut run = std::pin::pin!(h.publisher.run_subscription( + &mut stream, + &mut serving, + &mut finished, + &mut goaways, + async {}, + None + )); let mut served = None; for _ in 0..50 { if let std::task::Poll::Ready(done) = futures::poll!(run.as_mut()) { @@ -7282,6 +7377,8 @@ mod serve_tests { let h = serve(version); let mut session = ScriptedSession::new(vec![0x02, 0, 6, 2, 1, 0x29, 2, 0, 0]); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = + super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -7292,7 +7389,7 @@ mod serve_tests { ); let result = h .publisher - .run_subscription(&mut stream, &mut serving, &mut false, async {}, None) + .run_subscription(&mut stream, &mut serving, &mut false, &mut goaways, async {}, None) .await; assert!( matches!(result, Some(Served::Track(Err(Error::Decode(_))))), @@ -7314,6 +7411,8 @@ mod serve_tests { let h = serve(version); let mut session = ScriptedSession::new(Vec::new()); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = + super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -7325,7 +7424,7 @@ mod serve_tests { h.track.clone().abort(Error::Decode(DecodeError::InvalidValue)).unwrap(); let result = h .publisher - .run_subscription(&mut stream, &mut serving, &mut false, async {}, None) + .run_subscription(&mut stream, &mut serving, &mut false, &mut goaways, async {}, None) .await; assert!( matches!(result, Some(Served::Track(Err(Error::Decode(_))))), @@ -12073,6 +12172,8 @@ mod serve_tests { let h = serve_with_auth(version, auth, Vec::new()); let mut session = ScriptedSession::per_stream(vec![update_with_tokens(version, &[TOKEN])]); let mut stream = Stream::open(&mut session, version).await.unwrap(); + let mut goaways = + super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut serving = TrackServe::new( h.session.clone(), h.track.subscribe(None), @@ -12082,11 +12183,14 @@ mod serve_tests { None, ); let mut finished = false; - let mut run = - std::pin::pin!( - h.publisher - .run_subscription(&mut stream, &mut serving, &mut finished, async {}, None) - ); + let mut run = std::pin::pin!(h.publisher.run_subscription( + &mut stream, + &mut serving, + &mut finished, + &mut goaways, + async {}, + None + )); let mut served = None; for _ in 0..50 { if let std::task::Poll::Ready(done) = futures::poll!(run.as_mut()) { From f24171e74c9aa1d5c3728bf215b4a59d8d571133 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 19 Oct 2026 17:19:08 -0700 Subject: [PATCH 4/8] fix(net): keep the SETUP stream and session errors through GOAWAY handling - Hold the SETUP writer when the drain trigger drops instead of FINing it, and surface only its failures to the session driver. - Report a session close or idle timeout under a control stream as itself, not a protocol violation, in Rust and JS. - Fail a presenter Auth stream as soon as a non-GOAWAY type arrives. - Read the joining FETCH stream only where GOAWAY can arrive (draft 18+). - Drop the idle STOP_SENDING poll from the legacy control writer; a write failure is still a protocol violation. - Script update answers after the update in tests, since an idle request now reads its stream. Co-Authored-By: Claude Opus 5.5 --- js/net/src/error.ts | 12 +++++++-- js/net/src/ietf/adapter.ts | 7 ++--- js/net/src/ietf/connection.ts | 8 ++++-- rs/moq-net/src/ietf/adapter.rs | 32 +++++++++++------------ rs/moq-net/src/ietf/auth.rs | 23 ++++++++++++----- rs/moq-net/src/ietf/publisher.rs | 34 ++++++++++++++++-------- rs/moq-net/src/ietf/request_stream.rs | 8 +++--- rs/moq-net/src/ietf/session.rs | 37 +++++++++++++++++++-------- rs/moq-net/src/ietf/subscriber.rs | 16 +++++------- rs/moq-net/tests/integration/auth.rs | 7 +++-- 10 files changed, 119 insertions(+), 65 deletions(-) diff --git a/js/net/src/error.ts b/js/net/src/error.ts index 9032ffcdb54..0ccb1cfbb57 100644 --- a/js/net/src/error.ts +++ b/js/net/src/error.ts @@ -546,6 +546,15 @@ export function closeError(quic: WebTransport): Promise { ); } +/** + * Whether a stream failed because its whole session closed, rather than on its own. + * + * @internal + */ +export function sessionClosed(err: unknown): boolean { + return typeof err === "object" && err !== null && (err as { source?: unknown }).source === "session"; +} + /** * Report a failure the session's close caused as the session's own error, which carries the * peer's close code; any other failure passes through. @@ -553,8 +562,7 @@ export function closeError(quic: WebTransport): Promise { * @internal */ export async function sessionCause(quic: WebTransport | undefined, err: unknown): Promise { - const source = typeof err === "object" && err !== null ? (err as { source?: unknown }).source : undefined; - if (quic && source === "session") return closeError(quic); + if (quic && sessionClosed(err)) return closeError(quic); return error(err); } diff --git a/js/net/src/ietf/adapter.ts b/js/net/src/ietf/adapter.ts index 856134e6522..5551dfcf59e 100644 --- a/js/net/src/ietf/adapter.ts +++ b/js/net/src/ietf/adapter.ts @@ -1,7 +1,7 @@ import { Once, race } from "@moq/signals"; import { Mutex } from "async-mutex"; import type { Drain } from "../connection/goaway.ts"; -import { error, ProtocolViolation, SessionCode, SessionError } from "../error.ts"; +import { error, ProtocolViolation, SessionCode, SessionError, sessionClosed } from "../error.ts"; import { type OpenOptions, Reader, Stream, type Writer } from "../stream.ts"; import { untilAborted } from "../util/abort.ts"; import * as Varint from "../varint.ts"; @@ -538,9 +538,10 @@ export class ControlStreamAdapter implements Session { }); await race([read(), stopped]); } catch (err: unknown) { + // A closing session fails this stream too, which reports the session's error. cause = - err instanceof ProtocolViolation || err instanceof RequestWindowError - ? err + err instanceof ProtocolViolation || err instanceof RequestWindowError || sessionClosed(err) + ? error(err) : new ProtocolViolation(error(err).message, { cause: err }); throw cause; } finally { diff --git a/js/net/src/ietf/connection.ts b/js/net/src/ietf/connection.ts index 71eee975d31..19b7ee7f694 100644 --- a/js/net/src/ietf/connection.ts +++ b/js/net/src/ietf/connection.ts @@ -7,7 +7,7 @@ import type { Established } from "../connection/established.ts"; import type { Drain } from "../connection/goaway.ts"; import { type Probe, type Stats, transportStats } from "../connection/stats.ts"; import { type Transport, transportOf } from "../connection/transport.ts"; -import { error, fromClose, ProtocolViolation, SessionCode, StreamCode, StreamError } from "../error.ts"; +import { error, fromClose, ProtocolViolation, SessionCode, StreamCode, StreamError, sessionClosed } from "../error.ts"; import type { Consumer as OriginConsumer } from "../origin.ts"; import * as Path from "../path.ts"; import { type Reader, Readers, type Stream } from "../stream.ts"; @@ -191,6 +191,10 @@ export class Connection implements Established { this.#close({ closeCode: err.code, reason: err.message }); return; } + if (sessionClosed(err)) { + this.#close(); + return; + } this.#violated( err instanceof ProtocolViolation ? err @@ -660,7 +664,7 @@ export class Connection implements Established { }); await race([read(), stopped]); } catch (err) { - if (!this.#closed) + if (!this.#closed && !sessionClosed(err)) this.#violated( err instanceof ProtocolViolation ? err diff --git a/rs/moq-net/src/ietf/adapter.rs b/rs/moq-net/src/ietf/adapter.rs index dc8f52a3e7a..293cae0a6f8 100644 --- a/rs/moq-net/src/ietf/adapter.rs +++ b/rs/moq-net/src/ietf/adapter.rs @@ -47,6 +47,12 @@ impl Queue { true } + /// Dequeue the next message, waiting while the queue is open and empty. + /// Returns `None` once the queue is closed and drained. + async fn pop(&self) -> Option { + kio::wait(|waiter| self.poll_pop(waiter)).await + } + /// Poll for the next message; ready with `None` once closed and drained. fn poll_pop(&self, waiter: &kio::Waiter) -> Poll> { self.0 @@ -60,7 +66,7 @@ impl Queue { .map(|mut state| state.messages.pop_front()) } - /// Stop future pushes; buffered messages still drain, then `poll_pop` returns `None`. + /// Stop future pushes; buffered messages still drain, then `pop` returns `None`. fn close(&self) { self.0.lock().closed = true; } @@ -870,25 +876,17 @@ impl ControlStreamAdapter { let _ = self.shared.control.push(raw.into()); } - /// Writer task: drains the queue and writes to the control stream. + /// Writer task: drains the queue and writes to the control stream. A write failing, + /// such as after the peer's STOP_SENDING, is a protocol violation. async fn run_write(&self, mut writer: Writer) -> Result<(), Error> { - loop { - let message = kio::wait(|waiter| { - if writer.poll_closed(&mut waiter.context()).is_ready() { - return Poll::Ready(Err(Error::ProtocolViolation)); - } - self.shared.control.poll_pop(waiter).map(Ok) - }) - .await?; - let Some(message) = message else { - return Ok(()); - }; - let mut buf = std::io::Cursor::new(message); + while let Some(msg) = self.shared.control.pop().await { + let mut buf = std::io::Cursor::new(msg); writer .write_all(&mut buf) .await .map_err(super::session::control_stream_error)?; } + Ok(()) } /// Dispatcher loop that reads control stream messages and routes them. @@ -1456,7 +1454,7 @@ mod tests { shared .open_incoming(target_id, Bytes::from_static(b"request"), None) .unwrap(); - let (_, mut recv) = kio::wait(|waiter| shared.incoming.poll_pop(waiter)).await.unwrap(); + let (_, mut recv) = shared.incoming.pop().await.unwrap(); assert_eq!( recv.read_chunk(usize::MAX).await.unwrap(), Some(Bytes::from_static(b"request")) @@ -1589,7 +1587,7 @@ mod tests { let n = stream.write(b"hello").await.unwrap(); assert_eq!(n, 5); - let data = kio::wait(|waiter| control.poll_pop(waiter)).await.unwrap(); + let data = control.pop().await.unwrap(); assert_eq!(data, &b"hello"[..]); } @@ -1650,7 +1648,7 @@ mod tests { .open_incoming(request_id, encode_msg(&msg, version), None) .unwrap(); - let (_, mut recv) = kio::wait(|waiter| shared.incoming.poll_pop(waiter)).await.unwrap(); + let (_, mut recv) = shared.incoming.pop().await.unwrap(); // Drain the advertisement the stream opened with, so both halves are quiescent // and a later read only sees what the terminal message routes. diff --git a/rs/moq-net/src/ietf/auth.rs b/rs/moq-net/src/ietf/auth.rs index 97591fb5e32..a4a78bc0164 100644 --- a/rs/moq-net/src/ietf/auth.rs +++ b/rs/moq-net/src/ietf/auth.rs @@ -488,6 +488,19 @@ impl Serve { } } +/// Anything but a GOAWAY after the presenter's Auth: refused once its type is read, +/// rather than waiting on a body that cannot make it legal. +#[cfg(feature = "async")] +#[derive(Debug)] +struct Unexpected; + +#[cfg(feature = "async")] +impl crate::coding::Decode for Unexpected { + fn decode(r: &mut crate::coding::Decoder<'_>, _: Version) -> Result { + Err(crate::coding::DecodeError::InvalidMessage(r.varint()?)) + } +} + /// Write the acceptor's replies until either side ends the token. `default` feeds /// the default acceptor's grant into the outbox as it changes. #[cfg(feature = "async")] @@ -507,12 +520,10 @@ async fn serve_issue( loop { let next = kio::wait(|waiter| { let mut cx = std::task::Context::from_waker(waiter.waker()); - if let Poll::Ready(res) = goaways.poll_next(&mut stream.reader, &mut cx).map(|res| { - res.and_then(|message| match message { - None => Ok(()), - Some(_) => Err(Error::ProtocolViolation), - }) - }) { + if let Poll::Ready(res) = goaways + .poll_next::(&mut stream.reader, &mut cx) + .map(|res| res.map(|_| ())) + { return Poll::Ready(Next::Withdrawn(res)); } if let Some(default) = default.as_deref_mut() diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index 3b62fa4d136..1e18d98b390 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -14093,9 +14093,10 @@ mod tests { .unwrap(); settle().await; - // One stream: the PUBLISH_NAMESPACE request and its update, each answered OK. + // One stream, answering the PUBLISH_NAMESPACE. The update goes unanswered: an answer + // scripted ahead of it would arrive while the request is idle, which is a violation. let ok = publish_namespace_ok(VERSION).await; - let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![[ok.clone(), ok].concat()]); + let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![ok]); let log = session.log.clone(); let publisher = Publisher::new( @@ -14179,8 +14180,9 @@ mod tests { .unwrap(); let counted = counted.writes.lock().unwrap().clone(); let ok = publish_namespace_ok(VERSION).await; - let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![[ok, counted].concat()]); + let session = crate::lite::test_transport::ScriptedSession::new(ok); let log = session.log.clone(); + let peer = session.clone(); let publisher = Publisher::new( crate::time::sim(), @@ -14202,6 +14204,9 @@ mod tests { } assert_eq!(occurrences(&log, b"cam"), 1, "the advertisement never went out"); + // Queued behind the OK the idle request already read, so it answers the update: + // nothing wakes the reader until the update goes out. + peer.push(&counted); // Repricing sends the REQUEST_UPDATE whose OK is counted. let _warm = origin .announce("cam", crate::origin::Route::default().with_epoch(epoch).with_cost(0)) @@ -14244,9 +14249,10 @@ mod tests { .unwrap(); settle().await; - // One stream: the advertisement from A and its update to B, each answered OK. + // One stream, answering the advertisement from A. Its update to B goes unanswered: an + // answer scripted ahead of it would arrive while the request is idle. let ok = publish_namespace_ok(VERSION).await; - let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![[ok.clone(), ok].concat()]); + let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![ok]); let log = session.log.clone(); let publisher = Publisher::new( @@ -14382,8 +14388,10 @@ mod tests { .unwrap(); settle().await; + // The update goes unanswered: an answer scripted ahead of it would arrive while the + // request is idle. let ok = publish_namespace_ok(VERSION).await; - let (publisher, log) = auth_publisher(&origin, &auth, vec![[ok.clone(), ok].concat()], VERSION); + let (publisher, log) = auth_publisher(&origin, &auth, vec![ok], VERSION); let mut run = std::pin::pin!(publisher.run_publish_namespaces()); poll_until(&mut run, &log, b"cam", 1).await; assert_eq!(occurrences(&log, b"cam"), 1, "the advertisement never went out"); @@ -14562,8 +14570,9 @@ mod tests { settle().await; let ok = publish_namespace_ok(VERSION).await; - let session = crate::lite::test_transport::ScriptedSession::per_stream_reset(vec![ok.clone(), ok]); + let session = crate::lite::test_transport::ScriptedSession::per_stream(vec![ok.clone(), ok]); let log = session.log.clone(); + let peer = session.clone(); let publisher = Publisher::new( crate::time::sim(), session, @@ -14576,6 +14585,9 @@ mod tests { .with_auth(auth.clone()); let mut run = std::pin::pin!(publisher.run_publish_namespaces()); poll_until(&mut run, &log, b"first", 1).await; + // The idle request has read its OK and parked, so the reset waits for the renewal + // to wake it. + peer.close(crate::lite::test_transport::Close::Reset); cam.update(crate::origin::Route::default().with_auth(present(b"second"))) .unwrap(); poll_until(&mut run, &log, b"second", 1).await; @@ -14706,12 +14718,13 @@ mod tests { settle().await; // Stream 1 accepts the advertisement and refuses its update, with a wait shorter - // than the retry sweep; stream 2 accepts the fresh advertisement. + // than the retry sweep. The streams share one script, so the refusal is queued once + // the idle request has read its OK. let ok = publish_namespace_ok(VERSION).await; let refusal = publish_namespace_error(VERSION, 50).await; - let session = - crate::lite::test_transport::ScriptedSession::per_stream(vec![[ok.clone(), refusal].concat(), ok]); + let session = crate::lite::test_transport::ScriptedSession::new(ok); let log = session.log.clone(); + let peer = session.clone(); let publisher = Publisher::new( crate::time::sim(), @@ -14733,6 +14746,7 @@ mod tests { } assert_eq!(occurrences(&log, b"cam"), 1, "the advertisement never went out"); + peer.push(&refusal); let _warm = origin .announce("cam", crate::origin::Route::default().with_epoch(epoch).with_cost(0)) .unwrap(); diff --git a/rs/moq-net/src/ietf/request_stream.rs b/rs/moq-net/src/ietf/request_stream.rs index f279bc2e540..6a11c72d8d4 100644 --- a/rs/moq-net/src/ietf/request_stream.rs +++ b/rs/moq-net/src/ietf/request_stream.rs @@ -205,13 +205,15 @@ impl GoAways { } Ok(()) } - pub fn poll_next( + + /// Read the next `T`, consuming at most one GOAWAY before it. + pub fn poll_next + std::fmt::Debug, R: crate::transport::poll::RecvStream>( &mut self, reader: &mut crate::coding::Reader, cx: &mut Context<'_>, - ) -> Poll, Error>> { + ) -> Poll, Error>> { loop { - match ready!(reader.poll_decode_maybe::>(cx))? { + match ready!(reader.poll_decode_maybe::>(cx))? { Some(Next::GoAway { redirect }) => self.receive(redirect)?, Some(Next::Message(message)) => return Poll::Ready(Ok(Some(message))), None => return Poll::Ready(Ok(None)), diff --git a/rs/moq-net/src/ietf/session.rs b/rs/moq-net/src/ietf/session.rs index 8e4d3afeb49..f51c5a3ed5d 100644 --- a/rs/moq-net/src/ietf/session.rs +++ b/rs/moq-net/src/ietf/session.rs @@ -390,8 +390,9 @@ where } _ => { let control = Control::new(None, client).with_history(limits.requests()); - // Send SETUP and retain its writer for the session's lifetime. - let setup = run_setup( + // Send SETUP and retain its writer for the session's lifetime. Only a failure + // ends the session; the other branches report how it closed. + let setup = err_only(run_setup( runtime.clone(), session.clone(), version, @@ -405,7 +406,7 @@ where }, goaway.clone(), control.clone(), - ); + )); // Only the dialing side fails loud on a publication outside its grant: a // server's publish origin is everything the peer may read, not what it @@ -566,8 +567,8 @@ where if let Poll::Ready(err) = waiter.poll_future(enforce.as_mut()) { return Poll::Ready(Err(err)); } - if let Poll::Ready(result) = waiter.poll_future(setup.as_mut()) { - return Poll::Ready(result); + if let Poll::Ready(err) = waiter.poll_future(setup.as_mut()) { + return Poll::Ready(Err(err)); } if task_set.poll(waiter).is_ready() { return Poll::Ready(Ok(())); @@ -817,8 +818,9 @@ async fn run_setup( // Hold the writer alive until the session closes, sending a GOAWAY if the // drain trigger fires meanwhile. The trigger resolves `None` when the session - // drops without draining; keep holding either way (closing this stream - // mid-session is a protocol violation on strict peers). + // drops without draining; keep holding either way, since a FIN mid-session is + // a protocol violation the peer closes over. + let mut untriggered = false; let payload = kio::wait(|waiter| { let mut cx = waiter.context(); if session.poll_closed(&mut cx).is_ready() { @@ -827,7 +829,14 @@ async fn run_setup( if writer.poll_closed(&mut cx).is_ready() { return std::task::Poll::Ready(Err(Error::ProtocolViolation)); } - goaway.poll_triggered(waiter).map(Ok) + if !untriggered { + match goaway.poll_triggered(waiter) { + std::task::Poll::Ready(Some(payload)) => return std::task::Poll::Ready(Ok(Some(payload))), + std::task::Poll::Ready(None) => untriggered = true, + std::task::Poll::Pending => {} + } + } + std::task::Poll::Pending }) .await?; @@ -1413,9 +1422,10 @@ async fn run_goaway( .map_err(control_stream_error) } -/// A control stream cannot end independently of its session. +/// A control stream cannot end independently of its session, so its own failure is the +/// peer's violation. The session closing or timing out under it passes through. pub(super) fn control_stream_error(err: Error) -> Error { - if is_protocol_violation(&err) || matches!(err, Error::Session(_) | Error::Encode(_)) { + if is_protocol_violation(&err) || matches!(err, Error::Session(_) | Error::Encode(_) | Error::IdleTimeout) { err } else { Error::ProtocolViolation @@ -3455,7 +3465,12 @@ mod tests { .unwrap(); let _ = moq_clock::timeout(std::time::Duration::from_secs(10), driver).await; let closes = log.closes(); - assert!(closes.len() <= 1, "closed more than once: {closes:?}"); + // A request stream closes at the source and its task may close again; the transport + // keeps the first, so only a disagreeing code would reach the peer. + assert!( + closes.iter().all(|(code, _)| *code == closes[0].0), + "closed with different codes: {closes:?}" + ); closes.first().map(|(code, _)| SessionError::from_code(*code)) } diff --git a/rs/moq-net/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index e06a7e0537a..c69a7d42718 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -3680,19 +3680,17 @@ where .await }; if accepted { - // The request stays open while the subscription still needs its fill. - let mut finished = false; + // The request stays open while the subscription still needs its fill. From draft 18 + // it may carry a GOAWAY meanwhile; before that, nothing follows the answer here. + let mut finished = matches!( + self.version, + Version::Draft14 | Version::Draft15 | Version::Draft16 | Version::Draft17 + ); let mut failed = false; kio::wait(|waiter| { if !finished { let mut cx = waiter.context(); - let ended = match self.version { - Version::Draft14 | Version::Draft15 | Version::Draft16 => { - super::request_stream::poll_legacy_end(&mut stream, self.version, &mut cx) - } - _ => messages.poll_end(&mut stream.reader, &mut cx), - }; - match ended { + match messages.poll_end(&mut stream.reader, &mut cx) { Poll::Ready(Ok(())) => finished = true, Poll::Ready(Err(_)) => { failed = true; diff --git a/rs/moq-net/tests/integration/auth.rs b/rs/moq-net/tests/integration/auth.rs index b18c09d8ec9..05a56d4bd73 100644 --- a/rs/moq-net/tests/integration/auth.rs +++ b/rs/moq-net/tests/integration/auth.rs @@ -153,9 +153,12 @@ async fn moqt_22_renewing_a_cancelled_announce_keeps_the_session() { broadcast.announce(origin::Route::default().with_auth(first)).unwrap(); let (_, first) = tokens.next().await.expect("the announce's token"); - // Ending the grant cancels the announcement, which the client has yet to read when - // the swap writes its update. + // Ending the grant cancels the announcement. The idle request reads that and the + // retry offers it again under the token the route still holds, so the swap renews + // the new request. drop(first); + let (token, _again) = tokens.next().await.expect("offered again after the cancel"); + assert_eq!(token, b"first"); moq_clock::sleep(Duration::from_secs(1)).await; let second = pair.client.auth().add("second").await.expect("kept for requests"); broadcast.announce(origin::Route::default().with_auth(second)).unwrap(); From 913614286b86f095fff622893656a95009773ea6 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 19 Oct 2026 18:40:06 -0700 Subject: [PATCH 5/8] fix(net): name the first skipped peer ID as the draft-18 GOAWAY cutoff A reordered stream can leave a gap below the next expected ID, and that gap was never processed, so the cutoff is its start when one exists. Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/src/ietf/control.rs | 20 ++++++++++++++------ rs/moq-net/src/ietf/session.rs | 7 ++++--- 2 files changed, 18 insertions(+), 9 deletions(-) diff --git a/rs/moq-net/src/ietf/control.rs b/rs/moq-net/src/ietf/control.rs index af3900a188a..5698a3b05b4 100644 --- a/rs/moq-net/src/ietf/control.rs +++ b/rs/moq-net/src/ietf/control.rs @@ -169,15 +169,17 @@ impl Control { self } - /// Freeze draft-18 admission and name the first peer ID beyond those already admitted. + /// Freeze draft-18 admission and name the smallest peer ID not admitted: the first one + /// a reordered stream skipped, or else the next. pub fn goaway(&self) -> Result { let mut state = self.state.lock(); - let next = state.modern.next; - if next >= 1 << 62 { + let modern = &state.modern; + let cutoff = modern.missing.keys().next().copied().unwrap_or(modern.next); + if cutoff >= 1 << 62 { return Err(SessionError::Internal.into()); } state.going_away = true; - Ok(RequestId(next)) + Ok(RequestId(cutoff)) } pub fn max_request_id(&self, max: RequestId) { @@ -328,11 +330,17 @@ mod tests { assert_eq!(control.goaway().unwrap(), RequestId(first)); assert!(matches!(control.accept(RequestId(first)), Err(Error::GoingAway))); + let control = Control::new(None, client); + control.accept(RequestId(first)).unwrap(); + control.accept(RequestId(first + 2)).unwrap(); + assert_eq!(control.goaway().unwrap(), RequestId(first + 4)); + + // A reordered stream skipped first + 2, which is the smallest ID not processed. let control = Control::new(None, client); control.accept(RequestId(first)).unwrap(); control.accept(RequestId(first + 4)).unwrap(); - assert_eq!(control.goaway().unwrap(), RequestId(first + 6)); - // Cross-stream reordering may deliver an older ID after GOAWAY too. + assert_eq!(control.goaway().unwrap(), RequestId(first + 2)); + // The skipped ID may still arrive after GOAWAY, and is past the cutoff too. for id in [first + 2, first + 6, first + 8] { assert!(matches!(control.accept(RequestId(id)), Err(Error::GoingAway))); } diff --git a/rs/moq-net/src/ietf/session.rs b/rs/moq-net/src/ietf/session.rs index f51c5a3ed5d..b0d44a01a63 100644 --- a/rs/moq-net/src/ietf/session.rs +++ b/rs/moq-net/src/ietf/session.rs @@ -3399,7 +3399,8 @@ mod tests { } } - /// Draft-18 GOAWAY carries the admission cutoff, preserving the peer's parity. + /// Draft-18 GOAWAY names the smallest peer ID not processed, here one a reordered stream + /// skipped, preserving the peer's parity. #[moq_clock::test] async fn our_draft18_goaway_names_the_admitted_request_cutoff() { const VERSION: Version = Version::Draft18; @@ -3425,9 +3426,9 @@ mod tests { )); handle.producer().send(crate::goaway::Goaway::new()).unwrap(); assert!(futures::poll!(setup.as_mut()).is_pending()); - let sent = goaway(VERSION, Some(first + 6)); + let sent = goaway(VERSION, Some(first + 2)); assert_eq!(occurrences(&log, &sent), 1, "client={client}"); - assert!(matches!(control.accept(RequestId(first + 6)), Err(Error::GoingAway))); + assert!(matches!(control.accept(RequestId(first + 2)), Err(Error::GoingAway))); } } From b988721204cf4b612be87e12d6130cc9fc29ff00 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 19 Oct 2026 19:59:23 -0700 Subject: [PATCH 6/8] fix(net): see an idle STOP_SENDING and refuse AUTH past the cutoff in kind The draft 14-16 control writer now watches for STOP_SENDING while its queue is empty, so a peer that stops it and keeps its own half open still closes the session with PROTOCOL_VIOLATION. The extra wake had made track_tail lose its group on draft 14: the publisher answered SUBSCRIBE after the test wrote group 0, leaving the frame to a joining FETCH the ended subscription refused. The test now lets the publisher answer while the track is empty. An AUTH past our draft-18 GOAWAY cutoff is answered with AUTH_ERROR carrying GOING_AWAY, since its presenter reads nothing else. Rust and JS presenters take that code as a refusal of the request, not the token, and the auth draft lists it. Co-Authored-By: Claude Opus 5.5 --- drafts/draft-lcurley-moq-auth.md | 3 +- js/net/src/auth_session.ts | 7 ++- js/net/src/ietf/auth.test.ts | 5 +- js/net/src/ietf/auth.ts | 5 +- rs/moq-net/src/ietf/adapter.rs | 43 ++++++++++++-- rs/moq-net/src/ietf/auth.rs | 24 +++++++- rs/moq-net/src/ietf/session.rs | 66 ++++++++++++++++------ rs/moq-net/tests/integration/track_tail.rs | 5 ++ 8 files changed, 130 insertions(+), 28 deletions(-) diff --git a/drafts/draft-lcurley-moq-auth.md b/drafts/draft-lcurley-moq-auth.md index c202c7cccf7..9243d800e07 100644 --- a/drafts/draft-lcurley-moq-auth.md +++ b/drafts/draft-lcurley-moq-auth.md @@ -185,7 +185,8 @@ AUTH_ERROR Message { **Error Code**: A code MUST fit in 32 bits; a larger value is a PROTOCOL_VIOLATION. -A code from the REQUEST_ERROR registry ({{moqt}}): UNAUTHORIZED, MALFORMED_AUTH_TOKEN, EXPIRED_AUTH_TOKEN, or NOT_SUPPORTED ({{prefixes}}). +A code from the REQUEST_ERROR registry ({{moqt}}): UNAUTHORIZED, MALFORMED_AUTH_TOKEN, EXPIRED_AUTH_TOKEN, NOT_SUPPORTED ({{prefixes}}), or GOING_AWAY. +GOING_AWAY answers an AUTH the acceptor no longer admits after its GOAWAY ({{moqt}}); it refuses the request, not the token, so the token stays valid for another session. **Reason Phrase**: A human-readable reason, at most 8,192 bytes. diff --git a/js/net/src/auth_session.ts b/js/net/src/auth_session.ts index 46cde30367b..084cf1e666b 100644 --- a/js/net/src/auth_session.ts +++ b/js/net/src/auth_session.ts @@ -479,8 +479,11 @@ export class AuthSession implements Handle { } console.warn("auth token refused", reply.refused); // A refused setup token leaves an empty union, not an unknown (unrestricted) - // one. A grant the acceptor could not tell is unknown, not empty. - if (!(reply.refused instanceof Unsupported)) this.#replied = true; + // one. A grant the acceptor could not tell, or never judged, is unknown, not empty. + const unjudged = + reply.refused instanceof Unsupported || + (reply.refused instanceof StreamError && reply.refused.code === StreamCode.GoingAway); + if (!unjudged) this.#replied = true; result = reply.refused; stream.close(); break; diff --git a/js/net/src/ietf/auth.test.ts b/js/net/src/ietf/auth.test.ts index ca86a33bb56..b5f67c57a0d 100644 --- a/js/net/src/ietf/auth.test.ts +++ b/js/net/src/ietf/auth.test.ts @@ -1,6 +1,6 @@ import { expect, test } from "bun:test"; import { Unsupported } from "../auth.ts"; -import { SessionCode, type SessionError } from "../error.ts"; +import { SessionCode, type SessionError, StreamCode, type StreamError } from "../error.ts"; import * as Path from "../path.ts"; import { Reader, Writer } from "../stream.ts"; import { AuthError, AuthMessage, AuthOk, fromSetup, intoSetup } from "./auth.ts"; @@ -131,6 +131,9 @@ test("AUTH_ERROR preserves actionable refusal kinds", async () => { expect(expired.code).toBe(SessionCode.Expired); const unauthorized = new AuthError(0x1, "bad").toError() as SessionError; expect(unauthorized.code).toBe(SessionCode.Unauthorized); + // Past the acceptor's GOAWAY: the request is refused, not the token. + const goingAway = new AuthError(0x6, "going away").toError() as StreamError; + expect(goingAway.code).toBe(StreamCode.GoingAway); }); test("drafts before 17 carry no AUTH", async () => { diff --git a/js/net/src/ietf/auth.ts b/js/net/src/ietf/auth.ts index 5168588a1fb..e329365f39d 100644 --- a/js/net/src/ietf/auth.ts +++ b/js/net/src/ietf/auth.ts @@ -1,6 +1,6 @@ import { Unsupported } from "../auth.ts"; import type { AuthWire, WireGrant, WireReply } from "../auth_session.ts"; -import { ProtocolViolation, SessionCode, SessionError } from "../error.ts"; +import { ProtocolViolation, SessionCode, SessionError, StreamCode, StreamError } from "../error.ts"; import * as Path from "../path.ts"; import type { Reader, Stream, Writer } from "../stream.ts"; import type { Session } from "./adapter.ts"; @@ -47,6 +47,8 @@ export function intoSetup(params: SetupOptions, version: IetfVersion) { const UNAUTHORIZED = 0x1; const NOT_SUPPORTED = 0x3; const EXPIRED_AUTH_TOKEN = 0x5; +/** Draft-17 assigned it, the first draft this extension negotiates on. */ +const GOING_AWAY = 0x6; /** Longest AUTH_ERROR reason, in bytes, matching the Rust decoder. */ const MAX_REASON = 8192; @@ -211,6 +213,7 @@ export class AuthError { toError(): Error { if (this.code === NOT_SUPPORTED) return new Unsupported(this.reason); if (this.code === EXPIRED_AUTH_TOKEN) return new SessionError(SessionCode.Expired, { reason: this.reason }); + if (this.code === GOING_AWAY) return new StreamError(StreamCode.GoingAway, { reason: this.reason }); return new SessionError(SessionCode.Unauthorized, { reason: this.reason }); } } diff --git a/rs/moq-net/src/ietf/adapter.rs b/rs/moq-net/src/ietf/adapter.rs index 293cae0a6f8..3caf4da826d 100644 --- a/rs/moq-net/src/ietf/adapter.rs +++ b/rs/moq-net/src/ietf/adapter.rs @@ -49,6 +49,7 @@ impl Queue { /// Dequeue the next message, waiting while the queue is open and empty. /// Returns `None` once the queue is closed and drained. + #[cfg(test)] async fn pop(&self) -> Option { kio::wait(|waiter| self.poll_pop(waiter)).await } @@ -66,7 +67,7 @@ impl Queue { .map(|mut state| state.messages.pop_front()) } - /// Stop future pushes; buffered messages still drain, then `pop` returns `None`. + /// Stop future pushes; buffered messages still drain, then `poll_pop` returns `None`. fn close(&self) { self.0.lock().closed = true; } @@ -876,10 +877,22 @@ impl ControlStreamAdapter { let _ = self.shared.control.push(raw.into()); } - /// Writer task: drains the queue and writes to the control stream. A write failing, - /// such as after the peer's STOP_SENDING, is a protocol violation. + /// Writer task: drains the queue and writes to the control stream. The peer's + /// STOP_SENDING, seen while idle or as a failed write, is a protocol violation. async fn run_write(&self, mut writer: Writer) -> Result<(), Error> { - while let Some(msg) = self.shared.control.pop().await { + loop { + let msg = kio::wait(|waiter| { + // Never finished, so any end is the peer's or the session's. + if let Poll::Ready(res) = writer.poll_closed(&mut waiter.context()) { + let err = res + .err() + .map_or(Error::ProtocolViolation, super::session::control_stream_error); + return Poll::Ready(Err(err)); + } + self.shared.control.poll_pop(waiter).map(Ok) + }) + .await?; + let Some(msg) = msg else { break }; let mut buf = std::io::Cursor::new(msg); writer .write_all(&mut buf) @@ -1970,6 +1983,28 @@ mod tests { } } + /// A STOP_SENDING on a legacy control stream ends the session even with nothing queued + /// to write, while the peer keeps its own half open. + #[moq_clock::test] + async fn a_legacy_control_stream_stopped_while_idle_is_a_protocol_violation() { + use crate::transport::memory; + for version in [Version::Draft14, Version::Draft15, Version::Draft16] { + let (mut session, mut peer) = memory::pair(memory::Config::default()); + let stream = crate::coding::Stream::open(&mut session, version).await.unwrap(); + let mut remote = crate::coding::Stream::accept(&mut peer, version).await.unwrap(); + remote.reader.abort(&Error::Cancel); + let adapter = ControlStreamAdapter::new(session, Control::new(None, true), version); + let (_handle, protocol) = crate::goaway::Handle::new(false); + let res = moq_clock::timeout( + std::time::Duration::from_secs(10), + adapter.run(stream.reader, stream.writer, protocol), + ) + .await + .expect("an idle writer missed the STOP_SENDING"); + assert!(matches!(res, Err(Error::ProtocolViolation)), "{version:?}: {res:?}"); + } + } + /// A request ID at the MAX_REQUEST_ID we advertised closes the session with the /// draft's TOO_MANY_REQUESTS, before the request is queued. #[moq_clock::test] diff --git a/rs/moq-net/src/ietf/auth.rs b/rs/moq-net/src/ietf/auth.rs index a4a78bc0164..71ecc4097f0 100644 --- a/rs/moq-net/src/ietf/auth.rs +++ b/rs/moq-net/src/ietf/auth.rs @@ -198,6 +198,8 @@ impl Message for AuthError { const UNAUTHORIZED: u64 = 0x1; const NOT_SUPPORTED: u64 = 0x3; const EXPIRED_AUTH_TOKEN: u64 = 0x5; +/// Draft-17 assigned it, the first draft this extension negotiates on. +const GOING_AWAY: u64 = 0x6; /// The AUTH_ERROR code for a refusal. The public API speaks session codes, and the /// actionable distinctions this registry carries are unsupported, expired, and unauthorized. @@ -214,10 +216,26 @@ fn from_code(code: u64) -> Error { match code { NOT_SUPPORTED => Error::Unsupported, EXPIRED_AUTH_TOKEN => Error::Expired, + GOING_AWAY => Error::GoingAway, _ => Error::Session(SessionError::Unauthorized), } } +/// Refuse an AUTH past our GOAWAY cutoff with AUTH_ERROR, the only answer its presenter reads. +#[cfg(feature = "async")] +pub(super) async fn refuse_going_away( + mut stream: Stream, +) -> Result<(), Error> { + let reply = AuthError { + code: GOING_AWAY, + reason: "going away".to_string(), + }; + stream.writer.encode_message(&reply).await?; + // A peer dropping the response after reading the refusal is a normal end. + let _ = stream.writer.close().await; + Ok(()) +} + /// What the peer's connection credential earns by default: publishing what our /// subscribe half accepts, and subscribing to what our publish half serves. pub(super) fn peer_grant( @@ -387,9 +405,9 @@ impl Present { }; let err = from_code(refused.code); tracing::warn!(%err, code = refused.code, reason = %refused.reason, "auth token refused"); - // A grant the acceptor could not tell is unknown, not empty, so only a - // real refusal settles the union. - if !matches!(err, Error::Unsupported) { + // A grant the acceptor could not tell, or never judged, is unknown, not + // empty, so only a real refusal settles the union. + if !matches!(err, Error::Unsupported | Error::GoingAway) { self.handle.refused(self.id); } return err; diff --git a/rs/moq-net/src/ietf/session.rs b/rs/moq-net/src/ietf/session.rs index b0d44a01a63..8eb57208d2d 100644 --- a/rs/moq-net/src/ietf/session.rs +++ b/rs/moq-net/src/ietf/session.rs @@ -1346,22 +1346,7 @@ impl Bidi { ) { let request_id = RequestId::decode(&mut data.decoder(version), version)?; match publisher.control.accept(request_id) { - Err(Error::GoingAway) => { - return super::request_stream::reject( - stream, - ietf::RequestError { - request_id: None, - error_code: super::error::request::to_code( - &Error::GoingAway, - super::error::request::Kind::Subscribe, - version, - ), - reason_phrase: "going away".into(), - retry_interval: 0, - }, - ) - .await; - } + Err(Error::GoingAway) => return refuse_going_away(stream, id, version).await, result => { result?; } @@ -1409,6 +1394,32 @@ impl Bidi { } } +/// Refuse a request past our GOAWAY cutoff with the answer its kind reads: an AUTH +/// presenter reads only AUTH_OK and AUTH_ERROR. +async fn refuse_going_away( + stream: Stream, + id: u64, + version: Version, +) -> Result<(), Error> { + if id == auth::Auth::ID { + return auth::refuse_going_away(stream).await; + } + super::request_stream::reject( + stream, + ietf::RequestError { + request_id: None, + error_code: super::error::request::to_code( + &Error::GoingAway, + super::error::request::Kind::Subscribe, + version, + ), + reason_phrase: "going away".into(), + retry_interval: 0, + }, + ) + .await +} + /// Monitor the peer's SETUP stream for GOAWAY until the session closes. /// A FIN or reset of this control stream is a protocol violation. async fn run_goaway( @@ -3475,6 +3486,29 @@ mod tests { closes.first().map(|(code, _)| SessionError::from_code(*code)) } + /// A request past our GOAWAY cutoff is refused in the answer its kind reads: an AUTH + /// with AUTH_ERROR carrying GOING_AWAY, since its presenter takes anything else as a + /// violation, and the rest with REQUEST_ERROR. + #[moq_clock::test] + async fn a_request_past_our_goaway_is_refused_in_its_own_answer() { + const VERSION: Version = Version::Draft18; + let reason = b"going away"; + let body = [&[0x6, reason.len() as u8][..], reason].concat(); + for (id, answer) in [ + (auth::Auth::ID, frame(VERSION, auth::AuthError::ID, &body)), + ( + ietf::Subscribe::ID, + frame(VERSION, ietf::RequestError::ID, &[&[0x6, 0][..], &body[1..]].concat()), + ), + ] { + let mut session = crate::lite::test_transport::ScriptedSession::new(Vec::new()); + let log = session.log.clone(); + let stream = Stream::open(&mut session, VERSION).await.unwrap(); + refuse_going_away(stream, id, VERSION).await.unwrap(); + assert_eq!(*log.writes.lock().unwrap(), answer, "{id:#x}"); + } + } + /// A malformed request closes the session with the draft's code: a Request ID of the /// wrong parity, a namespace or name outside its bounds, or a body that does not fill /// its length. diff --git a/rs/moq-net/tests/integration/track_tail.rs b/rs/moq-net/tests/integration/track_tail.rs index 5f148b8d29a..1b4aa4bbe94 100644 --- a/rs/moq-net/tests/integration/track_tail.rs +++ b/rs/moq-net/tests/integration/track_tail.rs @@ -144,6 +144,11 @@ async fn round(version: &str, late: Late, final_sequence: u64) -> Outcome { moq_clock::timeout(TIMEOUT, support::harness::subscribed(&track)) .await .expect("no subscriber appeared"); + // Let the publisher answer while the track is still empty. Before draft 20, a group + // written first sits below SUBSCRIBE_OK's Largest Object, so it would arrive as a + // joining FETCH, which the track ending first refuses, not as the subscription's own + // late stream. Paused time advances only once every task is idle. + moq_clock::sleep(Duration::from_millis(1)).await; pair.server_transport.hold_unis(); if final_sequence > 0 { From 4f438906c918f81066f312e99440976c7e241a3c Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 19 Oct 2026 21:08:40 -0700 Subject: [PATCH 7/8] fix(net): re-offer a JS advertisement whose idle answer ends A draft-18+ PUBLISH_NAMESPACE keeps reading while idle, but in JS only a detached catch saw its stream end, so the request stayed in the loop's map and the namespace was never withdrawn or offered again. The idle reader now drops the request on a FIN or reset and wakes the announce loop, which re-offers it, as Rust already does. A Rust test pins that behavior. The auth draft's changelog records GOING_AWAY as an AUTH_ERROR code. Co-Authored-By: Claude Opus 5.5 --- drafts/draft-lcurley-moq-auth.md | 6 ++++ js/net/src/ietf/goaway.test.ts | 38 +++++++++++++++++++++++++ js/net/src/ietf/publisher.ts | 36 ++++++++++++++++++++---- rs/moq-net/src/ietf/publisher.rs | 48 ++++++++++++++++++++++++++++++++ 4 files changed, 122 insertions(+), 6 deletions(-) diff --git a/drafts/draft-lcurley-moq-auth.md b/drafts/draft-lcurley-moq-auth.md index 9243d800e07..a212c19d635 100644 --- a/drafts/draft-lcurley-moq-auth.md +++ b/drafts/draft-lcurley-moq-auth.md @@ -230,6 +230,12 @@ This document requests three registrations in the "MOQT Message Types" registry --- back +# Changelog + +## Since draft-lcurley-moq-auth-00 (in progress) + +- AUTH_ERROR can carry GOING_AWAY, refusing an AUTH past the acceptor's GOAWAY without refusing the token. + # Acknowledgments {:numbered="false"} diff --git a/js/net/src/ietf/goaway.test.ts b/js/net/src/ietf/goaway.test.ts index c29361a511a..bc208e82f08 100644 --- a/js/net/src/ietf/goaway.test.ts +++ b/js/net/src/ietf/goaway.test.ts @@ -264,4 +264,42 @@ for (const [version, alpn] of [ origin.close(); } }); + + for (const end of ["FIN", "reset"] as const) { + test(`${alpn} an idle advertisement whose answer ends by ${end} is offered again`, async () => { + const pair = createMockTransportPair(alpn); + const control = await Stream.open(pair.server, { version }); + await Stream.accept(pair.client, version); + const origin = new OriginProducer(); + origin.createBroadcast(Path.from("room")).announce(); + const connection = new Connection({ + url: new URL("https://relay.example/"), + quic: pair.server, + control, + maxRequestId: 100n, + version, + client: false, + publish: origin.consume(), + }); + const offered = async () => { + const request = await Stream.accept(pair.client, version); + if (!request) throw new Error("no advertisement"); + expect(await request.reader.u53()).toBe(PublishNamespace.id); + const msg = await PublishNamespace.decode(request.reader, version); + expect(msg.trackNamespace).toEqual(Path.from("room")); + return request; + }; + try { + const first = await offered(); + await first.writer.u53(RequestOk.id); + await new RequestOk({ requestId: undefined }).encode(first.writer, version); + if (end === "reset") first.writer.reset(new StreamError(StreamCode.Cancel)); + else first.writer.close(); + await offered(); + } finally { + connection.abort(); + origin.close(); + } + }); + } } diff --git a/js/net/src/ietf/publisher.ts b/js/net/src/ietf/publisher.ts index bb8edd95de5..464ef99d08f 100644 --- a/js/net/src/ietf/publisher.ts +++ b/js/net/src/ietf/publisher.ts @@ -326,6 +326,9 @@ export class Publisher { // told on request. On draft-16 and later {@link runSubscribeNamespace} also carries // every match: a NAMESPACE is discovery, not a second route. #advertised: Getter; + // Bumped when an idle draft-18+ advertisement ends without an update, so the announce + // loop re-offers it instead of holding a request the peer dropped. + #lapsed = new Signal(0); #publish?: OriginConsumer; // What every advertisement carries on a session that negotiated the MoQ Cluster @@ -1513,13 +1516,20 @@ export class Publisher { const grant = this.#grant.changed(() => resolve("changed")); // A token that ended leaves the request carrying it to be made again without. const ended = this.#auth?.ended.changed(() => resolve("changed")); + const lapsed = this.#lapsed.changed(() => resolve("changed")); dispose = () => { table(); grant(); ended?.(); + lapsed(); }; }); + // The peer no longer holds a namespace whose request ended while idle. + for (const key of [...ns.active.keys()]) { + if (!requests.has(key)) ns.active.delete(key); + } + const advertised = this.#advertised.peek(); if (!advertised) { dispose?.(); @@ -1783,7 +1793,7 @@ export class Publisher { if (answer === "held" && request) { const held: NamespaceRequest = { path, requestId, stream: request, auth }; requests.set(path, held); - if (this.#session.version >= Version.DRAFT_18) held.reply = this.#readAdvertisement(held); + if (this.#session.version >= Version.DRAFT_18) held.reply = this.#readAdvertisement(held, requests); } return answer; } catch (err: unknown) { @@ -1801,8 +1811,11 @@ export class Publisher { } } - // Keep reading while an advertisement is idle, so GOAWAY validation never waits for an update. - #readAdvertisement(request: NamespaceRequest): Promise { + /** + * Keep reading while an advertisement is idle, so GOAWAY validation never waits for an + * update. A stream that ends while idle drops the request, and the announce loop re-offers it. + */ + #readAdvertisement(request: NamespaceRequest, requests: Requests): Promise { const reply = nextMessage(request.stream.reader, this.#session.version, this.#session.client) .then((type) => { if (type !== undefined && !request.updating) @@ -1816,11 +1829,22 @@ export class Publisher { } throw err; }); - // A later update consumes the result; failures are acted on as soon as they arrive. - void reply.catch(() => undefined); + // A later update consumes an answer; an end is acted on as soon as it arrives. + void reply.then( + (type) => type === undefined && this.#lapse(request, requests), + () => this.#lapse(request, requests), + ); return reply; } + /** Drop an idle advertisement whose stream ended, unless an update already took it over. */ + #lapse(request: NamespaceRequest, requests: Requests) { + if (request.updating || requests.get(request.path) !== request) return; + requests.delete(request.path); + request.stream.abort(new StreamError(StreamCode.Cancel, { message: "advertisement ended" })); + this.#lapsed.update((n) => n + 1); + } + /** * Check a REQUEST_OK answering a PUBLISH_NAMESPACE. ACTIVE_COUNT only answers * SUBSCRIBE_NAMESPACE (MoQ Active Count), and the session closes over it here, with the @@ -1889,7 +1913,7 @@ export class Publisher { } this.#answered(await RequestOk.decode(reader, version)); request.updating = false; - if (version >= Version.DRAFT_18) request.reply = this.#readAdvertisement(request); + if (version >= Version.DRAFT_18) request.reply = this.#readAdvertisement(request, requests); return "held"; })(), ADVERTISE_TIMEOUT, diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index dcab74aedd0..25b89129f8e 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -14621,6 +14621,54 @@ mod tests { ); } + /// From draft 18 an idle advertisement keeps reading, so a peer that FINs or resets its + /// answer while nothing is pending has the namespace offered again. + #[moq_clock::test] + async fn an_idle_advertisement_that_ends_is_offered_again() { + use crate::transport::memory; + const VERSION: Version = Version::Draft18; + + for fin in [true, false] { + let origin = unheld_origin(); + let _cam = origin.announce("cam", crate::origin::Route::default()).unwrap(); + settle().await; + + let (session, mut peer) = memory::pair(memory::Config::default()); + let publisher = Publisher::new( + crate::time::sim(), + session, + origin.consume(), + Control::new(None, false), + None, + declared(Some(false)), + VERSION, + ); + let run = moq_clock::sim::spawn(publisher.run_publish_namespaces()); + + let mut offered = async || { + let mut stream = moq_clock::timeout(Duration::from_secs(10), Stream::accept(&mut peer, VERSION)) + .await + .expect("no advertisement") + .unwrap(); + assert_eq!(stream.reader.varint().await.unwrap(), ietf::PublishNamespace::ID); + let _: ietf::Body = stream.reader.decode().await.unwrap(); + stream + }; + let mut first = offered().await; + let mut ok = bytes::Bytes::from(publish_namespace_ok(VERSION).await); + first.writer.write_all(&mut ok).await.unwrap(); + // Paused time advances once every task is idle: the answer was read, and the + // advertisement is parked on its idle reader. + moq_clock::sleep(Duration::from_millis(1)).await; + match fin { + true => first.writer.finish().unwrap(), + false => first.writer.abort(&Error::Cancel), + } + offered().await; + assert!(!run.is_finished(), "fin={fin}: the loop ended"); + } + } + /// A peer that resets a request's stream while its renewal is in flight ends only that /// request: the loop keeps running and advertises the namespace afresh. #[moq_clock::test] From a37e6591f63c17bc3a26bd52a69f5564b7f2be22 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 19 Oct 2026 22:06:53 -0700 Subject: [PATCH 8/8] fix(net): back off re-offering an advertisement the peer keeps ending A draft-18+ PUBLISH_NAMESPACE whose stream ends while idle was re-offered at once in JS, so a peer that ends every advertisement it accepts drove a request stream per loop turn. Rust paced it on the shared retry timer, but that resets whenever the re-offer lands, so it never backed off either. Record each idle end as a refusal with a per-namespace wait that starts at RETRY_BASE and doubles to RETRY_MAX, cleared when another broadcast takes the path. Both regression tests check each repeated lapse waits at least twice as long. Co-Authored-By: Claude Opus 5.5 --- js/net/src/ietf/publisher.test.ts | 29 ++++++++++++++++ js/net/src/ietf/publisher.ts | 24 ++++++++++--- rs/moq-net/src/ietf/publisher.rs | 58 +++++++++++++++++++++++-------- 3 files changed, 93 insertions(+), 18 deletions(-) diff --git a/js/net/src/ietf/publisher.test.ts b/js/net/src/ietf/publisher.test.ts index f300507adef..5287493377f 100644 --- a/js/net/src/ietf/publisher.test.ts +++ b/js/net/src/ietf/publisher.test.ts @@ -1933,6 +1933,35 @@ test("a change while an update is unanswered waits for its answer", async () => } }); +/** + * From draft 18 an idle advertisement keeps reading, so one the peer ends is offered again. + * The wait doubles each time, so a peer that ends every advertisement it accepts gets them + * on a backoff instead of a stream per turn of the loop. + */ +test("an advertisement the peer keeps ending comes back on a growing backoff", async () => { + const { pub, origin, streams, close } = clustered(); + try { + origin.createBroadcast(Path.from("mine")).announce({ hops: [VIA], cost: 4n }); + void pub.runPublishNamespaces(); + + let stream = await take(streams); + for (const wait of [100, 200, 400, 800]) { + await acceptClustered(stream); + stream.writer.close(); + await flush(); + + // Just short of the wait, nothing has been offered yet. + await advance(wait - 50); + expect(streams).toHaveLength(0); + + await advanceUntil(() => streams.length > 0, 10_000); + stream = await take(streams); + } + } finally { + close(); + } +}); + /** * A peer that never answers an update cannot be assumed to hold either price, so the * request is dropped and the namespace comes back on a fresh one. diff --git a/js/net/src/ietf/publisher.ts b/js/net/src/ietf/publisher.ts index 464ef99d08f..1bfb9ce067f 100644 --- a/js/net/src/ietf/publisher.ts +++ b/js/net/src/ietf/publisher.ts @@ -1500,6 +1500,9 @@ export class Publisher { // Keyed by path. const ns: Namespaces = { active: new Map(), refused: new Map(), offered: new Map() }; + // How long to stay away the next time the peer ends each advertisement while idle, + // and the instance that wait is about. + const lapses = new Map(); let retry = 0; for (;;) { @@ -1525,9 +1528,16 @@ export class Publisher { }; }); - // The peer no longer holds a namespace whose request ended while idle. - for (const key of [...ns.active.keys()]) { - if (!requests.has(key)) ns.active.delete(key); + // The peer no longer holds a namespace whose request ended while idle. The wait + // before offering it again doubles each time, so a peer that ends every one it + // accepts sees them on a backoff rather than in a loop. + for (const [key, snap] of [...ns.active]) { + if (requests.has(key)) continue; + ns.active.delete(key); + const wait = lapses.get(key)?.wait ?? RETRY_BASE; + lapses.set(key, { snap, wait: Math.min(wait * 2, RETRY_MAX) }); + ns.refused.set(key, Instant.add(now(), Nano.fromMilli(Milli(wait)))); + ns.offered.set(key, snap); } const advertised = this.#advertised.peek(); @@ -1548,6 +1558,11 @@ export class Publisher { continue; updated.set(covered, candidates[0]); } + // Another broadcast at the path starts its backoff fresh, as a refusal does. + for (const [key, lapse] of lapses) { + const snap = updated.get(key); + if (snap === undefined || !sameInstance(lapse.snap, snap)) lapses.delete(key); + } const outstanding = await this.#reconcile(ns, updated, target); retry = outstanding ? Math.min(retry ? retry * 2 : RETRY_BASE, RETRY_MAX) : 0; @@ -1813,7 +1828,8 @@ export class Publisher { /** * Keep reading while an advertisement is idle, so GOAWAY validation never waits for an - * update. A stream that ends while idle drops the request, and the announce loop re-offers it. + * update. A stream that ends while idle drops the request, and the announce loop re-offers it + * after a backoff. */ #readAdvertisement(request: NamespaceRequest, requests: Requests): Promise { const reply = nextMessage(request.stream.reader, this.#session.version, this.#session.client) diff --git a/rs/moq-net/src/ietf/publisher.rs b/rs/moq-net/src/ietf/publisher.rs index 25b89129f8e..cb19eab2ce2 100644 --- a/rs/moq-net/src/ietf/publisher.rs +++ b/rs/moq-net/src/ietf/publisher.rs @@ -267,6 +267,8 @@ struct Watched { deferred: bool, /// What the peer's refusal said about coming back, which outranks that timer. refused: Refused, + /// How long to stay away the next time the peer ends this advertisement while idle. + lapse: Duration, } /// What a refusal said about re-offering the namespace. @@ -314,8 +316,17 @@ impl Watched { sent: Advert::None, deferred: false, refused: Refused::No, + lapse: RETRY_BASE, } } + + /// The peer ended an advertisement it had accepted. The wait doubles each time, so a + /// peer that ends every one it accepts sees them on a backoff rather than in a loop. + fn lapsed(&mut self, now: crate::time::Instant) -> Refused { + let wait = self.lapse; + self.lapse = (wait * 2).min(RETRY_MAX); + Refused::Until(now + wait) + } } /// What to advertise to this peer for one broadcast. @@ -3454,7 +3465,8 @@ where /// REQUEST_ERROR closed the stream and withdrew the advertisement (moq-transport Section /// 9.5.1), so the request is dropped and the retry re-offers it fresh. An unanswered /// update is dropped the same way, since a peer that ignored it cannot be assumed to hold - /// either version, and so is one the peer cancelled instead of answering. + /// either version, and so is one the peer cancelled instead of answering. An idle + /// advertisement the peer ends waits out its own growing backoff before coming back. async fn answered( &self, ns: &mut Namespaces, @@ -3465,7 +3477,7 @@ where let Some(request) = ns.requests.get_mut(&suffix) else { return Ok(()); }; - request.pending = None; + let idle = request.pending.take().is_none(); let absolute = self.origin.absolute(&request.path).to_owned(); // A reset stream ends only this request, like a FIN; a malformed answer is the peer's @@ -3484,6 +3496,15 @@ where ns.requests.remove(&suffix); Refused::No } + Answer::Ended if idle => { + tracing::debug!(broadcast = %absolute, "advertisement ended"); + self.withdraw_namespace(&mut ns.target, &mut ns.requests, suffix.clone()) + .await?; + let now = self.runtime.now(); + ns.watched + .get_mut(&suffix) + .map_or(Refused::No, |watch| watch.lapsed(now)) + } Answer::Ended => { tracing::debug!(broadcast = %absolute, "update cancelled"); // The peer closed its side; closing ours completes the withdrawal. @@ -14622,7 +14643,8 @@ mod tests { } /// From draft 18 an idle advertisement keeps reading, so a peer that FINs or resets its - /// answer while nothing is pending has the namespace offered again. + /// answer while nothing is pending has the namespace offered again, after a wait that + /// doubles each time so a peer ending every advertisement does not get a request loop. #[moq_clock::test] async fn an_idle_advertisement_that_ends_is_offered_again() { use crate::transport::memory; @@ -14654,17 +14676,25 @@ mod tests { let _: ietf::Body = stream.reader.decode().await.unwrap(); stream }; - let mut first = offered().await; - let mut ok = bytes::Bytes::from(publish_namespace_ok(VERSION).await); - first.writer.write_all(&mut ok).await.unwrap(); - // Paused time advances once every task is idle: the answer was read, and the - // advertisement is parked on its idle reader. - moq_clock::sleep(Duration::from_millis(1)).await; - match fin { - true => first.writer.finish().unwrap(), - false => first.writer.abort(&Error::Cancel), - } - offered().await; + let mut stream = offered().await; + for wait in [100, 200, 400, 800].map(Duration::from_millis) { + let mut ok = bytes::Bytes::from(publish_namespace_ok(VERSION).await); + stream.writer.write_all(&mut ok).await.unwrap(); + // Paused time advances once every task is idle: the answer was read, and the + // advertisement is parked on its idle reader. + moq_clock::sleep(Duration::from_millis(1)).await; + match fin { + true => stream.writer.finish().unwrap(), + false => stream.writer.abort(&Error::Cancel), + } + let ended = moq_clock::Instant::now(); + stream = offered().await; + assert!( + ended.elapsed() >= wait, + "fin={fin}: re-offered after {:?}", + ended.elapsed() + ); + } assert!(!run.is_finished(), "fin={fin}: the loop ended"); } }