rwebtransport 0.2.2 → 0.2.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (99) hide show
  1. package/Cargo.lock +523 -140
  2. package/Cargo.toml +5 -5
  3. package/README.md +8 -4
  4. package/crates/echo-server/src/bin/gen-test-cert.rs +1 -1
  5. package/crates/native/Cargo.toml +2 -0
  6. package/crates/native/src/config.rs +69 -8
  7. package/crates/native/src/driver.rs +253 -90
  8. package/crates/native/src/lib.rs +80 -57
  9. package/crates/native/src/parser_memory.rs +203 -0
  10. package/crates/native/src/server.rs +215 -183
  11. package/crates/native/src/session.rs +1341 -243
  12. package/crates/native/src/test_support.rs +119 -0
  13. package/crates/wtcore/Cargo.toml +1 -0
  14. package/crates/wtcore/src/h3.rs +250 -46
  15. package/dist/index.js +218 -75
  16. package/dist/index.js.map +7 -1
  17. package/dist/index.mjs +214 -69
  18. package/dist/index.mjs.map +7 -1
  19. package/dist/native.d.ts +10 -4
  20. package/dist/server.d.ts +1 -0
  21. package/package.json +84 -78
  22. package/prebuilds/darwin-arm64/rwebtransport.node +0 -0
  23. package/prebuilds/linux-arm64/rwebtransport.node +0 -0
  24. package/prebuilds/linux-x64/rwebtransport.node +0 -0
  25. package/prebuilds/win32-x64/rwebtransport.node +0 -0
  26. package/scripts/build-linux-prebuilt.sh +46 -0
  27. package/scripts/build-ts.js +41 -0
  28. package/scripts/build.js +10 -3
  29. package/vendor/quiche/AGENTS.md +10 -0
  30. package/vendor/quiche/Cargo.lock +239 -248
  31. package/vendor/quiche/Cargo.toml +23 -10
  32. package/vendor/quiche/examples/Makefile +4 -4
  33. package/vendor/quiche/examples/client.rs +10 -28
  34. package/vendor/quiche/examples/http3-client.rs +20 -34
  35. package/vendor/quiche/examples/http3-server.rs +47 -78
  36. package/vendor/quiche/examples/server.rs +19 -49
  37. package/vendor/quiche/include/quiche.h +35 -4
  38. package/vendor/quiche/src/build.rs +17 -0
  39. package/vendor/quiche/src/cid.rs +129 -61
  40. package/vendor/quiche/src/crypto/boringssl.rs +98 -86
  41. package/vendor/quiche/src/crypto/mod.rs +64 -77
  42. package/vendor/quiche/src/dgram.rs +2 -3
  43. package/vendor/quiche/src/error.rs +22 -20
  44. package/vendor/quiche/src/ffi.rs +558 -280
  45. package/vendor/quiche/src/flowcontrol.rs +0 -7
  46. package/vendor/quiche/src/frame.rs +134 -135
  47. package/vendor/quiche/src/h3/ffi.rs +73 -60
  48. package/vendor/quiche/src/h3/frame.rs +70 -90
  49. package/vendor/quiche/src/h3/mod.rs +1024 -593
  50. package/vendor/quiche/src/h3/qpack/decoder.rs +248 -34
  51. package/vendor/quiche/src/h3/qpack/dynamic_table.rs +859 -0
  52. package/vendor/quiche/src/h3/qpack/encoder.rs +14 -17
  53. package/vendor/quiche/src/h3/qpack/mod.rs +48 -0
  54. package/vendor/quiche/src/h3/qpack/static_table.rs +86 -73
  55. package/vendor/quiche/src/h3/stream.rs +1009 -194
  56. package/vendor/quiche/src/lib.rs +1361 -1195
  57. package/vendor/quiche/src/minmax.rs +2 -6
  58. package/vendor/quiche/src/packet.rs +420 -552
  59. package/vendor/quiche/src/path.rs +202 -72
  60. package/vendor/quiche/src/pmtud.rs +18 -16
  61. package/vendor/quiche/src/ranges.rs +184 -82
  62. package/vendor/quiche/src/recovery/AGENTS.md +5 -2
  63. package/vendor/quiche/src/recovery/bandwidth.rs +59 -40
  64. package/vendor/quiche/src/recovery/bytes_in_flight.rs +2 -2
  65. package/vendor/quiche/src/recovery/congestion/cubic.rs +38 -47
  66. package/vendor/quiche/src/recovery/congestion/delivery_rate.rs +54 -60
  67. package/vendor/quiche/src/recovery/congestion/hystart.rs +6 -10
  68. package/vendor/quiche/src/recovery/congestion/mod.rs +110 -42
  69. package/vendor/quiche/src/recovery/congestion/prr.rs +4 -1
  70. package/vendor/quiche/src/recovery/congestion/recovery.rs +91 -95
  71. package/vendor/quiche/src/recovery/congestion/reno.rs +17 -12
  72. package/vendor/quiche/src/recovery/congestion/test_sender.rs +8 -27
  73. package/vendor/quiche/src/recovery/gcongestion/bbr/bandwidth_sampler.rs +159 -247
  74. package/vendor/quiche/src/recovery/gcongestion/bbr/windowed_filter.rs +9 -14
  75. package/vendor/quiche/src/recovery/gcongestion/bbr2/drain.rs +18 -15
  76. package/vendor/quiche/src/recovery/gcongestion/bbr2/mode.rs +43 -28
  77. package/vendor/quiche/src/recovery/gcongestion/bbr2/network_model.rs +349 -76
  78. package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_bw.rs +147 -195
  79. package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_rtt.rs +29 -27
  80. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min.rs +180 -0
  81. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min_tests.rs +221 -0
  82. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm.rs +395 -0
  83. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm_tests.rs +473 -0
  84. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/mod.rs +175 -0
  85. package/vendor/quiche/src/recovery/gcongestion/bbr2/startup.rs +33 -26
  86. package/vendor/quiche/src/recovery/gcongestion/bbr2.rs +107 -60
  87. package/vendor/quiche/src/recovery/gcongestion/mod.rs +64 -11
  88. package/vendor/quiche/src/recovery/gcongestion/pacer.rs +34 -25
  89. package/vendor/quiche/src/recovery/gcongestion/recovery.rs +81 -86
  90. package/vendor/quiche/src/recovery/mod.rs +414 -173
  91. package/vendor/quiche/src/recovery/rtt.rs +8 -5
  92. package/vendor/quiche/src/stream/mod.rs +864 -133
  93. package/vendor/quiche/src/stream/recv_buf.rs +476 -172
  94. package/vendor/quiche/src/stream/send_buf.rs +343 -81
  95. package/vendor/quiche/src/test_utils.rs +78 -64
  96. package/vendor/quiche/src/tests.rs +2559 -1335
  97. package/vendor/quiche/src/tls/boringssl.rs +60 -63
  98. package/vendor/quiche/src/tls/mod.rs +146 -193
  99. package/vendor/quiche/src/transport_params.rs +87 -103
@@ -13,6 +13,9 @@
13
13
  //! * uni `14, 18, ...` are WebTransport unidirectional streams.
14
14
 
15
15
  use std::collections::{HashMap, VecDeque};
16
+ use std::sync::Arc;
17
+
18
+ use crate::parser_memory::{ParserBuffer, ParserMemory};
16
19
 
17
20
  use wtcore::h3;
18
21
 
@@ -43,6 +46,10 @@ const SERVER_FIRST_WT_UNI_ID: u64 = 15;
43
46
  /// hostile peer advertising a huge length).
44
47
  const MAX_CONTROL_FRAME: usize = 1 << 20;
45
48
 
49
+ /// Bound all parser allocations on a connection as well as the shared server
50
+ /// total, so opening many control streams cannot consume the entire budget.
51
+ const MAX_SESSION_PARSER_MEMORY: usize = 8 * 1024 * 1024;
52
+
46
53
  /// Per-session flow-control credit we grant the peer once established. Large,
47
54
  /// because QUIC's connection flow control is the real limit (one session per
48
55
  /// connection); this only keeps a strict peer from stalling on our advertised
@@ -50,6 +57,36 @@ const MAX_CONTROL_FRAME: usize = 1 << 20;
50
57
  const WT_GRANT_MAX_DATA: u64 = 1 << 34;
51
58
  const WT_GRANT_MAX_STREAMS: u64 = 1 << 20;
52
59
 
60
+ /// Receive work admitted to one native event batch, shared by all connections
61
+ /// on a listener. Count reads as well as bytes so tiny messages are bounded.
62
+ pub struct ReceiveBudget {
63
+ bytes: usize,
64
+ items: usize,
65
+ }
66
+
67
+ impl ReceiveBudget {
68
+ pub fn new() -> Self {
69
+ Self {
70
+ bytes: 256 * 1024,
71
+ items: 128,
72
+ }
73
+ }
74
+
75
+ pub fn exhausted(&self) -> bool {
76
+ self.bytes == 0 || self.items == 0
77
+ }
78
+
79
+ #[cfg(test)]
80
+ fn blocked() -> Self {
81
+ Self { bytes: 0, items: 0 }
82
+ }
83
+
84
+ fn record(&mut self, bytes: usize) {
85
+ self.bytes = self.bytes.saturating_sub(bytes);
86
+ self.items -= 1;
87
+ }
88
+ }
89
+
53
90
  /// Events the session emits for the driver to forward to JS.
54
91
  #[derive(Debug)]
