diff --git a/js/qmux/src/credit.test.ts b/js/qmux/src/credit.test.ts index 517931bc..71c22407 100644 --- a/js/qmux/src/credit.test.ts +++ b/js/qmux/src/credit.test.ts @@ -67,3 +67,26 @@ describe("Credit.close reason propagation", () => { expect(await settle(credit.claim(1n))).toBe(first); }); }); + +describe("Credit.increaseMax ignores stale limits", () => { + test("a lower or equal limit neither reduces credit nor wakes a waiter", async () => { + const credit = new Credit(2n); + expect(credit.tryClaim(2n)).toBe(2n); + + let woke = false; + const pending = credit.claim(1n).then((v) => { + woke = true; + return v; + }); + + credit.increaseMax(1n); + credit.increaseMax(2n); + await Promise.resolve(); + expect(credit.max).toBe(2n); + expect(woke).toBe(false); + + credit.increaseMax(3n); + expect(await pending).toBe(1n); + expect(credit.max).toBe(3n); + }); +}); diff --git a/js/qmux/src/credit.ts b/js/qmux/src/credit.ts index 71df9531..50527b09 100644 --- a/js/qmux/src/credit.ts +++ b/js/qmux/src/credit.ts @@ -67,13 +67,12 @@ export class Credit { this.#wake(); } - /** Increase the max. Returns false if new_max < current max. */ - increaseMax(newMax: bigint): boolean { - if (newMax < this.#max) return false; - if (newMax === this.#max) return true; + /** Raise the max to `newMax`. A non-increasing value is stale and ignored, + * as RFC 9000 §19.9–§19.11 require for MAX_DATA, MAX_STREAM_DATA and MAX_STREAMS. */ + increaseMax(newMax: bigint): void { + if (newMax <= this.#max) return; this.#max = newMax; this.#wake(); - return true; } /** Close the credit, rejecting all pending and future `claim()` calls. diff --git a/js/qmux/src/frame.test.ts b/js/qmux/src/frame.test.ts index e1a711e4..d7c5260f 100644 --- a/js/qmux/src/frame.test.ts +++ b/js/qmux/src/frame.test.ts @@ -166,6 +166,21 @@ describe("QMux01 record framing", () => { }); }); +describe("MAX_STREAMS bounds", () => { + for (const type of ["max_streams_bidi", "max_streams_uni"] as const) { + test(`${type} accepts 2^60 and rejects anything larger`, () => { + const limit = 1n << 60n; + const ok = Frame.encode({ type, max: limit }, "qmux-01"); + expect(Frame.decodeRecord(ok)).toEqual([{ type, max: limit }]); + expect(Frame.decode(ok, "qmux-00")).toEqual({ type, max: limit }); + + const over = Frame.encode({ type, max: limit + 1n }, "qmux-01"); + expect(() => Frame.decodeRecord(over)).toThrow("MAX_STREAMS exceeds 2^60"); + expect(() => Frame.decode(over, "qmux-00")).toThrow("MAX_STREAMS exceeds 2^60"); + }); + } +}); + describe("QMux02 (draft-02)", () => { test("qmux-02 shares the qmux-01 record wire format", () => { const id = new Stream.Id(VarInt.from(4n)); diff --git a/js/qmux/src/frame.ts b/js/qmux/src/frame.ts index 798b3b8a..36c07fc4 100644 --- a/js/qmux/src/frame.ts +++ b/js/qmux/src/frame.ts @@ -287,6 +287,17 @@ const QX_PING_RESPONSE = 0x348c67529ef8c7ben; // RESET_STREAM_AT (draft-ietf-quic-reliable-stream-reset), permitted by QMux // draft-02. Decode-only: accepted, validated, and treated as a plain reset. const RESET_STREAM_AT = 0x24n; +// RFC 9000 §19.11: a stream count above 2^60 can't be encoded as a stream ID. +const MAX_STREAM_COUNT = 1n << 60n; + +/** Validate a decoded MAX_STREAMS count; one above 2^60 is a FRAME_ENCODING_ERROR. */ +function maxStreams(max: bigint): bigint { + if (max > MAX_STREAM_COUNT) { + throw new Error("MAX_STREAMS exceeds 2^60"); + } + return max; +} + // max_record_size transport parameter ID const MAX_RECORD_SIZE_ID = 0x0571c59429cd0845n; // application_protocols transport parameter ID (QMux-specific, non-TLS ALPN). @@ -897,13 +908,13 @@ function decodeQMux(buffer: Uint8Array): Any | null { // MAX_STREAMS (bidi) if (frameType === 0x12n) { [v, buffer] = VarInt.decode(buffer); - return { type: "max_streams_bidi", max: v.value }; + return { type: "max_streams_bidi", max: maxStreams(v.value) }; } // MAX_STREAMS (uni) if (frameType === 0x13n) { [v, buffer] = VarInt.decode(buffer); - return { type: "max_streams_uni", max: v.value }; + return { type: "max_streams_uni", max: maxStreams(v.value) }; } // DATA_BLOCKED @@ -1087,13 +1098,13 @@ function decodeQMuxOne(buffer: Uint8Array): [Any | null, Uint8Array] | null { // MAX_STREAMS (bidi) if (frameType === 0x12n) { [v, buffer] = VarInt.decode(buffer); - return [{ type: "max_streams_bidi", max: v.value }, buffer]; + return [{ type: "max_streams_bidi", max: maxStreams(v.value) }, buffer]; } // MAX_STREAMS (uni) if (frameType === 0x13n) { [v, buffer] = VarInt.decode(buffer); - return [{ type: "max_streams_uni", max: v.value }, buffer]; + return [{ type: "max_streams_uni", max: maxStreams(v.value) }, buffer]; } // DATA_BLOCKED diff --git a/js/qmux/src/session.test.ts b/js/qmux/src/session.test.ts index 7726f41f..f8211a82 100644 --- a/js/qmux/src/session.test.ts +++ b/js/qmux/src/session.test.ts @@ -494,6 +494,65 @@ describe("Session integration (scripted peer)", () => { session.close(); }); + test("stale MAX_STREAMS, MAX_DATA and MAX_STREAM_DATA limits are ignored", async () => { + const { session, peer } = connect(); + await session.ready; + peer.send({ + type: "transport_parameters", + params: peerParams({ initialMaxStreamsUni: 1n, initialMaxData: 4n, initialMaxStreamDataUni: 4n }), + }); + + const first = (await session.createUnidirectionalStream()).getWriter(); + const id = Stream.Id.create(0n, Stream.Dir.Uni, false); + + // Each larger limit is followed by a lower and an equal one, as reordered + // updates from a peer would arrive. None may close the session or shrink credit. + peer.send({ type: "max_streams_uni", max: 3n }); + peer.send({ type: "max_streams_uni", max: 2n }); + peer.send({ type: "max_streams_uni", max: 3n }); + peer.send({ type: "max_data", max: 8n }); + peer.send({ type: "max_data", max: 6n }); + peer.send({ type: "max_stream_data", id, max: 8n }); + peer.send({ type: "max_stream_data", id, max: 6n }); + peer.send({ type: "ping_request", sequence: 1n }); + await waitFor(() => peer.has("ping_response")); + + await session.createUnidirectionalStream(); + await session.createUnidirectionalStream(); + await first.write(new Uint8Array(8)); + await waitFor(() => peer.count("stream") >= 1); + const sent = peer + .received() + .filter((f): f is Frame.Data => f.type === "stream" && f.id.value.value === id.value.value) + .reduce((n, f) => n + f.data.byteLength, 0); + expect(sent).toBe(8); + expect(peer.has("connection_close")).toBe(false); + session.close(); + }); + + test("MAX_STREAMS above 2^60 is a connection error", async () => { + const { session, peer } = connect(); + await session.ready; + peer.send({ type: "transport_parameters", params: peerParams() }); + + peer.send({ type: "max_streams_bidi", max: (1n << 60n) + 1n }); + + await expectSessionFailure(session); + await waitFor(() => sentCloseCode(peer) === 1002); + }); + + test("MAX_STREAM_DATA on a receive-only stream is a connection error", async () => { + const { session, peer } = connect(); + await session.ready; + peer.send({ type: "transport_parameters", params: peerParams() }); + + // A server-initiated uni stream is receive-only for this client. + peer.send({ type: "max_stream_data", id: Stream.Id.create(0n, Stream.Dir.Uni, true), max: 10n }); + + await expectSessionFailure(session); + await waitFor(() => sentCloseCode(peer) === 1002); + }); + test("draft-01 tolerates the legacy zero final_size after data", async () => { const { session, peer } = connect(); await session.ready; diff --git a/js/qmux/src/session.ts b/js/qmux/src/session.ts index 44fe9a72..0a0bc641 100644 --- a/js/qmux/src/session.ts +++ b/js/qmux/src/session.ts @@ -908,6 +908,11 @@ export default class Session implements WebTransport { } else if (frame.type === "max_data") { this.#connCredit.increaseMax(frame.max); } else if (frame.type === "max_stream_data") { + // RFC 9000 §19.10: MAX_STREAM_DATA for a receive-only stream is a + // STREAM_STATE_ERROR. + if (!frame.id.canSend(this.#isServer)) { + throw new Error("MAX_STREAM_DATA on a receive-only stream"); + } const flow = this.#streamFlow.get(frame.id.value.value); if (flow) flow.sendCredit.increaseMax(frame.max); } else if (frame.type === "max_streams_bidi") { diff --git a/quest/a0/README.md b/quest/a0/README.md index 91d3795c..43262472 100644 --- a/quest/a0/README.md +++ b/quest/a0/README.md @@ -12,7 +12,6 @@ The Required list is ordered by priority. Independent children may proceed concu - [Bound decoded CONNECT headers](/quest/a0/qpack-field-section.md) - a CONNECT can make its receiver hold at most a 16 KiB field section, released as web-transport-proto 0.6.3 - [Quinn final Session drop](/quest/a0/quinn-session-drop.md) - close the connection and release the capsule reader -- [QMux credit updates](/quest/a0/qmux-credit-updates.md) - serialize advertisements and ignore stale peer limits - [Quiche lifecycle](/quest/a0/quiche/README.md) - deterministic harness and retirement handling - [QMux socket teardown](/quest/a0/qmux-socket-teardown.md) - release retained stats descriptors - [WebSocket handshake timeout](/quest/a0/qmux-ws-handshake-timeout.md) - close sessions whose peer never sends parameters diff --git a/quest/a0/qmux-credit-updates.md b/quest/a0/qmux-credit-updates.md deleted file mode 100644 index faad8461..00000000 --- a/quest/a0/qmux-credit-updates.md +++ /dev/null @@ -1,25 +0,0 @@ -# [M] Serialize QMux credit updates and accept stale limits - -## Goal - -Concurrent receive consumption and stream retirement cannot close a QMux session through reordered credit updates. Valid non-increasing peer limits are ignored while actual flow-control and encoding violations remain errors. - -## Plan - -Reproduce #439 deterministically: `Credit::consume` assigns an absolute maximum under its mutex, but callers enqueue the corresponding frame after releasing the lock, allowing concurrent MAX_DATA or MAX_STREAMS updates to reverse. Serialize calculation and nonblocking control-channel enqueueing under the existing credit lock at every consuming call site, including reset accounting and stream retirement. Prefer this bounded local change over moving coalescing state into the writer; wake waiters after releasing the lock and review channel/lock ordering for reentrancy and deadlocks. - -Ignore non-increasing received MAX_DATA, MAX_STREAM_DATA and both MAX_STREAMS limits without reducing effective credit or spuriously waking blocked operations. This follows [RFC 9000 section 4.1](https://www.rfc-editor.org/rfc/rfc9000.html#section-4.1) and [section 19.11](https://www.rfc-editor.org/rfc/rfc9000.html#section-19.11), whose frame semantics [QMux draft-02 section 4](https://www.ietf.org/archive/id/draft-ietf-quic-qmux-02.html#section-4) preserves. Keep initial transport-parameter validation separate where needed. Preserve existing validation and apply protocol-required frame bounds and stream-state checks before ignoring stale values; genuine flow-control violations must remain errors. Audit every supported Rust QMux version and the TypeScript peer for corresponding behavior; fix affected equivalents within this credit-update scope. - -Add controlled-interleaving regressions for concurrent stream-count and connection-data replenishment, plus lower/equal/higher received limits and preserved rejection of malformed input. Establish that regressions fail without the fix. Exercise uni/bidi and supported QMux negotiation modes, with transport integration coverage showing sustained progress. Measure the enqueue-under-lock change across independent session and stream/task counts; record contention/throughput results. Run focused Rust/TypeScript checks as applicable and the repository gates. - -Coordinate overlapping receive-credit changes with PR #412. The retained-Session receive hang reported in #439's comment belongs to PR #437; verify its coverage and track its status when resolving the issue, without duplicating that fix or making credit work depend on it unnecessarily. The existing socket-stats teardown quest owns descriptor retention. - -Keep public APIs and wire encodings unchanged; accepted peer input changes to match the protocol. Update affected docs/examples inline, with no separate guide. Work on main only: no QMux 0.5 backport, version bump or publication. Prioritize after the session-ownership quests. - -## Closes - -- [#439](https://github.com/moq-dev/web-transport/issues/439) - fix credit-ordering failures and account for the separately owned receive-hang report - -## Related - -- [QMux socket teardown](/quest/a0/qmux-socket-teardown.md) - descriptor retention is a separate resource-lifetime problem diff --git a/rs/qmux/Cargo.toml b/rs/qmux/Cargo.toml index ab3fd554..7701f8e8 100644 --- a/rs/qmux/Cargo.toml +++ b/rs/qmux/Cargo.toml @@ -49,6 +49,11 @@ url = "2" web-transport-proto = { workspace = true } web-transport-trait = { workspace = true } +[[bench]] +name = "credit" +harness = false +required-features = ["tcp"] + [[example]] name = "h3qx" required-features = ["tcp"] diff --git a/rs/qmux/benches/credit.rs b/rs/qmux/benches/credit.rs new file mode 100644 index 00000000..aaf9aba8 --- /dev/null +++ b/rs/qmux/benches/credit.rs @@ -0,0 +1,94 @@ +//! Stream and data turnover with small receive windows, so every round trip +//! replenishes MAX_STREAMS or MAX_DATA. Scales independent sessions and the +//! concurrent tasks sharing each session's credit. Run with +//! `cargo bench -p qmux --bench credit`. +use std::time::Instant; + +use qmux::{transport::Stream, Config, Session, Version}; +use web_transport_trait::{RecvStream as _, SendStream as _, Session as _}; + +const ROUNDS: usize = 4096; +const MESSAGE: usize = 256; + +fn config() -> Config { + let mut config = Config::new(Version::QMux02); + config.max_streams_bidi = 16; + config.max_data = 16 * 1024; + config +} + +async fn pair() -> (Session, Session) { + let (a, b) = tokio::io::duplex(256 * 1024); + let cfg = config(); + let server = tokio::spawn({ + let cfg = cfg.clone(); + Session::accept(Stream::new(b, cfg.version, cfg.max_record_size), cfg) + }); + let client = Session::connect(Stream::new(a, cfg.version, cfg.max_record_size), cfg) + .await + .unwrap(); + (client, server.await.unwrap().unwrap()) +} + +fn serve(server: Session) { + tokio::spawn(async move { + while let Ok((mut send, mut recv)) = server.accept_bi().await { + tokio::spawn(async move { + let data = recv.read_all().await?; + send.write_all(&data).await?; + send.finish() + }); + } + }); +} + +/// Run `ROUNDS` echo round trips per session, split across `tasks` tasks. +async fn run(sessions: usize, tasks: usize) -> f64 { + let mut pairs = Vec::new(); + for _ in 0..sessions { + let (client, server) = pair().await; + serve(server.clone()); + pairs.push((client, server)); + } + + let start = Instant::now(); + let mut handles = Vec::new(); + for (client, _) in &pairs { + for _ in 0..tasks { + let client = client.clone(); + handles.push(tokio::spawn(async move { + let message = vec![7u8; MESSAGE]; + for _ in 0..ROUNDS / tasks { + let (mut send, mut recv) = client.open_bi().await.unwrap(); + send.write_all(&message).await.unwrap(); + send.finish().unwrap(); + assert_eq!(recv.read_all().await.unwrap().len(), MESSAGE); + } + })); + } + } + for handle in handles { + handle.await.unwrap(); + } + let elapsed = start.elapsed(); + + for (client, server) in pairs { + client.close(0, "done"); + server.close(0, "done"); + } + (sessions * ROUNDS) as f64 / elapsed.as_secs_f64() +} + +fn main() { + let runtime = tokio::runtime::Builder::new_multi_thread() + .enable_all() + .build() + .unwrap(); + println!("sessions,tasks_per_session,streams_per_sec"); + for sessions in [1usize, 4, 16] { + for tasks in [1usize, 16, 64] { + let rate = runtime.block_on(run(sessions, tasks)); + println!("{sessions},{tasks},{rate:.0}"); + } + } +} diff --git a/rs/qmux/src/credit.rs b/rs/qmux/src/credit.rs index ef1a7430..6f8c80c3 100644 --- a/rs/qmux/src/credit.rs +++ b/rs/qmux/src/credit.rs @@ -4,7 +4,9 @@ use std::{ task::{Context, Poll, Waker}, }; -use crate::Error; +use tokio::sync::mpsc; + +use crate::{Error, Frame}; #[derive(Debug, Clone, Copy)] struct CreditState { @@ -20,7 +22,7 @@ struct CreditState { /// /// Works for both send and recv flow control: /// - **Send**: `try_claim`/`claim` to reserve credit, `release` for rollback, `increase_max` on peer's MAX_DATA. -/// - **Recv**: `receive` to validate incoming data, `consume` to track app consumption and trigger window updates. +/// - **Recv**: `receive` to validate incoming data, `consume` to track app consumption and queue window updates. /// /// Clone is cheap (internally `Arc`'d). /// @@ -176,23 +178,18 @@ impl Credit { wake_all(wakers); } - /// Increase the max. Returns error if new_max < current max. - pub fn increase_max(&self, new_max: u64) -> Result<(), Error> { - let (ok, wakers) = self.inner.lock().unwrap().update(|state| { - if new_max < state.max { - return (false, false); + /// Raise the max to `new_max`. A non-increasing value is ignored, as RFC 9000 + /// §19.9–§19.11 require for MAX_DATA, MAX_STREAM_DATA and MAX_STREAMS: an + /// update can arrive after a larger one, so it is stale rather than invalid. + pub fn increase_max(&self, new_max: u64) { + let ((), wakers) = self.inner.lock().unwrap().update(|state| { + let changed = new_max > state.max; + if changed { + state.max = new_max; } - let changed = new_max != state.max; - state.max = new_max; - (true, changed) + ((), changed) }); wake_all(wakers); - - if ok { - Ok(()) - } else { - Err(Error::FlowControlError) - } } // --- Recv-side methods --- @@ -218,10 +215,21 @@ impl Credit { true } - /// Report that `len` bytes have been consumed by the application. - /// Returns `Some(new_max)` if a window update should be sent. - pub fn consume(&self, len: u64) -> Option { - let (update, wakers) = self.inner.lock().unwrap().update(|state| { + /// Report that `len` units have been consumed by the application, queueing + /// `frame(new_max)` on `control` when a window update is due. + /// + /// The update is queued before the lock is released, so concurrent consumers + /// of one credit queue their limits in increasing order. Computing it under the + /// lock and sending afterwards would let a smaller limit overtake a larger one. + /// The unbounded send never blocks or reenters this credit. + pub(crate) fn consume( + &self, + len: u64, + control: &mpsc::UnboundedSender, + frame: impl FnOnce(u64) -> Frame, + ) { + let mut inner = self.inner.lock().unwrap(); + let ((), wakers) = inner.update(|state| { state.released += len; // Send a window update when: used + 2*released > max @@ -230,12 +238,127 @@ impl Credit { let new_max = state.max + state.released; state.max = new_max; state.released = 0; - (Some(new_max), true) + control.send(frame(new_max)).ok(); + ((), true) } else { - (None, false) + ((), false) } }); + drop(inner); wake_all(wakers); - update + } +} + +#[cfg(test)] +mod tests { + use std::{ + sync::{ + atomic::{AtomicUsize, Ordering}, + mpsc as std_mpsc, Arc, TryLockError, + }, + task::{Context, Poll, Wake, Waker}, + thread, + }; + + use tokio::sync::mpsc; + + use super::Credit; + use crate::Frame; + + #[derive(Default)] + struct CountingWaker(AtomicUsize); + + impl Wake for CountingWaker { + fn wake(self: Arc) { + self.0.fetch_add(1, Ordering::SeqCst); + } + } + + fn drain(rx: &mut mpsc::UnboundedReceiver) -> Vec { + let mut out = Vec::new(); + while let Ok(frame) = rx.try_recv() { + match frame { + Frame::MaxData(max) => out.push(max), + other => panic!("unexpected frame {other:?}"), + } + } + out + } + + /// Two consumers race to replenish one credit. The first is paused while it + /// queues its update, which must happen under the credit lock: otherwise the + /// second could compute and queue a larger limit ahead of it. + #[test] + fn concurrent_updates_are_queued_in_increasing_order() { + let credit = Credit::new(4); + assert!(credit.receive(4)); + let (control, mut rx) = mpsc::unbounded_channel(); + + let (inside_tx, inside_rx) = std_mpsc::channel(); + let (release_tx, release_rx) = std_mpsc::channel::<()>(); + let first = thread::spawn({ + let credit = credit.clone(); + let control = control.clone(); + move || { + credit.consume(2, &control, |max| { + inside_tx.send(()).unwrap(); + release_rx.recv().unwrap(); + Frame::MaxData(max) + }); + } + }); + inside_rx.recv().unwrap(); + + // The first update is computed but not yet queued. Holding the lock here + // is what keeps any other consumer from computing a later limit first. + assert!( + matches!(credit.inner.try_lock(), Err(TryLockError::WouldBlock)), + "the update is queued after the credit lock is released" + ); + + let second = thread::spawn({ + let credit = credit.clone(); + let control = control.clone(); + move || credit.consume(2, &control, Frame::MaxData) + }); + release_tx.send(()).unwrap(); + first.join().unwrap(); + second.join().unwrap(); + + assert_eq!(drain(&mut rx), [6, 8]); + } + + /// A consumer that doesn't cross the replenish threshold queues nothing. + #[test] + fn consume_below_threshold_queues_nothing() { + let credit = Credit::new(10); + assert!(credit.receive(2)); + let (control, mut rx) = mpsc::unbounded_channel(); + credit.consume(2, &control, Frame::MaxData); + assert!(drain(&mut rx).is_empty()); + credit.consume(4, &control, Frame::MaxData); + assert_eq!(drain(&mut rx), [16]); + } + + /// A lower or equal limit keeps the current credit and leaves waiters parked; + /// a higher one releases them. + #[test] + fn non_increasing_limits_are_ignored_without_waking() { + let credit = Credit::new(2); + assert_eq!(credit.try_claim(2), 2); + + let counter = Arc::new(CountingWaker::default()); + let waker = Waker::from(counter.clone()); + let mut cx = Context::from_waker(&waker); + assert!(credit.poll_claim(&mut cx, 1).is_pending()); + + credit.increase_max(1); + credit.increase_max(2); + assert_eq!(counter.0.load(Ordering::SeqCst), 0); + assert_eq!(credit.try_claim(1), 0); + + credit.increase_max(3); + assert_eq!(counter.0.load(Ordering::SeqCst), 1); + assert!(matches!(credit.poll_claim(&mut cx, 1), Poll::Ready(Ok(1)))); } } diff --git a/rs/qmux/src/proto/frame.rs b/rs/qmux/src/proto/frame.rs index 4480d29b..7e19d201 100644 --- a/rs/qmux/src/proto/frame.rs +++ b/rs/qmux/src/proto/frame.rs @@ -22,6 +22,8 @@ const STREAMS_BLOCKED_BIDI: VarInt = VarInt::from_u32(0x16); const STREAMS_BLOCKED_UNI: VarInt = VarInt::from_u32(0x17); const APPLICATION_CLOSE: VarInt = VarInt::from_u32(0x1d); const CONNECTION_CLOSE: VarInt = VarInt::from_u32(0x1c); +// RFC 9000 §19.11: a stream count above 2^60 can't be encoded as a stream ID. +const MAX_STREAM_COUNT: u64 = 1 << 60; // DATAGRAM frames (RFC 9221). 0x30 has no length (the payload runs to the end of // the record); 0x31 prefixes a length varint. Datagrams are only ever sent on // QMux01, where each rides its own record, so the record boundary would already @@ -202,6 +204,16 @@ pub enum Frame { Datagram(Datagram), } +/// Decode a MAX_STREAMS count, rejecting one above [`MAX_STREAM_COUNT`] as a +/// FRAME_ENCODING_ERROR. +fn decode_max_streams(data: &mut B) -> Result { + let max = VarInt::decode(data)?.into_inner(); + if max > MAX_STREAM_COUNT { + return Err(Error::FrameEncoding); + } + Ok(max) +} + impl Frame { /// Encode the frame into bytes using the given wire format version. /// @@ -372,12 +384,12 @@ impl Frame { } // MAX_STREAMS (bidi) 0x12 => { - let max = VarInt::decode(data)?.into_inner(); + let max = decode_max_streams(data)?; Ok(Some(Frame::MaxStreamsBidi(max))) } // MAX_STREAMS (uni) 0x13 => { - let max = VarInt::decode(data)?.into_inner(); + let max = decode_max_streams(data)?; Ok(Some(Frame::MaxStreamsUni(max))) } // DATA_BLOCKED @@ -769,12 +781,12 @@ impl Frame { } // MAX_STREAMS (bidi) 0x12 => { - let max = VarInt::decode(&mut data)?.into_inner(); + let max = decode_max_streams(&mut data)?; Ok(Some(Frame::MaxStreamsBidi(max))) } // MAX_STREAMS (uni) 0x13 => { - let max = VarInt::decode(&mut data)?.into_inner(); + let max = decode_max_streams(&mut data)?; Ok(Some(Frame::MaxStreamsUni(max))) } // DATA_BLOCKED diff --git a/rs/qmux/src/proto/wire_format_tests.rs b/rs/qmux/src/proto/wire_format_tests.rs index fd7d108a..55b0544e 100644 --- a/rs/qmux/src/proto/wire_format_tests.rs +++ b/rs/qmux/src/proto/wire_format_tests.rs @@ -559,6 +559,28 @@ fn qmux00_max_streams_uni() { assert_round_trip(Version::QMux00, &bytes, &frame); } +#[test] +fn max_streams_above_2_60_rejected() { + // 2^60 is an 8-byte varint: 0xd0 followed by seven zero bytes. One more is a + // FRAME_ENCODING_ERROR (RFC 9000 §19.11), in bare frames and in records. + for (frame_type, frame) in [ + (0x12, Frame::MaxStreamsBidi(1 << 60)), + (0x13, Frame::MaxStreamsUni(1 << 60)), + ] { + let limit = [frame_type, 0xd0, 0, 0, 0, 0, 0, 0, 0]; + assert_round_trip(Version::QMux00, &limit, &frame); + let decoded = Frame::decode_record(Bytes::copy_from_slice(&limit)).unwrap(); + assert_eq!(decoded.len(), 1); + assert_frames_eq(&decoded[0], &frame, Version::QMux01); + + let over = [frame_type, 0xd0, 0, 0, 0, 0, 0, 0, 1]; + let err = Frame::decode(Bytes::copy_from_slice(&over), Version::QMux00).unwrap_err(); + assert!(matches!(err, Error::FrameEncoding), "got {err:?}"); + let err = Frame::decode_record(Bytes::copy_from_slice(&over)).unwrap_err(); + assert!(matches!(err, Error::FrameEncoding), "got {err:?}"); + } +} + #[test] fn qmux00_data_blocked() { // 0x14 + limit(=1024). diff --git a/rs/qmux/src/session.rs b/rs/qmux/src/session.rs index 6b34abf5..7b9827a9 100644 --- a/rs/qmux/src/session.rs +++ b/rs/qmux/src/session.rs @@ -148,7 +148,7 @@ impl Streams { StreamDir::Uni => self.peer_initial_max_stream_data_uni, StreamDir::Bi => self.peer_initial_max_stream_data_bidi_remote, }; - credit.increase_max(max).ok(); + credit.increase_max(max); } self.insert_send(id, send); if let Some(recv) = recv { @@ -480,6 +480,14 @@ fn note_closed(closed: &watch::Sender>, err: Error) { }); } +/// The MAX_STREAMS frame constructor for streams in `dir`. +fn max_streams_frame(dir: StreamDir) -> fn(u64) -> Frame { + match dir { + StreamDir::Bi => Frame::MaxStreamsBidi, + StreamDir::Uni => Frame::MaxStreamsUni, + } +} + /// Writer-side task state: owns the transport send half and is the sole producer /// on the wire. It pulls the outbound queues in strict priority order via /// [`next_outbound`], retires the stream a terminal frame closes and encodes it @@ -1773,9 +1781,8 @@ impl SessionState { // The gap consumes connection flow control, but no bytes in it can // ever occupy receive memory. Make it immediately eligible to // replenish the connection window. - if let Some(new_max) = self.conn_recv_credit.consume(gap) { - self.control.send(Frame::MaxData(new_max)).ok(); - } + self.conn_recv_credit + .consume(gap, &self.control, Frame::MaxData); match live { // Deliver the reset. The id was recorded in `recv_open` at @@ -1796,13 +1803,7 @@ impl SessionState { StreamDir::Bi => &self.recv_bi_credit, StreamDir::Uni => &self.recv_uni_credit, }; - if let Some(new_max) = credit.consume(1) { - let frame = match reset_id.dir() { - StreamDir::Bi => Frame::MaxStreamsBidi(new_max), - StreamDir::Uni => Frame::MaxStreamsUni(new_max), - }; - self.control.send(frame).ok(); - } + credit.consume(1, &self.control, max_streams_frame(reset_id.dir())); } } } @@ -1837,22 +1838,28 @@ impl SessionState { }, ); } - // Flow control frames + // Flow control frames. A limit that doesn't increase is stale and is + // ignored (RFC 9000 §19.9–§19.11); `increase_max` handles that. Frame::MaxData(max) => { - self.conn_send_credit.increase_max(max)?; + self.conn_send_credit.increase_max(max); } Frame::MaxStreamData { id, max } => { + // RFC 9000 §19.10: MAX_STREAM_DATA for a receive-only stream is a + // STREAM_STATE_ERROR. + if !id.can_send(self.is_server) { + return Err(Error::InvalidStreamId); + } if let Some(send) = self.streams.lock().unwrap().send.get(&id) { if let Some(credit) = &send.stream_credit { - credit.increase_max(max)?; + credit.increase_max(max); } } } Frame::MaxStreamsBidi(max) => { - self.open_bi_credit.increase_max(max)?; + self.open_bi_credit.increase_max(max); } Frame::MaxStreamsUni(max) => { - self.open_uni_credit.increase_max(max)?; + self.open_uni_credit.increase_max(max); } // Informational frames — peer is telling us they're blocked. // We don't need to act on these since we auto-tune windows. @@ -1949,17 +1956,13 @@ impl SessionState { } // Set connection-level send credit from peer's initial_max_data - self.conn_send_credit - .increase_max(params.initial_max_data) - .ok(); + self.conn_send_credit.increase_max(params.initial_max_data); // Set stream count limits from peer's params self.open_bi_credit - .increase_max(params.initial_max_streams_bidi) - .ok(); + .increase_max(params.initial_max_streams_bidi); self.open_uni_credit - .increase_max(params.initial_max_streams_uni) - .ok(); + .increase_max(params.initial_max_streams_uni); // Publish the peer's initial per-stream send limits and credit the streams // we've already opened — both under one lock, so a stream being opened @@ -1985,7 +1988,7 @@ impl SessionState { } StreamDir::Uni => params.initial_max_stream_data_uni, }; - credit.increase_max(initial).ok(); + credit.increase_max(initial); } } } @@ -3032,20 +3035,14 @@ impl RecvStream { return; } - // Per-stream window update - if let Some(new_max) = self.recv_credit.consume(len) { - let frame = Frame::MaxStreamData { - id: self.id, - max: new_max, - }; - self.outbound_priority.send(frame).ok(); - } - - // Connection-level window update - if let Some(new_max) = self.conn_recv_credit.consume(len) { - let frame = Frame::MaxData(new_max); - self.outbound_priority.send(frame).ok(); - } + let id = self.id; + self.recv_credit + .consume(len, &self.outbound_priority, |max| Frame::MaxStreamData { + id, + max, + }); + self.conn_recv_credit + .consume(len, &self.outbound_priority, Frame::MaxData); } } @@ -3057,13 +3054,7 @@ impl Drop for RecvStream { // Replenish stream count when this recv half is done if let Some(credit) = &self.recv_streams_credit { - if let Some(new_max) = credit.consume(1) { - let frame = match self.id.dir() { - StreamDir::Bi => Frame::MaxStreamsBidi(new_max), - StreamDir::Uni => Frame::MaxStreamsUni(new_max), - }; - self.outbound_priority.send(frame).ok(); - } + credit.consume(1, &self.outbound_priority, max_streams_frame(self.id.dir())); } } } @@ -5259,3 +5250,217 @@ mod ping_backpressure_tests { } } } + +#[cfg(test)] +mod credit_update_tests { + use std::sync::{Arc, Mutex}; + use std::time::Duration; + + use bytes::Bytes; + use tokio::sync::mpsc; + use web_transport_trait::{SendStream as _, Session as _}; + + use super::{Reader, Session, Transport, Writer}; + use crate::proto::{Frame, TransportParams}; + use crate::{Config, Error, StreamDir, StreamId, Version}; + + const VERSIONS: [Version; 3] = [Version::QMux00, Version::QMux01, Version::QMux02]; + + /// A transport whose inbound frames are scripted and whose outbound records + /// are kept for inspection. + struct ScriptedTransport { + incoming: mpsc::UnboundedReceiver, + outgoing: Arc>>, + } + + struct ScriptedWriter { + outgoing: Arc>>, + } + + struct ScriptedReader { + incoming: mpsc::UnboundedReceiver, + } + + impl Transport for ScriptedTransport { + type Writer = ScriptedWriter; + type Reader = ScriptedReader; + + fn split(self) -> (ScriptedWriter, ScriptedReader) { + ( + ScriptedWriter { + outgoing: self.outgoing, + }, + ScriptedReader { + incoming: self.incoming, + }, + ) + } + } + + impl Writer for ScriptedWriter { + async fn send(&mut self, data: Bytes) -> Result<(), Error> { + self.outgoing.lock().unwrap().push(data); + Ok(()) + } + + async fn close(&mut self) -> Result<(), Error> { + Ok(()) + } + } + + impl Reader for ScriptedReader { + async fn recv(&mut self) -> Result { + match self.incoming.recv().await { + Some(bytes) => Ok(bytes), + None => std::future::pending().await, + } + } + } + + struct Peer { + version: Version, + inbound: mpsc::UnboundedSender, + outbound: Arc>>, + } + + impl Peer { + fn send(&self, frame: Frame) { + self.inbound + .send(frame.encode(self.version).unwrap()) + .unwrap(); + } + + /// Payload bytes the session has written on stream `id`. + fn sent_on(&self, id: StreamId) -> usize { + self.outbound + .lock() + .unwrap() + .iter() + .flat_map(|record| match self.version { + Version::QMux00 => Frame::decode(record.clone(), self.version) + .unwrap() + .into_iter() + .collect(), + _ => Frame::decode_record(record.clone()).unwrap(), + }) + .map(|frame| match frame { + Frame::Stream(stream) if stream.id == id => stream.data.len(), + _ => 0, + }) + .sum() + } + } + + /// A client session opposite a scripted server that has announced `params`. + fn scripted_session(version: Version, params: TransportParams) -> (Session, Peer) { + let (tx, rx) = mpsc::unbounded_channel(); + let outbound = Arc::new(Mutex::new(Vec::new())); + let session = Session::new( + ScriptedTransport { + incoming: rx, + outgoing: outbound.clone(), + }, + false, + Config::new(version), + ); + let peer = Peer { + version, + inbound: tx, + outbound, + }; + peer.send(Frame::TransportParameters(params)); + (session, peer) + } + + fn small_params(version: Version) -> TransportParams { + let mut params = Config::new(version).to_transport_params(); + params.initial_max_streams_bidi = 1; + params.initial_max_streams_uni = 1; + params.initial_max_data = 4; + params.initial_max_stream_data_uni = 4; + params + } + + /// Lower and equal limits after a higher one arrive as a peer's reordered + /// updates would. They are ignored: the session stays open and keeps the + /// highest credit for stream counts, connection data and stream data. + #[tokio::test(start_paused = true)] + async fn stale_limits_are_ignored() { + for version in VERSIONS { + let (session, peer) = scripted_session(version, small_params(version)); + let mut send = session.open_uni().await.unwrap(); + let id = StreamId::new(0, StreamDir::Uni, false); + + for frame in [ + Frame::MaxStreamsUni(3), + Frame::MaxStreamsUni(2), + Frame::MaxStreamsUni(3), + Frame::MaxStreamsBidi(2), + Frame::MaxStreamsBidi(1), + Frame::MaxData(8), + Frame::MaxData(6), + Frame::MaxData(8), + Frame::MaxStreamData { id, max: 8 }, + Frame::MaxStreamData { id, max: 6 }, + ] { + peer.send(frame); + } + + // Paused time only advances once every task is idle, so this fires + // only if an open or write stalls on credit or the session closed. + tokio::time::timeout(Duration::from_secs(10), async { + session.open_uni().await.unwrap(); + session.open_uni().await.unwrap(); + session.open_bi().await.unwrap(); + session.open_bi().await.unwrap(); + let mut written = 0; + while written < 8 { + written += send.write(&[0; 8][written..]).await.unwrap(); + } + while peer.sent_on(id) < 8 { + tokio::task::yield_now().await; + } + }) + .await + .unwrap_or_else(|_| panic!("{version:?}: stale limit reduced credit")); + assert_eq!(peer.sent_on(id), 8, "{version:?}"); + + let closed = tokio::time::timeout(Duration::from_millis(1), session.closed()).await; + assert!(closed.is_err(), "{version:?}: session closed: {closed:?}"); + } + } + + async fn closed_with(frame: Frame) -> Vec { + let mut errors = Vec::new(); + for version in VERSIONS { + let (session, peer) = scripted_session(version, small_params(version)); + peer.send(frame.clone()); + let err = tokio::time::timeout(Duration::from_secs(10), session.closed()) + .await + .unwrap_or_else(|_| panic!("{version:?}: {frame:?} was accepted")); + errors.push(err); + } + errors + } + + #[tokio::test(start_paused = true)] + async fn max_streams_above_2_60_is_a_frame_encoding_error() { + for frame in [ + Frame::MaxStreamsBidi((1 << 60) + 1), + Frame::MaxStreamsUni((1 << 60) + 1), + ] { + for err in closed_with(frame).await { + assert!(matches!(err, Error::FrameEncoding), "got {err:?}"); + } + } + } + + #[tokio::test(start_paused = true)] + async fn max_stream_data_on_receive_only_stream_is_rejected() { + // A server-initiated uni stream is receive-only for this client. + let id = StreamId::new(0, StreamDir::Uni, true); + for err in closed_with(Frame::MaxStreamData { id, max: 10 }).await { + assert!(matches!(err, Error::InvalidStreamId), "got {err:?}"); + } + } +} diff --git a/rs/qmux/tests/credit_updates.rs b/rs/qmux/tests/credit_updates.rs new file mode 100644 index 00000000..1570c439 --- /dev/null +++ b/rs/qmux/tests/credit_updates.rs @@ -0,0 +1,123 @@ +//! Sustained stream and data turnover over TCP with small receive windows, so +//! concurrent consumers replenish MAX_STREAMS and MAX_DATA constantly. Reordered +//! credit updates used to close such sessions with a flow-control error. + +#![cfg(feature = "tcp")] + +use std::time::Duration; + +use qmux::{transport::Stream, Config, Session, Version}; +use tokio::net::{TcpListener, TcpStream}; +use web_transport_trait::{RecvStream as _, SendStream as _, Session as _}; + +const TASKS: usize = 32; +const ROUNDS: usize = 100; +const MESSAGE: usize = 256; + +fn config(version: Version) -> Config { + let mut config = Config::new(version); + config.max_streams_bidi = 8; + config.max_streams_uni = 8; + config.max_data = 4096; + config.max_stream_data_bidi_local = 1024; + config.max_stream_data_bidi_remote = 1024; + config.max_stream_data_uni = 1024; + config +} + +async fn pair(version: Version) -> (Session, Session) { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let addr = listener.local_addr().unwrap(); + let cfg = config(version); + + let server = tokio::spawn({ + let cfg = cfg.clone(); + async move { + let (sock, _) = listener.accept().await.unwrap(); + let transport = Stream::new(sock, cfg.version, cfg.max_record_size); + Session::accept(transport, cfg).await.unwrap() + } + }); + + let sock = TcpStream::connect(addr).await.unwrap(); + let transport = Stream::new(sock, cfg.version, cfg.max_record_size); + let client = Session::connect(transport, cfg).await.unwrap(); + (client, server.await.unwrap()) +} + +/// Echo every bidi stream and drain every uni stream until the session closes. +fn serve(server: Session) { + tokio::spawn({ + let server = server.clone(); + async move { + while let Ok((mut send, mut recv)) = server.accept_bi().await { + tokio::spawn(async move { + let data = recv.read_all().await?; + send.write_all(&data).await?; + send.finish() + }); + } + } + }); + tokio::spawn(async move { + while let Ok(mut recv) = server.accept_uni().await { + tokio::spawn(async move { recv.read_all().await }); + } + }); +} + +async fn churn(version: Version) { + let (client, server) = pair(version).await; + serve(server.clone()); + + let tasks: Vec<_> = (0..TASKS) + .map(|_| { + let client = client.clone(); + tokio::spawn(async move { + let message = vec![7u8; MESSAGE]; + for _ in 0..ROUNDS { + let (mut send, mut recv) = client.open_bi().await?; + send.write_all(&message).await?; + send.finish()?; + let echoed = recv.read_all().await?; + assert_eq!(echoed.len(), MESSAGE); + + let mut uni = client.open_uni().await?; + uni.write_all(&message).await?; + uni.finish()?; + } + Ok::<_, qmux::Error>(()) + }) + }) + .collect(); + + // Real networking on a multi-threaded runtime: the deadline only guards + // against a hang, since a credit-ordering failure closes the session. + tokio::time::timeout(Duration::from_secs(60), async { + for task in tasks { + task.await + .unwrap() + .unwrap_or_else(|err| panic!("{version:?}: {err}")); + } + }) + .await + .unwrap_or_else(|_| panic!("{version:?}: stream churn stalled")); + + client.close(0, "done"); + server.close(0, "done"); +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 4)] +async fn sustained_churn_qmux00() { + churn(Version::QMux00).await; +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 4)] +async fn sustained_churn_qmux01() { + churn(Version::QMux01).await; +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 4)] +async fn sustained_churn_qmux02() { + churn(Version::QMux02).await; +}