Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
23 changes: 23 additions & 0 deletions js/qmux/src/credit.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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);
});
});
9 changes: 4 additions & 5 deletions js/qmux/src/credit.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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.
Expand Down
15 changes: 15 additions & 0 deletions js/qmux/src/frame.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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));
Expand Down
19 changes: 15 additions & 4 deletions js/qmux/src/frame.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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).
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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
Expand Down
59 changes: 59 additions & 0 deletions js/qmux/src/session.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down
5 changes: 5 additions & 0 deletions js/qmux/src/session.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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") {
Expand Down
1 change: 0 additions & 1 deletion quest/a0/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -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
25 changes: 0 additions & 25 deletions quest/a0/qmux-credit-updates.md

This file was deleted.

5 changes: 5 additions & 0 deletions rs/qmux/Cargo.toml
Original file line number Diff line number Diff line change
Expand Up @@ -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"]
Expand Down
94 changes: 94 additions & 0 deletions rs/qmux/benches/credit.rs
Original file line number Diff line number Diff line change
@@ -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}");
}
}
}
Loading
Loading