55
92
  pub enum Ev {
@@ -88,6 +125,8 @@ pub enum Ev {
88
125
  Error(String),
89
126
  /// A WebTransport datagram was received.
90
127
  Datagram(Vec<u8>),
128
+ /// Updated maximum datagram payload for one server connection.
129
+ DatagramSize(usize),
91
130
  /// The peer opened a WebTransport stream.
92
131
  IncomingStream { id: u64, bidi: bool },
93
132
  /// Application data arrived on a WebTransport stream.
@@ -101,7 +140,7 @@ pub enum Ev {
101
140
  /// A locally requested stream open completed; `id` is the QUIC stream id.
102
141
  StreamOpened { request_id: u64, id: u64 },
103
142
  /// A write's bytes were fully handed to quiche (backpressure signal).
104
- WriteAck { request_id: u64 },
143
+ WriteAck { request_id: u64, accepted: bool },
105
144
  /// A datagram send request was processed (sent or intentionally dropped).
106
145
  DatagramAck { request_id: u64, sent: bool },
107
146
  /// Result of a getStats() request.
@@ -149,25 +188,6 @@ pub fn build_stats(conn: &quiche::Connection, request_id: u64) -> Ev {
149
188
  }
150
189
  }
151
190
 
152
- /// Export `length` bytes of TLS keying material (RFC 5705) into a
153
- /// [`Ev::KeyingMaterial`] for `request_id`. `data` is `None` if the export
154
- /// failed. WebTransport always supplies a context, so it is passed through even
155
- /// when empty (an empty context differs from no context per RFC 5705).
156
- pub fn build_keying_material(
157
- conn: &mut quiche::Connection,
158
- request_id: u64,
159
- label: &[u8],
160
- context: &[u8],
161
- length: u32,
162
- ) -> Ev {
163
- let mut out = vec![0u8; length as usize];
164
- let data = match conn.export_keying_material(&mut out, label, Some(context)) {
165
- Ok(()) => Some(out),
166
- Err(_) => None,
167
- };
168
- Ev::KeyingMaterial { request_id, data }
169
- }
170
-
171
191
  /// One queued outbound chunk on a stream.
172
192
  struct OutChunk {
173
193
  data: Vec<u8>,
@@ -186,8 +206,13 @@ enum Role {
186
206
  PeerControl,
187
207
  /// A peer uni stream we drain and discard (QPACK/push/unknown).
188
208
  Ignored,
209
+ PeerQpack {
210
+ encoder: bool,
211
+ },
189
212
  /// A resolved WebTransport data stream.
190
- WtData { bidi: bool },
213
+ WtData {
214
+ bidi: bool,
215
+ },
191
216
  /// A peer-initiated uni stream whose type varint isn't fully read yet.
192
217
  PendingUni,
193
218
  /// A peer-initiated bidi stream whose WT signal isn't fully read yet.
@@ -197,7 +222,7 @@ enum Role {
197
222
  struct Stream {
198
223
  role: Role,
199
224
  /// Classification accumulator (pending server streams) / control byte carry.
200
- class_buf: Vec<u8>,
225
+ class_buf: ParserBuffer,
201
226
  /// HTTP/3 frame parser (Connect + PeerControl).
202
227
  frames: FrameParser,
203
228
  /// CONNECT stream: response HEADERS already parsed.
@@ -209,27 +234,40 @@ struct Stream {
209
234
  /// Application asked to FIN once `out` drains.
210
235
  fin_queued: bool,
211
236
  fin_sent: bool,
237
+ reset_pending: Option<u64>,
212
238
  /// Peer already reset/finished, stop touching recv.
213
239
  recv_dead: bool,
240
+ recv_payload: u64,
241
+ recv_prefix: u64,
242
+ send_payload: u64,
243
+ send_prefix: u64,
214
244
  }
215
245
 
216
246
  impl Stream {
217
- fn new(role: Role) -> Self {
247
+ fn new(role: Role, memory: Arc<ParserMemory>) -> Self {
218
248
  Self {
219
249
  role,
220
- class_buf: Vec::new(),
221
- frames: FrameParser::default(),
250
+ class_buf: ParserBuffer::new(memory.clone()),
251
+ frames: FrameParser::new(memory),
222
252
  headers_done: false,
223
- paused: false,
253
+ paused: matches!(role, Role::WtData { .. }),
224
254
  out: VecDeque::new(),
225
255
  fin_queued: false,
226
256
  fin_sent: false,
257
+ reset_pending: None,
227
258
  recv_dead: false,
259
+ recv_payload: 0,
260
+ recv_prefix: 0,
261
+ send_payload: 0,
262
+ send_prefix: 0,
228
263
  }
229
264
  }
230
265
 
231
- fn with_prefix(role: Role, prefix: Vec<u8>) -> Self {
232
- let mut s = Self::new(role);
266
+ fn with_prefix(role: Role, prefix: Vec<u8>, memory: Arc<ParserMemory>) -> Self {
267
+ let mut s = Self::new(role, memory);
268
+ if matches!(role, Role::WtData { .. }) {
269
+ s.send_prefix = prefix.len() as u64;
270
+ }
233
271
  if !prefix.is_empty() {
234
272
  s.out.push_back(OutChunk {
235
273
  data: prefix,
@@ -242,36 +280,53 @@ impl Stream {
242
280
  }
243
281
 
244
282
  /// Incremental HTTP/3 frame reassembler.
245
- #[derive(Default)]
246
283
  struct FrameParser {
247
- buf: Vec<u8>,
284
+ buf: ParserBuffer,
248
285
  error: bool,
249
286
  }
250
287
 
251
288
  impl FrameParser {
289
+ fn new(memory: Arc<ParserMemory>) -> Self {
290
+ Self {
291
+ buf: ParserBuffer::new(memory),
292
+ error: false,
293
+ }
294
+ }
295
+
252
296
  fn push(&mut self, data: &[u8]) {
253
- self.buf.extend_from_slice(data);
297
+ if self.error {
298
+ return;
299
+ }
300
+ if self.buf.extend_from_slice(data).is_err() {
301
+ self.error = true;
302
+ }
254
303
  }
255
304
 
256
305
  /// Pop the next complete `(type, payload)` frame, or `None` if incomplete.
257
- fn next_frame(&mut self) -> Option<(u64, Vec<u8>)> {
306
+ fn next_frame(&mut self) -> Option<(u64, ParserBuffer)> {
258
307
  if self.error {
259
308
  return None;
260
309
  }
261
310
  let (ty, n1) = h3::read_varint(&self.buf)?;
262
311
  let (len, n2) = h3::read_varint(&self.buf[n1..])?;
263
- let len = len as usize;
264
- if len > MAX_CONTROL_FRAME {
312
+ if len > MAX_CONTROL_FRAME as u64 {
265
313
  self.error = true;
266
314
  return None;
267
315
  }
316
+ let len = len as usize;
268
317
  let header = n1 + n2;
269
318
  let total = header + len;
270
319
  if self.buf.len() < total {
271
320
  return None;
272
321
  }
273
- let payload = self.buf[header..total].to_vec();
274
- self.buf.drain(..total);
322
+ let payload = match self.buf.copy_range(header..total) {
323
+ Ok(payload) => payload,
324
+ Err(()) => {
325
+ self.error = true;
326
+ return None;
327
+ }
328
+ };
329
+ self.buf.consume(total);
275
330
  Some((ty, payload))
276
331
  }
277
332
  }
@@ -304,8 +359,10 @@ pub struct WtSession {
304
359
 
305
360
  next_bidi: u64,
306
361
  next_uni: u64,
362
+ pending_opens: VecDeque<(bool, u64)>,
307
363
 
308
364
  setup_sent: bool,
365
+ latest_protocol: bool,
309
366
  ready: bool,
310
367
  closed: bool,
311
368
  /// Client role only: the Extended CONNECT is built but deferred until the
@@ -319,28 +376,33 @@ pub struct WtSession {
319
376
  /// Set once we granted the peer per-session flow-control credit.
320
377
  fc_credit_granted: bool,
321
378
  /// Peer's send-side session limits (from SETTINGS_WT_INITIAL_* and WT_MAX_*
322
- /// capsules). QUIC performs the actual send enforcement under the
323
- /// one-session-per-connection model; these drive only the WT_*_BLOCKED
324
- /// signaling below.
379
+ /// capsules), enforced in addition to QUIC's transport-level limits.
325
380
  fc_max_data_remote: u64,
326
381
  fc_max_streams_bidi_remote: u64,
327
382
  fc_max_streams_uni_remote: u64,
328
383
  /// Cumulative WebTransport stream payload bytes handed to quiche, compared
329
384
  /// against `fc_max_data_remote` to detect a WT_DATA_BLOCKED condition.
330
385
  fc_data_sent: u64,
386
+ fc_data_received: u64,
387
+ fc_max_data_local: u64,
388
+ fc_max_streams_local: [u64; 2],
389
+ fc_streams_received: [u64; 2],
390
+ terminal_error: Option<(u64, Vec<u8>)>,
331
391
  /// The WT_MAX_DATA / WT_MAX_STREAMS_* limit value we last announced as blocked
332
- /// at (0 = none), so a BLOCKED capsule is re-sent only when the limit changes.
333
- data_blocked_at: u64,
334
- streams_bidi_blocked_at: u64,
335
- streams_uni_blocked_at: u64,
392
+ /// at (None = no signal yet), so a BLOCKED capsule is re-sent only when the limit changes.
393
+ data_blocked_at: Option<u64>,
394
+ streams_bidi_blocked_at: Option<u64>,
395
+ streams_uni_blocked_at: Option<u64>,
336
396
  /// Reassembly buffer for capsules on the session (CONNECT) stream: RFC 9297
337
397
  /// lets a capsule span multiple HTTP/3 DATA frames, so bytes are accumulated
338
398
  /// here and only whole capsules are consumed.
339
- capsule_buf: Vec<u8>,
399
+ capsule_buf: ParserBuffer,
400
+ parser_memory: Arc<ParserMemory>,
340
401
 
341
402
  peer_settings: Option<h3::PeerSettings>,
342
403
 
343
404
  streams: HashMap<u64, Stream>,
405
+ next_read_stream: u64,
344
406
 
345
407
  close_req: Option<CloseReq>,
346
408
  /// Set once the QUIC connection should be closed (after connect FIN flush).
@@ -357,6 +419,33 @@ pub struct WtSession {
357
419
  }
358
420
 
359
421
  impl WtSession {
422
+ pub fn build_keying_material(
423
+ &self,
424
+ conn: &mut quiche::Connection,
425
+ request_id: u64,
426
+ label: &[u8],
427
+ context: &[u8],
428
+ length: u32,
429
+ ) -> Ev {
430
+ let data = (|| {
431
+ if !self.ready || self.closed || !(1..=4096).contains(&length) {
432
+ return None;
433
+ }
434
+ let mut out = vec![0; length as usize];
435
+ let context_buf;
436
+ let (label, context) = if self.latest_protocol {
437
+ context_buf = h3::exporter_context(CONNECT_ID, label, context)?;
438
+ (h3::WT_EXPORTER_LABEL, context_buf.as_slice())
439
+ } else {
440
+ (label, context)
441
+ };
442
+ conn.export_keying_material(&mut out, label, Some(context))
443
+ .ok()?;
444
+ Some(out)
445
+ })();
446
+ Ev::KeyingMaterial { request_id, data }
447
+ }
448
+
360
449
  /// A client-role session that will send an Extended CONNECT.
361
450
  pub fn new_client(
362
451
  authority: String,
@@ -365,6 +454,7 @@ impl WtSession {
365
454
  extra_headers: Vec<(String, String)>,
366
455
  protocols: Vec<String>,
367
456
  ) -> Self {
457
+ let parser_memory = ParserMemory::new(MAX_SESSION_PARSER_MEMORY);
368
458
  Self {
369
459
  is_server: false,
370
460
  authority,
@@ -377,7 +467,9 @@ impl WtSession {
377
467
  response_headers: Vec::new(),
378
468
  next_bidi: CLIENT_FIRST_WT_BIDI_ID,
379
469
  next_uni: CLIENT_FIRST_WT_UNI_ID,
470
+ pending_opens: VecDeque::new(),
380
471
  setup_sent: false,
472
+ latest_protocol: false,
381
473
  ready: false,
382
474
  closed: false,
383
475
  connect_pending: false,
@@ -388,12 +480,19 @@ impl WtSession {
388
480
  fc_max_streams_bidi_remote: 0,
389
481
  fc_max_streams_uni_remote: 0,
390
482
  fc_data_sent: 0,
391
- data_blocked_at: 0,
392
- streams_bidi_blocked_at: 0,
393
- streams_uni_blocked_at: 0,
394
- capsule_buf: Vec::new(),
483
+ fc_data_received: 0,
484
+ fc_max_data_local: h3::WT_INITIAL_MAX_DATA,
485
+ fc_max_streams_local: [h3::WT_INITIAL_MAX_STREAMS; 2],
486
+ fc_streams_received: [0; 2],
487
+ terminal_error: None,
488
+ data_blocked_at: None,
489
+ streams_bidi_blocked_at: None,
490
+ streams_uni_blocked_at: None,
491
+ capsule_buf: ParserBuffer::new(parser_memory.clone()),
492
+ parser_memory,
395
493
  peer_settings: None,
396
494
  streams: HashMap::new(),
495
+ next_read_stream: 0,
397
496
  close_req: None,
398
497
  want_quic_close: None,
399
498
  close_deferred_once: false,
@@ -410,7 +509,9 @@ impl WtSession {
410
509
  supported_protocols: Vec<String>,
411
510
  allowed_origins: Option<Vec<String>>,
412
511
  response_headers: Vec<(String, String)>,
512
+ parser_memory: Arc<ParserMemory>,
413
513
  ) -> Self {
514
+ let parser_memory = ParserMemory::child(parser_memory, MAX_SESSION_PARSER_MEMORY);
414
515
  Self {
415
516
  is_server: true,
416
517
  authority: String::new(),
@@ -423,7 +524,9 @@ impl WtSession {
423
524
  response_headers,
424
525
  next_bidi: SERVER_FIRST_WT_BIDI_ID,
425
526
  next_uni: SERVER_FIRST_WT_UNI_ID,
527
+ pending_opens: VecDeque::new(),
426
528
  setup_sent: false,
529
+ latest_protocol: false,
427
530
  ready: false,
428
531
  closed: false,
429
532
  connect_pending: false,
@@ -434,12 +537,19 @@ impl WtSession {
434
537
  fc_max_streams_bidi_remote: 0,
435
538
  fc_max_streams_uni_remote: 0,
436
539
  fc_data_sent: 0,
437
- data_blocked_at: 0,
438
- streams_bidi_blocked_at: 0,
439
- streams_uni_blocked_at: 0,
440
- capsule_buf: Vec::new(),
540
+ fc_data_received: 0,
541
+ fc_max_data_local: h3::WT_INITIAL_MAX_DATA,
542
+ fc_max_streams_local: [h3::WT_INITIAL_MAX_STREAMS; 2],
543
+ fc_streams_received: [0; 2],
544
+ terminal_error: None,
545
+ data_blocked_at: None,
546
+ streams_bidi_blocked_at: None,
547
+ streams_uni_blocked_at: None,
548
+ capsule_buf: ParserBuffer::new(parser_memory.clone()),
549
+ parser_memory,
441
550
  peer_settings: None,
442
551
  streams: HashMap::new(),
552
+ next_read_stream: 0,
443
553
  close_req: None,
444
554
  want_quic_close: None,
445
555
  close_deferred_once: false,
@@ -453,10 +563,10 @@ impl WtSession {
453
563
  }
454
564
 
455
565
  /// Called once the QUIC connection is established: open the HTTP/3
456
- /// control-plane streams and advertise SETTINGS. A client also sends the
457
- /// Extended CONNECT immediately; a server waits for the client's CONNECT on
458
- /// bidi stream 0.
459
- pub fn on_established(&mut self) {
566
+ /// control-plane streams and advertise SETTINGS. A client waits for the
567
+ /// server's SETTINGS before sending CONNECT; a server waits for the client's
568
+ /// CONNECT on bidi stream 0.
569
+ pub fn on_established(&mut self, reliable_reset: bool) {
460
570
  if self.setup_sent {
461
571
  return;
462
572
  }
@@ -471,20 +581,24 @@ impl WtSession {
471
581
  // HTTP/3 control stream: type prefix + SETTINGS.
472
582
  self.streams.insert(
473
583
  control_id,
474
- Stream::with_prefix(Role::LocalControlPlane, h3::control_stream_prefix()),
584
+ Stream::with_prefix(
585
+ Role::LocalControlPlane,
586
+ h3::control_stream_prefix_for(reliable_reset),
587
+ self.parser_memory.clone(),
588
+ ),
475
589
  );
476
590
  // QPACK encoder / decoder streams (dynamic table disabled → type only).
477
591
  let mut enc = Vec::new();
478
592
  h3::put_varint(h3::QPACK_ENCODER_STREAM_TYPE, &mut enc);
479
593
  self.streams.insert(
480
594
  qpack_enc_id,
481
- Stream::with_prefix(Role::LocalControlPlane, enc),
595
+ Stream::with_prefix(Role::LocalControlPlane, enc, self.parser_memory.clone()),
482
596
  );
483
597
  let mut dec = Vec::new();
484
598
  h3::put_varint(h3::QPACK_DECODER_STREAM_TYPE, &mut dec);
485
599
  self.streams.insert(
486
600
  qpack_dec_id,
487
- Stream::with_prefix(Role::LocalControlPlane, dec),
601
+ Stream::with_prefix(Role::LocalControlPlane, dec, self.parser_memory.clone()),
488
602
  );
489
603
 
490
604
  if !self.is_server {
@@ -502,50 +616,81 @@ impl WtSession {
502
616
  }
503
617
  }
504
618
 
505
- /// Process a readable QUIC stream. `backpressured` is a global signal that
506
- /// the JS thread is behind; when set, resolved WebTransport data streams are
507
- /// left unread (flow-controlling the peer) while control-plane streams still
508
- /// drain.
509
- pub fn on_readable(
619
+ #[cfg(test)]
620
+ fn on_readable(&mut self, conn: &mut quiche::Connection, id: u64, ev: &mut Vec<Ev>) {
621
+ let mut budget = ReceiveBudget::new();
622
+ self.read_stream(conn, id, &mut budget, ev);
623
+ if !self.closed && self.streams.get(&id).is_some_and(|s| s.paused) {
624
+ self.set_paused(id, false);
625
+ self.read_stream(conn, id, &mut budget, ev);
626
+ }
627
+ }
628
+
629
+ fn read_stream(
510
630
  &mut self,
511
631
  conn: &mut quiche::Connection,
512
632
  id: u64,
513
- backpressured: bool,
633
+ budget: &mut ReceiveBudget,
514
634
  ev: &mut Vec<Ev>,
515
635
  ) {
636
+ if self.closed {
637
+ return;
638
+ }
516
639
  let is_server = self.is_server;
517
- self.streams
518
- .entry(id)
519
- .or_insert_with(|| Stream::new(classify_new(id, is_server)));
640
+ self.streams.entry(id).or_insert_with(|| {
641
+ Stream::new(classify_new(id, is_server), self.parser_memory.clone())
642
+ });
520
643
 
521
- // Respect per-stream and global read backpressure for resolved data
522
- // streams (leave the bytes in quiche so the peer is flow-controlled).
523
- let (paused, is_data, recv_dead) = {
524
- let st = &self.streams[&id];
525
- (
526
- st.paused,
527
- matches!(st.role, Role::WtData { .. }),
528
- st.recv_dead,
529
- )
530
- };
531
- if recv_dead {
644
+ let st = &self.streams[&id];
645
+ if st.recv_dead {
532
646
  return;
533
647
  }
534
- if (paused || backpressured) && is_data {
648
+ if !self.ready && st.role == Role::PendingBidi {
535
649
  return;
536
650
  }
537
651
 
538
- // Drain everything quiche currently has for this stream.
539
- let mut chunk = Vec::new();
540
- let mut fin = false;
541
652
  let mut reset: Option<u64> = None;
542
653
  let mut buf = [0u8; 16 * 1024];
543
- loop {
544
- match conn.stream_recv(id, &mut buf) {
654
+ while !budget.exhausted() {
655
+ let Some(st) = self.streams.get(&id) else {
656
+ return;
657
+ };
658
+ if st.paused && !conn.stream_finished(id) {
659
+ // Leave data in QUIC until the JS reader asks for one chunk.
660
+ // Empty FIN and RESET_STREAM do not require read credit.
661
+ return;
662
+ }
663
+ let read_len = if matches!(st.role, Role::PendingUni | Role::PendingBidi) {
664
+ // Classify the stream without consuming WebTransport payload
665
+ // before CONNECT has been accepted and reported to Node.
666
+ if !self.ready
667
+ && h3::read_varint(&st.class_buf)
668
+ .is_some_and(|(ty, _)| ty == h3::WT_UNI_STREAM_TYPE)
669
+ {
670
+ return;
671
+ }
672
+ 1
673
+ } else {
674
+ buf.len().min(budget.bytes)
675
+ };
676
+ let final_size = conn.stream_recv_final_size(id);
677
+ match conn.stream_recv(id, &mut buf[..read_len]) {
545
678
  Ok((n, f)) => {
546
- chunk.extend_from_slice(&buf[..n]);
679
+ budget.record(n);
680
+ // Parse bounded chunks immediately. Do not build an entire
681
+ // stream-sized scratch allocation outside the parser budget.
682
+ let was_ready = self.ready;
683
+ self.process_recv(conn, id, buf[..n].to_vec(), f, ev);
684
+ if !was_ready && self.ready {
685
+ // Decoded headers can span reads and expand on decode.
686
+ budget.bytes = budget
687
+ .bytes
688
+ .saturating_sub(4 * h3::MAX_HEADER_BLOCK as usize);
689
+ }
690
+ if self.closed {
691
+ return;
692
+ }
547
693
  if f {
548
- fin = true;
549
694
  break;
550
695
  }
551
696
  if n == 0 {
@@ -554,6 +699,18 @@ impl WtSession {
554
699
  }
555
700
  Err(quiche::Error::Done) => break,
556
701
  Err(quiche::Error::StreamReset(code)) => {
702
+ budget.record(0);
703
+ if let Some(size) = final_size {
704
+ let st = &self.streams[&id];
705
+ if matches!(st.role, Role::WtData { .. }) {
706
+ let missing = size
707
+ .saturating_sub(st.recv_prefix)
708
+ .saturating_sub(st.recv_payload);
709
+ if !self.account_receive(id, missing, ev) {
710
+ return;
711
+ }
712
+ }
713
+ }
557
714
  reset = Some(code);
558
715
  break;
559
716
  }
@@ -573,6 +730,9 @@ impl WtSession {
573
730
  let app = h3::http_code_to_webtransport_code(code).unwrap_or(code);
574
731
  ev.push(Ev::StreamReset { id, code: app })
575
732
  }
733
+ Some(Role::PeerControl | Role::PeerQpack { .. }) => {
734
+ self.protocol_error(conn, ev, 0x104, "peer reset a critical HTTP/3 stream");
735
+ }
576
736
  Some(Role::Connect) if !self.closed => {
577
737
  // A reset of the session (CONNECT) stream ends the session;
578
738
  // if we swallowed it, ready/closed would hang forever.
@@ -583,23 +743,18 @@ impl WtSession {
583
743
  }
584
744
  self.mark_closed(ev, code as u32, Vec::new(), true);
585
745
  }
746
+ Some(Role::PendingBidi | Role::PendingUni) => self.ignore_stream(conn, id),
586
747
  _ => {}
587
748
  }
588
- return;
589
749
  }
750
+ }
590
751
 
591
- if dbg_on() {
592
- let role = self
593
- .streams
594
- .get(&id)
595
- .map(|s| role_name(s.role))
596
- .unwrap_or("?");
597
- eprintln!(
598
- "[rwt-session] readable id={id} role={role} chunk={} fin={fin}",
599
- chunk.len()
600
- );
752
+ fn ignore_stream(&mut self, conn: &mut quiche::Connection, id: u64) {
753
+ let _ = conn.stream_shutdown(id, quiche::Shutdown::Read, 0);
754
+ if id & 2 == 0 {
755
+ let _ = conn.stream_shutdown(id, quiche::Shutdown::Write, 0);
601
756
  }
602
- self.process_recv(conn, id, chunk, fin, ev);
757
+ self.streams.remove(&id);
603
758
  }
604
759
 
605
760
  fn process_recv(
@@ -611,10 +766,22 @@ impl WtSession {
611
766
  ev: &mut Vec<Ev>,
612
767
  ) {
613
768
  let role = self.streams.get(&id).map(|s| s.role);
769
+ if dbg_on() {
770
+ eprintln!(
771
+ "[rwt-session] readable id={id} role={} chunk={} fin={fin}",
772
+ role.map(role_name).unwrap_or("?"),
773
+ chunk.len()
774
+ );
775
+ }
614
776
  match role {
615
777
  Some(Role::LocalControlPlane) | None => {
616
778
  // Our send-only control-plane streams / unknown: discard reads.
617
779
  }
780
+ Some(Role::PeerQpack { .. }) => {
781
+ if fin {
782
+ self.protocol_error(conn, ev, 0x104, "peer closed a critical QPACK stream");
783
+ }
784
+ }
618
785
  Some(Role::Ignored) => {
619
786
  // A drained peer stream (QPACK/push/unknown): mark it finished so
620
787
  // it can be pruned, otherwise stream churn grows the map.
@@ -628,7 +795,10 @@ impl WtSession {
628
795
  if let Some(st) = self.streams.get_mut(&id) {
629
796
  st.frames.push(&chunk);
630
797
  }
631
- self.parse_control_frames(id, ev);
798
+ self.parse_control_frames(conn, id, ev);
799
+ if fin && !self.closed {
800
+ self.protocol_error(conn, ev, 0x104, "peer closed the HTTP/3 control stream");
801
+ }
632
802
  // A malformed control stream is a fatal H3 error; stop reading it
633
803
  // so a hostile server cannot keep us draining (and re-crediting)
634
804
  // an oversized frame into an unbounded buffer.
@@ -657,11 +827,24 @@ impl WtSession {
657
827
  let _ = conn.close(true, 0, b"h3 connect error");
658
828
  }
659
829
  if fin && !self.closed {
660
- self.mark_closed(ev, 0, Vec::new(), true);
830
+ if self
831
+ .streams
832
+ .get(&id)
833
+ .is_some_and(|st| !st.frames.buf.is_empty())
834
+ || !self.capsule_buf.is_empty()
835
+ {
836
+ self.protocol_error(conn, ev, 0x106, "truncated CONNECT frame or capsule");
837
+ } else {
838
+ self.mark_closed(ev, 0, Vec::new(), true);
839
+ }
661
840
  }
662
841
  }
663
842
  Some(Role::WtData { .. }) => {
843
+ if !self.account_receive(id, chunk.len() as u64, ev) {
844
+ return;
845
+ }
664
846
  if !chunk.is_empty() {
847
+ self.streams.get_mut(&id).unwrap().paused = true;
665
848
  ev.push(Ev::StreamData { id, data: chunk });
666
849
  }
667
850
  if fin {
@@ -680,15 +863,34 @@ impl WtSession {
680
863
  }
681
864
  }
682
865
 
683
- fn parse_control_frames(&mut self, id: u64, ev: &mut Vec<Ev>) {
684
- loop {
866
+ fn parse_control_frames(&mut self, conn: &mut quiche::Connection, id: u64, ev: &mut Vec<Ev>) {
867
+ while !self.closed {
685
868
  let frame = self
686
869
  .streams
687
870
  .get_mut(&id)
688
871
  .and_then(|s| s.frames.next_frame());
689
872
  let Some((ty, payload)) = frame else { break };
873
+ let first = !self.streams[&id].headers_done;
874
+ if first && ty != h3::FRAME_SETTINGS {
875
+ self.protocol_error(conn, ev, 0x10a, "SETTINGS must be the first control frame");
876
+ return;
877
+ }
690
878
  if ty == h3::FRAME_SETTINGS {
691
- let settings = h3::parse_settings(&payload);
879
+ if !first {
880
+ self.protocol_error(conn, ev, 0x105, "repeated SETTINGS frame");
881
+ return;
882
+ }
883
+ self.streams.get_mut(&id).unwrap().headers_done = true;
884
+ let settings = match h3::parse_settings(&payload) {
885
+ Ok(settings) => settings,
886
+ Err(message) => {
887
+ self.protocol_error(conn, ev, 0x109, &message);
888
+ return;
889
+ }
890
+ };
891
+ if dbg_on() {
892
+ eprintln!("[rwt-session] peer settings={settings:?}");
893
+ }
692
894
  self.peer_settings = Some(settings);
693
895
  // Seed the peer's per-session flow-control limits from its SETTINGS.
694
896
  self.fc_max_data_remote = settings.wt_initial_max_data;
@@ -699,15 +901,30 @@ impl WtSession {
699
901
  // otherwise reject the session.
700
902
  if self.connect_pending {
701
903
  self.connect_pending = false;
702
- if settings.webtransport_ok() {
904
+ self.latest_protocol = settings.enable_connect_protocol
905
+ && settings.h3_datagram
906
+ && (settings.wt_enabled || settings.wt_enabled_draft15)
907
+ && conn.dgram_max_writable_len().is_some()
908
+ && conn.reliable_stream_reset_negotiated();
909
+ if self.latest_protocol || settings.webtransport_ok() {
703
910
  self.queue_connect(ev);
704
911
  } else {
705
912
  ev.push(Ev::Error(
706
913
  "server does not advertise WebTransport support".to_string(),
707
914
  ));
708
915
  self.mark_closed(ev, 0, b"webtransport not supported".to_vec(), false);
916
+ let _ = conn.close(true, h3::H3_NO_ERROR, b"webtransport not supported");
709
917
  }
710
918
  }
919
+ if self.is_server && self.streams.contains_key(&CONNECT_ID) {
920
+ self.parse_server_connect_frames(conn, CONNECT_ID, ev);
921
+ }
922
+ } else if matches!(
923
+ ty,
924
+ h3::FRAME_DATA | h3::FRAME_HEADERS | 0x2 | 0x6 | 0x8 | 0x9
925
+ ) {
926
+ self.protocol_error(conn, ev, 0x105, "unexpected frame on control stream");
927
+ return;
711
928
  } else if ty == h3::FRAME_GOAWAY && !self.drain_emitted && !self.closed {
712
929
  // The peer is gracefully shutting down the HTTP/3 connection.
713
930
  // Exactly one WebTransport session rides it, so surface GOAWAY as
@@ -721,7 +938,12 @@ impl WtSession {
721
938
  /// Build and queue the client's Extended CONNECT on the session (bidi 0)
722
939
  /// stream. Called once the server's SETTINGS have confirmed WebTransport.
723
940
  fn queue_connect(&mut self, ev: &mut Vec<Ev>) {
724
- let headers = h3::connect_headers(
941
+ let headers = h3::connect_headers_for(
942
+ if self.latest_protocol {
943
+ h3::WT_H3_TOKEN
944
+ } else {
945
+ h3::LEGACY_WT_TOKEN
946
+ },
725
947
  &self.authority,
726
948
  &self.path,
727
949
  self.origin.as_deref(),
@@ -730,15 +952,17 @@ impl WtSession {
730
952
  );
731
953
  match h3::encode_headers_frame(&headers) {
732
954
  Ok(frame) => {
733
- self.streams
734
- .insert(CONNECT_ID, Stream::with_prefix(Role::Connect, frame));
955
+ self.streams.insert(
956
+ CONNECT_ID,
957
+ Stream::with_prefix(Role::Connect, frame, self.parser_memory.clone()),
958
+ );
735
959
  }
736
960
  Err(e) => ev.push(Ev::Error(format!("failed to encode CONNECT: {e}"))),
737
961
  }
738
962
  }
739
963
 
740
964
  fn parse_connect_frames(&mut self, conn: &mut quiche::Connection, id: u64, ev: &mut Vec<Ev>) {
741
- loop {
965
+ while !self.closed {
742
966
  let (frame, headers_done) = {
743
967
  let Some(st) = self.streams.get_mut(&id) else {
744
968
  return;
@@ -751,19 +975,42 @@ impl WtSession {
751
975
  eprintln!("[rwt-session] connect frame ty={ty} len={}", payload.len());
752
976
  }
753
977
  if ty == h3::FRAME_HEADERS && !headers_done {
754
- if let Some(st) = self.streams.get_mut(&id) {
755
- st.headers_done = true;
756
- }
757
978
  match h3::decode_header_block(&payload) {
758
979
  Ok(headers) => {
759
- let status = h3::status_of(&headers).unwrap_or(0);
980
+ let Some(status) = h3::status_of(&headers) else {
981
+ self.protocol_error(
982
+ conn,
983
+ ev,
984
+ 0x10e,
985
+ "malformed CONNECT response headers",
986
+ );
987
+ return;
988
+ };
989
+ if (100..200).contains(&status) {
990
+ continue;
991
+ }
992
+ if let Some(st) = self.streams.get_mut(&id) {
993
+ st.headers_done = true;
994
+ }
760
995
  if dbg_on() {
761
996
  eprintln!("[rwt-session] CONNECT response status={status}");
762
997
  }
763
998
  if (200..300).contains(&status) {
764
999
  if !self.ready {
765
- self.ready = true;
766
1000
  let protocol = h3::wt_protocol_of(&headers);
1001
+ if protocol
1002
+ .as_ref()
1003
+ .is_some_and(|p| !self.protocols.contains(p))
1004
+ {
1005
+ self.protocol_error(
1006
+ conn,
1007
+ ev,
1008
+ 0x0817b3dd,
1009
+ "server selected an unoffered or malformed subprotocol",
1010
+ );
1011
+ return;
1012
+ }
1013
+ self.ready = true;
767
1014
  let resp_headers = h3::response_headers(&headers);
768
1015
  ev.push(Ev::Ready {
769
1016
  protocol,
@@ -779,12 +1026,20 @@ impl WtSession {
779
1026
  }
780
1027
  }
781
1028
  Err(e) => {
782
- ev.push(Ev::Error(format!("failed to decode CONNECT response: {e}")));
1029
+ self.protocol_error(
1030
+ conn,
1031
+ ev,
1032
+ 0x10e,
1033
+ &format!("failed to decode CONNECT response: {e}"),
1034
+ );
1035
+ return;
783
1036
  }
784
1037
  }
785
- } else if ty == h3::FRAME_DATA {
786
- // Capsule-protocol content. Best-effort scan for a session close.
1038
+ } else if ty == h3::FRAME_DATA && self.ready {
787
1039
  self.scan_capsules(&payload, ev);
1040
+ } else if ty == h3::FRAME_DATA || ty == h3::FRAME_HEADERS {
1041
+ self.protocol_error(conn, ev, 0x105, "unexpected frame on CONNECT stream");
1042
+ return;
788
1043
  }
789
1044
  }
790
1045
  }
@@ -792,8 +1047,14 @@ impl WtSession {
792
1047
  fn scan_capsules(&mut self, payload: &[u8], ev: &mut Vec<Ev>) {
793
1048
  // A capsule may span multiple HTTP/3 DATA frames (RFC 9297), so append
794
1049
  // this frame's payload and consume only whole capsules from the buffer.
795
- self.capsule_buf.extend_from_slice(payload);
796
- loop {
1050
+ if self.closed {
1051
+ return;
1052
+ }
1053
+ if self.capsule_buf.extend_from_slice(payload).is_err() {
1054
+ self.parser_limit_exceeded(ev);
1055
+ return;
1056
+ }
1057
+ while !self.closed {
797
1058
  let (ty, start, len) = {
798
1059
  let buf = &self.capsule_buf;
799
1060
  let Some((ty, n1)) = h3::read_varint(buf) else {
@@ -802,18 +1063,26 @@ impl WtSession {
802
1063
  let Some((len, n2)) = h3::read_varint(&buf[n1..]) else {
803
1064
  break;
804
1065
  };
805
- (ty, n1 + n2, len as usize)
1066
+ (ty, n1 + n2, len)
806
1067
  };
807
1068
  // Guard against a hostile/oversized declared length.
808
- if len > MAX_CONTROL_FRAME {
809
- self.capsule_buf.clear();
1069
+ if len > MAX_CONTROL_FRAME as u64 {
1070
+ ev.push(Ev::Error("oversized WebTransport capsule".to_string()));
1071
+ self.mark_closed(ev, 0, Vec::new(), true);
810
1072
  break;
811
1073
  }
1074
+ let len = len as usize;
812
1075
  if self.capsule_buf.len() < start + len {
813
1076
  break; // capsule not fully arrived; wait for the next DATA frame
814
1077
  }
815
- let value: Vec<u8> = self.capsule_buf[start..start + len].to_vec();
816
- self.capsule_buf.drain(..start + len);
1078
+ let value = match self.capsule_buf.copy_range(start..start + len) {
1079
+ Ok(value) => value,
1080
+ Err(()) => {
1081
+ self.parser_limit_exceeded(ev);
1082
+ return;
1083
+ }
1084
+ };
1085
+ self.capsule_buf.consume(start + len);
817
1086
 
818
1087
  if ty == h3::WT_CLOSE_SESSION_CAPSULE && !self.closed {
819
1088
  let (code, reason) = if value.len() >= 4 {
@@ -828,17 +1097,40 @@ impl WtSession {
828
1097
  } else if ty == h3::WT_DRAIN_SESSION_CAPSULE && !self.drain_emitted && !self.closed {
829
1098
  self.drain_emitted = true;
830
1099
  ev.push(Ev::Draining);
831
- } else if ty == h3::WT_MAX_DATA_CAPSULE {
832
- if let Some((v, _)) = h3::read_varint(&value) {
833
- self.fc_max_data_remote = self.fc_max_data_remote.max(v);
1100
+ } else if matches!(
1101
+ ty,
1102
+ h3::WT_MAX_DATA_CAPSULE
1103
+ | h3::WT_MAX_STREAMS_BIDI_CAPSULE
1104
+ | h3::WT_MAX_STREAMS_UNI_CAPSULE
1105
+ | h3::WT_DATA_BLOCKED_CAPSULE
1106
+ | h3::WT_STREAMS_BLOCKED_BIDI_CAPSULE
1107
+ | h3::WT_STREAMS_BLOCKED_UNI_CAPSULE
1108
+ ) {
1109
+ if self.latest_protocol && !self.uses_session_flow_control() {
1110
+ continue;
834
1111
  }
835
- } else if ty == h3::WT_MAX_STREAMS_BIDI_CAPSULE {
836
- if let Some((v, _)) = h3::read_varint(&value) {
837
- self.fc_max_streams_bidi_remote = self.fc_max_streams_bidi_remote.max(v);
1112
+ let Some((v, n)) = h3::read_varint(&value) else {
1113
+ self.flow_error(ev, "truncated flow-control capsule");
1114
+ return;
1115
+ };
1116
+ let stream_limit =
1117
+ ty != h3::WT_MAX_DATA_CAPSULE && ty != h3::WT_DATA_BLOCKED_CAPSULE;
1118
+ if n != value.len() || (stream_limit && v > (1 << 60)) {
1119
+ self.flow_error(ev, "invalid flow-control capsule");
1120
+ return;
838
1121
  }
839
- } else if ty == h3::WT_MAX_STREAMS_UNI_CAPSULE {
840
- if let Some((v, _)) = h3::read_varint(&value) {
841
- self.fc_max_streams_uni_remote = self.fc_max_streams_uni_remote.max(v);
1122
+ let limit = match ty {
1123
+ h3::WT_MAX_DATA_CAPSULE => Some(&mut self.fc_max_data_remote),
1124
+ h3::WT_MAX_STREAMS_BIDI_CAPSULE => Some(&mut self.fc_max_streams_bidi_remote),
1125
+ h3::WT_MAX_STREAMS_UNI_CAPSULE => Some(&mut self.fc_max_streams_uni_remote),
1126
+ _ => None,
1127
+ };
1128
+ if let Some(limit) = limit {
1129
+ if v <= *limit {
1130
+ self.flow_error(ev, "flow-control credit must increase");
1131
+ return;
1132
+ }
1133
+ *limit = v;
842
1134
  }
843
1135
  }
844
1136
  }
@@ -852,7 +1144,12 @@ impl WtSession {
852
1144
  id: u64,
853
1145
  ev: &mut Vec<Ev>,
854
1146
  ) {
855
- loop {
1147
+ // Streams can arrive before SETTINGS because QUIC orders each stream
1148
+ // independently. Keep CONNECT buffered until negotiation is validated.
1149
+ if self.peer_settings.is_none() {
1150
+ return;
1151
+ }
1152
+ while !self.closed && (self.ready || self.close_req.is_none()) {
856
1153
  let (frame, headers_done) = {
857
1154
  let Some(st) = self.streams.get_mut(&id) else {
858
1155
  return;
@@ -872,8 +1169,11 @@ impl WtSession {
872
1169
  self.reject_connect(conn, id, 400, ev);
873
1170
  }
874
1171
  }
875
- } else if ty == h3::FRAME_DATA {
1172
+ } else if ty == h3::FRAME_DATA && self.ready {
876
1173
  self.scan_capsules(&payload, ev);
1174
+ } else if ty == h3::FRAME_DATA || ty == h3::FRAME_HEADERS {
1175
+ self.protocol_error(conn, ev, 0x105, "unexpected frame on CONNECT stream");
1176
+ return;
877
1177
  }
878
1178
  }
879
1179
  }
@@ -886,24 +1186,32 @@ impl WtSession {
886
1186
  ev: &mut Vec<Ev>,
887
1187
  ) {
888
1188
  use quiche::h3::NameValue;
889
- let mut method: Option<&[u8]> = None;
890
- let mut protocol: Option<&[u8]> = None;
891
- let mut authority = String::new();
892
- let mut path = String::from("/");
893
- let mut origin: Option<String> = None;
894
- let mut requested_protocols: Vec<String> = Vec::new();
1189
+ let Some(target) = h3::validate_connect_headers(headers) else {
1190
+ self.reject_connect(conn, id, 400, ev);
1191
+ return;
1192
+ };
1193
+ let Some(settings) = self.peer_settings else {
1194
+ return;
1195
+ };
1196
+ let latest = target.protocol == h3::WT_H3_TOKEN
1197
+ && conn.reliable_stream_reset_negotiated()
1198
+ && conn.dgram_max_writable_len().is_some();
1199
+ let legacy = target.protocol == h3::LEGACY_WT_TOKEN
1200
+ && (settings.enable_webtransport || settings.wt_max_sessions > 0);
1201
+ if !settings.h3_datagram || !(latest || legacy) {
1202
+ self.reject_connect(conn, id, 400, ev);
1203
+ return;
1204
+ }
1205
+ self.latest_protocol = latest;
1206
+ let mut protocol_fields: Vec<String> = Vec::new();
895
1207
  let mut extra: Vec<(String, String)> = Vec::new();
896
1208
  for h in headers {
897
1209
  let name = h.name();
898
1210
  let value = h.value();
899
1211
  match name {
900
- b":method" => method = Some(value),
901
- b":protocol" => protocol = Some(value),
902
- b":authority" => authority = String::from_utf8_lossy(value).into_owned(),
903
- b":path" => path = String::from_utf8_lossy(value).into_owned(),
904
- b"origin" => origin = Some(String::from_utf8_lossy(value).into_owned()),
1212
+ b"origin" => {}
905
1213
  _ if name == h3::WT_AVAILABLE_PROTOCOLS => {
906
- requested_protocols = h3::parse_sf_string_list(&String::from_utf8_lossy(value));
1214
+ protocol_fields.push(String::from_utf8_lossy(value).into_owned());
907
1215
  }
908
1216
  _ if name.starts_with(b":") => {} // other pseudo-headers
909
1217
  _ => extra.push((
@@ -913,17 +1221,13 @@ impl WtSession {
913
1221
  }
914
1222
  }
915
1223
 
916
- let ok = method == Some(b"CONNECT".as_ref()) && protocol == Some(b"webtransport".as_ref());
917
- if !ok {
918
- self.reject_connect(conn, id, 400, ev);
919
- return;
920
- }
1224
+ let requested_protocols = h3::parse_sf_string_list(&protocol_fields.join(", "));
921
1225
 
922
1226
  // Origin verification (draft-ietf-webtrans-http3 3.3): if an allowlist is
923
1227
  // configured, the request's origin must be present in it.
924
1228
  if let Some(allowed) = &self.allowed_origins {
925
- let permitted = origin
926
- .as_deref()
1229
+ let permitted = target
1230
+ .origin
927
1231
  .map(|o| allowed.iter().any(|a| a == o))
928
1232
  .unwrap_or(false);
929
1233
  if !permitted {
@@ -968,9 +1272,9 @@ impl WtSession {
968
1272
  None => (String::new(), 0),
969
1273
  };
970
1274
  ev.push(Ev::ServerReady {
971
- authority,
972
- path,
973
- origin,
1275
+ authority: target.authority.to_owned(),
1276
+ path: target.path.to_owned(),
1277
+ origin: target.origin.map(str::to_owned),
974
1278
  headers: extra,
975
1279
  requested_protocols,
976
1280
  protocol: selected,
@@ -1004,7 +1308,13 @@ impl WtSession {
1004
1308
  if !self.ready && !self.closed {
1005
1309
  ev.push(Ev::Error(format!("rejected CONNECT with status {status}")));
1006
1310
  }
1007
- self.mark_closed(ev, 0, Vec::new(), false);
1311
+ // Keep the queued HTTP response until it has been flushed. Marking
1312
+ // the session closed here would clear CONNECT's send queue.
1313
+ self.close_req = Some(CloseReq {
1314
+ code: 0,
1315
+ reason: Vec::new(),
1316
+ capsule_queued: true,
1317
+ });
1008
1318
  let _ = conn;
1009
1319
  }
1010
1320
 
@@ -1020,8 +1330,11 @@ impl WtSession {
1020
1330
  let Some(st) = self.streams.get_mut(&id) else {
1021
1331
  return;
1022
1332
  };
1023
- st.class_buf.extend_from_slice(&chunk);
1024
- st.class_buf.clone()
1333
+ if st.class_buf.extend_from_slice(&chunk).is_err() {
1334
+ self.parser_limit_exceeded(ev);
1335
+ return;
1336
+ }
1337
+ st.class_buf.to_vec()
1025
1338
  };
1026
1339
  let Some((ty, n)) = h3::read_varint(&buf) else {
1027
1340
  // Peer FIN'd before we could classify: no more bytes will ever
@@ -1033,21 +1346,40 @@ impl WtSession {
1033
1346
  };
1034
1347
  match ty {
1035
1348
  t if t == h3::H3_CONTROL_STREAM_TYPE => {
1349
+ if self
1350
+ .streams
1351
+ .iter()
1352
+ .any(|(&other, st)| other != id && st.role == Role::PeerControl)
1353
+ {
1354
+ self.protocol_error(conn, ev, 0x103, "duplicate HTTP/3 control stream");
1355
+ return;
1356
+ }
1036
1357
  let rest = buf[n..].to_vec();
1037
1358
  let Some(st) = self.streams.get_mut(&id) else {
1038
1359
  return;
1039
1360
  };
1040
1361
  st.role = Role::PeerControl;
1041
1362
  st.class_buf.clear();
1042
- st.frames.push(&rest);
1043
- self.parse_control_frames(id, ev);
1363
+ // Use the common control path so a budget failure in the very
1364
+ // first chunk is fatal even if the peer sends nothing else.
1365
+ self.process_recv(conn, id, rest, fin, ev);
1044
1366
  }
1045
1367
  t if t == h3::QPACK_ENCODER_STREAM_TYPE || t == h3::QPACK_DECODER_STREAM_TYPE => {
1046
- let Some(st) = self.streams.get_mut(&id) else {
1368
+ let encoder = t == h3::QPACK_ENCODER_STREAM_TYPE;
1369
+ if self
1370
+ .streams
1371
+ .iter()
1372
+ .any(|(&other, st)| other != id && st.role == (Role::PeerQpack { encoder }))
1373
+ {
1374
+ self.protocol_error(conn, ev, 0x103, "duplicate QPACK stream");
1047
1375
  return;
1048
- };
1049
- st.role = Role::Ignored;
1376
+ }
1377
+ let st = self.streams.get_mut(&id).unwrap();
1378
+ st.role = Role::PeerQpack { encoder };
1050
1379
  st.class_buf.clear();
1380
+ if fin {
1381
+ self.protocol_error(conn, ev, 0x104, "peer closed a critical QPACK stream");
1382
+ }
1051
1383
  }
1052
1384
  t if t == h3::WT_UNI_STREAM_TYPE => {
1053
1385
  let Some((session, n2)) = h3::read_varint(&buf[n..]) else {
@@ -1058,12 +1390,7 @@ impl WtSession {
1058
1390
  return; // need session id
1059
1391
  };
1060
1392
  if session != CONNECT_ID {
1061
- let _ = conn.stream_shutdown(id, quiche::Shutdown::Read, 0);
1062
- let Some(st) = self.streams.get_mut(&id) else {
1063
- return;
1064
- };
1065
- st.role = Role::Ignored;
1066
- st.class_buf.clear();
1393
+ self.ignore_stream(conn, id);
1067
1394
  return;
1068
1395
  }
1069
1396
  let data = buf[n + n2..].to_vec();
@@ -1072,8 +1399,15 @@ impl WtSession {
1072
1399
  return;
1073
1400
  };
1074
1401
  st.role = Role::WtData { bidi: false };
1402
+ st.paused = true;
1075
1403
  st.class_buf.clear();
1076
1404
  }
1405
+ self.streams.get_mut(&id).unwrap().recv_prefix = (n + n2) as u64;
1406
+ if !self.account_incoming(false, ev)
1407
+ || !self.account_receive(id, data.len() as u64, ev)
1408
+ {
1409
+ return;
1410
+ }
1077
1411
  ev.push(Ev::IncomingStream { id, bidi: false });
1078
1412
  if !data.is_empty() {
1079
1413
  ev.push(Ev::StreamData { id, data });
@@ -1085,13 +1419,7 @@ impl WtSession {
1085
1419
  ev.push(Ev::StreamFinished { id });
1086
1420
  }
1087
1421
  }
1088
- _ => {
1089
- let Some(st) = self.streams.get_mut(&id) else {
1090
- return;
1091
- };
1092
- st.role = Role::Ignored;
1093
- st.class_buf.clear();
1094
- }
1422
+ _ => self.ignore_stream(conn, id),
1095
1423
  }
1096
1424
  }
1097
1425
 
@@ -1107,39 +1435,32 @@ impl WtSession {
1107
1435
  let Some(st) = self.streams.get_mut(&id) else {
1108
1436
  return;
1109
1437
  };
1110
- st.class_buf.extend_from_slice(&chunk);
1111
- st.class_buf.clone()
1438
+ if st.class_buf.extend_from_slice(&chunk).is_err() {
1439
+ self.parser_limit_exceeded(ev);
1440
+ return;
1441
+ }
1442
+ st.class_buf.to_vec()
1112
1443
  };
1113
1444
  let Some((signal, n)) = h3::read_varint(&buf) else {
1114
- // Peer FIN'd before we could classify: reclaim the entry.
1445
+ // Peer FIN'd before we could classify: release both halves.
1115
1446
  if fin {
1116
- self.streams.remove(&id);
1447
+ self.ignore_stream(conn, id);
1117
1448
  }
1118
1449
  return;
1119
1450
  };
1120
1451
  if signal != h3::WT_BIDI_FRAME_TYPE {
1121
- let _ = conn.stream_shutdown(id, quiche::Shutdown::Read, 0);
1122
- let Some(st) = self.streams.get_mut(&id) else {
1123
- return;
1124
- };
1125
- st.role = Role::Ignored;
1126
- st.class_buf.clear();
1452
+ self.ignore_stream(conn, id);
1127
1453
  return;
1128
1454
  }
1129
1455
  let Some((session, n2)) = h3::read_varint(&buf[n..]) else {
1130
- // Peer FIN'd mid-header: reclaim the entry instead of leaking.
1456
+ // Peer FIN'd mid-header: release both halves.
1131
1457
  if fin {
1132
- self.streams.remove(&id);
1458
+ self.ignore_stream(conn, id);
1133
1459
  }
1134
1460
  return;
1135
1461
  };
1136
1462
  if session != CONNECT_ID {
1137
- let _ = conn.stream_shutdown(id, quiche::Shutdown::Read, 0);
1138
- let Some(st) = self.streams.get_mut(&id) else {
1139
- return;
1140
- };
1141
- st.role = Role::Ignored;
1142
- st.class_buf.clear();
1463
+ self.ignore_stream(conn, id);
1143
1464
  return;
1144
1465
  }
1145
1466
  let data = buf[n + n2..].to_vec();
@@ -1148,8 +1469,16 @@ impl WtSession {
1148
1469
  return;
1149
1470
  };
1150
1471
  st.role = Role::WtData { bidi: true };
1472
+ st.paused = true;
1151
1473
  st.class_buf.clear();
1152
1474
  }
1475
+ self.streams.get_mut(&id).unwrap().recv_prefix = (n + n2) as u64;
1476
+ if self.latest_protocol {
1477
+ let _ = conn.stream_set_reliable_reset(id, 0);
1478
+ }
1479
+ if !self.account_incoming(true, ev) || !self.account_receive(id, data.len() as u64, ev) {
1480
+ return;
1481
+ }
1153
1482
  ev.push(Ev::IncomingStream { id, bidi: true });
1154
1483
  if !data.is_empty() {
1155
1484
  ev.push(Ev::StreamData { id, data });
@@ -1162,11 +1491,45 @@ impl WtSession {
1162
1491
  }
1163
1492
  }
1164
1493
 
1165
- pub fn on_datagrams(&mut self, conn: &mut quiche::Connection, ev: &mut Vec<Ev>) {
1166
- let mut buf = [0u8; 65_536];
1167
- loop {
1494
+ /// Read reliable data before datagrams so the latter cannot starve streams.
1495
+ pub fn read_pending(
1496
+ &mut self,
1497
+ conn: &mut quiche::Connection,
1498
+ budget: &mut ReceiveBudget,
1499
+ ev: &mut Vec<Ev>,
1500
+ ) {
1501
+ if self.closed || (!self.ready && self.close_req.is_some()) || budget.exhausted() {
1502
+ return;
1503
+ }
1504
+ let mut readable: Vec<_> = conn.readable().collect();
1505
+ // Start with the remaining streams from the previous pass when a busy
1506
+ // connection exhausted the budget before reaching the end of the list.
1507
+ readable.sort_unstable();
1508
+ let start = readable.partition_point(|&id| id < self.next_read_stream);
1509
+ readable.rotate_left(start);
1510
+ for id in readable {
1511
+ self.read_stream(conn, id, budget, ev);
1512
+ if budget.exhausted() {
1513
+ self.next_read_stream = id + 1;
1514
+ return;
1515
+ }
1516
+ }
1517
+ if self.ready && !self.closed {
1518
+ self.on_datagrams(conn, budget, ev);
1519
+ }
1520
+ }
1521
+
1522
+ fn on_datagrams(
1523
+ &mut self,
1524
+ conn: &mut quiche::Connection,
1525
+ budget: &mut ReceiveBudget,
1526
+ ev: &mut Vec<Ev>,
1527
+ ) {
1528
+ let mut buf = [0u8; crate::driver::MAX_RECV_UDP_PAYLOAD];
1529
+ while !budget.exhausted() {
1168
1530
  match conn.dgram_recv(&mut buf) {
1169
1531
  Ok(n) => {
1532
+ budget.record(n);
1170
1533
  let data = &buf[..n];
1171
1534
  if let Some((qsi, off)) = h3::read_varint(data) {
1172
1535
  // quarter-stream-id for our session is CONNECT_ID / 4 = 0.
@@ -1201,6 +1564,54 @@ impl WtSession {
1201
1564
  }
1202
1565
 
1203
1566
  pub fn open_stream(&mut self, bidi: bool, request_id: u64, ev: &mut Vec<Ev>) {
1567
+ self.pending_opens.push_back((bidi, request_id));
1568
+ self.release_pending_opens(ev);
1569
+ }
1570
+
1571
+ fn uses_session_flow_control(&self) -> bool {
1572
+ self.peer_settings.is_some_and(|settings| {
1573
+ if self.latest_protocol {
1574
+ settings.wt_initial_max_data != 0
1575
+ || settings.wt_initial_max_streams_bidi != 0
1576
+ || settings.wt_initial_max_streams_uni != 0
1577
+ } else {
1578
+ settings.wt_max_sessions > 0
1579
+ }
1580
+ })
1581
+ }
1582
+
1583
+ fn release_pending_opens(&mut self, ev: &mut Vec<Ev>) {
1584
+ if !self.ready || self.closed {
1585
+ return;
1586
+ }
1587
+ let mut pending = std::mem::take(&mut self.pending_opens);
1588
+ while let Some((bidi, request_id)) = pending.pop_front() {
1589
+ let first = if self.is_server {
1590
+ if bidi {
1591
+ SERVER_FIRST_WT_BIDI_ID
1592
+ } else {
1593
+ SERVER_FIRST_WT_UNI_ID
1594
+ }
1595
+ } else if bidi {
1596
+ CLIENT_FIRST_WT_BIDI_ID
1597
+ } else {
1598
+ CLIENT_FIRST_WT_UNI_ID
1599
+ };
1600
+ let next = if bidi { self.next_bidi } else { self.next_uni };
1601
+ let limit = if bidi {
1602
+ self.fc_max_streams_bidi_remote
1603
+ } else {
1604
+ self.fc_max_streams_uni_remote
1605
+ };
1606
+ if self.uses_session_flow_control() && (next - first) / 4 >= limit {
1607
+ self.pending_opens.push_back((bidi, request_id));
1608
+ continue;
1609
+ }
1610
+ self.allocate_stream(bidi, request_id, ev);
1611
+ }
1612
+ }
1613
+
1614
+ fn allocate_stream(&mut self, bidi: bool, request_id: u64, ev: &mut Vec<Ev>) {
1204
1615
  let id = if bidi {
1205
1616
  let id = self.next_bidi;
1206
1617
  self.next_bidi += 4;
@@ -1218,19 +1629,24 @@ impl WtSession {
1218
1629
  h3::put_varint(h3::WT_UNI_STREAM_TYPE, &mut prefix);
1219
1630
  }
1220
1631
  h3::put_varint(CONNECT_ID, &mut prefix);
1221
- self.streams
1222
- .insert(id, Stream::with_prefix(Role::WtData { bidi }, prefix));
1632
+ self.streams.insert(
1633
+ id,
1634
+ Stream::with_prefix(Role::WtData { bidi }, prefix, self.parser_memory.clone()),
1635
+ );
1223
1636
  ev.push(Ev::StreamOpened { request_id, id });
1224
1637
  }
1225
1638
 
1226
1639
  pub fn stream_write(&mut self, id: u64, data: Vec<u8>, request_id: u64, ev: &mut Vec<Ev>) {
1227
1640
  match self.streams.get_mut(&id) {
1228
- Some(st) => st.out.push_back(OutChunk {
1641
+ Some(st) if !st.fin_sent && st.reset_pending.is_none() => st.out.push_back(OutChunk {
1229
1642
  data,
1230
1643
  off: 0,
1231
1644
  request_id: Some(request_id),
1232
1645
  }),
1233
- None => ev.push(Ev::WriteAck { request_id }),
1646
+ _ => ev.push(Ev::WriteAck {
1647
+ request_id,
1648
+ accepted: false,
1649
+ }),
1234
1650
  }
1235
1651
  }
1236
1652
 
@@ -1241,11 +1657,19 @@ impl WtSession {
1241
1657
  }
1242
1658
 
1243
1659
  pub fn stream_reset(&mut self, conn: &mut quiche::Connection, id: u64, code: u64) {
1660
+ let h = h3::webtransport_code_to_http_code(code);
1661
+ if self.latest_protocol {
1662
+ if let Some(st) = self.streams.get_mut(&id) {
1663
+ st.out.retain(|chunk| chunk.request_id.is_none());
1664
+ st.reset_pending.get_or_insert(h);
1665
+ }
1666
+ return;
1667
+ }
1244
1668
  if self.streams.contains_key(&id) {
1245
1669
  // The QUIC RESET_STREAM code must be the WebTransport application code
1246
1670
  // mapped into the HTTP/3 error space.
1247
- let h = h3::webtransport_code_to_http_code(code);
1248
1671
  let _ = conn.stream_shutdown(id, quiche::Shutdown::Write, h);
1672
+ self.reconcile_send_final_size(conn, id);
1249
1673
  if let Some(st) = self.streams.get_mut(&id) {
1250
1674
  st.out.clear();
1251
1675
  st.fin_sent = true;
@@ -1325,17 +1749,63 @@ impl WtSession {
1325
1749
  /// Returns an optional `(code, reason)` if the QUIC connection should now be
1326
1750
  /// closed.
1327
1751
  pub fn flush(&mut self, conn: &mut quiche::Connection, ev: &mut Vec<Ev>) {
1752
+ if let Some((code, message)) = self.terminal_error.take() {
1753
+ let _ = conn.close(true, code, &message);
1754
+ }
1328
1755
  // Once established, grant the peer ample per-session flow-control credit.
1329
1756
  // Exactly one WebTransport session rides this QUIC connection, so QUIC's
1330
1757
  // connection-level flow control is the real limit; granting a large WT
1331
1758
  // credit here keeps a strict peer that honors our advertised session
1332
1759
  // limits from stalling, while QUIC does the actual enforcement.
1333
- if self.ready && !self.fc_credit_granted && !self.closed {
1760
+ if self.ready
1761
+ && !self.fc_credit_granted
1762
+ && !self.closed
1763
+ && (!self.latest_protocol || self.uses_session_flow_control())
1764
+ {
1334
1765
  self.fc_credit_granted = true;
1766
+ self.fc_max_data_local = WT_GRANT_MAX_DATA;
1767
+ self.fc_max_streams_local = [WT_GRANT_MAX_STREAMS; 2];
1335
1768
  self.queue_session_capsule(h3::WT_MAX_DATA_CAPSULE, WT_GRANT_MAX_DATA);
1336
1769
  self.queue_session_capsule(h3::WT_MAX_STREAMS_BIDI_CAPSULE, WT_GRANT_MAX_STREAMS);
1337
1770
  self.queue_session_capsule(h3::WT_MAX_STREAMS_UNI_CAPSULE, WT_GRANT_MAX_STREAMS);
1338
1771
  }
1772
+ // Replenish cumulative credit for long-lived sessions before the peer
1773
+ // reaches the advertised limit. QUIC independently bounds buffering.
1774
+ if self.ready && self.fc_credit_granted && self.uses_session_flow_control() && !self.closed
1775
+ {
1776
+ if self.fc_max_data_local.saturating_sub(self.fc_data_received) <= WT_GRANT_MAX_DATA / 2
1777
+ {
1778
+ let limit = self
1779
+ .fc_data_received
1780
+ .saturating_add(WT_GRANT_MAX_DATA)
1781
+ .min((1 << 62) - 1);
1782
+ if limit > self.fc_max_data_local {
1783
+ self.fc_max_data_local = limit;
1784
+ self.queue_session_capsule(h3::WT_MAX_DATA_CAPSULE, limit);
1785
+ }
1786
+ }
1787
+ for direction in 0..2 {
1788
+ if self.fc_max_streams_local[direction]
1789
+ .saturating_sub(self.fc_streams_received[direction])
1790
+ <= WT_GRANT_MAX_STREAMS / 2
1791
+ {
1792
+ let limit = self.fc_streams_received[direction]
1793
+ .saturating_add(WT_GRANT_MAX_STREAMS)
1794
+ .min(1 << 60);
1795
+ if limit > self.fc_max_streams_local[direction] {
1796
+ self.fc_max_streams_local[direction] = limit;
1797
+ self.queue_session_capsule(
1798
+ if direction == 0 {
1799
+ h3::WT_MAX_STREAMS_UNI_CAPSULE
1800
+ } else {
1801
+ h3::WT_MAX_STREAMS_BIDI_CAPSULE
1802
+ },
1803
+ limit,
1804
+ );
1805
+ }
1806
+ }
1807
+ }
1808
+ }
1339
1809
  // Queue the CLOSE_WEBTRANSPORT_SESSION capsule + FIN once, if requested.
1340
1810
  if let Some(req) = self.close_req.as_mut() {
1341
1811
  if !req.capsule_queued {
@@ -1362,6 +1832,7 @@ impl WtSession {
1362
1832
  }
1363
1833
  }
1364
1834
 
1835
+ self.release_pending_opens(ev);
1365
1836
  let ids: Vec<u64> = self.streams.keys().copied().collect();
1366
1837
  let mut wt_sent = 0u64;
1367
1838
  for id in ids {
@@ -1442,18 +1913,16 @@ impl WtSession {
1442
1913
 
1443
1914
  /// Emit WT_DATA_BLOCKED / WT_STREAMS_BLOCKED_* capsules when the peer's
1444
1915
  /// advertised WebTransport limits are holding back a send, once per distinct
1445
- /// limit value. QUIC's own flow control does the real enforcement under the
1446
- /// one-session-per-connection model; this is the protocol-conformant signal
1447
- /// asking the peer to raise the limit.
1916
+ /// limit value, asking the peer to raise the limit.
1448
1917
  fn signal_flow_control_blocked(&mut self) {
1449
1918
  // Limits are only meaningful once the peer's SETTINGS have seeded them.
1450
- if self.peer_settings.is_none() || self.closed {
1919
+ if !self.uses_session_flow_control() || self.closed {
1451
1920
  return;
1452
1921
  }
1453
1922
 
1454
1923
  // Data-blocked: unsent WT stream payload while at the peer's WT_MAX_DATA.
1455
1924
  if self.fc_data_sent >= self.fc_max_data_remote
1456
- && self.data_blocked_at != self.fc_max_data_remote
1925
+ && self.data_blocked_at != Some(self.fc_max_data_remote)
1457
1926
  {
1458
1927
  let has_pending = self.streams.values().any(|s| {
1459
1928
  matches!(s.role, Role::WtData { .. })
@@ -1462,11 +1931,11 @@ impl WtSession {
1462
1931
  if has_pending {
1463
1932
  let limit = self.fc_max_data_remote;
1464
1933
  self.queue_session_capsule(h3::WT_DATA_BLOCKED_CAPSULE, limit);
1465
- self.data_blocked_at = limit;
1934
+ self.data_blocked_at = Some(limit);
1466
1935
  }
1467
1936
  }
1468
1937
 
1469
- // Streams-blocked: more streams opened in a direction than WT_MAX_STREAMS_*.
1938
+ // Streams-blocked: a requested open is waiting at WT_MAX_STREAMS_*.
1470
1939
  let (first_bidi, first_uni) = if self.is_server {
1471
1940
  (SERVER_FIRST_WT_BIDI_ID, SERVER_FIRST_WT_UNI_ID)
1472
1941
  } else {
@@ -1475,19 +1944,21 @@ impl WtSession {
1475
1944
  let opened_bidi = (self.next_bidi - first_bidi) / 4;
1476
1945
  let opened_uni = (self.next_uni - first_uni) / 4;
1477
1946
 
1478
- if opened_bidi > self.fc_max_streams_bidi_remote
1479
- && self.streams_bidi_blocked_at != self.fc_max_streams_bidi_remote
1947
+ if opened_bidi >= self.fc_max_streams_bidi_remote
1948
+ && self.pending_opens.iter().any(|(bidi, _)| *bidi)
1949
+ && self.streams_bidi_blocked_at != Some(self.fc_max_streams_bidi_remote)
1480
1950
  {
1481
1951
  let limit = self.fc_max_streams_bidi_remote;
1482
1952
  self.queue_session_capsule(h3::WT_STREAMS_BLOCKED_BIDI_CAPSULE, limit);
1483
- self.streams_bidi_blocked_at = limit;
1953
+ self.streams_bidi_blocked_at = Some(limit);
1484
1954
  }
1485
- if opened_uni > self.fc_max_streams_uni_remote
1486
- && self.streams_uni_blocked_at != self.fc_max_streams_uni_remote
1955
+ if opened_uni >= self.fc_max_streams_uni_remote
1956
+ && self.pending_opens.iter().any(|(bidi, _)| !*bidi)
1957
+ && self.streams_uni_blocked_at != Some(self.fc_max_streams_uni_remote)
1487
1958
  {
1488
1959
  let limit = self.fc_max_streams_uni_remote;
1489
1960
  self.queue_session_capsule(h3::WT_STREAMS_BLOCKED_UNI_CAPSULE, limit);
1490
- self.streams_uni_blocked_at = limit;
1961
+ self.streams_uni_blocked_at = Some(limit);
1491
1962
  }
1492
1963
  }
1493
1964
 
@@ -1498,6 +1969,8 @@ impl WtSession {
1498
1969
  ev: &mut Vec<Ev>,
1499
1970
  wt_sent: &mut u64,
1500
1971
  ) {
1972
+ self.reconcile_send_final_size(conn, id);
1973
+ let enforce = self.uses_session_flow_control();
1501
1974
  let Some(st) = self.streams.get_mut(&id) else {
1502
1975
  return;
1503
1976
  };
@@ -1505,6 +1978,17 @@ impl WtSession {
1505
1978
  // chunks) counts toward WT_MAX_DATA; the stream-signal prefix and CONNECT
1506
1979
  // capsules do not.
1507
1980
  let is_wt_data = matches!(st.role, Role::WtData { .. });
1981
+ if is_wt_data {
1982
+ if let Err(quiche::Error::StreamStopped(code)) = conn.stream_capacity(id) {
1983
+ if !st.fin_sent {
1984
+ let app = h3::http_code_to_webtransport_code(code).unwrap_or(code);
1985
+ ev.push(Ev::StreamStopSending { id, code: app });
1986
+ st.out.clear();
1987
+ st.fin_sent = true;
1988
+ }
1989
+ return;
1990
+ }
1991
+ }
1508
1992
  // Note: we call `stream_send` directly rather than pre-checking
1509
1993
  // `stream_capacity`, because a stream does not exist in quiche until its
1510
1994
  // first `stream_send`, and `stream_capacity` errors (InvalidStreamState)
@@ -1512,16 +1996,33 @@ impl WtSession {
1512
1996
  while let Some(front) = st.out.front_mut() {
1513
1997
  let remaining_len = front.data.len() - front.off;
1514
1998
  let is_payload = is_wt_data && front.request_id.is_some();
1515
- match conn.stream_send(id, &front.data[front.off..], false) {
1999
+ let allowance = self
2000
+ .fc_max_data_remote
2001
+ .saturating_sub(self.fc_data_sent.saturating_add(*wt_sent));
2002
+ let amount = if enforce && is_payload {
2003
+ remaining_len.min(allowance as usize)
2004
+ } else {
2005
+ remaining_len
2006
+ };
2007
+ if amount == 0 && remaining_len != 0 {
2008
+ return;
2009
+ }
2010
+ match conn.stream_send(id, &front.data[front.off..front.off + amount], false) {
1516
2011
  Ok(sent) => {
1517
2012
  if is_payload {
1518
2013
  *wt_sent += sent as u64;
2014
+ st.send_payload += sent as u64;
1519
2015
  }
1520
2016
  front.off += sent;
1521
2017
  if front.off >= front.data.len() {
1522
2018
  let done = st.out.pop_front().unwrap();
1523
2019
  if let Some(rid) = done.request_id {
1524
- ev.push(Ev::WriteAck { request_id: rid });
2020
+ ev.push(Ev::WriteAck {
2021
+ request_id: rid,
2022
+ accepted: true,
2023
+ });
2024
+ } else if is_wt_data && self.latest_protocol {
2025
+ let _ = conn.stream_set_reliable_reset(id, st.send_prefix);
1525
2026
  }
1526
2027
  }
1527
2028
  if sent < remaining_len {
@@ -1530,23 +2031,18 @@ impl WtSession {
1530
2031
  }
1531
2032
  Err(quiche::Error::Done) => return,
1532
2033
  Err(quiche::Error::StreamLimit) => return, // no stream credit yet; retry next loop
1533
- Err(quiche::Error::StreamStopped(code)) => {
1534
- let app = h3::http_code_to_webtransport_code(code).unwrap_or(code);
1535
- ev.push(Ev::StreamStopSending { id, code: app });
1536
- // Settle every queued write's promise so a stalled write()
1537
- // (and its WritableStream) cannot hang forever.
1538
- for chunk in st.out.drain(..) {
1539
- if let Some(rid) = chunk.request_id {
1540
- ev.push(Ev::WriteAck { request_id: rid });
1541
- }
1542
- }
1543
- st.fin_sent = true;
1544
- return;
1545
- }
1546
2034
  Err(_) => return,
1547
2035
  }
1548
2036
  }
1549
2037
 
2038
+ if let Some(code) = st.reset_pending.take() {
2039
+ let reset = conn.stream_shutdown(id, quiche::Shutdown::Write, code);
2040
+ st.fin_sent = true;
2041
+ if reset.is_ok() {
2042
+ self.reconcile_send_final_size(conn, id);
2043
+ }
2044
+ return;
2045
+ }
1550
2046
  if st.out.is_empty()
1551
2047
  && st.fin_queued
1552
2048
  && !st.fin_sent
@@ -1561,6 +2057,11 @@ impl WtSession {
1561
2057
  return;
1562
2058
  }
1563
2059
  self.closed = true;
2060
+ // Closed connections can linger during QUIC draining. Release receive
2061
+ // allocations immediately rather than tying the budget to that timer.
2062
+ self.capsule_buf.clear();
2063
+ self.streams.clear();
2064
+ self.pending_opens.clear();
1564
2065
  ev.push(Ev::Closed {
1565
2066
  code,
1566
2067
  reason,
@@ -1572,6 +2073,13 @@ impl WtSession {
1572
2073
  self.closed
1573
2074
  }
1574
2075
 
2076
+ fn parser_limit_exceeded(&mut self, ev: &mut Vec<Ev>) {
2077
+ if !self.closed {
2078
+ ev.push(Ev::Error("parser memory limit exceeded".to_string()));
2079
+ self.mark_closed(ev, 0, Vec::new(), true);
2080
+ }
2081
+ }
2082
+
1575
2083
  /// Whether a stream's HTTP/3 frame parser has latched a fatal error.
1576
2084
  fn frame_error(&self, id: u64) -> bool {
1577
2085
  self.streams
@@ -1580,14 +2088,82 @@ impl WtSession {
1580
2088
  .unwrap_or(false)
1581
2089
  }
1582
2090
 
1583
- /// Stop reading a stream and release its receive buffers (used when a stream
1584
- /// is finished, reset, or has produced a fatal protocol error), so a hostile
1585
- /// server cannot keep us draining it into an unbounded buffer.
2091
+ /// Return credit for buffered payload omitted from a reset's final size.
2092
+ fn reconcile_send_final_size(&mut self, conn: &quiche::Connection, id: u64) {
2093
+ let Some(final_size) = conn.stream_send_final_size(id) else {
2094
+ return;
2095
+ };
2096
+ let Some(st) = self.streams.get_mut(&id) else {
2097
+ return;
2098
+ };
2099
+ if !matches!(st.role, Role::WtData { .. }) {
2100
+ return;
2101
+ }
2102
+ let final_payload = final_size.saturating_sub(st.send_prefix);
2103
+ // RESET_STREAM discards bytes accepted by quiche but never serialized.
2104
+ // Those bytes are absent from the final size and consume no WT credit.
2105
+ if final_payload < st.send_payload {
2106
+ self.fc_data_sent = self
2107
+ .fc_data_sent
2108
+ .saturating_sub(st.send_payload - final_payload);
2109
+ st.send_payload = final_payload;
2110
+ }
2111
+ }
2112
+
2113
+ fn flow_error(&mut self, ev: &mut Vec<Ev>, message: &str) {
2114
+ if self.closed {
2115
+ return;
2116
+ }
2117
+ self.terminal_error = Some((0x045d4487, message.as_bytes().to_vec()));
2118
+ ev.push(Ev::Error(message.to_string()));
2119
+ self.mark_closed(ev, 0, Vec::new(), true);
2120
+ }
2121
+
2122
+ fn account_incoming(&mut self, bidi: bool, ev: &mut Vec<Ev>) -> bool {
2123
+ let direction = usize::from(bidi);
2124
+ self.fc_streams_received[direction] += 1;
2125
+ let limit = self.fc_max_streams_local[direction];
2126
+ if self.uses_session_flow_control() && self.fc_streams_received[direction] > limit {
2127
+ self.flow_error(ev, "peer exceeded the session stream limit");
2128
+ return false;
2129
+ }
2130
+ true
2131
+ }
2132
+
2133
+ fn account_receive(&mut self, id: u64, amount: u64, ev: &mut Vec<Ev>) -> bool {
2134
+ self.fc_data_received = self.fc_data_received.saturating_add(amount);
2135
+ if let Some(st) = self.streams.get_mut(&id) {
2136
+ st.recv_payload = st.recv_payload.saturating_add(amount);
2137
+ }
2138
+ let limit = self.fc_max_data_local;
2139
+ if self.uses_session_flow_control() && self.fc_data_received > limit {
2140
+ self.flow_error(ev, "peer exceeded the session data limit");
2141
+ return false;
2142
+ }
2143
+ true
2144
+ }
2145
+
2146
+ fn protocol_error(
2147
+ &mut self,
2148
+ conn: &mut quiche::Connection,
2149
+ ev: &mut Vec<Ev>,
2150
+ code: u64,
2151
+ message: &str,
2152
+ ) {
2153
+ if self.closed {
2154
+ return;
2155
+ }
2156
+ ev.push(Ev::Error(message.to_string()));
2157
+ self.mark_closed(ev, 0, Vec::new(), true);
2158
+ let _ = conn.close(true, code, message.as_bytes());
2159
+ }
2160
+
2161
+ /// Stop reading and release parser buffers after a fatal stream error.
1586
2162
  fn kill_recv(&mut self, conn: &mut quiche::Connection, id: u64) {
1587
2163
  if let Some(st) = self.streams.get_mut(&id) {
1588
2164
  st.recv_dead = true;
1589
- st.frames.buf = Vec::new();
1590
- st.class_buf = Vec::new();
2165
+ st.frames.buf.clear();
2166
+ st.class_buf.clear();
1591
2167
  }
1592
2168
  let _ = conn.stream_shutdown(id, quiche::Shutdown::Read, 0);
1593
2169
  }
@@ -1599,6 +2175,7 @@ fn role_name(role: Role) -> &'static str {
1599
2175
  Role::Connect => "Connect",
1600
2176
  Role::PeerControl => "PeerControl",
1601
2177
  Role::Ignored => "Ignored",
2178
+ Role::PeerQpack { .. } => "PeerQpack",
1602
2179
  Role::WtData { .. } => "WtData",
1603
2180
  Role::PendingUni => "PendingUni",
1604
2181
  Role::PendingBidi => "PendingBidi",
@@ -1637,12 +2214,532 @@ fn classify_new(id: u64, is_server: bool) -> Role {
1637
2214
  mod tests {
1638
2215
  use super::*;
1639
2216
 
2217
+ fn established_server(
2218
+ settings: Vec<u8>,
2219
+ ) -> (quiche::Connection, quiche::Connection, WtSession) {
2220
+ let (mut client, mut server) =
2221
+ crate::test_support::pair(None, Some("wrong.example"), false);
2222
+ crate::test_support::exchange(&mut client, &mut server);
2223
+ assert!(server.is_established());
2224
+ let mut session = server_with_connect(ParserMemory::new(64 * 1024 * 1024));
2225
+ session.ready = false;
2226
+ session.peer_settings = None;
2227
+ session.on_established(false);
2228
+ let mut control = vec![0];
2229
+ control.extend_from_slice(&h3::frame(h3::FRAME_SETTINGS, &settings));
2230
+ client.stream_send(2, &control, false).unwrap();
2231
+ let headers = h3::connect_headers("wrong.example", "/", None, &[], &[]);
2232
+ client
2233
+ .stream_send(0, &h3::encode_headers_frame(&headers).unwrap(), false)
2234
+ .unwrap();
2235
+ crate::test_support::exchange(&mut client, &mut server);
2236
+ let mut events = Vec::new();
2237
+ // Exercise out-of-order arrival: CONNECT must wait for SETTINGS.
2238
+ session.on_readable(&mut server, 0, &mut events);
2239
+ assert!(!session.ready);
2240
+ session.on_readable(&mut server, 2, &mut events);
2241
+ assert!(session.ready);
2242
+ (client, server, session)
2243
+ }
2244
+
2245
+ fn capsule(ty: u64, value: u64) -> Vec<u8> {
2246
+ let mut body = Vec::new();
2247
+ h3::put_varint(value, &mut body);
2248
+ let mut out = Vec::new();
2249
+ h3::put_varint(ty, &mut out);
2250
+ h3::put_varint(body.len() as u64, &mut out);
2251
+ out.extend_from_slice(&body);
2252
+ out
2253
+ }
2254
+
2255
+ #[test]
2256
+ fn resetting_unsent_data_restores_session_send_credit() {
2257
+ let (_, mut conn, mut session) = established_server(h3::settings_payload());
2258
+ session.fc_max_data_remote = 8;
2259
+ session.open_stream(false, 1, &mut Vec::new());
2260
+ let id = SERVER_FIRST_WT_UNI_ID;
2261
+ session.stream_write(id, vec![1; 8], 2, &mut Vec::new());
2262
+ session.flush(&mut conn, &mut Vec::new());
2263
+ assert_eq!(session.fc_data_sent, 8);
2264
+ // Reset before conn.send serializes any of this stream's bytes.
2265
+ session.stream_reset(&mut conn, id, 0);
2266
+ assert_eq!(session.fc_data_sent, 0);
2267
+ }
2268
+
2269
+ #[test]
2270
+ fn reset_final_size_consumes_session_credit_without_delivered_payload() {
2271
+ let (mut client, mut server, mut session) = established_server(h3::settings_payload());
2272
+ let mut prefix = Vec::new();
2273
+ h3::put_varint(h3::WT_UNI_STREAM_TYPE, &mut prefix);
2274
+ h3::put_varint(0, &mut prefix);
2275
+ client.stream_send(14, &prefix, false).unwrap();
2276
+ crate::test_support::exchange(&mut client, &mut server);
2277
+ session.on_readable(&mut server, 14, &mut Vec::new());
2278
+ client.stream_send(14, &[5; 8192], false).unwrap();
2279
+ // Serialize the bytes into QUIC without delivering them to the app.
2280
+ crate::test_support::exchange(&mut client, &mut server);
2281
+ client
2282
+ .stream_shutdown(14, quiche::Shutdown::Write, 0)
2283
+ .unwrap();
2284
+ crate::test_support::exchange(&mut client, &mut server);
2285
+ let mut events = Vec::new();
2286
+ session.on_readable(&mut server, 14, &mut events);
2287
+ assert_eq!(session.fc_data_received, 8192);
2288
+ assert!(events
2289
+ .iter()
2290
+ .any(|e| matches!(e, Ev::StreamReset { id: 14, .. })));
2291
+ assert!(!events.iter().any(|e| matches!(e, Ev::StreamData { .. })));
2292
+ }
2293
+
2294
+ #[test]
2295
+ fn peer_exceeding_advertised_data_or_stream_credit_is_terminal() {
2296
+ for data_limit in [false, true] {
2297
+ let (mut client, mut server, mut session) = established_server(h3::settings_payload());
2298
+ if data_limit {
2299
+ session.fc_data_received = session.fc_max_data_local;
2300
+ } else {
2301
+ session.fc_streams_received[0] = session.fc_max_streams_local[0];
2302
+ }
2303
+ let mut stream = Vec::new();
2304
+ h3::put_varint(h3::WT_UNI_STREAM_TYPE, &mut stream);
2305
+ h3::put_varint(0, &mut stream);
2306
+ stream.push(1);
2307
+ client.stream_send(14, &stream, true).unwrap();
2308
+ crate::test_support::exchange(&mut client, &mut server);
2309
+ let mut events = Vec::new();
2310
+ session.on_readable(&mut server, 14, &mut events);
2311
+ assert!(session.closed);
2312
+ assert!(!events.iter().any(|e| matches!(e, Ev::StreamData { .. })));
2313
+ if !data_limit {
2314
+ assert!(!events
2315
+ .iter()
2316
+ .any(|e| matches!(e, Ev::IncomingStream { .. })));
2317
+ }
2318
+ }
2319
+ }
2320
+
2321
+ #[test]
2322
+ fn new_uni_and_bidi_streams_wait_for_global_read_backpressure_to_clear() {
2323
+ for bidi in [false, true] {
2324
+ let (mut client, mut server, mut session) = established_server(h3::settings_payload());
2325
+ let mut prefix = Vec::new();
2326
+ h3::put_varint(
2327
+ if bidi {
2328
+ h3::WT_BIDI_FRAME_TYPE
2329
+ } else {
2330
+ h3::WT_UNI_STREAM_TYPE
2331
+ },
2332
+ &mut prefix,
2333
+ );
2334
+ h3::put_varint(0, &mut prefix);
2335
+ prefix.extend_from_slice(&[9; 1024]);
2336
+ let mut events = Vec::new();
2337
+ for i in 0..20 {
2338
+ let id = if bidi { 4 + i * 4 } else { 14 + i * 4 };
2339
+ client.stream_send(id, &prefix, true).unwrap();
2340
+ crate::test_support::exchange(&mut client, &mut server);
2341
+ session.read_pending(&mut server, &mut ReceiveBudget::blocked(), &mut events);
2342
+ session.flush(&mut server, &mut Vec::new());
2343
+ crate::test_support::exchange(&mut client, &mut server);
2344
+ }
2345
+ assert!(
2346
+ events.is_empty(),
2347
+ "application events leaked while backpressured"
2348
+ );
2349
+ session.read_pending(&mut server, &mut ReceiveBudget::new(), &mut events);
2350
+ assert!(!events.iter().any(|e| matches!(e, Ev::StreamData { .. })));
2351
+ for i in 0..20 {
2352
+ let id = if bidi { 4 + i * 4 } else { 14 + i * 4 };
2353
+ session.set_paused(id, false);
2354
+ }
2355
+ session.read_pending(&mut server, &mut ReceiveBudget::new(), &mut events);
2356
+ let bytes: usize = events
2357
+ .iter()
2358
+ .filter_map(|e| match e {
2359
+ Ev::StreamData { data, .. } => Some(data.len()),
2360
+ _ => None,
2361
+ })
2362
+ .sum();
2363
+ assert_eq!(bytes, 20 * 1024);
2364
+ assert_eq!(
2365
+ events
2366
+ .iter()
2367
+ .filter(|e| matches!(e, Ev::IncomingStream { .. }))
2368
+ .count(),
2369
+ 20
2370
+ );
2371
+ assert_eq!(
2372
+ events
2373
+ .iter()
2374
+ .filter(|e| matches!(e, Ev::StreamFinished { .. }))
2375
+ .count(),
2376
+ 20
2377
+ );
2378
+ }
2379
+ }
2380
+
2381
+ #[test]
2382
+ fn zero_session_credit_blocks_opens_and_writes_until_capsules_raise_limits() {
2383
+ let mut settings = Vec::new();
2384
+ for (id, value) in [
2385
+ (h3::SETTINGS_ENABLE_CONNECT_PROTOCOL, 1),
2386
+ (h3::SETTINGS_H3_DATAGRAM, 1),
2387
+ (h3::SETTINGS_WT_MAX_SESSIONS, 1),
2388
+ ] {
2389
+ h3::put_varint(id, &mut settings);
2390
+ h3::put_varint(value, &mut settings);
2391
+ }
2392
+ let (mut client, mut server, mut session) = established_server(settings);
2393
+ let mut events = Vec::new();
2394
+ session.open_stream(false, 11, &mut events);
2395
+ session.open_stream(true, 12, &mut events);
2396
+ session.flush(&mut server, &mut events);
2397
+ assert!(!events.iter().any(|e| matches!(e, Ev::StreamOpened { .. })));
2398
+ assert_eq!(session.pending_opens.len(), 2);
2399
+ session.scan_capsules(&capsule(h3::WT_MAX_STREAMS_UNI_CAPSULE, 1), &mut events);
2400
+ session.flush(&mut server, &mut events);
2401
+ let id = events
2402
+ .iter()
2403
+ .find_map(|e| match e {
2404
+ Ev::StreamOpened { request_id: 11, id } => Some(*id),
2405
+ _ => None,
2406
+ })
2407
+ .unwrap();
2408
+ assert!(!events
2409
+ .iter()
2410
+ .any(|e| matches!(e, Ev::StreamOpened { request_id: 12, .. })));
2411
+ session.stream_write(id, vec![7; 8], 13, &mut events);
2412
+ session.stream_fin(id);
2413
+ session.flush(&mut server, &mut events);
2414
+ crate::test_support::exchange(&mut client, &mut server);
2415
+ let mut buf = [0; 100];
2416
+ let (n, fin) = client.stream_recv(id, &mut buf).unwrap();
2417
+ assert_eq!(n, 3); // stream type and session ID, no payload
2418
+ assert!(!fin);
2419
+ assert_eq!(session.fc_data_sent, 0);
2420
+ session.scan_capsules(&capsule(h3::WT_MAX_DATA_CAPSULE, 3), &mut events);
2421
+ session.flush(&mut server, &mut events);
2422
+ crate::test_support::exchange(&mut client, &mut server);
2423
+ let (n, fin) = client.stream_recv(id, &mut buf).unwrap();
2424
+ assert_eq!(&buf[..n], &[7; 3]);
2425
+ assert!(!fin);
2426
+ assert!(!events
2427
+ .iter()
2428
+ .any(|e| matches!(e, Ev::WriteAck { request_id: 13, .. })));
2429
+ session.scan_capsules(&capsule(h3::WT_MAX_DATA_CAPSULE, 8), &mut events);
2430
+ session.scan_capsules(&capsule(h3::WT_MAX_STREAMS_BIDI_CAPSULE, 1), &mut events);
2431
+ session.flush(&mut server, &mut events);
2432
+ crate::test_support::exchange(&mut client, &mut server);
2433
+ let (n, fin) = client.stream_recv(id, &mut buf).unwrap();
2434
+ assert_eq!(&buf[..n], &[7; 5]);
2435
+ assert!(fin);
2436
+ assert_eq!(session.fc_data_sent, 8);
2437
+ assert_eq!(
2438
+ events
2439
+ .iter()
2440
+ .filter(|e| matches!(
2441
+ e,
2442
+ Ev::WriteAck {
2443
+ request_id: 13,
2444
+ accepted: true
2445
+ }
2446
+ ))
2447
+ .count(),
2448
+ 1
2449
+ );
2450
+ assert!(events
2451
+ .iter()
2452
+ .any(|e| matches!(e, Ev::StreamOpened { request_id: 12, .. })));
2453
+ }
2454
+
2455
+ #[test]
2456
+ fn session_credit_rejects_non_increasing_oversized_and_truncated_values() {
2457
+ for bytes in [
2458
+ capsule(h3::WT_MAX_DATA_CAPSULE, 0),
2459
+ capsule(h3::WT_MAX_STREAMS_UNI_CAPSULE, (1 << 60) + 1),
2460
+ capsule(h3::WT_STREAMS_BLOCKED_BIDI_CAPSULE, (1 << 60) + 1),
2461
+ vec![0x99, 0x0b, 0x4d, 0x3d, 1, 0x40],
2462
+ ] {
2463
+ let mut session = client_with_connect();
2464
+ session.scan_capsules(&bytes, &mut Vec::new());
2465
+ assert!(session.closed);
2466
+ }
2467
+ }
2468
+
2469
+ #[test]
2470
+ fn critical_streams_reject_fin_duplicates_and_settings_order_errors() {
2471
+ for (first, second, fin) in [
2472
+ (h3::control_stream_prefix(), None, true),
2473
+ (
2474
+ h3::control_stream_prefix(),
2475
+ Some(h3::frame(h3::FRAME_SETTINGS, &h3::settings_payload())),
2476
+ false,
2477
+ ),
2478
+ (vec![0, 0, 0], None, false),
2479
+ (vec![2], None, true),
2480
+ (vec![3], None, true),
2481
+ ] {
2482
+ let mut session = server_with_connect(ParserMemory::new(4096));
2483
+ session.streams.insert(
2484
+ 2,
2485
+ Stream::new(Role::PendingUni, session.parser_memory.clone()),
2486
+ );
2487
+ let mut conn = connection();
2488
+ let mut events = Vec::new();
2489
+ session.process_recv(&mut conn, 2, first, fin, &mut events);
2490
+ if let Some(second) = second {
2491
+ session.process_recv(&mut conn, 2, second, false, &mut events);
2492
+ }
2493
+ assert!(session.closed);
2494
+ assert!(events.iter().any(|e| matches!(e, Ev::Error(_))));
2495
+ }
2496
+ let mut session = server_with_connect(ParserMemory::new(4096));
2497
+ let mut conn = connection();
2498
+ for id in [2, 6] {
2499
+ session.streams.insert(
2500
+ id,
2501
+ Stream::new(Role::PendingUni, session.parser_memory.clone()),
2502
+ );
2503
+ session.process_recv(
2504
+ &mut conn,
2505
+ id,
2506
+ h3::control_stream_prefix(),
2507
+ false,
2508
+ &mut Vec::new(),
2509
+ );
2510
+ }
2511
+ assert!(session.closed);
2512
+ }
2513
+
2514
+ #[test]
2515
+ fn peer_reset_of_critical_stream_is_terminal() {
2516
+ let (mut client, mut server, mut session) = established_server(h3::settings_payload());
2517
+ client
2518
+ .stream_shutdown(2, quiche::Shutdown::Write, 0)
2519
+ .unwrap();
2520
+ crate::test_support::exchange(&mut client, &mut server);
2521
+ let mut events = Vec::new();
2522
+ session.on_readable(&mut server, 2, &mut events);
2523
+ assert!(session.closed);
2524
+ assert!(events
2525
+ .iter()
2526
+ .any(|e| matches!(e, Ev::Error(message) if message.contains("critical"))));
2527
+ }
2528
+
2529
+ #[test]
2530
+ fn unoffered_response_protocol_rejects_the_session() {
2531
+ let mut session = client_with_connect();
2532
+ session.ready = false;
2533
+ session.protocols = vec!["offered".into()];
2534
+ let frame = h3::encode_headers_frame(&[
2535
+ quiche::h3::Header::new(b":status", b"200"),
2536
+ quiche::h3::Header::new(h3::WT_PROTOCOL, b"\"unoffered\""),
2537
+ ])
2538
+ .unwrap();
2539
+ let mut events = Vec::new();
2540
+ session.process_recv(&mut connection(), CONNECT_ID, frame, false, &mut events);
2541
+ assert!(session.closed);
2542
+ assert!(!events.iter().any(|e| matches!(e, Ev::Ready { .. })));
2543
+ }
2544
+
2545
+ #[test]
2546
+ fn complete_capsules_release_retained_storage() {
2547
+ let mut session = client_with_connect();
2548
+ let mut capsule = Vec::new();
2549
+ h3::put_varint(0x42, &mut capsule);
2550
+ h3::put_varint(512 * 1024, &mut capsule);
2551
+ capsule.resize(capsule.len() + 512 * 1024, 0);
2552
+ session.scan_capsules(&capsule, &mut Vec::new());
2553
+ assert_eq!(session.capsule_buf.capacity(), 0);
2554
+ }
2555
+
2556
+ #[test]
2557
+ fn aggregate_incomplete_capsules_are_bounded() {
2558
+ let memory = ParserMemory::new(64 * 1024 * 1024);
2559
+ let mut sessions = Vec::new();
2560
+ let mut fragment = Vec::new();
2561
+ h3::put_varint(0x42, &mut fragment);
2562
+ h3::put_varint(MAX_CONTROL_FRAME as u64, &mut fragment);
2563
+ fragment.resize(512 * 1024, 0);
2564
+ for _ in 0..160 {
2565
+ let mut session = server_with_connect(memory.clone());
2566
+ session.scan_capsules(&fragment, &mut Vec::new());
2567
+ sessions.push(session);
2568
+ }
2569
+ let retained: usize = sessions.iter().map(|s| s.capsule_buf.capacity()).sum();
2570
+ assert!(
2571
+ retained <= 64 * 1024 * 1024,
2572
+ "retained {retained} parser bytes"
2573
+ );
2574
+ assert_eq!(memory.used(), retained);
2575
+ assert!(sessions.iter().any(WtSession::is_closed));
2576
+ assert!(sessions.iter().any(|s| !s.is_closed()));
2577
+ drop(sessions);
2578
+ assert_eq!(memory.used(), 0);
2579
+ }
2580
+
2581
+ #[test]
2582
+ fn equal_byte_complete_capsules_do_not_accumulate_across_sessions() {
2583
+ let memory = ParserMemory::new(4 * 1024 * 1024);
2584
+ let mut sessions = Vec::new();
2585
+ let mut capsule = Vec::new();
2586
+ h3::put_varint(0x42, &mut capsule);
2587
+ h3::put_varint(512 * 1024 - 6, &mut capsule);
2588
+ capsule.resize(512 * 1024, 0);
2589
+ for _ in 0..160 {
2590
+ let mut session = server_with_connect(memory.clone());
2591
+ session.scan_capsules(&capsule, &mut Vec::new());
2592
+ assert!(!session.is_closed());
2593
+ assert_eq!(memory.used(), 0);
2594
+ sessions.push(session);
2595
+ }
2596
+ }
2597
+
2598
+ fn connection() -> quiche::Connection {
2599
+ let mut config = quiche::Config::new(quiche::PROTOCOL_VERSION).unwrap();
2600
+ config.set_application_protos(&[b"h3"]).unwrap();
2601
+ quiche::connect(
2602
+ Some("localhost"),
2603
+ &quiche::ConnectionId::from_ref(&[0; 16]),
2604
+ "127.0.0.1:1234".parse().unwrap(),
2605
+ "127.0.0.1:4433".parse().unwrap(),
2606
+ &mut config,
2607
+ )
2608
+ .unwrap()
2609
+ }
2610
+
2611
+ #[test]
2612
+ fn fragmented_capsule_reassembles_across_data_frames_and_releases_budget() {
2613
+ let memory = ParserMemory::new(4096);
2614
+ let mut session = server_with_connect(memory.clone());
2615
+ let mut capsule = Vec::new();
2616
+ h3::put_varint(h3::WT_DRAIN_SESSION_CAPSULE, &mut capsule);
2617
+ h3::put_varint(0, &mut capsule);
2618
+ let mut conn = connection();
2619
+ let mut events = Vec::new();
2620
+ for byte in capsule {
2621
+ let frame = h3::frame(h3::FRAME_DATA, &[byte]);
2622
+ // Also split the HTTP/3 frame header across QUIC reads.
2623
+ for byte in frame {
2624
+ session.process_recv(&mut conn, CONNECT_ID, vec![byte], false, &mut events);
2625
+ }
2626
+ }
2627
+ assert_eq!(
2628
+ events.iter().filter(|e| matches!(e, Ev::Draining)).count(),
2629
+ 1
2630
+ );
2631
+ assert!(!session.is_closed());
2632
+ assert_eq!(memory.used(), 0);
2633
+ }
2634
+
2635
+ #[test]
2636
+ fn budget_failure_releases_all_offender_buffers_and_preserves_other_sessions() {
2637
+ let memory = ParserMemory::new(4096);
2638
+ let mut healthy = server_with_connect(memory.clone());
2639
+ healthy
2640
+ .streams
2641
+ .get_mut(&CONNECT_ID)
2642
+ .unwrap()
2643
+ .frames
2644
+ .push(&[0; 1000]);
2645
+ let mut offender = server_with_connect(memory.clone());
2646
+ let mut fragment = Vec::new();
2647
+ h3::put_varint(0x42, &mut fragment);
2648
+ h3::put_varint(MAX_CONTROL_FRAME as u64, &mut fragment);
2649
+ fragment.resize(1500, 0);
2650
+ offender.scan_capsules(&fragment, &mut Vec::new());
2651
+ offender
2652
+ .streams
2653
+ .get_mut(&CONNECT_ID)
2654
+ .unwrap()
2655
+ .class_buf
2656
+ .extend_from_slice(&[0; 500])
2657
+ .unwrap();
2658
+ assert_eq!(memory.used(), 1024 + 2048 + 512);
2659
+ let mut events = Vec::new();
2660
+ offender.scan_capsules(&[0; 2048], &mut events);
2661
+ assert!(offender.is_closed());
2662
+ assert!(events
2663
+ .iter()
2664
+ .any(|e| matches!(e, Ev::Error(message) if message.contains("memory limit"))));
2665
+ assert_eq!(memory.used(), 1024);
2666
+ assert!(!healthy.is_closed());
2667
+ let mut replacement = server_with_connect(memory.clone());
2668
+ replacement.scan_capsules(&[0x00, 0x00], &mut Vec::new());
2669
+ assert!(!replacement.is_closed());
2670
+ assert_eq!(memory.used(), 1024);
2671
+ healthy.mark_closed(&mut Vec::new(), 0, Vec::new(), false);
2672
+ assert_eq!(memory.used(), 0);
2673
+ }
2674
+
2675
+ #[test]
2676
+ fn initial_control_chunk_budget_failure_is_terminal() {
2677
+ let memory = ParserMemory::new(64);
2678
+ let mut session = server_with_connect(memory.clone());
2679
+ session.streams.insert(
2680
+ 2,
2681
+ Stream::new(Role::PendingUni, session.parser_memory.clone()),
2682
+ );
2683
+ let mut conn = connection();
2684
+ let mut events = Vec::new();
2685
+ session.process_recv(&mut conn, 2, vec![0; 65], false, &mut events);
2686
+ assert!(session.is_closed());
2687
+ assert_eq!(memory.used(), 0);
2688
+ }
2689
+
2690
+ #[test]
2691
+ fn oversized_lengths_are_rejected_without_truncation() {
2692
+ let memory = ParserMemory::new(4096);
2693
+ let mut session = server_with_connect(memory.clone());
2694
+ let mut header = Vec::new();
2695
+ h3::put_varint(0x42, &mut header);
2696
+ h3::put_varint(1 << 40, &mut header);
2697
+ session.scan_capsules(&header, &mut Vec::new());
2698
+ assert!(session.is_closed());
2699
+ assert_eq!(memory.used(), 0);
2700
+ let mut frames = FrameParser::new(memory.clone());
2701
+ frames.push(&header);
2702
+ assert!(frames.next_frame().is_none());
2703
+ assert!(frames.error);
2704
+ drop(frames);
2705
+ assert_eq!(memory.used(), 0);
2706
+ }
2707
+
2708
+ fn server_with_connect(memory: Arc<ParserMemory>) -> WtSession {
2709
+ let mut s = WtSession::new_server(
2710
+ "127.0.0.1:4433".parse().unwrap(),
2711
+ Vec::new(),
2712
+ None,
2713
+ Vec::new(),
2714
+ memory,
2715
+ );
2716
+ s.streams.insert(
2717
+ CONNECT_ID,
2718
+ Stream::new(Role::Connect, s.parser_memory.clone()),
2719
+ );
2720
+ s.ready = true;
2721
+ s.peer_settings = Some(h3::PeerSettings {
2722
+ enable_connect_protocol: true,
2723
+ h3_datagram: true,
2724
+ wt_max_sessions: 1,
2725
+ ..Default::default()
2726
+ });
2727
+ s
2728
+ }
2729
+
1640
2730
  /// A minimal established-looking client session with a CONNECT stream (so
1641
2731
  /// queued session capsules have somewhere to go) and seeded peer settings.
1642
2732
  fn client_with_connect() -> WtSession {
1643
2733
  let mut s = WtSession::new_client("h".into(), "/".into(), None, Vec::new(), Vec::new());
1644
- s.streams.insert(CONNECT_ID, Stream::new(Role::Connect));
1645
- s.peer_settings = Some(h3::PeerSettings::default());
2734
+ s.streams.insert(
2735
+ CONNECT_ID,
2736
+ Stream::new(Role::Connect, s.parser_memory.clone()),
2737
+ );
2738
+ s.peer_settings = Some(h3::PeerSettings {
2739
+ wt_max_sessions: 1,
2740
+ ..Default::default()
2741
+ });
2742
+ s.ready = true;
1646
2743
  s
1647
2744
  }
1648
2745
 
@@ -1658,7 +2755,7 @@ mod tests {
1658
2755
  let mut s = client_with_connect();
1659
2756
  s.fc_max_data_remote = 100;
1660
2757
  s.fc_data_sent = 100;
1661
- let mut st = Stream::new(Role::WtData { bidi: true });
2758
+ let mut st = Stream::new(Role::WtData { bidi: true }, s.parser_memory.clone());
1662
2759
  st.out.push_back(OutChunk {
1663
2760
  data: vec![1, 2, 3],
1664
2761
  off: 0,
@@ -1684,7 +2781,7 @@ mod tests {
1684
2781
  s.fc_max_data_remote = 100;
1685
2782
  s.fc_data_sent = 100;
1686
2783
  // A WtData stream whose only queued chunk is the prefix (request_id None).
1687
- let mut st = Stream::new(Role::WtData { bidi: false });
2784
+ let mut st = Stream::new(Role::WtData { bidi: false }, s.parser_memory.clone());
1688
2785
  st.out.push_back(OutChunk {
1689
2786
  data: vec![0x54],
1690
2787
  off: 0,
@@ -1700,7 +2797,8 @@ mod tests {
1700
2797
  let mut s = client_with_connect();
1701
2798
  s.fc_max_streams_bidi_remote = 1;
1702
2799
  // Simulate having opened 2 bidi WT streams (next_bidi advanced twice).
1703
- s.next_bidi = CLIENT_FIRST_WT_BIDI_ID + 8;
2800
+ s.next_bidi = CLIENT_FIRST_WT_BIDI_ID + 4;
2801
+ s.pending_opens.push_back((true, 99));
1704
2802
  s.signal_flow_control_blocked();
1705
2803
  assert_eq!(connect_out_len(&s), 1); // WT_STREAMS_BLOCKED_BIDI
1706
2804
  s.signal_flow_control_blocked();