From c2671925824f01504482596b8102b3badeafe544 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 7 Nov 2026 00:39:12 -0800 Subject: [PATCH 01/11] chore(quest): claim quest/a0/node-session-lifetime.md Quest-Claim: 722e2fa487901171 From e3cd41161e00a69a9e6f1e8c358466aed55bc24c Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 7 Nov 2026 00:54:01 -0800 Subject: [PATCH 02/11] fix(node)!: reject session failures and release abandoned readers Preserve normal close details while exposing connection failures as session-sourced WebTransportError rejections. Wake owned read futures on cancellation or collection and keep pending read callbacks weak. Co-Authored-By: GPT-6.1 Sol --- js/web-transport/README.md | 9 + js/web-transport/napi.d.cts | 2 +- js/web-transport/package.json | 2 +- js/web-transport/src/session.ts | 63 +++++-- .../tests/fixtures/abandoned-reader.ts | 26 +++ js/web-transport/tests/session.test.ts | 171 +++++++++++++++++- quest/a0/README.md | 1 - quest/a0/node-server-close.md | 3 - quest/a0/node-session-lifetime.md | 32 ---- rs/web-transport-node/Cargo.toml | 2 +- .../examples/session-peer.rs | 32 ++++ rs/web-transport-node/src/lib.rs | 149 +++++++++------ 12 files changed, 374 insertions(+), 118 deletions(-) create mode 100644 js/web-transport/tests/fixtures/abandoned-reader.ts delete mode 100644 quest/a0/node-session-lifetime.md create mode 100644 rs/web-transport-node/examples/session-peer.rs diff --git a/js/web-transport/README.md b/js/web-transport/README.md index eddd00cc..916c5532 100644 --- a/js/web-transport/README.md +++ b/js/web-transport/README.md @@ -147,6 +147,11 @@ await writer.abort(new WebTransportError("cancelled", { streamErrorCode: 7 })); ### Closing +`session.closed` resolves with the application code and reason after a local or peer close, +including nonzero application codes. A failed connection or an underlying connection +failure rejects it with a `WebTransportError` whose `source` is `"session"` and +`streamErrorCode` is `null`. `session.ready` rejects with the same error if connecting fails. + ```ts // Close gracefully session.close({ closeCode: 0, reason: "done" }); @@ -156,6 +161,10 @@ const info = await session.closed; console.log(info.closeCode, info.reason); ``` +Cancel a reader when finished to release its receive stream immediately, even during a +pending read. If every reference to the reader and readable stream is abandoned, garbage +collection also releases the native stream and stops the peer with stream error code 0. + ## License MIT OR Apache-2.0 diff --git a/js/web-transport/napi.d.cts b/js/web-transport/napi.d.cts index e1b35f7a..6467497d 100644 --- a/js/web-transport/napi.d.cts +++ b/js/web-transport/napi.d.cts @@ -102,7 +102,7 @@ export declare class NapiSession { maxDatagramSize(): number; /** Close the session with a code and reason. */ close(code: number, reason: string): void; - /** Wait for the session to close, returning close info matching W3C WebTransportCloseInfo. */ + /** Wait for normal closure with its application details, or reject on a connection failure. */ closed(): Promise; } diff --git a/js/web-transport/package.json b/js/web-transport/package.json index 08e0cc07..e856e26c 100644 --- a/js/web-transport/package.json +++ b/js/web-transport/package.json @@ -28,7 +28,7 @@ "scripts": { "build": "napi build --platform --release --manifest-path ../../rs/web-transport-node/Cargo.toml --output-dir . --js napi.cjs --dts napi.d.cts && biome check --write napi.cjs napi.d.cts", "check": "tsc --project tsconfig.tests.json --noEmit", - "test": "bun test tests", + "test": "cargo build -p web-transport-node --example session-peer && bun test tests", "release": "bun scripts/release.ts" }, "devDependencies": { diff --git a/js/web-transport/src/session.ts b/js/web-transport/src/session.ts index 0a8ce332..9afe6dbf 100644 --- a/js/web-transport/src/session.ts +++ b/js/web-transport/src/session.ts @@ -6,23 +6,44 @@ import { fromNapi, resetCode, sessionError } from "./error.ts"; const { NapiClient } = napi; function wrapRecvStream(recv: NapiRecvStream): ReadableStream { + const state = { reading: false, cancelled: false }; return new ReadableStream({ - async pull(controller) { - const chunk = await recv.read(65536); - if (chunk === null) { - controller.close(); - } else if (chunk instanceof Uint8Array) { - controller.enqueue(new Uint8Array(chunk)); - } else { - controller.error(fromNapi(chunk)); - } + pull(controller) { + if (state.reading) return; + state.reading = true; + readChunk(recv.read(65536), controller, state); }, cancel(reason) { - recv.stop(resetCode(reason)).catch(() => {}); + state.cancelled = true; + return recv.stop(resetCode(reason)); }, }); } +// Returning the pending native promise from pull would let the Web Streams machinery +// retain the controller and its stream. Only this weak callback waits for the read. +function readChunk( + read: ReturnType, + controller: ReadableStreamDefaultController, + state: { reading: boolean; cancelled: boolean }, +) { + const ref = new WeakRef(controller); + void read.then( + (chunk) => { + state.reading = false; + const controller = ref.deref(); + if (!controller || state.cancelled) return; + if (chunk === null) controller.close(); + else if (chunk instanceof Uint8Array) controller.enqueue(new Uint8Array(chunk)); + else controller.error(fromNapi(chunk)); + }, + (err: unknown) => { + state.reading = false; + if (!state.cancelled) ref.deref()?.error(err); + }, + ); +} + // A STOP_SENDING or session failure errors the stream even while nothing is being written. // Declared outside wrapSendStream and holding the controller weakly, so the pending watch does not // keep an abandoned stream (and its native handle) alive, which would withhold its implicit FIN. @@ -77,6 +98,13 @@ export default class Session implements WebTransport { const closed = Promise.withResolvers(); this.ready = ready.promise; this.closed = closed.promise; + // The spec marks lifecycle promises handled; callers can still await their rejections. + void this.ready.catch(() => {}); + void this.closed.catch(() => {}); + + const watchSession = (session: NapiSession) => { + void session.closed().then(closed.resolve, (err: unknown) => closed.reject(sessionError(err))); + }; // Check if we got an existing NapiSession (server-side path) if (typeof urlOrSession === "object" && !(urlOrSession instanceof URL)) { @@ -85,9 +113,7 @@ export default class Session implements WebTransport { ready.resolve(); - urlOrSession.closed().then((info) => { - closed.resolve({ closeCode: info.closeCode, reason: info.reason }); - }); + watchSession(urlOrSession); } else { // Client-side: create NapiClient and connect const url = typeof urlOrSession === "string" ? urlOrSession : urlOrSession.toString(); @@ -131,14 +157,13 @@ export default class Session implements WebTransport { (this.datagrams as DeferredDatagrams).bind(session); ready.resolve(); - session.closed().then((info) => { - closed.resolve({ closeCode: info.closeCode, reason: info.reason }); - }); + watchSession(session); }) .catch((err) => { - (this.datagrams as DeferredDatagrams).fail(err instanceof Error ? err : new Error(String(err))); - ready.reject(err instanceof Error ? err : new Error(String(err))); - closed.resolve({ closeCode: 0, reason: String(err) }); + const error = sessionError(err); + (this.datagrams as DeferredDatagrams).fail(error); + ready.reject(error); + closed.reject(error); }); } } diff --git a/js/web-transport/tests/fixtures/abandoned-reader.ts b/js/web-transport/tests/fixtures/abandoned-reader.ts new file mode 100644 index 00000000..54aa1634 --- /dev/null +++ b/js/web-transport/tests/fixtures/abandoned-reader.ts @@ -0,0 +1,26 @@ +import { setImmediate } from "node:timers/promises"; +import Session from "../../src/session.ts"; + +const url = process.argv[2]; +if (!url || !globalThis.gc) throw new Error("requires a peer URL and --expose-gc"); +const session = new Session(url, { serverCertificateDisableVerify: true }); +await session.ready; + +await (async () => { + const { value: readable } = await session.incomingUnidirectionalStreams.getReader().read(); + if (!readable) throw new Error("no stream"); + const reader = readable.getReader(); + await reader.read(); + void reader.read(); +})(); + +// The peer closes the Session after observing STOP_SENDING from reader collection. +let closed = false; +const closure = session.closed.then(() => { + closed = true; +}); +while (!closed) { + globalThis.gc(); + await setImmediate(); +} +await closure; diff --git a/js/web-transport/tests/session.test.ts b/js/web-transport/tests/session.test.ts index bae50458..34724353 100644 --- a/js/web-transport/tests/session.test.ts +++ b/js/web-transport/tests/session.test.ts @@ -1,8 +1,12 @@ import { beforeAll, expect, test } from "bun:test"; import { createSocket } from "node:dgram"; +import { join } from "node:path"; +import { fileURLToPath } from "node:url"; import Session, { install, Server, WebTransportError } from "../src/index.ts"; let url: string; +let pem: Buffer; +let peerExecutable: string; // The peer of each client session, in connect order. const accepted: Session[] = []; @@ -10,7 +14,7 @@ const waiters: ((session: Session) => void)[] = []; beforeAll(async () => { // One PEM holding both the certificate and its key; the server reads each block out of it. - const pem = Bun.spawnSync( + const certificate = Bun.spawnSync( [ "openssl", "req", @@ -29,10 +33,19 @@ beforeAll(async () => { ], { stderr: "pipe" }, ); - if (!pem.success) throw new Error(`openssl failed: ${pem.stderr}`); + if (!certificate.success) throw new Error(`openssl failed: ${certificate.stderr}`); + pem = certificate.stdout; + const metadata = Bun.spawnSync(["cargo", "metadata", "--no-deps", "--format-version", "1"]); + if (!metadata.success) throw new Error(`cargo metadata failed: ${metadata.stderr}`); + peerExecutable = join( + JSON.parse(metadata.stdout.toString()).target_directory, + "debug", + "examples", + `session-peer${process.platform === "win32" ? ".exe" : ""}`, + ); const port = await freePort(); - const server = Server.bind(`127.0.0.1:${port}`, pem.stdout, pem.stdout); + const server = Server.bind(`127.0.0.1:${port}`, pem, pem); url = `https://127.0.0.1:${port}`; void (async () => { @@ -87,6 +100,62 @@ test("install() defines WebTransportError alongside WebTransport", () => { } }); +test("a failed TLS connection rejects ready and closed with a session error", async () => { + // The loopback server has a self-signed certificate, which system roots reject. + const client = new Session(url); + const closed = rejection(client.closed); + const ready = await rejection(client.ready); + expect(ready.source).toBe("session"); + expect(ready.streamErrorCode).toBeNull(); + expect(await closed).toBe(ready); +}); + +test("local and peer closes preserve nonzero application codes and reasons", async () => { + const { client, peer } = await connect(); + const info = { closeCode: 42, reason: "done" }; + client.close(info); + client.close({ closeCode: 43, reason: "ignored" }); + expect(await client.closed).toEqual(info); + expect(await peer.closed).toEqual(info); +}); + +for (const side of ["client", "server"] as const) { + test(`an underlying connection failure rejects the ${side} Session.closed`, async () => { + const child = Bun.spawn([peerExecutable, ...(side === "server" ? [url] : [])], { + env: { ...process.env, WEB_TRANSPORT_TEST_PEM: pem.toString() }, + stdin: "pipe", + stdout: "pipe", + stderr: "pipe", + }); + let session: Session | undefined; + try { + if (side === "client") { + const { value } = await child.stdout.getReader().read(); + if (!value) throw new Error("peer did not print its address"); + session = new Session(new TextDecoder().decode(value).trim(), { serverCertificateDisableVerify: true }); + await session.ready; + } else { + session = accepted.shift() ?? (await new Promise((resolve) => waiters.push(resolve))); + } + const closed = rejection(session.closed); + await session.datagrams.writable.getWriter().write(new Uint8Array([1])); + const err = await closed; + expect(err.source).toBe("session"); + expect(err.streamErrorCode).toBeNull(); + // A late local close must not turn an already observed failure into success. + session.close(); + expect(await rejection(session.closed)).toBe(err); + child.stdin.end(); + expect(await child.exited).toBe(0); + expect(await new Response(child.stderr).text()).toBe(""); + } finally { + session?.close(); + child.kill(); + await child.exited; + } + }); +} + test("a peer's RESET_STREAM errors the reader with its code", async () => { const { client, peer } = await connect(); @@ -191,3 +260,99 @@ test("an abandoned writer still finishes its stream", async () => { client.close(); }); + +test("cancelling a pending read stops the peer with the requested code", async () => { + const { client, peer } = await connect(); + try { + const writer = (await peer.createUnidirectionalStream()).getWriter(); + await writer.write(new Uint8Array([1])); + const { value: readable } = await client.incomingUnidirectionalStreams.getReader().read(); + if (!readable) throw new Error("no stream"); + const reader = readable.getReader(); + await reader.read(); + const read = reader.read(); + // Let the native call park before cancellation has to wake it. + await new Promise(setImmediate); + await reader.cancel(new WebTransportError("cancel", { streamErrorCode: 17 })); + expect((await read).done).toBe(true); + const err = await rejection(writer.closed); + expect(err.source).toBe("stream"); + expect(err.streamErrorCode).toBe(17); + } finally { + client.close(); + } +}); + +test("concurrent read requests keep pulling through data and FIN", async () => { + const { client, peer } = await connect(); + try { + const writer = (await peer.createUnidirectionalStream()).getWriter(); + await writer.write(new Uint8Array([1])); + const { value: readable } = await client.incomingUnidirectionalStreams.getReader().read(); + if (!readable) throw new Error("no stream"); + const reader = readable.getReader(); + expect((await reader.read()).value).toEqual(new Uint8Array([1])); + const first = reader.read(); + const second = reader.read(); + await writer.write(new Uint8Array([2])); + expect((await first).value).toEqual(new Uint8Array([2])); + await writer.write(new Uint8Array([3])); + expect((await second).value).toEqual(new Uint8Array([3])); + await writer.close(); + expect((await reader.read()).done).toBe(true); + } finally { + client.close(); + } +}); + +test("an abandoned reader stops its stream while a read is pending", async () => { + const { client, peer } = await connect(); + try { + const writer = (await peer.createUnidirectionalStream()).getWriter(); + await writer.write(new Uint8Array([1])); + await (async () => { + const { value: readable } = await client.incomingUnidirectionalStreams.getReader().read(); + if (!readable) throw new Error("no stream"); + const reader = readable.getReader(); + expect((await reader.read()).value).toEqual(new Uint8Array([1])); + void reader.read(); + })(); + + let stopped = false; + const closed = rejection(writer.closed).then((err) => { + expect(err.source).toBe("stream"); + expect(err.streamErrorCode).toBe(0); + stopped = true; + }); + // GC is only needed to trigger abandonment; the native drop/wakeup path is also + // exercised deterministically by cancelling a pending read above. + while (!stopped) { + Bun.gc(true); + await new Promise(setImmediate); + } + await closed; + } finally { + client.close(); + } +}); + +test("Node collects a reader with a pending native read", async () => { + const fixture = new URL("fixtures/abandoned-reader.ts", import.meta.url); + const child = Bun.spawn(["node", "--expose-gc", fileURLToPath(fixture), url], { stdout: "pipe", stderr: "pipe" }); + let peer: Session | undefined; + try { + peer = accepted.shift() ?? (await new Promise((resolve) => waiters.push(resolve))); + const writer = (await peer.createUnidirectionalStream()).getWriter(); + await writer.write(new Uint8Array([1])); + const err = await rejection(writer.closed); + expect(err.source).toBe("stream"); + expect(err.streamErrorCode).toBe(0); + peer.close(); + expect(await child.exited).toBe(0); + expect(await new Response(child.stderr).text()).toBe(""); + } finally { + peer?.close(); + child.kill(); + await child.exited; + } +}); diff --git a/quest/a0/README.md b/quest/a0/README.md index 26ce85f5..e5b44ca2 100644 --- a/quest/a0/README.md +++ b/quest/a0/README.md @@ -17,4 +17,3 @@ The Required list is ordered by priority. Independent children may proceed concu - [QMux initial stream-count bound](/quest/a0/qmux-max-streams-param.md) - refuse initial_max_streams parameters above 2^60 - [QMux stream-state checks](/quest/a0/qmux-stream-state.md) - refuse MAX_STREAM_DATA and STOP_SENDING for unopened local streams - [Node Server.close()](/quest/a0/node-server-close.md) - close completes while an accept is pending -- [Node session and reader lifetime](/quest/a0/node-session-lifetime.md) - `closed` rejects on an abnormal end, and an abandoned reader releases its stream diff --git a/quest/a0/node-server-close.md b/quest/a0/node-server-close.md index 445e7b2b..b8f0ccbd 100644 --- a/quest/a0/node-server-close.md +++ b/quest/a0/node-server-close.md @@ -14,9 +14,6 @@ Found while fixing [#470](https://github.com/moq-dev/web-transport/pull/470): hits. Find what both calls contend on (likely one lock held across the `accept` await) and let `close()` wake the waiter instead of waiting for it. -Decided 2026-10-28 (maintainer): its own quest in a0, apart from -[Node session and reader lifetime](/quest/a0/node-session-lifetime.md). - Add a loopback regression that fails without the fix: start the README's accept loop, wait until its `accept()` is pending in native code, then close the server and require both to finish, with `accept()` resolving to `null`. diff --git a/quest/a0/node-session-lifetime.md b/quest/a0/node-session-lifetime.md deleted file mode 100644 index 5ec2d00a..00000000 --- a/quest/a0/node-session-lifetime.md +++ /dev/null @@ -1,32 +0,0 @@ -# [S] Node session and reader lifetime - -## Goal - -In `@moq/web-transport`'s Node polyfill, `Session.closed` rejects with a -`WebTransportError` when a session ends abnormally, as browsers do, and an -abandoned reader's native stream is released even while a `read()` is -pending. - -## Plan - -Found while fixing [#470](https://github.com/moq-dev/web-transport/pull/470): - -- `Session.closed` (`js/web-transport/src/session.ts`) only resolves, so a - failed connect, a lost connection, or a peer's abnormal close never - rejects it. -- A pending `read()` keeps its native stream alive after the reader is - abandoned, because napi-rs keeps an object alive while one of its async - calls is pending. #470 hit the same cause on the writer side, for - STOP_SENDING, and fixed it there. - -Decided 2026-10-28 (maintainer): one quest for both, since they share the -session and stream teardown path, separate from -[Node Server.close()](/quest/a0/node-server-close.md). - -Add loopback regressions that fail without the fix: a failed connect and an -abnormal end each reject `closed` with the right `source` and code; dropping -every reference to a reader with a pending read, while the peer keeps the -stream open, makes the peer see the stream terminated, checked without -relying on GC timing where possible. - -Public API: `Session.closed` can now reject, matching the WebTransport spec. diff --git a/rs/web-transport-node/Cargo.toml b/rs/web-transport-node/Cargo.toml index d25509b6..61874988 100644 --- a/rs/web-transport-node/Cargo.toml +++ b/rs/web-transport-node/Cargo.toml @@ -16,7 +16,7 @@ http = "1" napi = { version = "3.10.0", features = ["async", "napi8"] } napi-derive = "3" rustls-pemfile = "2" -tokio = { version = "1", features = ["sync"] } +tokio = { version = "1", features = ["macros", "sync"] } url = "2" web-transport-quinn = { path = "../web-transport-quinn", version = "0.13" } diff --git a/rs/web-transport-node/examples/session-peer.rs b/rs/web-transport-node/examples/session-peer.rs new file mode 100644 index 00000000..37338456 --- /dev/null +++ b/rs/web-transport-node/examples/session-peer.rs @@ -0,0 +1,32 @@ +//! Loopback peer for the Node lifecycle tests, able to fail the underlying QUIC connection. + +use std::{io::Read, ops::Deref}; + +#[tokio::main(flavor = "current_thread")] +async fn main() -> Result<(), Box> { + let session = if let Some(url) = std::env::args().nth(1) { + let client = web_transport_quinn::ClientBuilder::new() + .dangerous() + .with_no_certificate_verification()?; + client.connect(url::Url::parse(&url)?).await? + } else { + let pem = std::env::var("WEB_TRANSPORT_TEST_PEM")?; + let pem = pem.as_bytes(); + let certs = rustls_pemfile::certs(&mut &pem[..]).collect::, _>>()?; + let key = rustls_pemfile::private_key(&mut &pem[..])?.ok_or("missing key")?; + let mut server = web_transport_quinn::ServerBuilder::new() + .with_addr("127.0.0.1:0".parse()?) + .with_certificate(certs, key)?; + println!("https://{}", server.local_addr()?); + server.accept().await.ok_or("server closed")?.ok().await? + }; + + // The JS side sends a datagram after attaching its closed handler, so the failure + // always occurs on an established Session rather than racing its handshake. + session.read_datagram().await?; + // QUIC application code 0 is outside WebTransport's HTTP/3 code space. + session.deref().close(0u32.into(), b"connection failure"); + // Await a second signal on stdin to keep the runtime alive while QUIC sends the close. + tokio::task::spawn_blocking(|| std::io::stdin().read(&mut [0])).await??; + Ok(()) +} diff --git a/rs/web-transport-node/src/lib.rs b/rs/web-transport-node/src/lib.rs index b6ac5ffb..77ee03a0 100644 --- a/rs/web-transport-node/src/lib.rs +++ b/rs/web-transport-node/src/lib.rs @@ -3,7 +3,7 @@ use std::sync::Arc; use napi::bindgen_prelude::*; use napi_derive::napi; -use tokio::sync::Mutex; +use tokio::sync::{watch, Mutex}; // Teardown safety: every `#[napi] async fn` below runs on napi-rs's global tokio // runtime. On `process.exit()` napi tears that runtime down with @@ -21,18 +21,15 @@ use tokio::sync::Mutex; // clones back into `self.inner.lock()` across an await -- that reintroduces the // crash. -fn session_error_to_close_info(err: &web_transport_quinn::SessionError) -> NapiCloseInfo { +fn session_error_to_close_info(err: &web_transport_quinn::SessionError) -> Result { match err { web_transport_quinn::SessionError::WebTransportError( web_transport_quinn::WebTransportError::Closed(code, reason), - ) => NapiCloseInfo { + ) => Ok(NapiCloseInfo { close_code: *code, reason: reason.clone(), - }, - other => NapiCloseInfo { - close_code: 0, - reason: other.to_string(), - }, + }), + other => Err(Error::from_reason(other.to_string())), } } @@ -141,7 +138,7 @@ impl NapiClient { .map_err(|e| Error::from_reason(e.to_string()))?; Ok(NapiSession { inner: session.clone(), - closed: Arc::new(Mutex::new(None)), + closed: Arc::new(std::sync::Mutex::new(None)), }) } } @@ -252,7 +249,7 @@ impl NapiRequest { .map_err(|e| Error::from_reason(e.to_string()))?; Ok(NapiSession { inner: session.clone(), - closed: Arc::new(Mutex::new(None)), + closed: Arc::new(std::sync::Mutex::new(None)), }) } @@ -279,8 +276,8 @@ impl NapiRequest { #[napi] pub struct NapiSession { inner: web_transport_quinn::Session, - // Cache the closed future result so multiple callers can await it. - closed: Arc>>, + // The backend reports local closes as LocallyClosed, without their application details. + closed: Arc>>, } /// Info about why a session was closed, matching W3C WebTransportCloseInfo. @@ -334,9 +331,7 @@ impl NapiSession { .accept_uni() .await .map_err(|e| Error::from_reason(e.to_string()))?; - Ok(NapiRecvStream { - inner: Arc::new(Mutex::new(recv)), - }) + Ok(NapiRecvStream::new(recv)) } /// Accept an incoming bidirectional stream. @@ -351,9 +346,7 @@ impl NapiSession { send: Some(NapiSendStream { inner: Arc::new(Mutex::new(send)), }), - recv: Some(NapiRecvStream { - inner: Arc::new(Mutex::new(recv)), - }), + recv: Some(NapiRecvStream::new(recv)), }) } @@ -382,9 +375,7 @@ impl NapiSession { send: Some(NapiSendStream { inner: Arc::new(Mutex::new(send)), }), - recv: Some(NapiRecvStream { - inner: Arc::new(Mutex::new(recv)), - }), + recv: Some(NapiRecvStream::new(recv)), }) } @@ -419,36 +410,29 @@ impl NapiSession { #[napi] pub fn close(&self, code: u32, reason: String) { within_runtime_if_available(|| { + let mut closed = self.closed.lock().unwrap(); + if closed.is_none() && self.inner.close_reason().is_none() { + *closed = Some(NapiCloseInfo { + close_code: code, + reason: reason.clone(), + }); + } self.inner.close(code, reason.as_bytes()); }); } - /// Wait for the session to close, returning close info matching W3C WebTransportCloseInfo. + /// Wait for normal closure with its application details, or reject on a connection failure. #[napi] pub async fn closed(&self) -> Result { - // Own the session handle and the cache for the duration of the future - // (see module note). + // Own both handles for the duration of the future (see module note). let session = self.inner.clone(); let cache = self.closed.clone(); - - // Check if we already have a cached result. - { - let cached = cache.lock().await; - if let Some(info) = cached.as_ref() { - return Ok(info.clone()); - } - } - let err = session.closed().await; - let info = session_error_to_close_info(&err); - - // Cache the result. - { - let mut cached = cache.lock().await; - *cached = Some(info.clone()); + let closed = cache.lock().unwrap(); + match closed.as_ref() { + Some(info) => Ok(info.clone()), + None => session_error_to_close_info(&err), } - - Ok(info) } } @@ -570,6 +554,30 @@ impl NapiSendClosed { #[napi] pub struct NapiRecvStream { inner: Arc>, + // Closing the sender cancels reads when the JS owner is collected. The read futures own + // only receivers, so neither napi-rs nor the shared stream can keep that owner alive. + stopped: watch::Sender, +} + +impl NapiRecvStream { + fn new(recv: web_transport_quinn::RecvStream) -> Self { + let (stopped, _) = watch::channel(false); + Self { + inner: Arc::new(Mutex::new(recv)), + stopped, + } + } +} + +impl Drop for NapiRecvStream { + fn drop(&mut self) { + // With no active read, stop now using the WebTransport code space. A pending read + // owns the lock and stops itself when dropping this sender closes its watch. + if let Ok(mut stream) = self.inner.try_lock() { + // An already finished/reset stream needs no further cleanup. + let _ = stream.stop(0); + } + } } #[napi] @@ -577,32 +585,59 @@ impl NapiRecvStream { /// Read up to `max_size` bytes from the stream. Returns null on FIN, or the error if the /// peer reset the stream or the session failed. #[napi] - pub async fn read(&self, max_size: u32) -> Result>> { + pub fn read<'env>( + &self, + env: &'env Env, + max_size: u32, + ) -> Result>> { use web_transport_quinn::ReadError; - // Own the shared stream for the duration of the future (see module note). + // A synchronous callback spawning an owned future avoids async fn's implicit JS + // receiver reference, which would prevent abandonment from cancelling this read. let inner = self.inner.clone(); - let mut stream = inner.lock().await; - let err = match stream.read_chunk(max_size as usize, true).await { - Ok(chunk) => { - return Ok(chunk.map(|chunk| Either::A(Buffer::from(chunk.bytes.to_vec())))) - } - Err(err @ ReadError::Reset(code)) => { - NapiStreamError::stream(Some(code), err.to_string()) + let mut stopped = self.stopped.subscribe(); + env.spawn_future(async move { + let mut stream = inner.lock().await; + if *stopped.borrow() { + return Ok(Either3::C(Null)); } - Err(err @ ReadError::InvalidReset(_)) => NapiStreamError::stream(None, err.to_string()), - Err(ReadError::SessionError(err)) => NapiStreamError::session(&err), - Err(err @ (ReadError::ClosedStream | ReadError::IllegalOrderedRead)) => { - return Err(Error::from_reason(err.to_string())) - } - }; - Ok(Some(Either::B(err))) + let result = tokio::select! { + biased; + changed = stopped.changed() => { + if changed.is_err() { + stream.stop(0).map_err(|e| Error::from_reason(e.to_string()))?; + } + return Ok(Either3::C(Null)); + }, + result = stream.read_chunk(max_size as usize, true) => result, + }; + let err = match result { + Ok(chunk) => { + return Ok(match chunk { + Some(chunk) => Either3::A(Buffer::from(chunk.bytes.to_vec())), + None => Either3::C(Null), + }) + } + Err(err @ ReadError::Reset(code)) => { + NapiStreamError::stream(Some(code), err.to_string()) + } + Err(err @ ReadError::InvalidReset(_)) => { + NapiStreamError::stream(None, err.to_string()) + } + Err(ReadError::SessionError(err)) => NapiStreamError::session(&err), + Err(err @ (ReadError::ClosedStream | ReadError::IllegalOrderedRead)) => { + return Err(Error::from_reason(err.to_string())) + } + }; + Ok(Either3::B(err)) + }) } /// Tell the peer to stop sending with the given error code. #[napi] pub async fn stop(&self, code: u32) -> Result<()> { let inner = self.inner.clone(); + self.stopped.send_replace(true); let mut stream = inner.lock().await; stream .stop(code) From bb07072cadbb3b0df354f31a762fc68f2dfe3658 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 7 Nov 2026 01:26:17 -0800 Subject: [PATCH 03/11] Preserve active readers and correct close outcomes Keep strong pending pulls after reproducing active reads hanging under collection. Retain the quest for the unresolved abandoned-reader lifetime decision. Correct clean CONNECT FIN, local-close priority, terminal cancellation, and final receive-stream cleanup. Co-Authored-By: GPT-6.1 Sol --- js/web-transport/README.md | 4 +- js/web-transport/napi.d.cts | 2 +- js/web-transport/src/session.ts | 38 ++----- .../tests/fixtures/abandoned-reader.ts | 26 ----- .../tests/fixtures/active-reader.ts | 45 ++++++++ js/web-transport/tests/session.test.ts | 106 ++++++++++++------ quest/a0/README.md | 1 + quest/a0/node-server-close.md | 3 + quest/a0/node-session-lifetime.md | 30 +++++ rs/web-transport-node/Cargo.toml | 4 + .../examples/session-peer.rs | 45 ++++++-- rs/web-transport-node/src/lib.rs | 83 +++++++++----- rs/web-transport-quinn/README.md | 5 + rs/web-transport-quinn/src/error.rs | 4 + rs/web-transport-quinn/src/session.rs | 98 ++++++++++++---- 15 files changed, 340 insertions(+), 154 deletions(-) delete mode 100644 js/web-transport/tests/fixtures/abandoned-reader.ts create mode 100644 js/web-transport/tests/fixtures/active-reader.ts create mode 100644 quest/a0/node-session-lifetime.md diff --git a/js/web-transport/README.md b/js/web-transport/README.md index 916c5532..8a511297 100644 --- a/js/web-transport/README.md +++ b/js/web-transport/README.md @@ -162,8 +162,8 @@ console.log(info.closeCode, info.reason); ``` Cancel a reader when finished to release its receive stream immediately, even during a -pending read. If every reference to the reader and readable stream is abandoned, garbage -collection also releases the native stream and stops the peer with stream error code 0. +pending read. Pending reads retain their receive stream until data, closure, or cancellation +settles them, so garbage collection alone does not cancel an abandoned pending read. ## License diff --git a/js/web-transport/napi.d.cts b/js/web-transport/napi.d.cts index 6467497d..b9ce48b6 100644 --- a/js/web-transport/napi.d.cts +++ b/js/web-transport/napi.d.cts @@ -30,7 +30,7 @@ export declare class NapiRecvStream { * peer reset the stream or the session failed. */ read(maxSize: number): Promise; - /** Tell the peer to stop sending with the given error code. */ + /** Tell the peer to stop sending with the given code; an already terminal stream is a no-op. */ stop(code: number): Promise; } diff --git a/js/web-transport/src/session.ts b/js/web-transport/src/session.ts index 9afe6dbf..e1a909da 100644 --- a/js/web-transport/src/session.ts +++ b/js/web-transport/src/session.ts @@ -6,42 +6,20 @@ import { fromNapi, resetCode, sessionError } from "./error.ts"; const { NapiClient } = napi; function wrapRecvStream(recv: NapiRecvStream): ReadableStream { - const state = { reading: false, cancelled: false }; + let cancelled = false; return new ReadableStream({ - pull(controller) { - if (state.reading) return; - state.reading = true; - readChunk(recv.read(65536), controller, state); - }, - cancel(reason) { - state.cancelled = true; - return recv.stop(resetCode(reason)); - }, - }); -} - -// Returning the pending native promise from pull would let the Web Streams machinery -// retain the controller and its stream. Only this weak callback waits for the read. -function readChunk( - read: ReturnType, - controller: ReadableStreamDefaultController, - state: { reading: boolean; cancelled: boolean }, -) { - const ref = new WeakRef(controller); - void read.then( - (chunk) => { - state.reading = false; - const controller = ref.deref(); - if (!controller || state.cancelled) return; + async pull(controller) { + const chunk = await recv.read(65536); + if (cancelled) return; if (chunk === null) controller.close(); else if (chunk instanceof Uint8Array) controller.enqueue(new Uint8Array(chunk)); else controller.error(fromNapi(chunk)); }, - (err: unknown) => { - state.reading = false; - if (!state.cancelled) ref.deref()?.error(err); + cancel(reason) { + cancelled = true; + return recv.stop(resetCode(reason)); }, - ); + }); } // A STOP_SENDING or session failure errors the stream even while nothing is being written. diff --git a/js/web-transport/tests/fixtures/abandoned-reader.ts b/js/web-transport/tests/fixtures/abandoned-reader.ts deleted file mode 100644 index 54aa1634..00000000 --- a/js/web-transport/tests/fixtures/abandoned-reader.ts +++ /dev/null @@ -1,26 +0,0 @@ -import { setImmediate } from "node:timers/promises"; -import Session from "../../src/session.ts"; - -const url = process.argv[2]; -if (!url || !globalThis.gc) throw new Error("requires a peer URL and --expose-gc"); -const session = new Session(url, { serverCertificateDisableVerify: true }); -await session.ready; - -await (async () => { - const { value: readable } = await session.incomingUnidirectionalStreams.getReader().read(); - if (!readable) throw new Error("no stream"); - const reader = readable.getReader(); - await reader.read(); - void reader.read(); -})(); - -// The peer closes the Session after observing STOP_SENDING from reader collection. -let closed = false; -const closure = session.closed.then(() => { - closed = true; -}); -while (!closed) { - globalThis.gc(); - await setImmediate(); -} -await closure; diff --git a/js/web-transport/tests/fixtures/active-reader.ts b/js/web-transport/tests/fixtures/active-reader.ts new file mode 100644 index 00000000..a4f9aeaf --- /dev/null +++ b/js/web-transport/tests/fixtures/active-reader.ts @@ -0,0 +1,45 @@ +import assert from "node:assert/strict"; +import { setImmediate } from "node:timers/promises"; +import Session from "../../src/session.ts"; + +const url = process.argv[2]; +if (!url || !globalThis.gc) throw new Error("requires a peer URL and --expose-gc"); +const session = new Session(url, { serverCertificateDisableVerify: true }); +await session.ready; +const incoming = session.incomingUnidirectionalStreams.getReader(); +const trigger = session.datagrams.writable.getWriter(); + +for (const pipe of [false, true]) { + const started = Promise.withResolvers(); + const result = (async () => { + const { value: readable } = await incoming.read(); + if (!readable) throw new Error("no stream"); + if (pipe) { + const observed = readable.pipeThrough( + new TransformStream({ + transform(chunk, controller) { + started.resolve(); + controller.enqueue(chunk); + }, + }), + ); + return new Response(observed).arrayBuffer(); + } + const reader = readable.getReader(); + await reader.read(); + started.resolve(); + return reader.read(); + })(); + // Wait for the first byte, then collect while only the consumer's result is retained. + await started.promise; + await setImmediate(); + globalThis.gc(); + await setImmediate(); + await trigger.write(new Uint8Array([1])); + const value = await result; + if (pipe) assert.deepEqual(new Uint8Array(value as ArrayBuffer), new Uint8Array([1, 2])); + else assert.deepEqual((value as ReadableStreamReadResult).value, new Uint8Array([2])); +} + +session.close(); +await session.closed; diff --git a/js/web-transport/tests/session.test.ts b/js/web-transport/tests/session.test.ts index 34724353..2000749c 100644 --- a/js/web-transport/tests/session.test.ts +++ b/js/web-transport/tests/session.test.ts @@ -1,7 +1,7 @@ import { beforeAll, expect, test } from "bun:test"; import { createSocket } from "node:dgram"; import { join } from "node:path"; -import { fileURLToPath } from "node:url"; +import napi from "../napi.cjs"; import Session, { install, Server, WebTransportError } from "../src/index.ts"; let url: string; @@ -305,49 +305,85 @@ test("concurrent read requests keep pulling through data and FIN", async () => { } }); -test("an abandoned reader stops its stream while a read is pending", async () => { - const { client, peer } = await connect(); - try { - const writer = (await peer.createUnidirectionalStream()).getWriter(); - await writer.write(new Uint8Array([1])); - await (async () => { - const { value: readable } = await client.incomingUnidirectionalStreams.getReader().read(); - if (!readable) throw new Error("no stream"); - const reader = readable.getReader(); - expect((await reader.read()).value).toEqual(new Uint8Array([1])); - void reader.read(); - })(); - - let stopped = false; - const closed = rejection(writer.closed).then((err) => { - expect(err.source).toBe("stream"); - expect(err.streamErrorCode).toBe(0); - stopped = true; - }); - // GC is only needed to trigger abandonment; the native drop/wakeup path is also - // exercised deterministically by cancelling a pending read above. - while (!stopped) { +test("native cancellation is idempotent after FIN and RESET_STREAM", async () => { + for (const reset of [false, true]) { + const client = await napi.NapiClient.disableVerify().connect(url); + const peer = accepted.shift() ?? (await new Promise((resolve) => waiters.push(resolve))); + try { + const writer = (await peer.createUnidirectionalStream()).getWriter(); + await writer.write(new Uint8Array([1])); + const recv = await client.acceptUni(); + await recv.read(65536); + if (reset) await writer.abort(new WebTransportError("reset", { streamErrorCode: 7 })); + else await writer.close(); + await recv.read(65536); + await recv.stop(17); + await recv.stop(17); + } finally { + client.close(0, "done"); + await client.closed(); + } + } +}); + +test("an awaited read and pipe retain an active receiver through collection", async () => { + for (const pipe of [false, true]) { + const { client, peer } = await connect(); + try { + const writer = (await peer.createUnidirectionalStream()).getWriter(); + await writer.write(new Uint8Array([1])); + const started = Promise.withResolvers(); + const result = (async () => { + const { value: readable } = await client.incomingUnidirectionalStreams.getReader().read(); + if (!readable) throw new Error("no stream"); + if (pipe) { + const observed = readable.pipeThrough( + new TransformStream({ + transform(chunk, controller) { + started.resolve(); + controller.enqueue(chunk); + }, + }), + ); + return new Response(observed).arrayBuffer(); + } + const reader = readable.getReader(); + await reader.read(); + started.resolve(); + return reader.read(); + })(); + // Force collection while only the consumer's pending result is retained. + await started.promise; + await new Promise(setImmediate); Bun.gc(true); await new Promise(setImmediate); + await writer.write(new Uint8Array([2])); + await writer.close(); + const value = await result; + if (pipe) expect(new Uint8Array(value as ArrayBuffer)).toEqual(new Uint8Array([1, 2])); + else expect((value as ReadableStreamReadResult).value).toEqual(new Uint8Array([2])); + } finally { + client.close(); } - await closed; - } finally { - client.close(); } }); -test("Node collects a reader with a pending native read", async () => { - const fixture = new URL("fixtures/abandoned-reader.ts", import.meta.url); - const child = Bun.spawn(["node", "--expose-gc", fileURLToPath(fixture), url], { stdout: "pipe", stderr: "pipe" }); +test("Node retains an awaited read and pipe through collection", async () => { + const child = Bun.spawn(["node", "--expose-gc", join(import.meta.dir, "fixtures/active-reader.ts"), url], { + stdout: "pipe", + stderr: "pipe", + }); let peer: Session | undefined; try { peer = accepted.shift() ?? (await new Promise((resolve) => waiters.push(resolve))); - const writer = (await peer.createUnidirectionalStream()).getWriter(); - await writer.write(new Uint8Array([1])); - const err = await rejection(writer.closed); - expect(err.source).toBe("stream"); - expect(err.streamErrorCode).toBe(0); - peer.close(); + const datagrams = peer.datagrams.readable.getReader(); + for (let i = 0; i < 2; i++) { + const writer = (await peer.createUnidirectionalStream()).getWriter(); + await writer.write(new Uint8Array([1])); + await datagrams.read(); + await writer.write(new Uint8Array([2])); + await writer.close(); + } expect(await child.exited).toBe(0); expect(await new Response(child.stderr).text()).toBe(""); } finally { diff --git a/quest/a0/README.md b/quest/a0/README.md index e5b44ca2..26ce85f5 100644 --- a/quest/a0/README.md +++ b/quest/a0/README.md @@ -17,3 +17,4 @@ The Required list is ordered by priority. Independent children may proceed concu - [QMux initial stream-count bound](/quest/a0/qmux-max-streams-param.md) - refuse initial_max_streams parameters above 2^60 - [QMux stream-state checks](/quest/a0/qmux-stream-state.md) - refuse MAX_STREAM_DATA and STOP_SENDING for unopened local streams - [Node Server.close()](/quest/a0/node-server-close.md) - close completes while an accept is pending +- [Node session and reader lifetime](/quest/a0/node-session-lifetime.md) - `closed` rejects on an abnormal end, and an abandoned reader releases its stream diff --git a/quest/a0/node-server-close.md b/quest/a0/node-server-close.md index b8f0ccbd..445e7b2b 100644 --- a/quest/a0/node-server-close.md +++ b/quest/a0/node-server-close.md @@ -14,6 +14,9 @@ Found while fixing [#470](https://github.com/moq-dev/web-transport/pull/470): hits. Find what both calls contend on (likely one lock held across the `accept` await) and let `close()` wake the waiter instead of waiting for it. +Decided 2026-10-28 (maintainer): its own quest in a0, apart from +[Node session and reader lifetime](/quest/a0/node-session-lifetime.md). + Add a loopback regression that fails without the fix: start the README's accept loop, wait until its `accept()` is pending in native code, then close the server and require both to finish, with `accept()` resolving to `null`. diff --git a/quest/a0/node-session-lifetime.md b/quest/a0/node-session-lifetime.md new file mode 100644 index 00000000..8e028a27 --- /dev/null +++ b/quest/a0/node-session-lifetime.md @@ -0,0 +1,30 @@ +# [M] Abandoned Node reader lifetime + +## Goal + +In `@moq/web-transport`'s Node polyfill, release an abandoned reader's native +stream even while a `read()` is pending, while preserving actively awaited +reads and pipes that retain only their result promises. + +## Plan + +[PR 486](https://github.com/moq-dev/web-transport/pull/486) implements +`Session.closed` rejection and pending-read cancellation. Automatic pending +reader cleanup remains unresolved. + +A weak controller callback allows native stream collection, but also collects +an actively awaited read when only its result promise remains reachable. The +user's promise then hangs after STOP_SENDING is sent. A strong pending pull +preserves ordinary Web Streams behavior, but also retains abandoned readers. +The first local review reproduced both sides of this tradeoff. + +Keep active reads safe while deciding the remaining ownership contract. The +existing explicit `reader.cancel()` path releases a pending native read and +preserves its requested STOP_SENDING code. + +- Maintainer decision: approve narrowing the reader goal to explicit cancellation, or + authorize a lifetime design that can distinguish an observed pending read + from an abandoned one without changing standard read and pipe behavior. + Recommend preserving standard Web Streams behavior and documenting the + explicit cancellation boundary. Validate any alternative with collection + tests for both abandoned readers and actively awaited read/pipe promises. diff --git a/rs/web-transport-node/Cargo.toml b/rs/web-transport-node/Cargo.toml index 61874988..36452b7e 100644 --- a/rs/web-transport-node/Cargo.toml +++ b/rs/web-transport-node/Cargo.toml @@ -22,3 +22,7 @@ web-transport-quinn = { path = "../web-transport-quinn", version = "0.13" } [build-dependencies] napi-build = "2" + +[dev-dependencies] +anyhow = "1" +tokio = { version = "1", features = ["rt"] } diff --git a/rs/web-transport-node/examples/session-peer.rs b/rs/web-transport-node/examples/session-peer.rs index 37338456..b45ec243 100644 --- a/rs/web-transport-node/examples/session-peer.rs +++ b/rs/web-transport-node/examples/session-peer.rs @@ -2,31 +2,54 @@ use std::{io::Read, ops::Deref}; +use anyhow::Context; + #[tokio::main(flavor = "current_thread")] -async fn main() -> Result<(), Box> { +async fn main() -> anyhow::Result<()> { let session = if let Some(url) = std::env::args().nth(1) { let client = web_transport_quinn::ClientBuilder::new() .dangerous() - .with_no_certificate_verification()?; - client.connect(url::Url::parse(&url)?).await? + .with_no_certificate_verification() + .context("create client")?; + client + .connect(url::Url::parse(&url).context("parse peer URL")?) + .await + .context("connect to peer")? } else { - let pem = std::env::var("WEB_TRANSPORT_TEST_PEM")?; + let pem = std::env::var("WEB_TRANSPORT_TEST_PEM").context("read test certificate")?; let pem = pem.as_bytes(); - let certs = rustls_pemfile::certs(&mut &pem[..]).collect::, _>>()?; - let key = rustls_pemfile::private_key(&mut &pem[..])?.ok_or("missing key")?; + let certs = rustls_pemfile::certs(&mut &pem[..]) + .collect::, _>>() + .context("parse certificate")?; + let key = rustls_pemfile::private_key(&mut &pem[..]) + .context("parse private key")? + .context("missing key")?; let mut server = web_transport_quinn::ServerBuilder::new() .with_addr("127.0.0.1:0".parse()?) - .with_certificate(certs, key)?; - println!("https://{}", server.local_addr()?); - server.accept().await.ok_or("server closed")?.ok().await? + .with_certificate(certs, key) + .context("bind server")?; + println!("https://{}", server.local_addr().context("server address")?); + server + .accept() + .await + .context("server closed")? + .ok() + .await + .context("accept session")? }; // The JS side sends a datagram after attaching its closed handler, so the failure // always occurs on an established Session rather than racing its handshake. - session.read_datagram().await?; + session + .read_datagram() + .await + .context("read trigger datagram")?; // QUIC application code 0 is outside WebTransport's HTTP/3 code space. session.deref().close(0u32.into(), b"connection failure"); // Await a second signal on stdin to keep the runtime alive while QUIC sends the close. - tokio::task::spawn_blocking(|| std::io::stdin().read(&mut [0])).await??; + tokio::task::spawn_blocking(|| std::io::stdin().read(&mut [0])) + .await + .context("join shutdown signal")? + .context("read shutdown signal")?; Ok(()) } diff --git a/rs/web-transport-node/src/lib.rs b/rs/web-transport-node/src/lib.rs index 77ee03a0..e5367024 100644 --- a/rs/web-transport-node/src/lib.rs +++ b/rs/web-transport-node/src/lib.rs @@ -21,7 +21,10 @@ use tokio::sync::{watch, Mutex}; // clones back into `self.inner.lock()` across an await -- that reintroduces the // crash. -fn session_error_to_close_info(err: &web_transport_quinn::SessionError) -> Result { +fn session_error_to_close_info( + err: &web_transport_quinn::SessionError, + local: Option, +) -> Result { match err { web_transport_quinn::SessionError::WebTransportError( web_transport_quinn::WebTransportError::Closed(code, reason), @@ -29,6 +32,9 @@ fn session_error_to_close_info(err: &web_transport_quinn::SessionError) -> Resul close_code: *code, reason: reason.clone(), }), + web_transport_quinn::SessionError::ConnectionError( + web_transport_quinn::quinn::ConnectionError::LocallyClosed, + ) => local.ok_or_else(|| Error::from_reason(err.to_string())), other => Err(Error::from_reason(other.to_string())), } } @@ -428,11 +434,10 @@ impl NapiSession { let session = self.inner.clone(); let cache = self.closed.clone(); let err = session.closed().await; - let closed = cache.lock().unwrap(); - match closed.as_ref() { - Some(info) => Ok(info.clone()), - None => session_error_to_close_info(&err), - } + // Only LocallyClosed uses these details. A peer close or connection failure can + // win the backend's first-close race before the native connection is closed. + let local = cache.lock().unwrap().clone(); + session_error_to_close_info(&err, local) } } @@ -553,30 +558,59 @@ impl NapiSendClosed { /// A receive stream for reading data. #[napi] pub struct NapiRecvStream { - inner: Arc>, + inner: Arc>, // Closing the sender cancels reads when the JS owner is collected. The read futures own // only receivers, so neither napi-rs nor the shared stream can keep that owner alive. stopped: watch::Sender, } +struct RecvStream(web_transport_quinn::RecvStream); + +impl Drop for RecvStream { + fn drop(&mut self) { + // Quinn's implicit drop uses raw QUIC code 0; the Node API needs WebTransport 0. + // An already finished/reset stream needs no further cleanup. + let _ = self.0.stop(0); + } +} + impl NapiRecvStream { fn new(recv: web_transport_quinn::RecvStream) -> Self { let (stopped, _) = watch::channel(false); Self { - inner: Arc::new(Mutex::new(recv)), + inner: Arc::new(Mutex::new(RecvStream(recv))), stopped, } } } -impl Drop for NapiRecvStream { - fn drop(&mut self) { - // With no active read, stop now using the WebTransport code space. A pending read - // owns the lock and stops itself when dropping this sender closes its watch. - if let Ok(mut stream) = self.inner.try_lock() { - // An already finished/reset stream needs no further cleanup. - let _ = stream.stop(0); - } +#[cfg(test)] +mod tests { + use super::*; + use web_transport_quinn::{quinn::ConnectionError, SessionError, WebTransportError}; + + #[test] + fn backend_close_wins_over_a_racing_local_request() { + let local = || { + Some(NapiCloseInfo { + close_code: 42, + reason: "local".into(), + }) + }; + let peer = SessionError::WebTransportError(WebTransportError::Closed(7, "peer".into())); + let info = session_error_to_close_info(&peer, local()).unwrap(); + assert_eq!((info.close_code, info.reason.as_str()), (7, "peer")); + assert!(session_error_to_close_info( + &SessionError::ConnectionError(ConnectionError::TimedOut), + local() + ) + .is_err()); + let info = session_error_to_close_info( + &SessionError::ConnectionError(ConnectionError::LocallyClosed), + local(), + ) + .unwrap(); + assert_eq!((info.close_code, info.reason.as_str()), (42, "local")); } } @@ -603,13 +637,8 @@ impl NapiRecvStream { } let result = tokio::select! { biased; - changed = stopped.changed() => { - if changed.is_err() { - stream.stop(0).map_err(|e| Error::from_reason(e.to_string()))?; - } - return Ok(Either3::C(Null)); - }, - result = stream.read_chunk(max_size as usize, true) => result, + _ = stopped.changed() => return Ok(Either3::C(Null)), + result = stream.0.read_chunk(max_size as usize, true) => result, }; let err = match result { Ok(chunk) => { @@ -633,14 +662,14 @@ impl NapiRecvStream { }) } - /// Tell the peer to stop sending with the given error code. + /// Tell the peer to stop sending with the given code; an already terminal stream is a no-op. #[napi] pub async fn stop(&self, code: u32) -> Result<()> { let inner = self.inner.clone(); self.stopped.send_replace(true); let mut stream = inner.lock().await; - stream - .stop(code) - .map_err(|e| Error::from_reason(e.to_string())) + // ClosedStream only means FIN, reset, or an earlier stop already made this terminal. + let _ = stream.0.stop(code); + Ok(()) } } diff --git a/rs/web-transport-quinn/README.md b/rs/web-transport-quinn/README.md index e17180b3..971c0026 100644 --- a/rs/web-transport-quinn/README.md +++ b/rs/web-transport-quinn/README.md @@ -58,6 +58,11 @@ Tokio works out of the box. To run on async-std or smol instead, enable quinn's Resolving a hostname in `Client::connect` still uses tokio, so outside a tokio runtime connect to an IP address or resolve the name yourself. ## API +`Session::closed` preserves the first close reason. A clean CONNECT-stream FIN without +a close capsule reports `WebTransportError::Closed(0, "")`; malformed or interrupted +capsules report `WebTransportError::CapsuleError` unless the underlying connection has +already reported its own error. An explicit local close reports `ConnectionError::LocallyClosed`. + The `web-transport-quinn` API is almost identical to the Quinn API, except that [Connection](https://docs.rs/quinn/latest/quinn/struct.Connection.html) is called [Session](https://docs.rs/web-transport-quinn/latest/web_transport_quinn/struct.Session.html). When possible, `Deref` is used to expose the underlying Quinn API. diff --git a/rs/web-transport-quinn/src/error.rs b/rs/web-transport-quinn/src/error.rs index 11880256..a0984f85 100644 --- a/rs/web-transport-quinn/src/error.rs +++ b/rs/web-transport-quinn/src/error.rs @@ -168,6 +168,10 @@ pub enum WebTransportError { #[error("write error: {0}")] WriteError(#[from] quinn::WriteError), + + /// The session's HTTP/3 capsule stream was malformed or interrupted, with a diagnostic message. + #[error("capsule error: {0}")] + CapsuleError(String), } /// An error when writing to [`crate::SendStream`]. Similar to [`quinn::WriteError`]. diff --git a/rs/web-transport-quinn/src/session.rs b/rs/web-transport-quinn/src/session.rs index c8cdb4aa..bf0dc6f9 100644 --- a/rs/web-transport-quinn/src/session.rs +++ b/rs/web-transport-quinn/src/session.rs @@ -184,52 +184,54 @@ impl Session { // then record the close error and tear down the connection. async fn run_recv(conn: quinn::Connection, recv: quinn::RecvStream, error: Arc) { let close_info = Self::read_capsules(recv).await; - let code = close_info.as_ref().map_or(0, |(c, _)| *c); - - let http3_code: quinn::VarInt = web_transport_proto::error_to_http3(code) - .try_into() - .unwrap(); - - // Try to record the remote close error. If close() already set - // the error, it owns the connection teardown, so we bail out. match close_info { - Some((code, reason)) => { + Ok((code, reason)) => { let err = WebTransportError::Closed(code, reason.clone()); if error.set(err.into()).is_err() { return; } - conn.close(http3_code, reason.as_bytes()); + if conn.close_reason().is_none() { + conn.close( + crate::error::encode_stream_code(code, false), + reason.as_bytes(), + ); + } } - None => { - let err = quinn::ConnectionError::LocallyClosed.into(); + Err(cause) => { + let err = conn.close_reason().map(Into::into).unwrap_or_else(|| { + SessionError::WebTransportError(WebTransportError::CapsuleError( + cause.to_string(), + )) + }); if error.set(err).is_err() { return; } - conn.close(http3_code, b""); + if conn.close_reason().is_none() { + // H3_MESSAGE_ERROR: the CONNECT stream did not contain valid capsules. + conn.close(0x10eu32.into(), b"invalid CONNECT capsule stream"); + } } }; } // Keep reading capsules from the CONNECT recv stream until it's closed. - // Returns Some((code, reason)) if a CloseWebTransportSession capsule was received, - // or None if the stream closed without a capsule. - async fn read_capsules(recv: quinn::RecvStream) -> Option<(u32, String)> { + // A clean FIN without a close capsule is the default successful close. + async fn read_capsules( + recv: quinn::RecvStream, + ) -> Result<(u32, String), web_transport_proto::CapsuleError> { let mut reader = web_transport_proto::Http3CapsuleReader::new(recv); loop { match reader.read().await { Ok(Some(web_transport_proto::Capsule::CloseWebTransportSession { code, reason, - })) => return Some((code, reason)), + })) => return Ok((code, reason)), Ok(Some(web_transport_proto::Capsule::Grease { .. })) => {} Ok(Some(web_transport_proto::Capsule::Unknown { typ, payload })) => { tracing::warn!(%typ, size = payload.len(), "unknown capsule"); } - Ok(None) => return None, - Err(e) => { - tracing::warn!(?e, "failed to read capsule"); - return None; - } + Ok(None) => return Ok((0, String::new())), + Err(e) => return Err(e), } } } @@ -1376,6 +1378,58 @@ mod tests { (client_conn, server_conn, [client, server]) } + #[tokio::test] + async fn clean_connect_fin_is_a_default_close() { + let (client, peer, _endpoints) = pair().await; + let (mut send, recv) = client.open_bi().await.unwrap(); + send.write_all(b"connect").await.unwrap(); + let (mut peer_send, _peer_recv) = peer.accept_bi().await.unwrap(); + peer_send.finish().unwrap(); + let error = Arc::new(CloseReason::http3()); + Session::run_recv(client, recv, error.clone()).await; + assert!(matches!( + error.get(), + Some(SessionError::WebTransportError(WebTransportError::Closed(0, reason))) + if reason.is_empty() + )); + } + + #[tokio::test] + async fn truncated_connect_data_is_a_capsule_error() { + let (client, peer, _endpoints) = pair().await; + let (mut send, recv) = client.open_bi().await.unwrap(); + send.write_all(b"connect").await.unwrap(); + let (mut peer_send, _peer_recv) = peer.accept_bi().await.unwrap(); + // DATA frame type, missing the frame length. + peer_send.write_all(&[0]).await.unwrap(); + peer_send.finish().unwrap(); + let error = Arc::new(CloseReason::http3()); + Session::run_recv(client, recv, error.clone()).await; + assert!(matches!( + error.get(), + Some(SessionError::WebTransportError( + WebTransportError::CapsuleError(_) + )) + )); + } + + #[tokio::test] + async fn failed_connect_stream_preserves_the_connection_failure() { + let (client, peer, _endpoints) = pair().await; + let (mut send, recv) = client.open_bi().await.unwrap(); + send.write_all(b"connect").await.unwrap(); + let _connect = peer.accept_bi().await.unwrap(); + peer.close(0u32.into(), b"failure"); + client.closed().await; + let error = Arc::new(CloseReason::http3()); + Session::run_recv(client, recv, error.clone()).await; + assert!(matches!( + error.get(), + Some(SessionError::ConnectionError(quinn::ConnectionError::ApplicationClosed(close))) + if close.error_code.into_inner() == 0 && close.reason == b"failure"[..] + )); + } + fn assert_reset(err: SessionError) { assert!( matches!( From ece37fc44c6e3ca09dc039088d6eeb51a56c13de Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 7 Nov 2026 01:39:05 -0800 Subject: [PATCH 04/11] Document session capsule errors Co-Authored-By: GPT-6.1 Sol --- rs/web-transport-quinn/src/error.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rs/web-transport-quinn/src/error.rs b/rs/web-transport-quinn/src/error.rs index a0984f85..06652393 100644 --- a/rs/web-transport-quinn/src/error.rs +++ b/rs/web-transport-quinn/src/error.rs @@ -154,7 +154,7 @@ pub(crate) fn decode_stream_code(code: quinn::VarInt, raw: bool) -> Option } } -/// An error that can occur when reading/writing the WebTransport stream header. +/// An error in a WebTransport stream header or session capsule. #[derive(Clone, Error, Debug)] pub enum WebTransportError { #[error("closed: code={0} reason={1}")] From f4f06aaa9e093794bee978b08b7bcadc59b3e740 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 7 Nov 2026 02:00:57 -0800 Subject: [PATCH 05/11] Align native close outcomes and receive-stream cleanup Preserve observed connection failures before local close, recognize orderly HTTP/3 shutdown in Node, and move receive-drop code mapping into the native streams. Align CONNECT FIN and malformed-capsule outcomes across Quinn, Noq, and Quiche; decode Quiche capsules inside HTTP/3 DATA frames. Document the public error variants and retain regression coverage for each reproduced failure. Co-Authored-By: GPT-6.1 Sol --- js/web-transport/README.md | 3 +- js/web-transport/tests/session.test.ts | 77 +++++---- .../examples/session-peer.rs | 9 +- rs/web-transport-node/src/lib.rs | 27 ++-- rs/web-transport-noq/README.md | 8 + rs/web-transport-noq/src/error.rs | 6 +- rs/web-transport-noq/src/recv.rs | 23 ++- rs/web-transport-noq/src/session.rs | 150 ++++++++++++++---- rs/web-transport-quiche/README.md | 5 + rs/web-transport-quiche/src/connection.rs | 55 ++++++- rs/web-transport-quinn/README.md | 4 + rs/web-transport-quinn/src/recv.rs | 10 +- rs/web-transport-quinn/src/session.rs | 39 ++++- 13 files changed, 330 insertions(+), 86 deletions(-) diff --git a/js/web-transport/README.md b/js/web-transport/README.md index 8a511297..49d256ef 100644 --- a/js/web-transport/README.md +++ b/js/web-transport/README.md @@ -148,7 +148,8 @@ await writer.abort(new WebTransportError("cancelled", { streamErrorCode: 7 })); ### Closing `session.closed` resolves with the application code and reason after a local or peer close, -including nonzero application codes. A failed connection or an underlying connection +including nonzero application codes. An orderly HTTP/3 connection shutdown (H3_NO_ERROR) +without application details resolves with code 0 and an empty reason. A failed connection or an underlying connection failure rejects it with a `WebTransportError` whose `source` is `"session"` and `streamErrorCode` is `null`. `session.ready` rejects with the same error if connecting fails. diff --git a/js/web-transport/tests/session.test.ts b/js/web-transport/tests/session.test.ts index 2000749c..cab2c677 100644 --- a/js/web-transport/tests/session.test.ts +++ b/js/web-transport/tests/session.test.ts @@ -120,40 +120,51 @@ test("local and peer closes preserve nonzero application codes and reasons", asy }); for (const side of ["client", "server"] as const) { - test(`an underlying connection failure rejects the ${side} Session.closed`, async () => { - const child = Bun.spawn([peerExecutable, ...(side === "server" ? [url] : [])], { - env: { ...process.env, WEB_TRANSPORT_TEST_PEM: pem.toString() }, - stdin: "pipe", - stdout: "pipe", - stderr: "pipe", - }); - let session: Session | undefined; - try { - if (side === "client") { - const { value } = await child.stdout.getReader().read(); - if (!value) throw new Error("peer did not print its address"); - session = new Session(new TextDecoder().decode(value).trim(), { serverCertificateDisableVerify: true }); - await session.ready; - } else { - session = accepted.shift() ?? (await new Promise((resolve) => waiters.push(resolve))); + for (const orderly of [false, true]) { + test(`${orderly ? "an orderly HTTP/3 shutdown resolves" : "an underlying connection failure rejects"} the ${side} Session.closed`, async () => { + const child = Bun.spawn([peerExecutable, ...(side === "server" ? [url] : [])], { + env: { + ...process.env, + WEB_TRANSPORT_TEST_PEM: pem.toString(), + WEB_TRANSPORT_TEST_ORDERLY_CLOSE: orderly ? "1" : undefined, + }, + stdin: "pipe", + stdout: "pipe", + stderr: "pipe", + }); + let session: Session | undefined; + try { + if (side === "client") { + const { value } = await child.stdout.getReader().read(); + if (!value) throw new Error("peer did not print its address"); + session = new Session(new TextDecoder().decode(value).trim(), { + serverCertificateDisableVerify: true, + }); + await session.ready; + } else { + session = accepted.shift() ?? (await new Promise((resolve) => waiters.push(resolve))); + } + const closed = orderly ? session.closed : rejection(session.closed); + await session.datagrams.writable.getWriter().write(new Uint8Array([1])); + if (orderly) expect(await closed).toEqual({ closeCode: 0, reason: "" }); + else { + const err = (await closed) as WebTransportError; + expect(err.source).toBe("session"); + expect(err.streamErrorCode).toBeNull(); + // A late local close must not turn an already observed failure into success. + session.close(); + expect(await rejection(session.closed)).toBe(err); + } + child.stdin.end(); + expect(await child.exited).toBe(0); + expect(await new Response(child.stderr).text()).toBe(""); + } finally { + session?.close(); + child.kill(); + await child.exited; } - const closed = rejection(session.closed); - await session.datagrams.writable.getWriter().write(new Uint8Array([1])); - const err = await closed; - expect(err.source).toBe("session"); - expect(err.streamErrorCode).toBeNull(); - // A late local close must not turn an already observed failure into success. - session.close(); - expect(await rejection(session.closed)).toBe(err); - child.stdin.end(); - expect(await child.exited).toBe(0); - expect(await new Response(child.stderr).text()).toBe(""); - } finally { - session?.close(); - child.kill(); - await child.exited; - } - }); + }); + } } test("a peer's RESET_STREAM errors the reader with its code", async () => { diff --git a/rs/web-transport-node/examples/session-peer.rs b/rs/web-transport-node/examples/session-peer.rs index b45ec243..4489c89a 100644 --- a/rs/web-transport-node/examples/session-peer.rs +++ b/rs/web-transport-node/examples/session-peer.rs @@ -44,8 +44,13 @@ async fn main() -> anyhow::Result<()> { .read_datagram() .await .context("read trigger datagram")?; - // QUIC application code 0 is outside WebTransport's HTTP/3 code space. - session.deref().close(0u32.into(), b"connection failure"); + // H3_NO_ERROR is orderly shutdown; raw QUIC 0 is outside WebTransport's HTTP/3 space. + let code = if std::env::var_os("WEB_TRANSPORT_TEST_ORDERLY_CLOSE").is_some() { + 0x100u32 + } else { + 0 + }; + session.deref().close(code.into(), b"connection shutdown"); // Await a second signal on stdin to keep the runtime alive while QUIC sends the close. tokio::task::spawn_blocking(|| std::io::stdin().read(&mut [0])) .await diff --git a/rs/web-transport-node/src/lib.rs b/rs/web-transport-node/src/lib.rs index e5367024..e42e5f14 100644 --- a/rs/web-transport-node/src/lib.rs +++ b/rs/web-transport-node/src/lib.rs @@ -32,6 +32,15 @@ fn session_error_to_close_info( close_code: *code, reason: reason.clone(), }), + web_transport_quinn::SessionError::ConnectionError( + web_transport_quinn::quinn::ConnectionError::ApplicationClosed(close), + ) if close.error_code.into_inner() == 0x100 => { + // H3_NO_ERROR is an orderly HTTP/3 shutdown without application close details. + Ok(NapiCloseInfo { + close_code: 0, + reason: String::new(), + }) + } web_transport_quinn::SessionError::ConnectionError( web_transport_quinn::quinn::ConnectionError::LocallyClosed, ) => local.ok_or_else(|| Error::from_reason(err.to_string())), @@ -558,27 +567,17 @@ impl NapiSendClosed { /// A receive stream for reading data. #[napi] pub struct NapiRecvStream { - inner: Arc>, + inner: Arc>, // Closing the sender cancels reads when the JS owner is collected. The read futures own // only receivers, so neither napi-rs nor the shared stream can keep that owner alive. stopped: watch::Sender, } -struct RecvStream(web_transport_quinn::RecvStream); - -impl Drop for RecvStream { - fn drop(&mut self) { - // Quinn's implicit drop uses raw QUIC code 0; the Node API needs WebTransport 0. - // An already finished/reset stream needs no further cleanup. - let _ = self.0.stop(0); - } -} - impl NapiRecvStream { fn new(recv: web_transport_quinn::RecvStream) -> Self { let (stopped, _) = watch::channel(false); Self { - inner: Arc::new(Mutex::new(RecvStream(recv))), + inner: Arc::new(Mutex::new(recv)), stopped, } } @@ -638,7 +637,7 @@ impl NapiRecvStream { let result = tokio::select! { biased; _ = stopped.changed() => return Ok(Either3::C(Null)), - result = stream.0.read_chunk(max_size as usize, true) => result, + result = stream.read_chunk(max_size as usize, true) => result, }; let err = match result { Ok(chunk) => { @@ -669,7 +668,7 @@ impl NapiRecvStream { self.stopped.send_replace(true); let mut stream = inner.lock().await; // ClosedStream only means FIN, reset, or an earlier stop already made this terminal. - let _ = stream.0.stop(code); + let _ = stream.stop(code); Ok(()) } } diff --git a/rs/web-transport-noq/README.md b/rs/web-transport-noq/README.md index a6d7dc15..99ca73bf 100644 --- a/rs/web-transport-noq/README.md +++ b/rs/web-transport-noq/README.md @@ -59,6 +59,14 @@ However some of the API is wrapped or unavailable due to WebTransport limitation - Stream IDs are not available. - Error codes are not full VarInts (62-bits) and significantly smaller. +A clean FIN on the HTTP/3 CONNECT stream without a close capsule reports +`WebTransportError::Closed(0, "")`. Malformed or interrupted capsule data reports +`WebTransportError::CapsuleError`, while an already closed native connection retains +its connection error. Explicit local `close` remains `ConnectionError::LocallyClosed`. +`WebTransportError::CapsuleError(String)` adds a diagnostic variant to the public +enum; exhaustive matches must handle it. Dropping a receive stream sends +application code 0 in the session's code space, preserving raw QUIC code 0 for raw sessions. + Session clones share ownership of the connection. Dropping the final `Session` closes it immediately, including raw QUIC sessions, even if streams or native `noq::Connection` handles remain. Keep a `Session` clone while using those handles. diff --git a/rs/web-transport-noq/src/error.rs b/rs/web-transport-noq/src/error.rs index 804b88cc..586f88d7 100644 --- a/rs/web-transport-noq/src/error.rs +++ b/rs/web-transport-noq/src/error.rs @@ -67,7 +67,7 @@ impl From for SessionError { } } -/// An error that can occur when reading/writing the WebTransport stream header. +/// An error in a WebTransport stream header or session capsule. #[derive(Clone, Error, Debug)] pub enum WebTransportError { #[error("closed: code={0} reason={1}")] @@ -81,6 +81,10 @@ pub enum WebTransportError { #[error("write error: {0}")] WriteError(#[from] noq::WriteError), + + /// The session's HTTP/3 capsule stream was malformed or interrupted, with a diagnostic message. + #[error("capsule error: {0}")] + CapsuleError(String), } /// An error when writing to [`crate::SendStream`]. Similar to [`noq::WriteError`]. diff --git a/rs/web-transport-noq/src/recv.rs b/rs/web-transport-noq/src/recv.rs index dcc5af6f..a4f3b186 100644 --- a/rs/web-transport-noq/src/recv.rs +++ b/rs/web-transport-noq/src/recv.rs @@ -9,18 +9,37 @@ use bytes::Bytes; use crate::{ClosedStream, ReadError, ReadExactError, ReadToEndError, SessionError}; -/// A stream that can be used to receive bytes. See [`noq::RecvStream`]. +/// A stream that can receive bytes, stopping with application code 0 on drop. See [`noq::RecvStream`]. #[derive(Debug)] pub struct RecvStream { inner: noq::RecvStream, error: Arc>, + raw: bool, +} + +impl Drop for RecvStream { + fn drop(&mut self) { + // Preserve the raw backend's default; HTTP/3 needs its mapped application code 0. + // FIN, reset, or an earlier stop can already have made the stream terminal. + let code = if self.raw { + 0 + } else { + web_transport_proto::error_to_http3(0) + }; + let _ = self.inner.stop(code.try_into().unwrap()); + } } impl RecvStream { - pub(crate) fn new(stream: noq::RecvStream, error: Arc>) -> Self { + pub(crate) fn new( + stream: noq::RecvStream, + error: Arc>, + raw: bool, + ) -> Self { Self { inner: stream, error, + raw, } } diff --git a/rs/web-transport-noq/src/session.rs b/rs/web-transport-noq/src/session.rs index cfe6fb73..69dd6597 100644 --- a/rs/web-transport-noq/src/session.rs +++ b/rs/web-transport-noq/src/session.rs @@ -209,52 +209,56 @@ impl Session { error: Arc>, ) { let close_info = Self::read_capsules(recv).await; - let code = close_info.as_ref().map_or(0, |(c, _)| *c); - - let http3_code: noq::VarInt = web_transport_proto::error_to_http3(code) - .try_into() - .unwrap(); - - // Try to record the remote close error. If close() already set - // the error, it owns the connection teardown, so we bail out. match close_info { - Some((code, reason)) => { + Ok((code, reason)) => { let err = WebTransportError::Closed(code, reason.clone()); if error.set(err.into()).is_err() { return; } - conn.close(http3_code, reason.as_bytes()); + if conn.close_reason().is_none() { + conn.close( + web_transport_proto::error_to_http3(code) + .try_into() + .unwrap(), + reason.as_bytes(), + ); + } } - None => { - let err = noq::ConnectionError::LocallyClosed.into(); + Err(cause) => { + let err = conn.close_reason().map(Into::into).unwrap_or_else(|| { + SessionError::WebTransportError(WebTransportError::CapsuleError( + cause.to_string(), + )) + }); if error.set(err).is_err() { return; } - conn.close(http3_code, b""); + if conn.close_reason().is_none() { + // H3_MESSAGE_ERROR: the CONNECT stream did not contain valid capsules. + conn.close(0x10eu32.into(), b"invalid CONNECT capsule stream"); + } } }; } // Keep reading capsules from the CONNECT recv stream until it's closed. - // Returns Some((code, reason)) if a CloseWebTransportSession capsule was received, - // or None if the stream closed without a capsule. - async fn read_capsules(recv: noq::RecvStream) -> Option<(u32, String)> { + // A clean FIN without a close capsule is the default successful close. + async fn read_capsules( + recv: noq::RecvStream, + ) -> Result<(u32, String), web_transport_proto::CapsuleError> { let mut reader = web_transport_proto::Http3CapsuleReader::new(recv); loop { match reader.read().await { Ok(Some(web_transport_proto::Capsule::CloseWebTransportSession { code, reason, - })) => return Some((code, reason)), + })) => return Ok((code, reason)), Ok(Some(web_transport_proto::Capsule::Grease { .. })) => {} Ok(Some(web_transport_proto::Capsule::Unknown { typ, payload })) => { tracing::warn!(%typ, size = payload.len(), "unknown capsule"); } - Ok(None) => return None, - Err(e) => { - tracing::warn!(?e, "failed to read capsule"); - return None; - } + Ok(None) => return Ok((0, String::new())), + Err(e) => return Err(e), } } } @@ -294,7 +298,7 @@ impl Session { .accept_uni() .await .map_err(|e| self.map_error(e))?; - Ok(RecvStream::new(recv, self.error.clone())) + Ok(RecvStream::new(recv, self.error.clone(), true)) } } @@ -308,7 +312,7 @@ impl Session { let (send, recv) = self.conn.accept_bi().await.map_err(|e| self.map_error(e))?; Ok(( SendStream::new(send, self.error.clone()), - RecvStream::new(recv, self.error.clone()), + RecvStream::new(recv, self.error.clone(), true), )) } } @@ -346,7 +350,7 @@ impl Session { send.set_priority(0).ok(); Ok(( SendStream::new(send, self.error.clone()), - RecvStream::new(recv, self.error.clone()), + RecvStream::new(recv, self.error.clone(), self.session_id.is_none()), )) } @@ -466,6 +470,11 @@ impl Session { // Record the local close error. First writer wins — if the background // task already set a remote close error, or close() was already called, // this is a no-op. + if let Some(err) = self.conn.close_reason() { + // A capsule task may not have observed it yet; preserve the first reason. + let _ = self.error.set(self.map_error(err)); + return; + } let err = SessionError::ConnectionError(noq::ConnectionError::LocallyClosed); if self.error.set(err).is_err() { return; @@ -915,7 +924,7 @@ impl SessionAccept { // Decide if we keep looping based on the type. match typ { StreamUni::WEBTRANSPORT => { - let recv = RecvStream::new(recv, self.error.clone()); + let recv = RecvStream::new(recv, self.error.clone(), false); return Poll::Ready(Ok(recv)); } StreamUni::QPACK_DECODER => { @@ -996,7 +1005,7 @@ impl SessionAccept { if let Some((send, recv)) = res { // Wrap the streams in our own types for correct error codes. let send = SendStream::new(send, self.error.clone()); - let recv = RecvStream::new(recv, self.error.clone()); + let recv = RecvStream::new(recv, self.error.clone(), false); return Poll::Ready(Ok((send, recv))); } @@ -1230,6 +1239,93 @@ mod tests { (client_conn, server_conn) } + #[tokio::test] + async fn clean_connect_fin_is_a_default_close() { + let (client, peer, _endpoints) = pair().await; + let (mut send, recv) = client.open_bi().await.unwrap(); + send.write_all(b"connect").await.unwrap(); + let (mut peer_send, _peer_recv) = peer.accept_bi().await.unwrap(); + peer_send.finish().unwrap(); + let error = Arc::new(OnceLock::new()); + Session::run_recv(client, recv, error.clone()).await; + assert!(matches!( + error.get(), + Some(SessionError::WebTransportError(WebTransportError::Closed(0, reason))) + if reason.is_empty() + )); + } + + #[tokio::test] + async fn truncated_connect_data_is_a_capsule_error() { + let (client, peer, _endpoints) = pair().await; + let (mut send, recv) = client.open_bi().await.unwrap(); + send.write_all(b"connect").await.unwrap(); + let (mut peer_send, _peer_recv) = peer.accept_bi().await.unwrap(); + // DATA frame type, missing the frame length. + peer_send.write_all(&[0]).await.unwrap(); + peer_send.finish().unwrap(); + let error = Arc::new(OnceLock::new()); + Session::run_recv(client, recv, error.clone()).await; + assert!(matches!( + error.get(), + Some(SessionError::WebTransportError( + WebTransportError::CapsuleError(_) + )) + )); + } + + #[tokio::test] + async fn failed_connect_stream_preserves_the_connection_failure() { + let (client, peer, _endpoints) = pair().await; + let (mut send, recv) = client.open_bi().await.unwrap(); + send.write_all(b"connect").await.unwrap(); + let _connect = peer.accept_bi().await.unwrap(); + peer.close(0u32.into(), b"failure"); + client.closed().await; + let error = Arc::new(OnceLock::new()); + Session::run_recv(client, recv, error.clone()).await; + assert!(matches!( + error.get(), + Some(SessionError::ConnectionError(noq::ConnectionError::ApplicationClosed(close))) + if close.error_code.into_inner() == 0 && close.reason == b"failure"[..] + )); + } + + #[tokio::test] + async fn local_close_preserves_a_native_failure_before_the_capsule_reader_runs() { + let (session, peer, _connect, _settings, _endpoints) = http3_pair().await; + session._owner.reader.as_ref().unwrap().abort(); + peer.close(0u32.into(), b"failure"); + session.conn.closed().await; + session.close(7, b"local"); + assert!(matches!( + session.closed().await, + SessionError::ConnectionError(noq::ConnectionError::ApplicationClosed(close)) + if close.error_code.into_inner() == 0 && close.reason == b"failure"[..] + )); + } + + #[tokio::test] + async fn receive_drop_uses_the_session_code_space() { + for raw in [false, true] { + let (client, peer, _endpoints) = pair().await; + let mut send = client.open_uni().await.unwrap(); + send.write_all(b"data").await.unwrap(); + let recv = peer.accept_uni().await.unwrap(); + let recv = RecvStream::new(recv, Arc::new(OnceLock::new()), raw); + drop(recv); + let code = if raw { + 0 + } else { + web_transport_proto::error_to_http3(0) + }; + assert_eq!( + send.stopped().await.unwrap(), + Some(code.try_into().unwrap()) + ); + } + } + async fn http3_pair() -> ( Session, noq::Connection, diff --git a/rs/web-transport-quiche/README.md b/rs/web-transport-quiche/README.md index 871922ce..596838fa 100644 --- a/rs/web-transport-quiche/README.md +++ b/rs/web-transport-quiche/README.md @@ -52,6 +52,11 @@ Call `Connection::close` before dropping to choose the close code and reason; final drop preserves an explicit close already in progress. Await `Connection::closed` when the application needs the driver to complete teardown. +The CONNECT reader decodes capsules inside HTTP/3 DATA frames. A clean FIN +without a close capsule closes the session with application code 0 and an empty +reason. Malformed capsules fail with H3_MESSAGE_ERROR, preserving any native +connection failure already observed. + ## Testing Run `cargo test -p web-transport-quiche` for the unit tests and socket integration diff --git a/rs/web-transport-quiche/src/connection.rs b/rs/web-transport-quiche/src/connection.rs index a3922a39..99888b93 100644 --- a/rs/web-transport-quiche/src/connection.rs +++ b/rs/web-transport-quiche/src/connection.rs @@ -207,8 +207,9 @@ impl Connection { // Keep reading from the control stream until it's closed. async fn run_closed(conn: ez::Connection, mut connect: h3::Connected) { + let mut reader = web_transport_proto::Http3CapsuleReader::new(&mut connect.recv); loop { - match web_transport_proto::Capsule::read(&mut connect.recv).await { + match reader.read().await { Ok(Some(web_transport_proto::Capsule::CloseWebTransportSession { code, reason, @@ -223,11 +224,14 @@ impl Connection { tracing::warn!("unknown capsule: type={typ} size={}", payload.len()); } Ok(None) => { - // Stream closed without capsule + conn.close(web_transport_proto::error_to_http3(0), ""); return; } Err(_) => { - conn.close(web_transport_proto::error_to_http3(500), "capsule error"); + if !conn.is_closed() { + // H3_MESSAGE_ERROR: the CONNECT stream did not contain valid capsules. + conn.close(0x10e, "invalid CONNECT capsule stream"); + } return; } } @@ -1097,6 +1101,51 @@ mod tests { }) } + #[tokio::test] + async fn clean_connect_fin_is_a_default_close() -> Result<()> { + let mut pair = http_pair().await?; + pair._connect.send.finish()?; + let closed = timeout(TIMEOUT, pair.session.closed()).await?; + assert!(matches!(closed, SessionError::Local(0, reason) if reason.is_empty())); + Ok(()) + } + + #[tokio::test] + async fn data_framed_close_capsule_preserves_application_details() -> Result<()> { + use tokio::io::AsyncWriteExt; + let mut pair = http_pair().await?; + let mut capsule = BytesMut::new(); + web_transport_proto::Capsule::CloseWebTransportSession { + code: 7, + reason: "done".into(), + } + .encode(&mut capsule); + let mut frame = BytesMut::new(); + web_transport_proto::Frame::DATA.encode(&mut frame); + VarInt::try_from(capsule.len())?.encode(&mut frame); + frame.extend_from_slice(&capsule); + pair._connect.send.write_all(&frame).await?; + pair._connect.send.finish()?; + let closed = timeout(TIMEOUT, pair.session.closed()).await?; + assert!(matches!(closed, SessionError::Local(7, reason) if reason == "done")); + Ok(()) + } + + #[tokio::test] + async fn truncated_capsule_is_a_protocol_error() -> Result<()> { + use tokio::io::AsyncWriteExt; + let mut pair = http_pair().await?; + // The first byte of a two-byte capsule type, with no second byte. + pair._connect.send.write_all(&[0x68]).await?; + pair._connect.send.finish()?; + let closed = timeout(TIMEOUT, pair.session.closed()).await?; + assert!(matches!( + closed, + SessionError::Connection(ez::ConnectionError::Local(0x10e, _)) + )); + Ok(()) + } + #[tokio::test] async fn final_http_frontend_drop_closes_with_connect_held_open() -> Result<()> { let HttpPair { diff --git a/rs/web-transport-quinn/README.md b/rs/web-transport-quinn/README.md index 971c0026..f5e2de91 100644 --- a/rs/web-transport-quinn/README.md +++ b/rs/web-transport-quinn/README.md @@ -63,6 +63,10 @@ a close capsule reports `WebTransportError::Closed(0, "")`; malformed or interru capsules report `WebTransportError::CapsuleError` unless the underlying connection has already reported its own error. An explicit local close reports `ConnectionError::LocallyClosed`. +`WebTransportError::CapsuleError(String)` adds a diagnostic variant to the public +enum; exhaustive matches must handle it. Dropping a receive stream sends +application code 0 in the session's code space, preserving raw QUIC code 0 for raw sessions. + The `web-transport-quinn` API is almost identical to the Quinn API, except that [Connection](https://docs.rs/quinn/latest/quinn/struct.Connection.html) is called [Session](https://docs.rs/web-transport-quinn/latest/web_transport_quinn/struct.Session.html). When possible, `Deref` is used to expose the underlying Quinn API. diff --git a/rs/web-transport-quinn/src/recv.rs b/rs/web-transport-quinn/src/recv.rs index c7e40c4e..b02093d1 100644 --- a/rs/web-transport-quinn/src/recv.rs +++ b/rs/web-transport-quinn/src/recv.rs @@ -14,7 +14,7 @@ use crate::{ ReadError, ReadExactError, ReadToEndError, SessionError, }; -/// A stream that can be used to recieve bytes. See [`quinn::RecvStream`]. +/// A stream that can receive bytes, stopping with application code 0 on drop. See [`quinn::RecvStream`]. #[derive(Debug)] pub struct RecvStream { inner: quinn::RecvStream, @@ -23,6 +23,14 @@ pub struct RecvStream { raw: bool, } +impl Drop for RecvStream { + fn drop(&mut self) { + // Use the session's code space rather than Quinn's implicit raw QUIC code 0. + // FIN, reset, or an earlier stop can already have made the stream terminal. + let _ = self.stop(0); + } +} + impl RecvStream { pub(crate) fn new(stream: quinn::RecvStream, error: Arc, raw: bool) -> Self { Self { diff --git a/rs/web-transport-quinn/src/session.rs b/rs/web-transport-quinn/src/session.rs index bf0dc6f9..2836b47e 100644 --- a/rs/web-transport-quinn/src/session.rs +++ b/rs/web-transport-quinn/src/session.rs @@ -406,9 +406,11 @@ impl Session { pub fn close(&self, code: u32, reason: &[u8]) { // Record the local close error. First writer wins — if the background // task already set a remote close error, or close() was already called, - // this is a no-op. A raw peer close that already arrived is latched first. + // this is a no-op. A native failure that already arrived is latched first. if let Some(err) = self.conn.close_reason() { - self.map_error(err); + // A capsule task may not have observed it yet; preserve the first reason. + let _ = self.error.set(self.map_error(err)); + return; } let err = SessionError::ConnectionError(quinn::ConnectionError::LocallyClosed); if self.error.set(err).is_err() { @@ -1378,6 +1380,39 @@ mod tests { (client_conn, server_conn, [client, server]) } + #[tokio::test] + async fn local_close_preserves_a_native_failure_before_the_capsule_reader_runs() { + let (client, peer, _endpoints) = pair().await; + let mut session = Session::raw(client); + // Model an HTTP/3 session whose capsule task has not recorded the failure yet. + session.session_id = Some(SESSION); + session.error = Arc::new(CloseReason::http3()); + peer.close(0u32.into(), b"failure"); + session.conn.closed().await; + session.close(7, b"local"); + assert!(matches!( + session.closed().await, + SessionError::ConnectionError(quinn::ConnectionError::ApplicationClosed(close)) + if close.error_code.into_inner() == 0 && close.reason == b"failure"[..] + )); + } + + #[tokio::test] + async fn receive_drop_uses_the_session_code_space() { + for raw in [false, true] { + let (client, peer, _endpoints) = pair().await; + let mut send = client.open_uni().await.unwrap(); + send.write_all(b"data").await.unwrap(); + let recv = peer.accept_uni().await.unwrap(); + let recv = RecvStream::new(recv, Arc::new(CloseReason::http3()), raw); + drop(recv); + assert_eq!( + send.stopped().await.unwrap(), + Some(crate::error::encode_stream_code(0, raw)) + ); + } + } + #[tokio::test] async fn clean_connect_fin_is_a_default_close() { let (client, peer, _endpoints) = pair().await; From dfd6edfc4eb2e1d0daa188f9584b74111e578c95 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 7 Nov 2026 02:09:08 -0800 Subject: [PATCH 06/11] Remove unused Quiche test imports Co-Authored-By: GPT-6.1 Sol --- rs/web-transport-quiche/src/connection.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/rs/web-transport-quiche/src/connection.rs b/rs/web-transport-quiche/src/connection.rs index 99888b93..b3c8c610 100644 --- a/rs/web-transport-quiche/src/connection.rs +++ b/rs/web-transport-quiche/src/connection.rs @@ -1112,7 +1112,6 @@ mod tests { #[tokio::test] async fn data_framed_close_capsule_preserves_application_details() -> Result<()> { - use tokio::io::AsyncWriteExt; let mut pair = http_pair().await?; let mut capsule = BytesMut::new(); web_transport_proto::Capsule::CloseWebTransportSession { @@ -1133,7 +1132,6 @@ mod tests { #[tokio::test] async fn truncated_capsule_is_a_protocol_error() -> Result<()> { - use tokio::io::AsyncWriteExt; let mut pair = http_pair().await?; // The first byte of a two-byte capsule type, with no second byte. pair._connect.send.write_all(&[0x68]).await?; From 1f37a66893dd58e330e049a41219abb58e1d4cf6 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 7 Nov 2026 02:17:28 -0800 Subject: [PATCH 07/11] Reuse Napi async receiver ownership for reads Keep the existing async read API and add cancellation before taking the stream mutex. Remove the unused synchronous future ownership path now that automatic pending-reader collection remains an open decision. Co-Authored-By: GPT-6.1 Sol --- rs/web-transport-node/src/lib.rs | 63 +++++++++++++------------------- 1 file changed, 25 insertions(+), 38 deletions(-) diff --git a/rs/web-transport-node/src/lib.rs b/rs/web-transport-node/src/lib.rs index e42e5f14..40204f22 100644 --- a/rs/web-transport-node/src/lib.rs +++ b/rs/web-transport-node/src/lib.rs @@ -568,8 +568,7 @@ impl NapiSendClosed { #[napi] pub struct NapiRecvStream { inner: Arc>, - // Closing the sender cancels reads when the JS owner is collected. The read futures own - // only receivers, so neither napi-rs nor the shared stream can keep that owner alive. + // Signal cancellation before stop waits for the receive-stream mutex. stopped: watch::Sender, } @@ -618,47 +617,35 @@ impl NapiRecvStream { /// Read up to `max_size` bytes from the stream. Returns null on FIN, or the error if the /// peer reset the stream or the session failed. #[napi] - pub fn read<'env>( - &self, - env: &'env Env, - max_size: u32, - ) -> Result>> { + pub async fn read(&self, max_size: u32) -> Result>> { use web_transport_quinn::ReadError; - // A synchronous callback spawning an owned future avoids async fn's implicit JS - // receiver reference, which would prevent abandonment from cancelling this read. + // Own the shared stream and cancellation receiver for the future (see module note). let inner = self.inner.clone(); let mut stopped = self.stopped.subscribe(); - env.spawn_future(async move { - let mut stream = inner.lock().await; - if *stopped.borrow() { - return Ok(Either3::C(Null)); + let mut stream = inner.lock().await; + if *stopped.borrow() { + return Ok(None); + } + let result = tokio::select! { + biased; + _ = stopped.changed() => return Ok(None), + result = stream.read_chunk(max_size as usize, true) => result, + }; + let err = match result { + Ok(chunk) => { + return Ok(chunk.map(|chunk| Either::A(Buffer::from(chunk.bytes.to_vec())))) } - let result = tokio::select! { - biased; - _ = stopped.changed() => return Ok(Either3::C(Null)), - result = stream.read_chunk(max_size as usize, true) => result, - }; - let err = match result { - Ok(chunk) => { - return Ok(match chunk { - Some(chunk) => Either3::A(Buffer::from(chunk.bytes.to_vec())), - None => Either3::C(Null), - }) - } - Err(err @ ReadError::Reset(code)) => { - NapiStreamError::stream(Some(code), err.to_string()) - } - Err(err @ ReadError::InvalidReset(_)) => { - NapiStreamError::stream(None, err.to_string()) - } - Err(ReadError::SessionError(err)) => NapiStreamError::session(&err), - Err(err @ (ReadError::ClosedStream | ReadError::IllegalOrderedRead)) => { - return Err(Error::from_reason(err.to_string())) - } - }; - Ok(Either3::B(err)) - }) + Err(err @ ReadError::Reset(code)) => { + NapiStreamError::stream(Some(code), err.to_string()) + } + Err(err @ ReadError::InvalidReset(_)) => NapiStreamError::stream(None, err.to_string()), + Err(ReadError::SessionError(err)) => NapiStreamError::session(&err), + Err(err @ (ReadError::ClosedStream | ReadError::IllegalOrderedRead)) => { + return Err(Error::from_reason(err.to_string())) + } + }; + Ok(Some(Either::B(err))) } /// Tell the peer to stop sending with the given code; an already terminal stream is a no-op. From bf0c999766d5d4917d1f9f4e01a8ee2df4343a6a Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Sat, 7 Nov 2026 02:57:10 -0800 Subject: [PATCH 08/11] Align cancellation and close outcomes across native backends Reject cancelled native reads instead of reporting FIN, preserve Iroh capsule failures, and use consistent raw stream codes in Noq. Cover native wire outcomes and capsule-free application close codes. Co-Authored-By: GPT-6.1 Sol --- js/web-transport/README.md | 1 + js/web-transport/napi.d.cts | 2 +- js/web-transport/tests/session.test.ts | 42 ++++++++- rs/web-transport-iroh/README.md | 13 +++ rs/web-transport-iroh/src/error.rs | 6 +- rs/web-transport-iroh/src/recv.rs | 9 +- rs/web-transport-iroh/src/session.rs | 93 ++++++++++++++++++- rs/web-transport-node/Cargo.toml | 1 + .../examples/session-peer.rs | 10 +- rs/web-transport-node/src/lib.rs | 13 ++- rs/web-transport-noq/README.md | 4 + rs/web-transport-noq/src/error.rs | 21 +++++ rs/web-transport-noq/src/recv.rs | 29 +++--- rs/web-transport-noq/src/send.rs | 30 ++++-- rs/web-transport-noq/src/session.rs | 60 +++++++++++- 15 files changed, 292 insertions(+), 42 deletions(-) diff --git a/js/web-transport/README.md b/js/web-transport/README.md index 49d256ef..4ac45a47 100644 --- a/js/web-transport/README.md +++ b/js/web-transport/README.md @@ -152,6 +152,7 @@ including nonzero application codes. An orderly HTTP/3 connection shutdown (H3_N without application details resolves with code 0 and an empty reason. A failed connection or an underlying connection failure rejects it with a `WebTransportError` whose `source` is `"session"` and `streamErrorCode` is `null`. `session.ready` rejects with the same error if connecting fails. +Backend teardown without an application `session.close()` also rejects `closed`. ```ts // Close gracefully diff --git a/js/web-transport/napi.d.cts b/js/web-transport/napi.d.cts index b9ce48b6..0848b068 100644 --- a/js/web-transport/napi.d.cts +++ b/js/web-transport/napi.d.cts @@ -27,7 +27,7 @@ export declare class NapiClient { export declare class NapiRecvStream { /** * Read up to `max_size` bytes from the stream. Returns null on FIN, or the error if the - * peer reset the stream or the session failed. + * peer reset the stream or the session failed. Local cancellation rejects the read. */ read(maxSize: number): Promise; /** Tell the peer to stop sending with the given code; an already terminal stream is a no-op. */ diff --git a/js/web-transport/tests/session.test.ts b/js/web-transport/tests/session.test.ts index cab2c677..85bb7e09 100644 --- a/js/web-transport/tests/session.test.ts +++ b/js/web-transport/tests/session.test.ts @@ -120,13 +120,14 @@ test("local and peer closes preserve nonzero application codes and reasons", asy }); for (const side of ["client", "server"] as const) { - for (const orderly of [false, true]) { - test(`${orderly ? "an orderly HTTP/3 shutdown resolves" : "an underlying connection failure rejects"} the ${side} Session.closed`, async () => { + for (const mode of ["failure", "orderly", "application"] as const) { + test(`${mode === "failure" ? "an underlying connection failure rejects" : `${mode} capsule-free shutdown resolves`} the ${side} Session.closed`, async () => { const child = Bun.spawn([peerExecutable, ...(side === "server" ? [url] : [])], { env: { ...process.env, WEB_TRANSPORT_TEST_PEM: pem.toString(), - WEB_TRANSPORT_TEST_ORDERLY_CLOSE: orderly ? "1" : undefined, + WEB_TRANSPORT_TEST_ORDERLY_CLOSE: mode === "orderly" ? "1" : undefined, + WEB_TRANSPORT_TEST_WT_CLOSE: mode === "application" ? "1" : undefined, }, stdin: "pipe", stdout: "pipe", @@ -144,9 +145,11 @@ for (const side of ["client", "server"] as const) { } else { session = accepted.shift() ?? (await new Promise((resolve) => waiters.push(resolve))); } - const closed = orderly ? session.closed : rejection(session.closed); + const closed = mode === "failure" ? rejection(session.closed) : session.closed; await session.datagrams.writable.getWriter().write(new Uint8Array([1])); - if (orderly) expect(await closed).toEqual({ closeCode: 0, reason: "" }); + if (mode === "orderly") expect(await closed).toEqual({ closeCode: 0, reason: "" }); + else if (mode === "application") + expect(await closed).toEqual({ closeCode: 42, reason: "connection shutdown" }); else { const err = (await closed) as WebTransportError; expect(err.source).toBe("session"); @@ -316,6 +319,35 @@ test("concurrent read requests keep pulling through data and FIN", async () => { } }); +test("native cancellation rejects pending and subsequent reads instead of reporting FIN", async () => { + const client = await napi.NapiClient.disableVerify().connect(url); + const peer = accepted.shift() ?? (await new Promise((resolve) => waiters.push(resolve))); + try { + const writer = (await peer.createUnidirectionalStream()).getWriter(); + const closed = rejection(writer.closed); + await writer.write(new Uint8Array([1])); + const recv = await client.acceptUni(); + await recv.read(65536); + const pending = recv.read(65536).then( + () => "unexpected FIN", + (err: Error) => err.message, + ); + await Bun.sleep(0); + await recv.stop(17); + expect(await pending).toBe("stream already closed"); + expect( + await recv.read(65536).then( + () => "unexpected FIN", + (err: Error) => err.message, + ), + ).toBe("stream already closed"); + expect(((await closed) as WebTransportError).streamErrorCode).toBe(17); + } finally { + client.close(0, "done"); + await client.closed(); + } +}); + test("native cancellation is idempotent after FIN and RESET_STREAM", async () => { for (const reset of [false, true]) { const client = await napi.NapiClient.disableVerify().connect(url); diff --git a/rs/web-transport-iroh/README.md b/rs/web-transport-iroh/README.md index 564d2603..4d6f7fe5 100644 --- a/rs/web-transport-iroh/README.md +++ b/rs/web-transport-iroh/README.md @@ -11,6 +11,19 @@ It implements the [`web-transport-trait`] traits for iroh connections and stream The crate was originally derived from [`web-transport-quinn`]. +## Session closure + +A peer close capsule reports `WebTransportError::Closed` with its application code +and reason. A clean CONNECT FIN without a capsule reports code 0 and an empty reason. +Malformed capsule data reports `WebTransportError::CapsuleError(String)` and closes +HTTP/3 with H3_MESSAGE_ERROR (0x10e). An existing connection failure keeps its cause. + +`CapsuleError(String)` is a new public enum variant; downstream exhaustive matches +must handle it when upgrading. + +Dropping a receive stream sends application code 0 in the session's code space: +HTTP/3 maps the code, while raw QUIC sends it unchanged. + ## License Copyright 2025 N0, INC. diff --git a/rs/web-transport-iroh/src/error.rs b/rs/web-transport-iroh/src/error.rs index da2af9e7..53287f13 100644 --- a/rs/web-transport-iroh/src/error.rs +++ b/rs/web-transport-iroh/src/error.rs @@ -72,13 +72,17 @@ pub(crate) fn decode_stream_code(code: endpoint::VarInt, raw: bool) -> Option Self { Self { inner: stream, raw } diff --git a/rs/web-transport-iroh/src/session.rs b/rs/web-transport-iroh/src/session.rs index 0a692141..07eaea3e 100644 --- a/rs/web-transport-iroh/src/session.rs +++ b/rs/web-transport-iroh/src/session.rs @@ -99,10 +99,25 @@ impl Session { } let (code, reason) = match closed { Ok(Some(close)) => close, - Ok(None) => (0, "stream closed".to_string()), + Ok(None) => { + peer_close.send_replace(Some( + WebTransportError::Closed { + code: 0, + reason: String::new(), + } + .into(), + )); + (0, String::new()) + } Err(err) => { tracing::warn!(?err, "failed to read capsule"); - (1, "capsule error".to_string()) + peer_close.send_replace(Some( + WebTransportError::CapsuleError(err.to_string()).into(), + )); + this2 + .conn + .close(0x10eu32.into(), b"invalid CONNECT capsule stream"); + return; } }; // TODO We shouldn't be closing the QUIC connection with the same error. @@ -269,7 +284,9 @@ impl Session { /// Wait until the session is closed, returning the error. See [`iroh::endpoint::Connection::closed`]. /// - /// A peer's `CloseWebTransportSession` capsule is reported as [`WebTransportError::Closed`]. + /// A peer's `CloseWebTransportSession` capsule, or a clean CONNECT FIN without a + /// capsule, is reported as [`WebTransportError::Closed`]. Malformed capsule data + /// returns [`WebTransportError::CapsuleError`]. pub async fn closed(&self) -> SessionError { let err = self.conn.closed().await; if let Some(h3) = &self.h3 { @@ -886,6 +903,76 @@ mod tests { (client_conn, server_conn, [client, server]) } + async fn http3_pair() -> (Session, Connection, Connected, Settings, [Endpoint; 2]) { + let (client, peer, endpoints) = pair().await; + let establish = Session::connect_h3(client, url::Url::parse("https://localhost/").unwrap()); + let accept = async { + let settings = Settings::connect(&peer).await.unwrap(); + let connect = crate::Connecting::accept(&peer) + .await + .unwrap() + .respond(http::StatusCode::OK) + .await + .unwrap(); + (connect, settings) + }; + let (session, (connect, settings)) = tokio::join!(establish, accept); + (session.unwrap(), peer, connect, settings, endpoints) + } + + #[tokio::test] + async fn clean_connect_fin_is_a_default_close() { + let (session, _peer, mut connect, _settings, _endpoints) = http3_pair().await; + connect.send.finish().unwrap(); + let err = session.closed().await; + assert!( + matches!(&err, SessionError::WebTransportError(WebTransportError::Closed { code: 0, reason }) if reason.is_empty()), + "{err:?}" + ); + } + + #[tokio::test] + async fn truncated_connect_data_is_a_protocol_failure() { + let (session, peer, mut connect, _settings, _endpoints) = http3_pair().await; + connect.send.write_all(&[0]).await.unwrap(); + connect.send.finish().unwrap(); + let err = peer.closed().await; + assert!( + matches!(&err, endpoint::ConnectionError::ApplicationClosed(close) if close.error_code.into_inner() == 0x10e), + "{err:?}" + ); + assert!(matches!( + session.closed().await, + SessionError::WebTransportError(WebTransportError::CapsuleError(_)) + )); + } + + #[tokio::test] + async fn failed_connect_stream_preserves_the_connection_failure() { + let (session, peer, _connect, _settings, _endpoints) = http3_pair().await; + peer.close(0u32.into(), b"failure"); + let err = session.closed().await; + assert!( + matches!(&err, SessionError::ConnectionError(endpoint::ConnectionError::ApplicationClosed(close)) if close.error_code.into_inner() == 0 && close.reason == b"failure"[..]), + "{err:?}" + ); + } + + #[tokio::test] + async fn receive_drop_uses_the_session_code_space() { + for raw in [false, true] { + let (client, peer, _endpoints) = pair().await; + let mut send = client.open_uni().await.unwrap(); + send.write_all(b"data").await.unwrap(); + let recv = peer.accept_uni().await.unwrap(); + drop(RecvStream::new(recv, raw)); + assert_eq!( + send.stopped().await.unwrap(), + Some(crate::error::encode_stream_code(0, raw)) + ); + } + } + fn assert_reset(err: SessionError) { assert!( matches!( diff --git a/rs/web-transport-node/Cargo.toml b/rs/web-transport-node/Cargo.toml index 36452b7e..67a4cd74 100644 --- a/rs/web-transport-node/Cargo.toml +++ b/rs/web-transport-node/Cargo.toml @@ -26,3 +26,4 @@ napi-build = "2" [dev-dependencies] anyhow = "1" tokio = { version = "1", features = ["rt"] } +web-transport-proto = { workspace = true } diff --git a/rs/web-transport-node/examples/session-peer.rs b/rs/web-transport-node/examples/session-peer.rs index 4489c89a..61bf8d96 100644 --- a/rs/web-transport-node/examples/session-peer.rs +++ b/rs/web-transport-node/examples/session-peer.rs @@ -45,12 +45,16 @@ async fn main() -> anyhow::Result<()> { .await .context("read trigger datagram")?; // H3_NO_ERROR is orderly shutdown; raw QUIC 0 is outside WebTransport's HTTP/3 space. - let code = if std::env::var_os("WEB_TRANSPORT_TEST_ORDERLY_CLOSE").is_some() { - 0x100u32 + let code: u64 = if std::env::var_os("WEB_TRANSPORT_TEST_WT_CLOSE").is_some() { + web_transport_proto::error_to_http3(42) + } else if std::env::var_os("WEB_TRANSPORT_TEST_ORDERLY_CLOSE").is_some() { + 0x100 } else { 0 }; - session.deref().close(code.into(), b"connection shutdown"); + session + .deref() + .close(code.try_into().unwrap(), b"connection shutdown"); // Await a second signal on stdin to keep the runtime alive while QUIC sends the close. tokio::task::spawn_blocking(|| std::io::stdin().read(&mut [0])) .await diff --git a/rs/web-transport-node/src/lib.rs b/rs/web-transport-node/src/lib.rs index 40204f22..325f3fae 100644 --- a/rs/web-transport-node/src/lib.rs +++ b/rs/web-transport-node/src/lib.rs @@ -609,13 +609,20 @@ mod tests { ) .unwrap(); assert_eq!((info.close_code, info.reason.as_str()), (42, "local")); + // A backend/endpoint teardown without Session.close() is a session failure, + // rather than an application close whose details we can report. + assert!(session_error_to_close_info( + &SessionError::ConnectionError(ConnectionError::LocallyClosed), + None + ) + .is_err()); } } #[napi] impl NapiRecvStream { /// Read up to `max_size` bytes from the stream. Returns null on FIN, or the error if the - /// peer reset the stream or the session failed. + /// peer reset the stream or the session failed. Local cancellation rejects the read. #[napi] pub async fn read(&self, max_size: u32) -> Result>> { use web_transport_quinn::ReadError; @@ -625,11 +632,11 @@ impl NapiRecvStream { let mut stopped = self.stopped.subscribe(); let mut stream = inner.lock().await; if *stopped.borrow() { - return Ok(None); + return Err(Error::from_reason(ReadError::ClosedStream.to_string())); } let result = tokio::select! { biased; - _ = stopped.changed() => return Ok(None), + _ = stopped.changed() => return Err(Error::from_reason(ReadError::ClosedStream.to_string())), result = stream.read_chunk(max_size as usize, true) => result, }; let err = match result { diff --git a/rs/web-transport-noq/README.md b/rs/web-transport-noq/README.md index 99ca73bf..9c527c9f 100644 --- a/rs/web-transport-noq/README.md +++ b/rs/web-transport-noq/README.md @@ -81,3 +81,7 @@ UTF-8 reason; the native fallback carries a prefix of at most 16 bytes at a char boundary. Already observed native errors are preserved. Peer delivery, endpoint draining and execution of awakened tasks require a live runtime. Forgotten futures, non-yielding tasks and process abort are outside this guarantee. + +Raw QUIC stream reset and stop codes are sent unchanged, matching Quinn and Iroh. +Raw receivers also accept HTTP/3-mapped codes from older peers. HTTP/3 stream codes +continue to use the reserved WebTransport mapping, including code 0 on receive drop. diff --git a/rs/web-transport-noq/src/error.rs b/rs/web-transport-noq/src/error.rs index 586f88d7..427a1212 100644 --- a/rs/web-transport-noq/src/error.rs +++ b/rs/web-transport-noq/src/error.rs @@ -67,6 +67,27 @@ impl From for SessionError { } } +/// The QUIC code to reset or stop a stream with. Raw QUIC sends the code as is, while +/// HTTP/3 maps it into its own code space. +pub(crate) fn encode_stream_code(code: u32, raw: bool) -> noq::VarInt { + if raw { + return code.into(); + } + noq::VarInt::try_from(web_transport_proto::error_to_http3(code)).unwrap() +} + +/// Decode the peer's QUIC code for a stream reset or stop, or None if it is not one. +pub(crate) fn decode_stream_code(code: noq::VarInt, raw: bool) -> Option { + let code = code.into_inner(); + // An older raw peer maps its codes into the HTTP/3 range too. No u32 reaches that + // range, so the mapped form cannot be mistaken for a raw code. + match web_transport_proto::error_from_http3(code) { + Some(code) => Some(code), + None if raw => u32::try_from(code).ok(), + None => None, + } +} + /// An error in a WebTransport stream header or session capsule. #[derive(Clone, Error, Debug)] pub enum WebTransportError { diff --git a/rs/web-transport-noq/src/recv.rs b/rs/web-transport-noq/src/recv.rs index a4f3b186..9724016a 100644 --- a/rs/web-transport-noq/src/recv.rs +++ b/rs/web-transport-noq/src/recv.rs @@ -7,7 +7,10 @@ use std::{ use bytes::Bytes; -use crate::{ClosedStream, ReadError, ReadExactError, ReadToEndError, SessionError}; +use crate::{ + error::{decode_stream_code, encode_stream_code}, + ClosedStream, ReadError, ReadExactError, ReadToEndError, SessionError, +}; /// A stream that can receive bytes, stopping with application code 0 on drop. See [`noq::RecvStream`]. #[derive(Debug)] @@ -19,14 +22,8 @@ pub struct RecvStream { impl Drop for RecvStream { fn drop(&mut self) { - // Preserve the raw backend's default; HTTP/3 needs its mapped application code 0. // FIN, reset, or an earlier stop can already have made the stream terminal. - let code = if self.raw { - 0 - } else { - web_transport_proto::error_to_http3(0) - }; - let _ = self.inner.stop(code.try_into().unwrap()); + let _ = self.stop(0); } } @@ -44,8 +41,14 @@ impl RecvStream { } /// Replace connection-level errors with the stored session error if available. - fn map_error(&self, e: impl Into) -> ReadError { - let e = e.into(); + fn map_error(&self, e: noq::ReadError) -> ReadError { + let e = match e { + noq::ReadError::Reset(code) => match decode_stream_code(code, self.raw) { + Some(code) => ReadError::Reset(code), + None => ReadError::InvalidReset(code), + }, + e => e.into(), + }; if let Some(err) = self.error.get() { if matches!(&e, ReadError::SessionError(_)) { return ReadError::SessionError(err.clone()); @@ -56,9 +59,9 @@ impl RecvStream { /// Tell the other end to stop sending data with the given error code. See [`noq::RecvStream::stop`]. /// This is a u32 with WebTransport since it shares the error space with HTTP/3. + /// A raw QUIC session sends the code as is. pub fn stop(&mut self, code: u32) -> Result<(), noq::ClosedStream> { - let code = web_transport_proto::error_to_http3(code); - let code = noq::VarInt::try_from(code).unwrap(); + let code = encode_stream_code(code, self.raw); self.inner.stop(code) } @@ -113,7 +116,7 @@ impl RecvStream { pub async fn received_reset(&mut self) -> Result, SessionError> { match self.inner.received_reset().await { Ok(None) => Ok(None), - Ok(Some(code)) => Ok(web_transport_proto::error_from_http3(code.into_inner())), + Ok(Some(code)) => Ok(decode_stream_code(code, self.raw)), Err(noq::ResetError::ConnectionLost(conn_err)) => { Err(self.error.get().cloned().unwrap_or_else(|| conn_err.into())) } diff --git a/rs/web-transport-noq/src/send.rs b/rs/web-transport-noq/src/send.rs index a54837a3..8d8309ad 100644 --- a/rs/web-transport-noq/src/send.rs +++ b/rs/web-transport-noq/src/send.rs @@ -7,7 +7,10 @@ use std::{ use bytes::{Buf, Bytes}; -use crate::{ClosedStream, SessionError, WriteError}; +use crate::{ + error::{decode_stream_code, encode_stream_code}, + ClosedStream, SessionError, WriteError, +}; /// A stream that can be used to send bytes. See [`noq::SendStream`]. /// @@ -17,16 +20,27 @@ use crate::{ClosedStream, SessionError, WriteError}; pub struct SendStream { stream: noq::SendStream, error: Arc>, + raw: bool, } impl SendStream { - pub(crate) fn new(stream: noq::SendStream, error: Arc>) -> Self { - Self { stream, error } + pub(crate) fn new( + stream: noq::SendStream, + error: Arc>, + raw: bool, + ) -> Self { + Self { stream, error, raw } } /// Replace connection-level errors with the stored session error if available. - fn map_error(&self, e: impl Into) -> WriteError { - let e = e.into(); + fn map_error(&self, e: noq::WriteError) -> WriteError { + let e = match e { + noq::WriteError::Stopped(code) => match decode_stream_code(code, self.raw) { + Some(code) => WriteError::Stopped(code), + None => WriteError::InvalidStopped(code), + }, + e => e.into(), + }; if let Some(err) = self.error.get() { if matches!(&e, WriteError::SessionError(_)) { return WriteError::SessionError(err.clone()); @@ -37,9 +51,9 @@ impl SendStream { /// Abruptly reset the stream with the provided error code. See [`noq::SendStream::reset`]. /// This is a u32 with WebTransport because we share the error space with HTTP/3. + /// A raw QUIC session sends the code as is. pub fn reset(&mut self, code: u32) -> Result<(), ClosedStream> { - let code = web_transport_proto::error_to_http3(code); - let code = noq::VarInt::try_from(code).unwrap(); + let code = encode_stream_code(code, self.raw); self.stream.reset(code).map_err(Into::into) } @@ -49,7 +63,7 @@ impl SendStream { /// Also unlike Noq, this returns a SessionError, not a StoppedError, because 0-RTT is not supported. pub async fn stopped(&self) -> Result, SessionError> { match self.stream.stopped().await { - Ok(Some(code)) => Ok(web_transport_proto::error_from_http3(code.into_inner())), + Ok(Some(code)) => Ok(decode_stream_code(code, self.raw)), Ok(None) => Ok(None), Err(noq::StoppedError::ConnectionLost(conn_err)) => { Err(self.error.get().cloned().unwrap_or_else(|| conn_err.into())) diff --git a/rs/web-transport-noq/src/session.rs b/rs/web-transport-noq/src/session.rs index 69dd6597..776e22be 100644 --- a/rs/web-transport-noq/src/session.rs +++ b/rs/web-transport-noq/src/session.rs @@ -311,7 +311,7 @@ impl Session { } else { let (send, recv) = self.conn.accept_bi().await.map_err(|e| self.map_error(e))?; Ok(( - SendStream::new(send, self.error.clone()), + SendStream::new(send, self.error.clone(), self.session_id.is_none()), RecvStream::new(recv, self.error.clone(), true), )) } @@ -331,7 +331,11 @@ impl Session { // Reset the stream priority back to the default of 0. send.set_priority(0).ok(); - Ok(SendStream::new(send, self.error.clone())) + Ok(SendStream::new( + send, + self.error.clone(), + self.session_id.is_none(), + )) } /// Open a new bidirectional stream. See [`noq::Connection::open_bi`]. @@ -349,7 +353,7 @@ impl Session { // Reset the stream priority back to the default of 0. send.set_priority(0).ok(); Ok(( - SendStream::new(send, self.error.clone()), + SendStream::new(send, self.error.clone(), self.session_id.is_none()), RecvStream::new(recv, self.error.clone(), self.session_id.is_none()), )) } @@ -1004,7 +1008,7 @@ impl SessionAccept { if let Some((send, recv)) = res { // Wrap the streams in our own types for correct error codes. - let send = SendStream::new(send, self.error.clone()); + let send = SendStream::new(send, self.error.clone(), false); let recv = RecvStream::new(recv, self.error.clone(), false); return Poll::Ready(Ok((send, recv))); } @@ -1305,6 +1309,54 @@ mod tests { )); } + #[tokio::test] + async fn raw_stream_codes_round_trip() { + let (client, peer, _endpoints) = pair().await; + let client = Session::raw(client); + let peer = Session::raw(peer); + let mut send = client.open_uni().await.unwrap(); + send.write_all(b"data").await.unwrap(); + let mut recv = peer.accept_uni().await.unwrap(); + recv.stop(17).unwrap(); + assert_eq!(send.stopped().await.unwrap(), Some(17)); + assert!(matches!( + send.write_all(b"more").await, + Err(crate::WriteError::Stopped(17)) + )); + + let mut send = client.open_uni().await.unwrap(); + send.write_all(b"data").await.unwrap(); + let mut recv = peer.accept_uni().await.unwrap(); + let mut buf = [0; 4]; + recv.read_exact(&mut buf).await.unwrap(); + send.reset(7).unwrap(); + assert!(matches!( + recv.read(&mut buf).await, + Err(crate::ReadError::Reset(7)) + )); + } + + #[tokio::test] + async fn receive_stop_uses_the_session_code_space() { + for raw in [false, true] { + let (client, peer, _endpoints) = pair().await; + let mut send = client.open_uni().await.unwrap(); + send.write_all(b"data").await.unwrap(); + let recv = peer.accept_uni().await.unwrap(); + let mut recv = RecvStream::new(recv, Arc::new(OnceLock::new()), raw); + recv.stop(17).unwrap(); + let code = if raw { + 17 + } else { + web_transport_proto::error_to_http3(17) + }; + assert_eq!( + send.stopped().await.unwrap(), + Some(code.try_into().unwrap()) + ); + } + } + #[tokio::test] async fn receive_drop_uses_the_session_code_space() { for raw in [false, true] { From f6b8393abfb0be930869983cf8d85c3a63c735ad Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 10 Nov 2026 22:34:44 -0800 Subject: [PATCH 09/11] Expect closed to reject after a failed server-close connection The server-close fixture's stalled client never connects. With this change, a failed connection rejects closed with the same error as ready. Co-Authored-By: Claude Opus 5.5 --- js/web-transport/tests/fixtures/server-close.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/js/web-transport/tests/fixtures/server-close.ts b/js/web-transport/tests/fixtures/server-close.ts index 9c753f7f..55db50cc 100644 --- a/js/web-transport/tests/fixtures/server-close.ts +++ b/js/web-transport/tests/fixtures/server-close.ts @@ -78,7 +78,7 @@ holding = false; assert(remoteClient); for (const flight of flights) proxy.send(flight, remoteClient.port, remoteClient.address); await rejected; -await stalled.closed; +await assert.rejects(stalled.closed); await new Promise((resolve) => proxy.close(resolve)); // Stopping the listener must not close sessions it already accepted. From 6c26d98538c4181df3440857e9140f4b90cc7895 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 10 Nov 2026 23:57:34 -0800 Subject: [PATCH 10/11] Expect idle expiry to reject closed An idle timeout is a connection failure, so after the merge with the Node idle options it rejects session.closed with a session WebTransportError instead of resolving with a "timed out" reason. Co-Authored-By: Claude Opus 5.5 --- js/web-transport/README.md | 2 +- js/web-transport/tests/fixtures/idle.ts | 8 +++++--- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/js/web-transport/README.md b/js/web-transport/README.md index 2eb0ca4a..f06935f4 100644 --- a/js/web-transport/README.md +++ b/js/web-transport/README.md @@ -60,7 +60,7 @@ const session = new Session("https://example.com:4443/path", { }); ``` -QUIC uses the smaller of both peers' idle timeouts, so disabling one endpoint's timeout leaves the peer's in effect. To keep an otherwise idle session open, set `keepAliveInterval` below the effective idle timeout on either endpoint. +QUIC uses the smaller of both peers' idle timeouts, so disabling one endpoint's timeout leaves the peer's in effect. To keep an otherwise idle session open, set `keepAliveInterval` below the effective idle timeout on either endpoint. An expired idle timeout is a connection failure, so it rejects `session.closed` with a session `WebTransportError`. ### Polyfill diff --git a/js/web-transport/tests/fixtures/idle.ts b/js/web-transport/tests/fixtures/idle.ts index 27154319..5a6e0092 100644 --- a/js/web-transport/tests/fixtures/idle.ts +++ b/js/web-transport/tests/fixtures/idle.ts @@ -2,7 +2,7 @@ import assert from "node:assert/strict"; import { execFileSync } from "node:child_process"; import { createSocket } from "node:dgram"; import { setTimeout as sleep } from "node:timers/promises"; -import Session, { Server, type ServerOptions, type SessionOptions } from "../../src/index.ts"; +import Session, { Server, type ServerOptions, type SessionOptions, WebTransportError } from "../../src/index.ts"; const pem = execFileSync("openssl", [ "req", @@ -47,8 +47,10 @@ const EXPIRY_BOUND_MS = 10_000; async function expectExpiry(serverOptions: ServerOptions | undefined, clientOptions: SessionOptions) { const { client, peer } = await connect(serverOptions, clientOptions); const start = performance.now(); - const [info] = await Promise.all([client.closed, peer.closed]); - assert.match(info.reason ?? "", /timed out/); + // An idle timeout is a connection failure, so both sides reject with a session error. + const timedOut = (err: unknown) => + err instanceof WebTransportError && err.source === "session" && /timed out/.test(err.message); + await Promise.all([assert.rejects(client.closed, timedOut), assert.rejects(peer.closed, timedOut)]); assert(performance.now() - start < EXPIRY_BOUND_MS); } From f989b35063d16ae251e5eaf4354f0c731b387562 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 11 Nov 2026 00:40:11 -0800 Subject: [PATCH 11/11] Truncate a capsule inside a DATA frame in the quiche test The raw 0x68 byte truncated an HTTP/3 frame header, so the test never reached capsule parsing. Wrap the partial capsule type in a DATA frame. Co-Authored-By: Claude Opus 5.5 --- rs/web-transport-quiche/src/connection.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/rs/web-transport-quiche/src/connection.rs b/rs/web-transport-quiche/src/connection.rs index aca37a02..56ee2a1d 100644 --- a/rs/web-transport-quiche/src/connection.rs +++ b/rs/web-transport-quiche/src/connection.rs @@ -1134,8 +1134,12 @@ mod tests { #[tokio::test] async fn truncated_capsule_is_a_protocol_error() -> Result<()> { let mut pair = http_pair().await?; - // The first byte of a two-byte capsule type, with no second byte. - pair._connect.send.write_all(&[0x68]).await?; + // A DATA frame carrying the first byte of a two-byte capsule type, with no second byte. + let mut frame = BytesMut::new(); + web_transport_proto::Frame::DATA.encode(&mut frame); + VarInt::from_u32(1).encode(&mut frame); + frame.extend_from_slice(&[0x68]); + pair._connect.send.write_all(&frame).await?; pair._connect.send.finish()?; let closed = timeout(TIMEOUT, pair.session.closed()).await?; assert!(matches!(