diff --git a/drafts/draft-lcurley-moq-auth.md b/drafts/draft-lcurley-moq-auth.md index c202c7cccf7..a212c19d635 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. @@ -229,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/auth_session.ts b/js/net/src/auth_session.ts index 33532e0068b..dc326b35b9c 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)), @@ -540,8 +539,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/error.ts b/js/net/src/error.ts index 0a01d822d28..170b8725547 100644 --- a/js/net/src/error.ts +++ b/js/net/src/error.ts @@ -544,6 +544,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. @@ -551,8 +560,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 e8786c5e7c6..52a93d8ef0f 100644 --- a/js/net/src/ietf/adapter.ts +++ b/js/net/src/ietf/adapter.ts @@ -1,7 +1,7 @@ -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"; +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"; @@ -471,81 +471,90 @@ 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; - const updated = this.#updates.get(requestId); - if ((route === Route.Response || route === Route.ErrorResponse) && updated !== undefined) { - // A refused update leaves its request open: the answer is all it ends. - this.#updates.delete(requestId); - if (this.version === Version.DRAFT_16) this.#pushMessage(updated, typeId, size, body); - continue; - } + const { route, requestId } = classified; + const updated = this.#updates.get(requestId); + if ((route === Route.Response || route === Route.ErrorResponse) && updated !== undefined) { + // A refused update leaves its request open: the answer is all it ends. + this.#updates.delete(requestId); + if (this.version === Version.DRAFT_16) this.#pushMessage(updated, typeId, size, body); + 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; + 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; + // A closing session fails this stream too, which reports the session's error. + cause = + err instanceof ProtocolViolation || err instanceof RequestWindowError || sessionClosed(err) + ? error(err) + : new ProtocolViolation(error(err).message, { cause: err }); + throw cause; } finally { this.close(cause); } 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 13c42ddb0e8..e329365f39d 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, 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"; 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"; /** @@ -46,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; @@ -210,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 }); } } @@ -233,8 +237,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 +260,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 e84fd7a5bf7..9d50a2bbe0c 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"; @@ -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"; @@ -192,8 +192,15 @@ export class Connection implements Established { this.#close({ closeCode: err.code, reason: err.message }); return; } - console.error("adapter error", err); - this.#close(); + if (sessionClosed(err)) { + this.#close(); + return; + } + this.#violated( + err instanceof ProtocolViolation + ? err + : new ProtocolViolation("control stream failed", { cause: err }), + ); }); } @@ -613,33 +620,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 && !sessionClosed(err)) + 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..bc208e82f08 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,218 @@ 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(); + } + }); + + 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.test.ts b/js/net/src/ietf/publisher.test.ts index 797e3c5d259..f33eed8c224 100644 --- a/js/net/src/ietf/publisher.test.ts +++ b/js/net/src/ietf/publisher.test.ts @@ -2132,6 +2132,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 501bd7119dd..2d48c91f4da 100644 --- a/js/net/src/ietf/publisher.ts +++ b/js/net/src/ietf/publisher.ts @@ -60,6 +60,7 @@ import { import { RequestError, RequestOk } from "./request.ts"; import { cancelled, + ended, finCancels, malformed, namespaceUpdate, @@ -166,7 +167,14 @@ type Refused = "never" | number; type Answer = "held" | "dropped" | Refused; /** One open PUBLISH_NAMESPACE request. */ -type NamespaceRequest = { path: Path.Valid; requestId: bigint; stream: Stream; auth?: Auth }; +type NamespaceRequest = { + path: Path.Valid; + requestId: bigint; + stream: Stream; + auth?: Auth; + reply?: Promise; + updating?: boolean; +}; /** The open PUBLISH_NAMESPACE request per advertised path. */ type Requests = Map; @@ -321,6 +329,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 @@ -624,12 +635,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; @@ -1237,9 +1249,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) }), ); @@ -1472,6 +1483,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 (;;) { @@ -1488,13 +1502,27 @@ 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. 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(); if (!advertised) { dispose?.(); @@ -1513,6 +1541,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; @@ -1728,7 +1761,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( @@ -1754,11 +1788,19 @@ export class Publisher { })(), ); - if (answer === "held" && request) requests.set(path, { path, requestId, stream: request, auth }); + 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, requests); + } 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) @@ -1767,6 +1809,41 @@ 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 + * after a backoff. + */ + #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) + 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 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 @@ -1819,6 +1896,7 @@ export class Publisher { answer = await withTimeout( (async (): Promise => { const { writer, reader } = request.stream; + request.updating = true; await writer.u53(PublishNamespaceUpdate.id); const namespaceRequestId = version === Version.DRAFT_16 ? request.requestId : undefined; await new PublishNamespaceUpdate({ requestId, namespaceRequestId, update, token }).encode( @@ -1830,7 +1908,8 @@ export class Publisher { // can beat the answer. if (version === Version.DRAFT_16 && (await reader.done())) return "dropped"; - 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); @@ -1841,6 +1920,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, requests); return "held"; })(), ADVERTISE_TIMEOUT, @@ -1848,6 +1929,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); // Aborting a request riding the control stream tells the peer nothing, so it would @@ -1950,7 +2035,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 abf2d1be629..510dca53600 100644 --- a/js/net/src/ietf/request_stream.test.ts +++ b/js/net/src/ietf/request_stream.test.ts @@ -7,11 +7,11 @@ import { FetchError } from "./fetch.ts"; import { PublishError } from "./publish.ts"; import { PublishNamespaceError } from "./publish_namespace.ts"; import { RequestError } from "./request.ts"; -import { namespaceUpdate, refuse, refuseUpdate } from "./request_stream.ts"; +import { namespaceUpdate, nextMessage, refuse, refuseUpdate } from "./request_stream.ts"; import { SubscribeError } from "./subscribe.ts"; import { SubscribeNamespaceError } from "./subscribe_namespace.ts"; import { TRACK_STATUS_ERROR_14 } from "./track.ts"; -import { type IetfVersion, Version } from "./version.ts"; +import { type IetfVersion, Version, versionName } from "./version.ts"; test("an oversized or truncated namespace update type is a protocol violation", async () => { // Both drafts use leading-ones varints. @@ -21,9 +21,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); } } }); @@ -32,9 +30,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); } }); @@ -42,13 +38,41 @@ 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); +}); + /** A stream recording what is written to it. */ function recording(version: IetfVersion) { const written: number[] = []; diff --git a/js/net/src/ietf/request_stream.ts b/js/net/src/ietf/request_stream.ts index b08eed8643a..5184f364aa9 100644 --- a/js/net/src/ietf/request_stream.ts +++ b/js/net/src/ietf/request_stream.ts @@ -100,7 +100,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. @@ -108,21 +111,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 @@ -130,11 +153,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) => { @@ -165,6 +188,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 9e40a3aa33f..bf621937bc1 100644 --- a/js/net/src/ietf/subscriber.ts +++ b/js/net/src/ietf/subscriber.ts @@ -65,7 +65,7 @@ import { PublishNamespaceUpdate, } from "./publish_namespace.ts"; import { RequestError, RequestOk } from "./request.ts"; -import { finCancels, refuse, refuseReserved, refuseUpdate } from "./request_stream.ts"; +import { finCancels, nextMessage, refuse, refuseReserved, refuseUpdate } from "./request_stream.ts"; import { joinFilter, Subscribe, SubscribeError, SubscribeOk, SubscribeUpdate, Unsubscribe } from "./subscribe.ts"; import { PublishBlocked, @@ -571,7 +571,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 @@ -604,14 +605,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`); @@ -691,6 +691,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)}`); @@ -842,6 +843,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); @@ -957,6 +959,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); @@ -991,8 +994,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)}`); @@ -1171,7 +1174,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 { @@ -1324,13 +1328,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. @@ -1471,6 +1477,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 @@ -1568,6 +1575,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 c001c7da834..31b18d2d737 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. @@ -160,58 +161,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(); } /// Publications held behind unanswered tokens, sweeping both the token table and paths. diff --git a/rs/moq-net/src/ietf/adapter.rs b/rs/moq-net/src/ietf/adapter.rs index c9ccf2a4f7f..45fc6ddd16e 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; } @@ -960,11 +961,27 @@ 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. 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).await?; + writer + .write_all(&mut buf) + .await + .map_err(super::session::control_stream_error)?; } Ok(()) } @@ -976,12 +993,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); @@ -2109,6 +2134,48 @@ 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 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 0cceeaed4bd..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( @@ -328,14 +346,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 +367,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. @@ -386,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; @@ -409,18 +428,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 +447,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 +471,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 { @@ -489,6 +506,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")] @@ -498,6 +528,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,12 +538,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) = stream.reader.poll_read_chunk(&mut cx, 1).map(|res| { - res.and_then(|chunk| match chunk { - 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/control.rs b/rs/moq-net/src/ietf/control.rs index be873ada8c5..5698a3b05b4 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,19 @@ impl Control { self } + /// 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 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(cutoff)) + } + 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 +207,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 +322,35 @@ 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 + 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 + 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))); + } + 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 9df2e28c9a7..14da04d6b7d 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. @@ -393,11 +404,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, } } @@ -406,7 +418,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 { @@ -416,7 +428,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; @@ -1127,6 +1141,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 @@ -1352,6 +1367,7 @@ where &mut stream, &mut track_serve, &mut request_finished, + &mut goaways, fill, request_grant.clone(), ) @@ -1378,6 +1394,7 @@ where if super::request_stream::poll_cancel( &mut stream, &mut request_finished, + &mut goaways, self.version, &mut cx, ) @@ -1468,6 +1485,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 { @@ -1485,7 +1503,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::GoAways::new(self.control.client()); // What one turn of the loop resolved to. enum Turn { @@ -1545,8 +1562,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", @@ -1682,6 +1703,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() @@ -2399,9 +2421,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) { @@ -2635,13 +2660,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) { @@ -2757,9 +2785,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() { @@ -2876,6 +2907,7 @@ where target, watched, requests, + woken, updates, .. } = ns; @@ -2975,6 +3007,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. @@ -3071,7 +3111,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); }; @@ -3112,6 +3153,7 @@ where requests.insert( suffix, NamespaceRequest { + messages, path: path.clone(), request_id, stream: request, @@ -3259,6 +3301,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. @@ -3268,18 +3311,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)); } } @@ -3300,7 +3352,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, @@ -3311,7 +3364,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 @@ -3340,6 +3393,15 @@ where } 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. @@ -3446,10 +3508,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); @@ -3760,7 +3825,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(()); @@ -3831,7 +3896,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. @@ -3864,13 +3931,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 @@ -5095,6 +5166,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, @@ -6066,6 +6138,141 @@ 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 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), + RequestId(0), + version, + ServeRange::default(), + None, + ); + let served = h + .publisher + .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()); + 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); + } + + #[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() @@ -6139,6 +6346,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), @@ -6148,11 +6357,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), @@ -6185,6 +6397,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), @@ -6194,9 +6408,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}"); } } @@ -6277,6 +6491,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), @@ -6286,11 +6501,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); @@ -6308,6 +6526,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), @@ -6318,11 +6537,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(); @@ -6348,6 +6570,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), @@ -6359,7 +6582,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))), @@ -6574,6 +6797,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), @@ -6586,7 +6810,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:?}"); @@ -6732,6 +6956,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), @@ -6741,11 +6967,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}"); @@ -6775,6 +7004,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), @@ -6786,7 +7017,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))), @@ -6947,10 +7178,13 @@ mod serve_tests { None, ); let mut finished = false; + let mut goaways = + super::super::request_stream::Messages::new(h.session.clone(), h.publisher.control.client()); let mut run = std::pin::pin!(h.publisher.run_subscription( &mut stream, &mut serving, &mut finished, + &mut goaways, async {}, None )); @@ -6974,6 +7208,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), @@ -6985,7 +7221,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))), @@ -7055,6 +7291,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), @@ -7066,7 +7304,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(_))), @@ -7154,6 +7392,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), @@ -7163,11 +7403,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()) { @@ -7196,6 +7439,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), @@ -7206,7 +7451,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(_))))), @@ -7228,6 +7473,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), @@ -7239,7 +7486,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(_))))), @@ -12230,6 +12477,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), @@ -12239,11 +12488,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()) { @@ -13875,9 +14127,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( @@ -13961,8 +14214,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(), @@ -13984,6 +14238,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)) @@ -14026,9 +14283,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( @@ -14167,8 +14425,14 @@ mod tests { .unwrap(); settle().await; + // From draft 18 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 script = match version { + Version::Draft16 => [ok.clone(), ok].concat(), + _ => ok, + }; + let (publisher, log) = auth_publisher(&origin, &auth, vec![script], version); let mut run = std::pin::pin!(publisher.run_publish_namespaces()); poll_until(&mut run, &log, b"cam", 1).await; assert_eq!( @@ -14432,6 +14696,63 @@ 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, 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; + 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 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"); + } + } + /// 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] @@ -14447,8 +14768,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, @@ -14461,6 +14783,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; @@ -14599,12 +14924,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(), @@ -14626,6 +14952,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 d269386deb2..1e58348b9a4 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,86 @@ impl GoAways { } Ok(()) } + + /// 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>> { + 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. @@ -259,7 +340,8 @@ pub(super) struct Update { pub(super) request_id: super::RequestId, pub(super) priority: Option, pub(super) max_age: 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, @@ -437,6 +519,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. @@ -456,10 +592,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 ))); @@ -481,6 +619,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 d0b86d5de84..8c7b01bd03e 100644 --- a/rs/moq-net/src/ietf/session.rs +++ b/rs/moq-net/src/ietf/session.rs @@ -389,37 +389,25 @@ 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. Only a failure + // ends the session; the other branches report how it closed. + let setup = err_only(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 +567,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(err) = waiter.poll_future(setup.as_mut()) { + return Poll::Ready(Err(err)); } if task_set.poll(waiter).is_ready() { return Poll::Ready(Ok(())); @@ -785,13 +773,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); @@ -825,38 +813,62 @@ 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 - // 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() { - 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) + 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; + .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(); @@ -1310,7 +1322,12 @@ 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 refuse_going_away(stream, id, version).await, + result => { + result?; + } + } } match id { // Draft-16 moved SUBSCRIBE_NAMESPACE to its own stream, past the control stream @@ -1354,25 +1371,52 @@ 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. +/// 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( 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, 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(_) | Error::IdleTimeout) { + err + } else { + Error::ProtocolViolation } } @@ -1426,7 +1470,7 @@ async fn read_goaways( timeout, })?; } - Ok(()) + Err(Error::ProtocolViolation) } /// Closes the auth handle when the session driver ends without finishing, releasing @@ -3132,10 +3176,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"))) } @@ -3150,7 +3195,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:?}"); } } @@ -3170,7 +3215,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:?}"); } } @@ -3218,12 +3263,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] @@ -3312,37 +3384,41 @@ 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 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_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 + 2)); assert_eq!(occurrences(&log, &sent), 1, "client={client}"); + assert!(matches!(control.accept(RequestId(first + 2)), Err(Error::GoingAway))); } } @@ -3380,10 +3456,38 @@ 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)) } + /// 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/src/ietf/subscriber.rs b/rs/moq-net/src/ietf/subscriber.rs index 38e8325b1df..499c3453c8c 100644 --- a/rs/moq-net/src/ietf/subscriber.rs +++ b/rs/moq-net/src/ietf/subscriber.rs @@ -1128,8 +1128,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 { @@ -1191,6 +1191,7 @@ where negotiated, &mut live, Initial { initial, snapshot }, + &mut messages, ) .await; for (path, advert) in live { @@ -1206,6 +1207,7 @@ where /// `live` tracks the suffixes this stream has advertised, so a repeat is recognized /// as an update rather than a second advertisement, and the caller can release /// whatever is still held when the stream ends. + #[allow(clippy::too_many_arguments)] async fn run_namespace_entries( &mut self, stream: &mut Stream, @@ -1214,19 +1216,19 @@ where negotiated: ietf::Negotiated, live: &mut HashMap, 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 { @@ -1695,6 +1697,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; @@ -1734,10 +1737,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)) } @@ -1758,7 +1758,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 @@ -1858,8 +1869,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 @@ -2055,6 +2078,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", @@ -2797,9 +2823,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()); @@ -3068,7 +3095,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() { @@ -3374,17 +3406,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); @@ -3394,7 +3424,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 => { @@ -3615,8 +3644,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); @@ -3628,8 +3658,31 @@ where .await }; if accepted { - // The request stays open while the subscription still needs its fill. - kio::wait(cancelled).await; + // 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(); + match messages.poll_end(&mut stream.reader, &mut cx) { + 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); } @@ -3639,9 +3692,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 { @@ -3661,10 +3717,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 { @@ -3814,8 +3873,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 { @@ -4860,11 +4919,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 { @@ -4995,7 +5055,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)), @@ -5055,9 +5115,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 { @@ -5642,8 +5705,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 { diff --git a/rs/moq-net/tests/integration/auth.rs b/rs/moq-net/tests/integration/auth.rs index 56012543ff3..8f915dfb52b 100644 --- a/rs/moq-net/tests/integration/auth.rs +++ b/rs/moq-net/tests/integration/auth.rs @@ -155,9 +155,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(); diff --git a/rs/moq-net/tests/integration/track_tail.rs b/rs/moq-net/tests/integration/track_tail.rs index cb191abe486..22733723167 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 {