rwebtransport 0.2.3 → 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 (96) hide show
  1. package/Cargo.lock +153 -226
  2. package/Cargo.toml +5 -5
  3. package/README.md +4 -4
  4. package/crates/echo-server/src/bin/gen-test-cert.rs +1 -1
  5. package/crates/native/Cargo.toml +1 -1
  6. package/crates/native/src/config.rs +13 -1
  7. package/crates/native/src/driver.rs +249 -91
  8. package/crates/native/src/lib.rs +9 -10
  9. package/crates/native/src/parser_memory.rs +1 -0
  10. package/crates/native/src/server.rs +197 -182
  11. package/crates/native/src/session.rs +329 -177
  12. package/crates/native/src/test_support.rs +2 -2
  13. package/crates/wtcore/src/h3.rs +166 -10
  14. package/dist/index.js +92 -45
  15. package/dist/index.js.map +2 -2
  16. package/dist/index.mjs +92 -45
  17. package/dist/index.mjs.map +2 -2
  18. package/dist/native.d.ts +9 -4
  19. package/package.json +14 -11
  20. package/prebuilds/darwin-arm64/rwebtransport.node +0 -0
  21. package/prebuilds/linux-arm64/rwebtransport.node +0 -0
  22. package/prebuilds/linux-x64/rwebtransport.node +0 -0
  23. package/prebuilds/win32-x64/rwebtransport.node +0 -0
  24. package/scripts/build-linux-prebuilt.sh +46 -0
  25. package/scripts/build.js +10 -3
  26. package/vendor/quiche/AGENTS.md +10 -0
  27. package/vendor/quiche/Cargo.lock +239 -248
  28. package/vendor/quiche/Cargo.toml +23 -10
  29. package/vendor/quiche/examples/Makefile +4 -4
  30. package/vendor/quiche/examples/client.rs +10 -28
  31. package/vendor/quiche/examples/http3-client.rs +20 -34
  32. package/vendor/quiche/examples/http3-server.rs +47 -78
  33. package/vendor/quiche/examples/server.rs +19 -49
  34. package/vendor/quiche/include/quiche.h +35 -4
  35. package/vendor/quiche/src/build.rs +17 -0
  36. package/vendor/quiche/src/cid.rs +129 -61
  37. package/vendor/quiche/src/crypto/boringssl.rs +98 -86
  38. package/vendor/quiche/src/crypto/mod.rs +64 -77
  39. package/vendor/quiche/src/dgram.rs +2 -3
  40. package/vendor/quiche/src/error.rs +22 -20
  41. package/vendor/quiche/src/ffi.rs +558 -280
  42. package/vendor/quiche/src/flowcontrol.rs +0 -7
  43. package/vendor/quiche/src/frame.rs +134 -135
  44. package/vendor/quiche/src/h3/ffi.rs +73 -60
  45. package/vendor/quiche/src/h3/frame.rs +70 -90
  46. package/vendor/quiche/src/h3/mod.rs +1024 -593
  47. package/vendor/quiche/src/h3/qpack/decoder.rs +248 -34
  48. package/vendor/quiche/src/h3/qpack/dynamic_table.rs +859 -0
  49. package/vendor/quiche/src/h3/qpack/encoder.rs +14 -17
  50. package/vendor/quiche/src/h3/qpack/mod.rs +48 -0
  51. package/vendor/quiche/src/h3/qpack/static_table.rs +86 -73
  52. package/vendor/quiche/src/h3/stream.rs +1009 -194
  53. package/vendor/quiche/src/lib.rs +1346 -1195
  54. package/vendor/quiche/src/minmax.rs +2 -6
  55. package/vendor/quiche/src/packet.rs +420 -552
  56. package/vendor/quiche/src/path.rs +202 -72
  57. package/vendor/quiche/src/pmtud.rs +18 -16
  58. package/vendor/quiche/src/ranges.rs +184 -82
  59. package/vendor/quiche/src/recovery/AGENTS.md +5 -2
  60. package/vendor/quiche/src/recovery/bandwidth.rs +59 -40
  61. package/vendor/quiche/src/recovery/bytes_in_flight.rs +2 -2
  62. package/vendor/quiche/src/recovery/congestion/cubic.rs +38 -47
  63. package/vendor/quiche/src/recovery/congestion/delivery_rate.rs +54 -60
  64. package/vendor/quiche/src/recovery/congestion/hystart.rs +6 -10
  65. package/vendor/quiche/src/recovery/congestion/mod.rs +110 -42
  66. package/vendor/quiche/src/recovery/congestion/prr.rs +4 -1
  67. package/vendor/quiche/src/recovery/congestion/recovery.rs +91 -95
  68. package/vendor/quiche/src/recovery/congestion/reno.rs +17 -12
  69. package/vendor/quiche/src/recovery/congestion/test_sender.rs +8 -27
  70. package/vendor/quiche/src/recovery/gcongestion/bbr/bandwidth_sampler.rs +159 -247
  71. package/vendor/quiche/src/recovery/gcongestion/bbr/windowed_filter.rs +9 -14
  72. package/vendor/quiche/src/recovery/gcongestion/bbr2/drain.rs +18 -15
  73. package/vendor/quiche/src/recovery/gcongestion/bbr2/mode.rs +43 -28
  74. package/vendor/quiche/src/recovery/gcongestion/bbr2/network_model.rs +349 -76
  75. package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_bw.rs +147 -195
  76. package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_rtt.rs +29 -27
  77. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min.rs +180 -0
  78. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min_tests.rs +221 -0
  79. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm.rs +395 -0
  80. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm_tests.rs +473 -0
  81. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/mod.rs +175 -0
  82. package/vendor/quiche/src/recovery/gcongestion/bbr2/startup.rs +33 -26
  83. package/vendor/quiche/src/recovery/gcongestion/bbr2.rs +107 -60
  84. package/vendor/quiche/src/recovery/gcongestion/mod.rs +64 -11
  85. package/vendor/quiche/src/recovery/gcongestion/pacer.rs +34 -25
  86. package/vendor/quiche/src/recovery/gcongestion/recovery.rs +81 -86
  87. package/vendor/quiche/src/recovery/mod.rs +414 -173
  88. package/vendor/quiche/src/recovery/rtt.rs +8 -5
  89. package/vendor/quiche/src/stream/mod.rs +864 -133
  90. package/vendor/quiche/src/stream/recv_buf.rs +471 -172
  91. package/vendor/quiche/src/stream/send_buf.rs +338 -81
  92. package/vendor/quiche/src/test_utils.rs +78 -64
  93. package/vendor/quiche/src/tests.rs +2559 -1335
  94. package/vendor/quiche/src/tls/boringssl.rs +60 -63
  95. package/vendor/quiche/src/tls/mod.rs +146 -193
  96. package/vendor/quiche/src/transport_params.rs +87 -103
@@ -24,6 +24,8 @@
24
24
  // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25
25
  // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
26
 
27
+ use std::mem::MaybeUninit;
28
+
27
29
  use crate::buffers::BufFactory;
28
30
 
29
31
  use super::Error;
@@ -37,7 +39,7 @@ pub const QPACK_ENCODER_STREAM_TYPE_ID: u64 = 0x2;
37
39
  pub const QPACK_DECODER_STREAM_TYPE_ID: u64 = 0x3;
38
40
 
39
41
  const MAX_STATE_BUF_SIZE: usize = (1 << 24) - 1;
40
-
42
+ const MAX_STATE_BUF_ALLOC_SIZE: usize = 4096;
41
43
  #[derive(Clone, Copy, Debug, PartialEq, Eq)]
42
44
  pub enum Type {
43
45
  Control,
@@ -85,6 +87,9 @@ pub enum State {
85
87
  /// Reading a QPACK instruction.
86
88
  QpackInstruction,
87
89
 
90
+ /// Reading the stream's current frame's payload without buffering the data.
91
+ SkipFramePayload,
92
+
88
93
  /// Reading and discarding data.
89
94
  Drain,
90
95
 
@@ -173,6 +178,15 @@ pub struct Stream {
173
178
 
174
179
  /// Whether a trailing HEADER field has been received.
175
180
  trailers_received: bool,
181
+
182
+ /// Max size of QPACK encoded headers carried in HEADERS or PUSH_PROMISE
183
+ /// frames. Related to SETTINGS_MAX_FIELD_LIST_SIZE; see
184
+ /// <https://datatracker.ietf.org/doc/html/rfc9114#section-7.2.4.1>
185
+ max_encoded_headers_payload_size: u64,
186
+
187
+ /// Max PRIORITY_UPDATE frame payload size; see
188
+ /// <https://datatracker.ietf.org/doc/html/rfc9218#section-7.2>
189
+ max_priority_update_size: u64,
176
190
  }
177
191
 
178
192
  impl Stream {
@@ -180,7 +194,12 @@ impl Stream {
180
194
  ///
181
195
  /// The `is_local` parameter indicates whether the stream was created by the
182
196
  /// local endpoint, or by the peer.
183
- pub fn new(id: u64, is_local: bool) -> Stream {
197
+ pub fn new(
198
+ id: u64,
199
+ is_local: bool,
200
+ max_field_section_size: u64,
201
+ max_priority_update_size: u64,
202
+ ) -> Stream {
184
203
  let (ty, state) = if crate::stream::is_bidi(id) {
185
204
  // All bidirectional streams are "request" streams, so we don't
186
205
  // need to read the stream type.
@@ -190,6 +209,12 @@ impl Stream {
190
209
  (None, State::StreamType)
191
210
  };
192
211
 
212
+ // Huffman encoding might inflate the size of encoded headers
213
+ // when transferred in HEADERS or PUSH_PROMISE frames. Scale up
214
+ // the limit by 50% to accommodate this.
215
+ let max_encoded_headers_payload_size =
216
+ max_field_section_size.saturating_add(max_field_section_size / 2);
217
+
193
218
  Stream {
194
219
  id,
195
220
  ty,
@@ -197,7 +222,7 @@ impl Stream {
197
222
  state,
198
223
 
199
224
  // Pre-allocate a buffer to avoid multiple tiny early allocations.
200
- state_buf: vec![0; 16],
225
+ state_buf: Vec::with_capacity(16),
201
226
 
202
227
  // Expect one byte for the initial state, to parse the initial
203
228
  // varint length.
@@ -223,6 +248,9 @@ impl Stream {
223
248
 
224
249
  trailers_sent: false,
225
250
  trailers_received: false,
251
+
252
+ max_encoded_headers_payload_size,
253
+ max_priority_update_size,
226
254
  }
227
255
  }
228
256
 
@@ -249,7 +277,7 @@ impl Stream {
249
277
  self.remote_initialized = true;
250
278
 
251
279
  State::QpackInstruction
252
- },
280
+ }
253
281
 
254
282
  Type::Unknown => State::Drain,
255
283
  };
@@ -282,58 +310,50 @@ impl Stream {
282
310
  // initialized, no more SETTINGS are permitted.
283
311
  match (ty, self.remote_initialized) {
284
312
  // Initialize control stream.
285
- (frame::SETTINGS_FRAME_TYPE_ID, false) =>
286
- self.remote_initialized = true,
313
+ (frame::SETTINGS_FRAME_TYPE_ID, false) => self.remote_initialized = true,
287
314
 
288
315
  // Non-SETTINGS frames not allowed on control stream
289
316
  // before initialization.
290
317
  (_, false) => return Err(Error::MissingSettings),
291
318
 
292
319
  // Additional SETTINGS frame.
293
- (frame::SETTINGS_FRAME_TYPE_ID, true) =>
294
- return Err(Error::FrameUnexpected),
320
+ (frame::SETTINGS_FRAME_TYPE_ID, true) => return Err(Error::FrameUnexpected),
295
321
 
296
322
  // Frames that can't be received on control stream
297
323
  // after initialization.
298
- (frame::DATA_FRAME_TYPE_ID, true) =>
299
- return Err(Error::FrameUnexpected),
324
+ (frame::DATA_FRAME_TYPE_ID, true) => return Err(Error::FrameUnexpected),
300
325
 
301
- (frame::HEADERS_FRAME_TYPE_ID, true) =>
302
- return Err(Error::FrameUnexpected),
326
+ (frame::HEADERS_FRAME_TYPE_ID, true) => return Err(Error::FrameUnexpected),
303
327
 
304
- (frame::PUSH_PROMISE_FRAME_TYPE_ID, true) =>
305
- return Err(Error::FrameUnexpected),
328
+ (frame::PUSH_PROMISE_FRAME_TYPE_ID, true) => {
329
+ return Err(Error::FrameUnexpected)
330
+ }
306
331
 
307
332
  // All other frames are ignored after initialization.
308
333
  (_, true) => (),
309
334
  }
310
- },
335
+ }
311
336
 
312
337
  Some(Type::Request) => {
313
338
  self.validate_request_frame_type(ty)?;
314
- },
339
+ }
315
340
 
316
341
  Some(Type::Push) => {
317
342
  match ty {
318
343
  // Frames that can never be received on request streams.
319
- frame::CANCEL_PUSH_FRAME_TYPE_ID =>
320
- return Err(Error::FrameUnexpected),
344
+ frame::CANCEL_PUSH_FRAME_TYPE_ID => return Err(Error::FrameUnexpected),
321
345
 
322
- frame::SETTINGS_FRAME_TYPE_ID =>
323
- return Err(Error::FrameUnexpected),
346
+ frame::SETTINGS_FRAME_TYPE_ID => return Err(Error::FrameUnexpected),
324
347
 
325
- frame::PUSH_PROMISE_FRAME_TYPE_ID =>
326
- return Err(Error::FrameUnexpected),
348
+ frame::PUSH_PROMISE_FRAME_TYPE_ID => return Err(Error::FrameUnexpected),
327
349
 
328
- frame::GOAWAY_FRAME_TYPE_ID =>
329
- return Err(Error::FrameUnexpected),
350
+ frame::GOAWAY_FRAME_TYPE_ID => return Err(Error::FrameUnexpected),
330
351
 
331
- frame::MAX_PUSH_FRAME_TYPE_ID =>
332
- return Err(Error::FrameUnexpected),
352
+ frame::MAX_PUSH_FRAME_TYPE_ID => return Err(Error::FrameUnexpected),
333
353
 
334
354
  _ => (),
335
355
  }
336
- },
356
+ }
337
357
 
338
358
  _ => return Err(Error::FrameUnexpected),
339
359
  }
@@ -362,12 +382,12 @@ impl Stream {
362
382
  // endpoint opened it.
363
383
  if matches!(
364
384
  ty,
365
- frame::CANCEL_PUSH_FRAME_TYPE_ID |
366
- frame::SETTINGS_FRAME_TYPE_ID |
367
- frame::GOAWAY_FRAME_TYPE_ID |
368
- frame::MAX_PUSH_FRAME_TYPE_ID |
369
- frame::PRIORITY_UPDATE_FRAME_REQUEST_TYPE_ID |
370
- frame::PRIORITY_UPDATE_FRAME_PUSH_TYPE_ID
385
+ frame::CANCEL_PUSH_FRAME_TYPE_ID
386
+ | frame::SETTINGS_FRAME_TYPE_ID
387
+ | frame::GOAWAY_FRAME_TYPE_ID
388
+ | frame::MAX_PUSH_FRAME_TYPE_ID
389
+ | frame::PRIORITY_UPDATE_FRAME_REQUEST_TYPE_ID
390
+ | frame::PRIORITY_UPDATE_FRAME_PUSH_TYPE_ID
371
391
  ) {
372
392
  return Err(Error::FrameUnexpected);
373
393
  }
@@ -381,10 +401,9 @@ impl Stream {
381
401
  match (ty, self.remote_initialized) {
382
402
  (frame::HEADERS_FRAME_TYPE_ID, false) => {
383
403
  self.remote_initialized = true;
384
- },
404
+ }
385
405
 
386
- (frame::DATA_FRAME_TYPE_ID, false) =>
387
- return Err(Error::FrameUnexpected),
406
+ (frame::DATA_FRAME_TYPE_ID, false) => return Err(Error::FrameUnexpected),
388
407
 
389
408
  (frame::HEADERS_FRAME_TYPE_ID, true) => {
390
409
  if self.trailers_received {
@@ -394,7 +413,7 @@ impl Stream {
394
413
  if self.data_received {
395
414
  self.trailers_received = true;
396
415
  }
397
- },
416
+ }
398
417
 
399
418
  (frame::DATA_FRAME_TYPE_ID, true) => {
400
419
  if self.trailers_received {
@@ -402,7 +421,7 @@ impl Stream {
402
421
  }
403
422
 
404
423
  self.data_received = true;
405
- },
424
+ }
406
425
 
407
426
  // All other frames can be ignored regardless of stream state.
408
427
  _ => (),
@@ -421,34 +440,122 @@ impl Stream {
421
440
  assert_eq!(self.state, State::FramePayloadLen);
422
441
 
423
442
  // Only expect frames on Control, Request and Push streams.
424
- if matches!(self.ty, Some(Type::Control | Type::Request | Type::Push)) {
425
- let (state, resize) = match self.frame_type {
426
- Some(frame::DATA_FRAME_TYPE_ID) => (State::Data, false),
427
-
428
- // These frame types can never have 0 payload length because
429
- // they always have fields that must be populated.
430
- Some(
431
- frame::GOAWAY_FRAME_TYPE_ID |
432
- frame::PUSH_PROMISE_FRAME_TYPE_ID |
433
- frame::CANCEL_PUSH_FRAME_TYPE_ID |
434
- frame::MAX_PUSH_FRAME_TYPE_ID,
435
- ) => {
436
- if len == 0 {
437
- return Err(Error::FrameError);
438
- }
443
+ if !matches!(self.ty, Some(Type::Control | Type::Request | Type::Push)) {
444
+ return Err(Error::InternalError);
445
+ }
439
446
 
440
- (State::FramePayload, true)
441
- },
447
+ let (state, resize) = match self.frame_type {
448
+ Some(frame::DATA_FRAME_TYPE_ID) => (State::Data, false),
442
449
 
443
- _ => (State::FramePayload, true),
444
- };
450
+ Some(frame::HEADERS_FRAME_TYPE_ID) => {
451
+ if len > self.max_encoded_headers_payload_size {
452
+ return Err(Error::ExcessiveLoad);
453
+ }
445
454
 
446
- self.state_transition(state, len as usize, resize)?;
455
+ (State::FramePayload, true)
456
+ }
447
457
 
448
- return Ok(());
458
+ // These frames carry a mandatory single varint, so their payload
459
+ // size has to be at least 1 byte and at most 8 bytes.
460
+ Some(frame::CANCEL_PUSH_FRAME_TYPE_ID)
461
+ | Some(frame::GOAWAY_FRAME_TYPE_ID)
462
+ | Some(frame::MAX_PUSH_FRAME_TYPE_ID) => {
463
+ if !(1..=8).contains(&len) {
464
+ return Err(Error::FrameError);
465
+ }
466
+
467
+ (State::FramePayload, true)
468
+ }
469
+
470
+ Some(frame::SETTINGS_FRAME_TYPE_ID) => {
471
+ if len > frame::MAX_SETTINGS_PAYLOAD_SIZE as u64 {
472
+ return Err(Error::FrameError);
473
+ }
474
+
475
+ (State::FramePayload, true)
476
+ }
477
+
478
+ Some(frame::PUSH_PROMISE_FRAME_TYPE_ID) => {
479
+ // A push promise payload includes a varint and a field section.
480
+ let max_push_promise_size = self.max_encoded_headers_payload_size.saturating_add(8);
481
+
482
+ if len == 0 {
483
+ return Err(Error::FrameError);
484
+ }
485
+
486
+ if len > max_push_promise_size {
487
+ return Err(Error::ExcessiveLoad);
488
+ }
489
+
490
+ (State::FramePayload, true)
491
+ }
492
+
493
+ Some(frame::PRIORITY_UPDATE_FRAME_REQUEST_TYPE_ID)
494
+ | Some(frame::PRIORITY_UPDATE_FRAME_PUSH_TYPE_ID) => {
495
+ if len == 0 {
496
+ return Err(Error::FrameError);
497
+ }
498
+
499
+ if len > self.max_priority_update_size {
500
+ return Err(Error::ExcessiveLoad);
501
+ }
502
+
503
+ (State::FramePayload, true)
504
+ }
505
+
506
+ // Ignore unknown frames' payloads.
507
+ _ => {
508
+ if len > MAX_STATE_BUF_SIZE as u64 {
509
+ return Err(Error::ExcessiveLoad);
510
+ }
511
+
512
+ (State::SkipFramePayload, false)
513
+ }
514
+ };
515
+
516
+ self.state_transition(state, len as usize, resize)?;
517
+
518
+ Ok(())
519
+ }
520
+
521
+ /// Returns a mutable slice over the state buffer's spare capacity,
522
+ /// reserving additional space if needed.
523
+ ///
524
+ /// Callers must initialize the returned bytes and call
525
+ /// [`commit_state_buf_read()`] with the number of bytes written.
526
+ fn spare_state_buf(&mut self) -> &mut [u8] {
527
+ let need = self.state_len - self.state_off;
528
+ let spare = self
529
+ .state_buf
530
+ .capacity()
531
+ .saturating_sub(self.state_buf.len());
532
+
533
+ if spare == 0 {
534
+ let additional = std::cmp::min(MAX_STATE_BUF_ALLOC_SIZE, need);
535
+ self.state_buf.reserve(additional);
449
536
  }
450
537
 
451
- Err(Error::InternalError)
538
+ let buf = self.state_buf.spare_capacity_mut();
539
+ let usable = std::cmp::min(need, buf.len());
540
+
541
+ // SAFETY: MaybeUninit<u8> has the same layout as u8. The caller
542
+ // contract requires initializing all returned bytes before calling
543
+ // commit_state_buf_read(), so no uninitialized memory is read.
544
+ unsafe { std::mem::transmute::<&mut [MaybeUninit<u8>], &mut [u8]>(&mut buf[..usable]) }
545
+ }
546
+
547
+ /// Advances the state buffer's initialized length and offset by `read`
548
+ /// bytes. The caller must have written `read` bytes into the slice
549
+ /// previously returned by [`spare_state_buf()`].
550
+ fn commit_state_buf_read(&mut self, read: usize) {
551
+ let buf_len = self.state_buf.len();
552
+ debug_assert!(buf_len + read <= self.state_buf.capacity());
553
+ // SAFETY: `read` bytes were written to spare capacity by the I/O
554
+ // layer. read <= spare_buf.len() <= spare_capacity, so
555
+ // buf_len + read <= capacity.
556
+ unsafe { self.state_buf.set_len(buf_len + read) };
557
+
558
+ self.state_off += read;
452
559
  }
453
560
 
454
561
  /// Tries to fill the state buffer by reading data from the corresponding
@@ -457,58 +564,116 @@ impl Stream {
457
564
  /// When not enough data can be read to complete the state, this returns
458
565
  /// `Error::Done`.
459
566
  pub fn try_fill_buffer<F: BufFactory>(
460
- &mut self, conn: &mut crate::Connection<F>,
567
+ &mut self,
568
+ conn: &mut crate::Connection<F>,
461
569
  ) -> Result<()> {
462
570
  // If no bytes are required to be read, return early.
463
571
  if self.state_buffer_complete() {
464
572
  return Ok(());
465
573
  }
466
574
 
467
- let buf = &mut self.state_buf[self.state_off..self.state_len];
575
+ loop {
576
+ let stream_id = self.id;
577
+
578
+ let spare_buf = self.spare_state_buf();
579
+ let spare_len = spare_buf.len();
580
+
581
+ match conn.stream_recv(stream_id, spare_buf) {
582
+ Ok((read, fin)) => {
583
+ self.commit_state_buf_read(read);
584
+
585
+ if self.critical_stream_closed(fin) {
586
+ super::close_conn_critical_stream(conn)?;
587
+ }
588
+
589
+ trace!(
590
+ "{} read {} bytes on stream {}",
591
+ conn.trace_id(),
592
+ read,
593
+ self.id,
594
+ );
595
+
596
+ if read < spare_len {
597
+ break;
598
+ }
599
+
600
+ if self.state_buffer_complete() {
601
+ return Ok(());
602
+ }
603
+ }
604
+
605
+ Err(e @ crate::Error::StreamReset(_)) => {
606
+ if self.critical_stream_closed(true) {
607
+ super::close_conn_critical_stream(conn)?;
608
+ }
609
+
610
+ return Err(e.into());
611
+ }
612
+
613
+ Err(e) => {
614
+ // The stream is not readable anymore, so re-arm the Data
615
+ // event.
616
+ if e == crate::Error::Done {
617
+ self.reset_data_event();
618
+ }
619
+
620
+ return Err(e.into());
621
+ }
622
+ };
623
+ }
624
+
625
+ if !self.state_buffer_complete() {
626
+ self.reset_data_event();
627
+
628
+ return Err(Error::Done);
629
+ }
630
+
631
+ Ok(())
632
+ }
633
+
634
+ /// Tries to read data from the corresponding transport stream up to the
635
+ /// state's size, without storing the data in the state buffer.
636
+ ///
637
+ /// When not enough data can be read to complete the state, this returns
638
+ /// `Error::Done`.
639
+ pub fn try_skip_data<F: BufFactory>(&mut self, conn: &mut crate::Connection<F>) -> Result<()> {
640
+ // If no bytes are required to be read, return early.
641
+ if self.state_buffer_complete() {
642
+ return Ok(());
643
+ }
644
+
645
+ let len = self.state_len - self.state_off;
468
646
 
469
- let read = match conn.stream_recv(self.id, buf) {
647
+ let read = match conn.stream_discard(self.id, len) {
470
648
  Ok((len, fin)) => {
471
- // Check whether one of the critical stream was closed.
472
- if fin &&
473
- matches!(
474
- self.ty,
475
- Some(Type::Control) |
476
- Some(Type::QpackEncoder) |
477
- Some(Type::QpackDecoder)
478
- )
479
- {
649
+ if self.critical_stream_closed(fin) {
480
650
  super::close_conn_critical_stream(conn)?;
481
651
  }
482
652
 
483
653
  len
484
- },
654
+ }
485
655
 
486
656
  Err(e @ crate::Error::StreamReset(_)) => {
487
- // Check whether one of the critical stream was closed.
488
- if matches!(
489
- self.ty,
490
- Some(Type::Control) |
491
- Some(Type::QpackEncoder) |
492
- Some(Type::QpackDecoder)
493
- ) {
657
+ if self.critical_stream_closed(true) {
494
658
  super::close_conn_critical_stream(conn)?;
495
659
  }
496
660
 
497
661
  return Err(e.into());
498
- },
662
+ }
499
663
 
500
664
  Err(e) => {
501
- // The stream is not readable anymore, so re-arm the Data event.
665
+ // The stream is not readable anymore, so re-arm the Data
666
+ // event.
502
667
  if e == crate::Error::Done {
503
668
  self.reset_data_event();
504
669
  }
505
670
 
506
671
  return Err(e.into());
507
- },
672
+ }
508
673
  };
509
674
 
510
675
  trace!(
511
- "{} read {} bytes on stream {}",
676
+ "{} discarded {} bytes on stream {}",
512
677
  conn.trace_id(),
513
678
  read,
514
679
  self.id,
@@ -546,8 +711,7 @@ impl Stream {
546
711
  }
547
712
 
548
713
  pub fn increment_headers_received(&mut self) {
549
- self.headers_received_count =
550
- self.headers_received_count.saturating_add(1);
714
+ self.headers_received_count = self.headers_received_count.saturating_add(1);
551
715
  }
552
716
 
553
717
  pub fn headers_received_count(&self) -> usize {
@@ -567,19 +731,39 @@ impl Stream {
567
731
  /// This is intended to replace `try_fill_buffer()` in tests, in order to
568
732
  /// avoid having to setup a transport connection.
569
733
  #[cfg(test)]
570
- fn try_fill_buffer_for_tests(
571
- &mut self, stream: &mut std::io::Cursor<Vec<u8>>,
572
- ) -> Result<()> {
734
+ fn try_fill_buffer_for_tests(&mut self, stream: &mut std::io::Cursor<Vec<u8>>) -> Result<()> {
573
735
  // If no bytes are required to be read, return early
574
736
  if self.state_buffer_complete() {
575
737
  return Ok(());
576
738
  }
577
739
 
578
- let buf = &mut self.state_buf[self.state_off..self.state_len];
740
+ loop {
741
+ let spare_buf = self.spare_state_buf();
742
+ let spare_len = spare_buf.len();
579
743
 
580
- let read = std::io::Read::read(stream, buf).unwrap();
744
+ let read = match std::io::Read::read(stream, spare_buf) {
745
+ Ok(0) => {
746
+ // end of stream, stop
747
+ break;
748
+ }
581
749
 
582
- self.state_off += read;
750
+ Ok(v) => v,
751
+
752
+ Err(_) => {
753
+ panic!("Test buffer reading should never fail");
754
+ }
755
+ };
756
+
757
+ self.commit_state_buf_read(read);
758
+
759
+ if read < spare_len {
760
+ break;
761
+ }
762
+
763
+ if self.state_buffer_complete() {
764
+ break;
765
+ }
766
+ }
583
767
 
584
768
  if !self.state_buffer_complete() {
585
769
  return Err(Error::Done);
@@ -592,7 +776,7 @@ impl Stream {
592
776
  pub fn try_consume_varint(&mut self) -> Result<u64> {
593
777
  if self.state_off == 1 {
594
778
  self.state_len = octets::varint_parse_len(self.state_buf[0]);
595
- self.state_buf.resize(self.state_len, 0);
779
+ self.state_buf.reserve(self.state_len);
596
780
  }
597
781
 
598
782
  // Return early if we don't have enough data in the state buffer to
@@ -617,20 +801,31 @@ impl Stream {
617
801
  let payload_len = self.state_len as u64;
618
802
 
619
803
  // TODO: properly propagate frame parsing errors.
620
- let frame = frame::Frame::from_bytes(
621
- self.frame_type.unwrap(),
622
- payload_len,
623
- &self.state_buf,
624
- )?;
804
+ let frame =
805
+ frame::Frame::from_bytes(self.frame_type.unwrap(), payload_len, &self.state_buf)?;
625
806
 
626
807
  self.state_transition(State::FrameType, 1, true)?;
627
808
 
628
809
  Ok((frame, payload_len))
629
810
  }
630
811
 
812
+ /// Tries to skip the current frame's payload.
813
+ pub fn try_skip_frame<F: BufFactory>(&mut self, conn: &mut crate::Connection<F>) -> Result<()> {
814
+ self.try_skip_data(conn)?;
815
+
816
+ // Processing a frame other than DATA, so re-arm the Data event.
817
+ self.reset_data_event();
818
+
819
+ self.state_transition(State::FrameType, 1, true)?;
820
+
821
+ Ok(())
822
+ }
823
+
631
824
  /// Tries to read DATA payload from the transport stream.
632
825
  pub fn try_consume_data<F: BufFactory, OUT: bytes::BufMut>(
633
- &mut self, conn: &mut crate::Connection<F>, out: OUT,
826
+ &mut self,
827
+ conn: &mut crate::Connection<F>,
828
+ out: OUT,
634
829
  ) -> Result<(usize, bool)> {
635
830
  debug_assert_eq!(self.state, State::Data);
636
831
  let out = out.limit(self.state_len - self.state_off);
@@ -645,7 +840,7 @@ impl Stream {
645
840
  }
646
841
 
647
842
  return Err(e.into());
648
- },
843
+ }
649
844
  };
650
845
 
651
846
  self.state_off += len;
@@ -674,7 +869,9 @@ impl Stream {
674
869
  /// avoid having to setup a transport connection.
675
870
  #[cfg(test)]
676
871
  fn try_consume_data_for_tests(
677
- &mut self, stream: &mut std::io::Cursor<Vec<u8>>, out: &mut [u8],
872
+ &mut self,
873
+ stream: &mut std::io::Cursor<Vec<u8>>,
874
+ out: &mut [u8],
678
875
  ) -> Result<usize> {
679
876
  let left = std::cmp::min(out.len(), self.state_len - self.state_off);
680
877
 
@@ -723,6 +920,14 @@ impl Stream {
723
920
  self.last_priority_update.is_some()
724
921
  }
725
922
 
923
+ /// Checks whether one of the critical streams was closed.
924
+ fn critical_stream_closed(&self, fin: bool) -> bool {
925
+ fin && matches!(
926
+ self.ty,
927
+ Some(Type::Control) | Some(Type::QpackEncoder) | Some(Type::QpackDecoder)
928
+ )
929
+ }
930
+
726
931
  /// Returns true if the state buffer has enough data to complete the state.
727
932
  fn state_buffer_complete(&self) -> bool {
728
933
  self.state_off == self.state_len
@@ -731,8 +936,13 @@ impl Stream {
731
936
  /// Transitions the stream to a new state, and optionally resets the state
732
937
  /// buffer.
733
938
  fn state_transition(
734
- &mut self, new_state: State, expected_len: usize, resize: bool,
939
+ &mut self,
940
+ new_state: State,
941
+ expected_len: usize,
942
+ resize: bool,
735
943
  ) -> Result<()> {
944
+ self.state_buf.clear();
945
+
736
946
  // Some states don't need the state buffer, so don't resize it if not
737
947
  // necessary.
738
948
  if resize {
@@ -743,7 +953,8 @@ impl Stream {
743
953
  return Err(Error::ExcessiveLoad);
744
954
  }
745
955
 
746
- self.state_buf.resize(expected_len, 0);
956
+ let reserve_len = std::cmp::min(expected_len, MAX_STATE_BUF_ALLOC_SIZE);
957
+ self.state_buf.reserve(reserve_len);
747
958
  }
748
959
 
749
960
  self.state = new_state;
@@ -757,11 +968,18 @@ impl Stream {
757
968
  #[cfg(test)]
758
969
  mod tests {
759
970
  use crate::h3::frame::*;
971
+ use crate::h3::PRIORITY_UPDATE_FRAME_PAYLOAD_MAX_SIZE_DEFAULT;
972
+ use crate::h3::SETTINGS_MAX_FIELD_SECTION_SIZE_DEFAULT;
760
973
 
761
974
  use super::*;
762
975
 
763
976
  fn open_uni(b: &mut octets::OctetsMut, ty: u64) -> Result<Stream> {
764
- let stream = <Stream>::new(2, false);
977
+ let stream = <Stream>::new(
978
+ 2,
979
+ false,
980
+ SETTINGS_MAX_FIELD_SECTION_SIZE_DEFAULT,
981
+ PRIORITY_UPDATE_FRAME_PAYLOAD_MAX_SIZE_DEFAULT,
982
+ );
765
983
  assert_eq!(stream.state, State::StreamType);
766
984
 
767
985
  b.put_varint(ty)?;
@@ -769,8 +987,19 @@ mod tests {
769
987
  Ok(stream)
770
988
  }
771
989
 
990
+ fn open_remote_request_stream() -> Stream {
991
+ Stream::new(
992
+ 0,
993
+ false,
994
+ SETTINGS_MAX_FIELD_SECTION_SIZE_DEFAULT,
995
+ PRIORITY_UPDATE_FRAME_PAYLOAD_MAX_SIZE_DEFAULT,
996
+ )
997
+ }
998
+
772
999
  fn parse_uni(
773
- stream: &mut Stream, ty: u64, cursor: &mut std::io::Cursor<Vec<u8>>,
1000
+ stream: &mut Stream,
1001
+ ty: u64,
1002
+ cursor: &mut std::io::Cursor<Vec<u8>>,
774
1003
  ) -> Result<()> {
775
1004
  stream.try_fill_buffer_for_tests(cursor)?;
776
1005
 
@@ -781,9 +1010,20 @@ mod tests {
781
1010
  Ok(())
782
1011
  }
783
1012
 
784
- fn parse_skip_frame(
785
- stream: &mut Stream, cursor: &mut std::io::Cursor<Vec<u8>>,
786
- ) -> Result<()> {
1013
+ /// Fill the buffer and parse a multi-byte varint that requires two
1014
+ /// fills (the first read gets the length prefix, the second gets the
1015
+ /// remaining bytes).
1016
+ fn parse_multibyte_varint(
1017
+ stream: &mut Stream,
1018
+ cursor: &mut std::io::Cursor<Vec<u8>>,
1019
+ ) -> Result<u64> {
1020
+ stream.try_fill_buffer_for_tests(cursor)?;
1021
+ assert_eq!(stream.try_consume_varint(), Err(Error::Done));
1022
+ stream.try_fill_buffer_for_tests(cursor)?;
1023
+ stream.try_consume_varint()
1024
+ }
1025
+
1026
+ fn parse_skip_frame(stream: &mut Stream, cursor: &mut std::io::Cursor<Vec<u8>>) -> Result<()> {
787
1027
  // Parse the frame type.
788
1028
  stream.try_fill_buffer_for_tests(cursor)?;
789
1029
 
@@ -836,8 +1076,7 @@ mod tests {
836
1076
 
837
1077
  let mut cursor = std::io::Cursor::new(d);
838
1078
 
839
- parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
840
- .unwrap();
1079
+ parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor).unwrap();
841
1080
  assert_eq!(stream.state, State::FrameType);
842
1081
 
843
1082
  // Parse the SETTINGS frame type.
@@ -886,8 +1125,7 @@ mod tests {
886
1125
 
887
1126
  let mut cursor = std::io::Cursor::new(d);
888
1127
 
889
- parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
890
- .unwrap();
1128
+ parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor).unwrap();
891
1129
  assert_eq!(stream.state, State::FrameType);
892
1130
 
893
1131
  // Parse the SETTINGS frame type.
@@ -943,8 +1181,7 @@ mod tests {
943
1181
 
944
1182
  let mut cursor = std::io::Cursor::new(d);
945
1183
 
946
- parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
947
- .unwrap();
1184
+ parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor).unwrap();
948
1185
  assert_eq!(stream.state, State::FrameType);
949
1186
 
950
1187
  // Parse the SETTINGS frame type.
@@ -1008,8 +1245,7 @@ mod tests {
1008
1245
 
1009
1246
  let mut cursor = std::io::Cursor::new(d);
1010
1247
 
1011
- parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
1012
- .unwrap();
1248
+ parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor).unwrap();
1013
1249
  assert_eq!(stream.state, State::FrameType);
1014
1250
 
1015
1251
  // Parse GOAWAY.
@@ -1052,8 +1288,7 @@ mod tests {
1052
1288
 
1053
1289
  let mut cursor = std::io::Cursor::new(d);
1054
1290
 
1055
- parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
1056
- .unwrap();
1291
+ parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor).unwrap();
1057
1292
  assert_eq!(stream.state, State::FrameType);
1058
1293
 
1059
1294
  // Parse first SETTINGS frame.
@@ -1080,7 +1315,7 @@ mod tests {
1080
1315
 
1081
1316
  #[test]
1082
1317
  fn request_no_data() {
1083
- let mut stream = <Stream>::new(0, false);
1318
+ let mut stream = open_remote_request_stream();
1084
1319
 
1085
1320
  assert_eq!(stream.ty, Some(Type::Request));
1086
1321
  assert_eq!(stream.state, State::FrameType);
@@ -1090,7 +1325,7 @@ mod tests {
1090
1325
 
1091
1326
  #[test]
1092
1327
  fn request_good() {
1093
- let mut stream = <Stream>::new(0, false);
1328
+ let mut stream = open_remote_request_stream();
1094
1329
 
1095
1330
  let mut d = vec![42; 128];
1096
1331
  let mut b = octets::OctetsMut::with_slice(&mut d);
@@ -1266,7 +1501,7 @@ mod tests {
1266
1501
 
1267
1502
  #[test]
1268
1503
  fn data_before_headers() {
1269
- let mut stream = <Stream>::new(0, false);
1504
+ let mut stream = open_remote_request_stream();
1270
1505
 
1271
1506
  let mut d = vec![42; 128];
1272
1507
  let mut b = octets::OctetsMut::with_slice(&mut d);
@@ -1290,7 +1525,7 @@ mod tests {
1290
1525
 
1291
1526
  #[test]
1292
1527
  fn additional_headers() {
1293
- let mut stream = Stream::new(0, false);
1528
+ let mut stream = open_remote_request_stream();
1294
1529
 
1295
1530
  let mut d = vec![42; 128];
1296
1531
  let mut b = octets::OctetsMut::with_slice(&mut d);
@@ -1416,12 +1651,183 @@ mod tests {
1416
1651
  assert_eq!(stream.state, State::FrameType);
1417
1652
  }
1418
1653
 
1419
- #[test]
1420
- fn zero_length_goaway() {
1421
- let mut d = vec![42; 128];
1654
+ /// Returns the frame type ID for a given frame variant.
1655
+ fn frame_type_id(frame: &Frame) -> u64 {
1656
+ match frame {
1657
+ Frame::Data { .. } => DATA_FRAME_TYPE_ID,
1658
+ Frame::Headers { .. } => HEADERS_FRAME_TYPE_ID,
1659
+ Frame::CancelPush { .. } => CANCEL_PUSH_FRAME_TYPE_ID,
1660
+ Frame::Settings { .. } => SETTINGS_FRAME_TYPE_ID,
1661
+ Frame::PushPromise { .. } => PUSH_PROMISE_FRAME_TYPE_ID,
1662
+ Frame::GoAway { .. } => GOAWAY_FRAME_TYPE_ID,
1663
+ Frame::MaxPushId { .. } => MAX_PUSH_FRAME_TYPE_ID,
1664
+ Frame::PriorityUpdateRequest { .. } => PRIORITY_UPDATE_FRAME_REQUEST_TYPE_ID,
1665
+ Frame::PriorityUpdatePush { .. } => PRIORITY_UPDATE_FRAME_PUSH_TYPE_ID,
1666
+ Frame::Unknown { .. } => unreachable!(),
1667
+ }
1668
+ }
1669
+
1670
+ /// Parse a large frame and check the size limit behavior.
1671
+ ///
1672
+ /// Writes the frame to a buffer, parses the frame type and payload
1673
+ /// length (handling multi-byte varint retry), then checks whether
1674
+ /// `set_frame_payload_len` accepts or rejects the frame. If accepted,
1675
+ /// also parses the payload and verifies `try_consume_frame` output.
1676
+ ///
1677
+ /// - `stream`: the H3 stream to parse the frame on.
1678
+ /// - `frame`: the frame to encode and parse back.
1679
+ /// - `expected_payload_len`: the expected encoded payload length.
1680
+ /// - `expect_accept`: if true, the frame should be accepted and fully
1681
+ /// parsed; if false, `set_frame_payload_len` should reject it with
1682
+ /// `Error::ExcessiveLoad`.
1683
+ fn check_large_frame_size_limit(
1684
+ stream: &mut Stream,
1685
+ frame: Frame,
1686
+ expected_payload_len: u64,
1687
+ expect_accept: bool,
1688
+ ) {
1689
+ let expected_type_id = frame_type_id(&frame);
1690
+
1691
+ let mut d = vec![42; 20000];
1422
1692
  let mut b = octets::OctetsMut::with_slice(&mut d);
1693
+ frame.to_bytes(&mut b).unwrap();
1694
+ let mut cursor = std::io::Cursor::new(d);
1423
1695
 
1424
- let frame = Frame::Settings {
1696
+ // Parse frame type.
1697
+ stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
1698
+ let frame_ty = stream.try_consume_varint().unwrap();
1699
+ assert_eq!(frame_ty, expected_type_id);
1700
+
1701
+ stream.set_frame_type(frame_ty).unwrap();
1702
+ assert_eq!(stream.state, State::FramePayloadLen);
1703
+
1704
+ // Parse frame payload length.
1705
+ let frame_payload_len = parse_multibyte_varint(stream, &mut cursor).unwrap();
1706
+ assert_eq!(frame_payload_len, expected_payload_len);
1707
+
1708
+ if expect_accept {
1709
+ stream.set_frame_payload_len(frame_payload_len).unwrap();
1710
+ assert_eq!(stream.state, State::FramePayload);
1711
+
1712
+ stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
1713
+
1714
+ assert_eq!(
1715
+ stream.try_consume_frame(),
1716
+ Ok((frame, expected_payload_len))
1717
+ );
1718
+ assert_eq!(stream.state, State::FrameType);
1719
+ } else {
1720
+ assert_eq!(
1721
+ stream.set_frame_payload_len(frame_payload_len),
1722
+ Err(Error::ExcessiveLoad)
1723
+ );
1724
+ }
1725
+ }
1726
+
1727
+ #[test]
1728
+ fn large_headers_default_limit() {
1729
+ let mut stream = open_remote_request_stream();
1730
+ let header_block = vec![0; 16384];
1731
+ let frame = Frame::Headers {
1732
+ header_block: header_block.clone(),
1733
+ };
1734
+
1735
+ check_large_frame_size_limit(&mut stream, frame, 16384, true);
1736
+ }
1737
+
1738
+ #[test]
1739
+ fn large_headers_limit_with_huffman() {
1740
+ // Create stream with a max_field_section_size limit of 4k.
1741
+ let mut stream = Stream::new(
1742
+ 0,
1743
+ false,
1744
+ 4196,
1745
+ PRIORITY_UPDATE_FRAME_PAYLOAD_MAX_SIZE_DEFAULT,
1746
+ );
1747
+
1748
+ // Size the header block so it will fit within the Huffman margin.
1749
+ // On this branch the margin is x + x/2 = 4196 + 2098 = 6294.
1750
+ let header_block = vec![0; 6294];
1751
+ let frame = Frame::Headers {
1752
+ header_block: header_block.clone(),
1753
+ };
1754
+
1755
+ check_large_frame_size_limit(&mut stream, frame, 6294, true);
1756
+ }
1757
+
1758
+ #[test]
1759
+ fn large_headers_small_limit() {
1760
+ // Create stream with a max_field_section_size limit of 4k.
1761
+ // Encoded headers at 16k are larger than the 4k limit.
1762
+ let mut stream = Stream::new(
1763
+ 0,
1764
+ false,
1765
+ 4196,
1766
+ PRIORITY_UPDATE_FRAME_PAYLOAD_MAX_SIZE_DEFAULT,
1767
+ );
1768
+ let header_block = vec![0; 16384];
1769
+ let frame = Frame::Headers {
1770
+ header_block: header_block.clone(),
1771
+ };
1772
+
1773
+ check_large_frame_size_limit(&mut stream, frame, 16384, false);
1774
+ }
1775
+
1776
+ #[test]
1777
+ fn large_push_promise_default_limit() {
1778
+ let mut stream = open_remote_request_stream();
1779
+ let header_block = vec![0; 16384];
1780
+ let frame = Frame::PushPromise {
1781
+ push_id: 0,
1782
+ header_block: header_block.clone(),
1783
+ };
1784
+
1785
+ check_large_frame_size_limit(&mut stream, frame, 1 + 16384, true);
1786
+ }
1787
+
1788
+ #[test]
1789
+ fn large_push_promise_limit_with_huffman() {
1790
+ // Create stream with a max_field_section_size limit of 4k.
1791
+ let mut stream = Stream::new(
1792
+ 0,
1793
+ false,
1794
+ 4196,
1795
+ PRIORITY_UPDATE_FRAME_PAYLOAD_MAX_SIZE_DEFAULT,
1796
+ );
1797
+
1798
+ // Size the header block so it will fit within the Huffman margin.
1799
+ // On this branch the margin is x + x/2 = 4196 + 2098 = 6294.
1800
+ let header_block = vec![0; 6294];
1801
+ let frame = Frame::PushPromise {
1802
+ push_id: 0,
1803
+ header_block: header_block.clone(),
1804
+ };
1805
+
1806
+ check_large_frame_size_limit(&mut stream, frame, 1 + 6294, true);
1807
+ }
1808
+
1809
+ #[test]
1810
+ fn large_push_promise_small_limit() {
1811
+ // Create stream with a max_field_section_size limit of 4k.
1812
+ // Encoded push promise at 16k is larger than the 4k limit.
1813
+ let mut stream = Stream::new(
1814
+ 0,
1815
+ false,
1816
+ 4196,
1817
+ PRIORITY_UPDATE_FRAME_PAYLOAD_MAX_SIZE_DEFAULT,
1818
+ );
1819
+ let header_block = vec![0; 16384];
1820
+ let frame = Frame::PushPromise {
1821
+ push_id: 0,
1822
+ header_block: header_block.clone(),
1823
+ };
1824
+
1825
+ check_large_frame_size_limit(&mut stream, frame, 1 + 16384, false);
1826
+ }
1827
+
1828
+ #[test]
1829
+ fn large_priority_update_large_limit() {
1830
+ let settings = Frame::Settings {
1425
1831
  max_field_section_size: None,
1426
1832
  qpack_max_table_capacity: None,
1427
1833
  qpack_blocked_streams: None,
@@ -1432,77 +1838,135 @@ mod tests {
1432
1838
  raw: Some(vec![]),
1433
1839
  };
1434
1840
 
1435
- let mut stream = open_uni(&mut b, HTTP3_CONTROL_STREAM_TYPE_ID).unwrap();
1436
- frame.to_bytes(&mut b).unwrap();
1841
+ let mut d = vec![42; 20000];
1842
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1437
1843
 
1438
- // Write a 0-length payload frame.
1439
- b.put_varint(GOAWAY_FRAME_TYPE_ID).unwrap();
1440
- b.put_varint(0).unwrap();
1844
+ // Control stream needs a SETTINGS frame to transition it into
1845
+ // being able to parse other frame types.
1846
+ let mut stream = <Stream>::new(2, false, SETTINGS_MAX_FIELD_SECTION_SIZE_DEFAULT, 20000);
1847
+ b.put_varint(HTTP3_CONTROL_STREAM_TYPE_ID).unwrap();
1848
+ settings.to_bytes(&mut b).unwrap();
1849
+
1850
+ let priority_field_value = vec![0; 16384];
1851
+ let pu = Frame::PriorityUpdateRequest {
1852
+ prioritized_element_id: 0,
1853
+ priority_field_value,
1854
+ };
1855
+
1856
+ pu.to_bytes(&mut b).unwrap();
1441
1857
 
1442
1858
  let mut cursor = std::io::Cursor::new(d);
1443
1859
 
1444
- parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
1445
- .unwrap();
1860
+ parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor).unwrap();
1446
1861
 
1447
1862
  // Skip SETTINGS frame type.
1448
1863
  parse_skip_frame(&mut stream, &mut cursor).unwrap();
1449
1864
 
1450
- // Parse frame type.
1865
+ // Parse the frame type.
1866
+ stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
1867
+
1868
+ // Parse fails because we need more bytes for the 4-byte encoded length.
1869
+ // This trial then sets the expected buffer size for us to fill.
1870
+ assert_eq!(stream.try_consume_varint(), Err(Error::Done));
1451
1871
  stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
1452
1872
  let frame_ty = stream.try_consume_varint().unwrap();
1453
- assert_eq!(frame_ty, GOAWAY_FRAME_TYPE_ID);
1873
+ assert_eq!(frame_ty, PRIORITY_UPDATE_FRAME_REQUEST_TYPE_ID);
1454
1874
 
1455
1875
  stream.set_frame_type(frame_ty).unwrap();
1456
1876
  assert_eq!(stream.state, State::FramePayloadLen);
1457
1877
 
1458
- // Parse frame payload length.
1878
+ // Parse the frame payload length.
1879
+ stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
1880
+
1881
+ // Parse fails because we need more bytes for the 4-byte encoded length.
1882
+ // This trial then sets the expected buffer size for us to fill.
1883
+ assert_eq!(stream.try_consume_varint(), Err(Error::Done));
1459
1884
  stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
1885
+
1460
1886
  let frame_payload_len = stream.try_consume_varint().unwrap();
1461
- assert_eq!(
1462
- Err(Error::FrameError),
1463
- stream.set_frame_payload_len(frame_payload_len)
1464
- );
1887
+ assert_eq!(frame_payload_len, 1 + 16384);
1888
+
1889
+ stream.set_frame_payload_len(frame_payload_len).unwrap();
1890
+ assert_eq!(stream.state, State::FramePayload);
1891
+
1892
+ // Parse the frame.
1893
+ stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
1894
+
1895
+ assert_eq!(stream.try_consume_frame(), Ok((pu, 1 + 16384)));
1896
+ assert_eq!(stream.state, State::FrameType);
1465
1897
  }
1466
1898
 
1467
1899
  #[test]
1468
- fn zero_length_push_promise() {
1469
- let mut d = vec![42; 128];
1900
+ fn large_priority_update_small_limit() {
1901
+ let settings = Frame::Settings {
1902
+ max_field_section_size: None,
1903
+ qpack_max_table_capacity: None,
1904
+ qpack_blocked_streams: None,
1905
+ connect_protocol_enabled: None,
1906
+ h3_datagram: None,
1907
+ grease: None,
1908
+ additional_settings: None,
1909
+ raw: Some(vec![]),
1910
+ };
1911
+
1912
+ let mut d = vec![42; 20000];
1470
1913
  let mut b = octets::OctetsMut::with_slice(&mut d);
1471
1914
 
1472
- let mut stream = <Stream>::new(0, false);
1915
+ // Control stream needs a SETTINGS frame to transition it into
1916
+ // being able to parse other frame types.
1917
+ let mut stream = <Stream>::new(2, false, SETTINGS_MAX_FIELD_SECTION_SIZE_DEFAULT, 123);
1918
+ b.put_varint(HTTP3_CONTROL_STREAM_TYPE_ID).unwrap();
1473
1919
 
1474
- assert_eq!(stream.ty, Some(Type::Request));
1475
- assert_eq!(stream.state, State::FrameType);
1920
+ settings.to_bytes(&mut b).unwrap();
1476
1921
 
1477
- // Write a 0-length payload frame.
1478
- b.put_varint(PUSH_PROMISE_FRAME_TYPE_ID).unwrap();
1479
- b.put_varint(0).unwrap();
1922
+ let priority_field_value = vec![0; 16384];
1923
+ let pu = Frame::PriorityUpdateRequest {
1924
+ prioritized_element_id: 0,
1925
+ priority_field_value,
1926
+ };
1927
+
1928
+ pu.to_bytes(&mut b).unwrap();
1480
1929
 
1481
1930
  let mut cursor = std::io::Cursor::new(d);
1482
1931
 
1483
- // Parse frame type.
1932
+ parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor).unwrap();
1933
+
1934
+ // Skip SETTINGS frame type.
1935
+ parse_skip_frame(&mut stream, &mut cursor).unwrap();
1936
+
1937
+ // Parse the frame type.
1938
+ stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
1939
+
1940
+ // Parse fails because we need more bytes for the 4-byte encoded length.
1941
+ // This trial then sets the expected buffer size for us to fill.
1942
+ assert_eq!(stream.try_consume_varint(), Err(Error::Done));
1484
1943
  stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
1485
1944
  let frame_ty = stream.try_consume_varint().unwrap();
1486
- assert_eq!(frame_ty, PUSH_PROMISE_FRAME_TYPE_ID);
1945
+ assert_eq!(frame_ty, PRIORITY_UPDATE_FRAME_REQUEST_TYPE_ID);
1487
1946
 
1488
1947
  stream.set_frame_type(frame_ty).unwrap();
1489
1948
  assert_eq!(stream.state, State::FramePayloadLen);
1490
1949
 
1491
- // Parse frame payload length.
1950
+ // Parse the frame payload length.
1492
1951
  stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
1952
+
1953
+ // Parse fails because we need more bytes for the 4-byte encoded length.
1954
+ // This trial then sets the expected buffer size for us to fill.
1955
+ assert_eq!(stream.try_consume_varint(), Err(Error::Done));
1956
+ stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
1957
+
1493
1958
  let frame_payload_len = stream.try_consume_varint().unwrap();
1959
+ assert_eq!(frame_payload_len, 1 + 16384);
1960
+
1494
1961
  assert_eq!(
1495
- Err(Error::FrameError),
1496
- stream.set_frame_payload_len(frame_payload_len)
1962
+ stream.set_frame_payload_len(frame_payload_len),
1963
+ Err(Error::ExcessiveLoad)
1497
1964
  );
1498
1965
  }
1499
1966
 
1500
1967
  #[test]
1501
- fn zero_length_cancel_push() {
1502
- let mut d = vec![42; 128];
1503
- let mut b = octets::OctetsMut::with_slice(&mut d);
1504
-
1505
- let frame = Frame::Settings {
1968
+ fn finite_sized_frame_limits() {
1969
+ let settings = Frame::Settings {
1506
1970
  max_field_section_size: None,
1507
1971
  qpack_max_table_capacity: None,
1508
1972
  qpack_blocked_streams: None,
@@ -1513,25 +1977,71 @@ mod tests {
1513
1977
  raw: Some(vec![]),
1514
1978
  };
1515
1979
 
1516
- let mut stream = open_uni(&mut b, HTTP3_CONTROL_STREAM_TYPE_ID).unwrap();
1517
- frame.to_bytes(&mut b).unwrap();
1980
+ for ty in [
1981
+ CANCEL_PUSH_FRAME_TYPE_ID,
1982
+ GOAWAY_FRAME_TYPE_ID,
1983
+ MAX_PUSH_FRAME_TYPE_ID,
1984
+ ] {
1985
+ // These frames must have a size between 1 and 8 bytes inclusive.
1986
+ for size in [0, 9] {
1987
+ let mut d = vec![42; 128];
1988
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1989
+
1990
+ // Control stream needs a SETTINGS frame to transition it into
1991
+ // being able to parse other frame types.
1992
+ let mut stream = open_uni(&mut b, HTTP3_CONTROL_STREAM_TYPE_ID).unwrap();
1993
+ settings.to_bytes(&mut b).unwrap();
1994
+
1995
+ // Write bytes as far as frame length.
1996
+ b.put_varint(ty).unwrap();
1997
+ b.put_varint(size).unwrap();
1998
+
1999
+ let mut cursor = std::io::Cursor::new(d);
2000
+
2001
+ parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor).unwrap();
2002
+
2003
+ // Skip SETTINGS frame type.
2004
+ parse_skip_frame(&mut stream, &mut cursor).unwrap();
2005
+
2006
+ // Parse frame type.
2007
+ stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
2008
+ let frame_ty = stream.try_consume_varint().unwrap();
2009
+ assert_eq!(frame_ty, ty);
2010
+
2011
+ stream.set_frame_type(frame_ty).unwrap();
2012
+ assert_eq!(stream.state, State::FramePayloadLen);
2013
+
2014
+ // Parse frame payload length.
2015
+ stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
2016
+ let frame_payload_len = stream.try_consume_varint().unwrap();
2017
+ assert_eq!(
2018
+ Err(Error::FrameError),
2019
+ stream.set_frame_payload_len(frame_payload_len)
2020
+ );
2021
+ }
2022
+ }
2023
+ }
2024
+
2025
+ #[test]
2026
+ fn zero_length_push_promise() {
2027
+ let mut d = vec![42; 128];
2028
+ let mut b = octets::OctetsMut::with_slice(&mut d);
2029
+
2030
+ let mut stream = open_remote_request_stream();
2031
+
2032
+ assert_eq!(stream.ty, Some(Type::Request));
2033
+ assert_eq!(stream.state, State::FrameType);
1518
2034
 
1519
2035
  // Write a 0-length payload frame.
1520
- b.put_varint(CANCEL_PUSH_FRAME_TYPE_ID).unwrap();
2036
+ b.put_varint(PUSH_PROMISE_FRAME_TYPE_ID).unwrap();
1521
2037
  b.put_varint(0).unwrap();
1522
2038
 
1523
2039
  let mut cursor = std::io::Cursor::new(d);
1524
2040
 
1525
- parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
1526
- .unwrap();
1527
-
1528
- // Skip SETTINGS frame type.
1529
- parse_skip_frame(&mut stream, &mut cursor).unwrap();
1530
-
1531
2041
  // Parse frame type.
1532
2042
  stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
1533
2043
  let frame_ty = stream.try_consume_varint().unwrap();
1534
- assert_eq!(frame_ty, CANCEL_PUSH_FRAME_TYPE_ID);
2044
+ assert_eq!(frame_ty, PUSH_PROMISE_FRAME_TYPE_ID);
1535
2045
 
1536
2046
  stream.set_frame_type(frame_ty).unwrap();
1537
2047
  assert_eq!(stream.state, State::FramePayloadLen);
@@ -1546,50 +2056,355 @@ mod tests {
1546
2056
  }
1547
2057
 
1548
2058
  #[test]
1549
- fn zero_length_max_push_id() {
1550
- let mut d = vec![42; 128];
2059
+ /// Drip feed data in chunks that exactly match spare capacity, forcing
2060
+ /// spare to hit 0 on every re-entry to try_fill_buffer_for_tests.
2061
+ fn large_state_buf_exact_spare_drip_feed() {
2062
+ const LARGE_HEADER_LEN: usize = 16384;
2063
+ let mut stream = Stream::new(
2064
+ 0,
2065
+ false,
2066
+ LARGE_HEADER_LEN as u64,
2067
+ PRIORITY_UPDATE_FRAME_PAYLOAD_MAX_SIZE_DEFAULT,
2068
+ );
2069
+
2070
+ let mut d = vec![42; 20000];
1551
2071
  let mut b = octets::OctetsMut::with_slice(&mut d);
1552
2072
 
1553
- let frame = Frame::Settings {
1554
- max_field_section_size: None,
1555
- qpack_max_table_capacity: None,
1556
- qpack_blocked_streams: None,
1557
- connect_protocol_enabled: None,
1558
- h3_datagram: None,
1559
- grease: None,
1560
- additional_settings: None,
1561
- raw: Some(vec![]),
2073
+ // Use nonzero fill to catch off-by-one errors in payload offset.
2074
+ let header_block = vec![0xAB; LARGE_HEADER_LEN];
2075
+ let hdrs = Frame::Headers {
2076
+ header_block: header_block.clone(),
1562
2077
  };
1563
2078
 
1564
- let mut stream = open_uni(&mut b, HTTP3_CONTROL_STREAM_TYPE_ID).unwrap();
1565
- frame.to_bytes(&mut b).unwrap();
1566
-
1567
- // Write a 0-length payload frame.
1568
- b.put_varint(MAX_PUSH_FRAME_TYPE_ID).unwrap();
1569
- b.put_varint(0).unwrap();
2079
+ hdrs.to_bytes(&mut b).unwrap();
1570
2080
 
1571
2081
  let mut cursor = std::io::Cursor::new(d);
1572
2082
 
1573
- parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
1574
- .unwrap();
2083
+ // Parse frame type.
2084
+ stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
2085
+ let frame_ty = stream.try_consume_varint().unwrap();
2086
+ assert_eq!(frame_ty, HEADERS_FRAME_TYPE_ID);
2087
+ stream.set_frame_type(frame_ty).unwrap();
1575
2088
 
1576
- // Skip SETTINGS frame type.
1577
- parse_skip_frame(&mut stream, &mut cursor).unwrap();
2089
+ // Parse frame payload length.
2090
+ let frame_payload_len = parse_multibyte_varint(&mut stream, &mut cursor).unwrap();
2091
+ assert_eq!(frame_payload_len, LARGE_HEADER_LEN as u64);
2092
+
2093
+ stream.set_frame_payload_len(frame_payload_len).unwrap();
2094
+ assert_eq!(stream.state, State::FramePayload);
2095
+
2096
+ // After state transition, initial reserve gives us
2097
+ // MAX_STATE_BUF_ALLOC_SIZE of spare capacity.
2098
+ assert_eq!(stream.state_buf.capacity(), MAX_STATE_BUF_ALLOC_SIZE);
2099
+ assert_eq!(stream.state_buf.len(), 0);
2100
+
2101
+ // Save the full cursor data then replace with an empty one so we
2102
+ // can drip feed exact amounts.
2103
+ let full_data = cursor.into_inner();
2104
+ let pos = 5; // 1 byte frame type + 4 byte varint (16384 >= 2^14)
2105
+ let payload_data = &full_data[pos..pos + LARGE_HEADER_LEN];
2106
+
2107
+ // Drip feed in chunks that exactly match MAX_STATE_BUF_ALLOC_SIZE.
2108
+ // Each chunk fully consumes spare, so on re-entry spare is exactly 0
2109
+ // and spare_state_buf must reserve.
2110
+ let mut fed = 0;
2111
+ while fed + MAX_STATE_BUF_ALLOC_SIZE <= LARGE_HEADER_LEN {
2112
+ let chunk = &payload_data[fed..fed + MAX_STATE_BUF_ALLOC_SIZE];
2113
+ let mut chunk_cursor = std::io::Cursor::new(chunk.to_vec());
2114
+
2115
+ let result = stream.try_fill_buffer_for_tests(&mut chunk_cursor);
2116
+
2117
+ fed += MAX_STATE_BUF_ALLOC_SIZE;
2118
+
2119
+ if fed < LARGE_HEADER_LEN {
2120
+ assert_eq!(result, Err(Error::Done));
2121
+ assert_eq!(stream.state_off, fed);
2122
+ // spare_state_buf should have reserved on each re-entry
2123
+ // since previous chunk consumed all spare.
2124
+ assert!(stream.state_buf.capacity() >= fed);
2125
+ } else {
2126
+ assert_eq!(result, Ok(()));
2127
+ assert_eq!(stream.state_off, LARGE_HEADER_LEN);
2128
+ }
2129
+ }
2130
+
2131
+ assert_eq!(
2132
+ stream.try_consume_frame(),
2133
+ Ok((hdrs, LARGE_HEADER_LEN as u64))
2134
+ );
2135
+ assert_eq!(stream.state, State::FrameType);
2136
+ }
2137
+
2138
+ #[test]
2139
+ /// Drip feed data in chunks smaller than spare capacity, so spare is
2140
+ /// small but nonzero on re-entry. Verifies that the buffer eventually
2141
+ /// grows when spare is fully consumed across multiple small reads.
2142
+ fn large_state_buf_small_leftover_spare() {
2143
+ const LARGE_HEADER_LEN: usize = 260000;
2144
+ let mut stream = Stream::new(
2145
+ 0,
2146
+ false,
2147
+ LARGE_HEADER_LEN as u64,
2148
+ PRIORITY_UPDATE_FRAME_PAYLOAD_MAX_SIZE_DEFAULT,
2149
+ );
2150
+
2151
+ let mut d = vec![42; LARGE_HEADER_LEN + 10];
2152
+ let mut b = octets::OctetsMut::with_slice(&mut d);
2153
+
2154
+ let header_block = vec![0; LARGE_HEADER_LEN];
2155
+ let hdrs = Frame::Headers {
2156
+ header_block: header_block.clone(),
2157
+ };
2158
+
2159
+ hdrs.to_bytes(&mut b).unwrap();
2160
+
2161
+ let mut cursor = std::io::Cursor::new(d);
1578
2162
 
1579
2163
  // Parse frame type.
1580
2164
  stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
1581
2165
  let frame_ty = stream.try_consume_varint().unwrap();
1582
- assert_eq!(frame_ty, MAX_PUSH_FRAME_TYPE_ID);
1583
-
2166
+ assert_eq!(frame_ty, HEADERS_FRAME_TYPE_ID);
1584
2167
  stream.set_frame_type(frame_ty).unwrap();
1585
- assert_eq!(stream.state, State::FramePayloadLen);
1586
2168
 
1587
2169
  // Parse frame payload length.
2170
+ let frame_payload_len = parse_multibyte_varint(&mut stream, &mut cursor).unwrap();
2171
+ assert_eq!(frame_payload_len, LARGE_HEADER_LEN as u64);
2172
+
2173
+ stream.set_frame_payload_len(frame_payload_len).unwrap();
2174
+ assert_eq!(stream.state, State::FramePayload);
2175
+ assert_eq!(stream.state_buf.capacity(), MAX_STATE_BUF_ALLOC_SIZE);
2176
+
2177
+ let full_data = cursor.into_inner();
2178
+ let pos = 5; // 1 byte frame type + 4 byte varint length
2179
+ let payload_data = &full_data[pos..pos + LARGE_HEADER_LEN];
2180
+
2181
+ // Drip feed 1000-byte chunks. These don't align with the 4096 spare
2182
+ // capacity, so spare will be nonzero but shrinking on each re-entry
2183
+ // until it hits 0 and forces a reserve.
2184
+ let chunk_size = 1000;
2185
+ let mut fed = 0;
2186
+ while fed < LARGE_HEADER_LEN {
2187
+ let end = std::cmp::min(fed + chunk_size, LARGE_HEADER_LEN);
2188
+ let chunk = &payload_data[fed..end];
2189
+ let mut chunk_cursor = std::io::Cursor::new(chunk.to_vec());
2190
+
2191
+ let result = stream.try_fill_buffer_for_tests(&mut chunk_cursor);
2192
+
2193
+ fed = end;
2194
+
2195
+ if fed < LARGE_HEADER_LEN {
2196
+ assert_eq!(result, Err(Error::Done));
2197
+ assert_eq!(stream.state_off, fed);
2198
+ // Capacity must always be at least as large as what we've
2199
+ // buffered.
2200
+ assert!(stream.state_buf.capacity() >= stream.state_buf.len());
2201
+ // Capacity should grow incrementally. The allocator may
2202
+ // over-allocate (typically doubling), so we allow up to
2203
+ // 2x (bytes_read + reserve_size) to account for that.
2204
+ // The key property: capacity never jumps to the full
2205
+ // frame size before we've read a proportional amount.
2206
+ assert!(
2207
+ stream.state_buf.capacity() <= (fed + MAX_STATE_BUF_ALLOC_SIZE) * 2,
2208
+ "capacity {} grew too far ahead of bytes read {} \
2209
+ (max alloc size {})",
2210
+ stream.state_buf.capacity(),
2211
+ fed,
2212
+ MAX_STATE_BUF_ALLOC_SIZE,
2213
+ );
2214
+ } else {
2215
+ assert_eq!(result, Ok(()));
2216
+ }
2217
+ }
2218
+
2219
+ assert_eq!(
2220
+ stream.try_consume_frame(),
2221
+ Ok((hdrs, LARGE_HEADER_LEN as u64))
2222
+ );
2223
+ assert_eq!(stream.state, State::FrameType);
2224
+ }
2225
+
2226
+ #[test]
2227
+ fn large_state_buf_allocation() {
2228
+ const LARGE_HEADER_LEN: usize = 260000;
2229
+ let mut stream = Stream::new(
2230
+ 0,
2231
+ false,
2232
+ LARGE_HEADER_LEN as u64,
2233
+ PRIORITY_UPDATE_FRAME_PAYLOAD_MAX_SIZE_DEFAULT,
2234
+ );
2235
+ assert_eq!(stream.state_buf.capacity(), 16);
2236
+
2237
+ let mut d = vec![42; 5];
2238
+ let mut b = octets::OctetsMut::with_slice(&mut d);
2239
+
2240
+ // Drip feed a large HEADERS frame into the "stream"
2241
+ b.put_varint(HEADERS_FRAME_TYPE_ID).unwrap();
2242
+ b.put_varint(LARGE_HEADER_LEN as u64).unwrap();
2243
+
2244
+ let mut cursor = std::io::Cursor::new(d);
2245
+
2246
+ // Parse the HEADERS frame type.
1588
2247
  stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
2248
+ assert_eq!(stream.state_buf.capacity(), 16);
2249
+
2250
+ let frame_ty = stream.try_consume_varint().unwrap();
2251
+ assert_eq!(frame_ty, HEADERS_FRAME_TYPE_ID);
2252
+ assert_eq!(stream.state_buf.capacity(), 16);
2253
+
2254
+ stream.set_frame_type(frame_ty).unwrap();
2255
+ assert_eq!(stream.state_buf.capacity(), 16);
2256
+
2257
+ // Parse the HEADERS frame payload length.
2258
+ stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
2259
+ assert_eq!(stream.state_buf.capacity(), 16);
2260
+
2261
+ // Parse fails because we need more bytes for the 4-byte encoded length.
2262
+ // This trial then sets the expected buffer size for us to fill.
2263
+ assert_eq!(stream.try_consume_varint(), Err(Error::Done));
2264
+ stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
2265
+ assert_eq!(stream.state_buf.capacity(), 16);
2266
+
1589
2267
  let frame_payload_len = stream.try_consume_varint().unwrap();
2268
+ assert_eq!(frame_payload_len, LARGE_HEADER_LEN as u64);
2269
+ assert_eq!(stream.state_buf.capacity(), 16);
2270
+
2271
+ stream.set_frame_payload_len(frame_payload_len).unwrap();
2272
+ assert_eq!(stream.state_buf.capacity(), MAX_STATE_BUF_ALLOC_SIZE);
2273
+
2274
+ /// Assert state_len, state_off, and state_buf.capacity() in one
2275
+ /// call, with labeled messages on failure.
2276
+ fn assert_state_buf_props(stream: &Stream, len: usize, off: usize, capacity: usize) {
2277
+ assert_eq!(stream.state_len, len, "state_len");
2278
+ assert_eq!(stream.state_off, off, "state_off");
2279
+ assert_eq!(stream.state_buf.capacity(), capacity, "capacity");
2280
+ }
2281
+
2282
+ // Start consuming HEADERS frame payload. It fails because the cursor
2283
+ // doesn't have the target size of data in it.
1590
2284
  assert_eq!(
1591
- Err(Error::FrameError),
1592
- stream.set_frame_payload_len(frame_payload_len)
2285
+ stream.try_fill_buffer_for_tests(&mut cursor),
2286
+ Err(Error::Done)
2287
+ );
2288
+ assert_state_buf_props(&stream, LARGE_HEADER_LEN, 0, MAX_STATE_BUF_ALLOC_SIZE);
2289
+
2290
+ // Drip feed data into the cursor to emulate a series of transport
2291
+ // reads. After set_frame_payload_len, the initial reserve gives us
2292
+ // MAX_STATE_BUF_ALLOC_SIZE (4096) bytes of spare capacity.
2293
+
2294
+ // Feed 2048 bytes: fits within the 4096 spare, no growth needed.
2295
+ cursor.get_mut().extend_from_slice(&[123; 2048]);
2296
+ assert_eq!(
2297
+ stream.try_fill_buffer_for_tests(&mut cursor),
2298
+ Err(Error::Done)
2299
+ );
2300
+ assert_state_buf_props(&stream, LARGE_HEADER_LEN, 2048, MAX_STATE_BUF_ALLOC_SIZE);
2301
+
2302
+ // Feed 1024 bytes: still fits in the remaining 2048 spare.
2303
+ cursor.get_mut().extend_from_slice(&[123; 1024]);
2304
+ assert_eq!(
2305
+ stream.try_fill_buffer_for_tests(&mut cursor),
2306
+ Err(Error::Done)
2307
+ );
2308
+ assert_state_buf_props(&stream, LARGE_HEADER_LEN, 3072, MAX_STATE_BUF_ALLOC_SIZE);
2309
+
2310
+ // Feed 512 bytes: fits in the remaining 1024 spare. Capacity
2311
+ // between state_off 4096 and 6144 stays stable because spare
2312
+ // doesn't hit 0.
2313
+ cursor.get_mut().extend_from_slice(&[123; 512]);
2314
+ assert_eq!(
2315
+ stream.try_fill_buffer_for_tests(&mut cursor),
2316
+ Err(Error::Done)
2317
+ );
2318
+ assert_state_buf_props(&stream, LARGE_HEADER_LEN, 3584, MAX_STATE_BUF_ALLOC_SIZE);
2319
+
2320
+ // Feed 4096 bytes: exceeds the remaining 512 spare. The loop reads
2321
+ // 512 to fill spare, then spare hits 0, triggers a reserve of
2322
+ // MAX_STATE_BUF_ALLOC_SIZE (4096), and reads the remaining 3584.
2323
+ // The allocator doubles capacity from 4096 to 8192.
2324
+ cursor.get_mut().extend_from_slice(&[123; 4096]);
2325
+ assert_eq!(
2326
+ stream.try_fill_buffer_for_tests(&mut cursor),
2327
+ Err(Error::Done)
2328
+ );
2329
+ assert_state_buf_props(
2330
+ &stream,
2331
+ LARGE_HEADER_LEN,
2332
+ 7680,
2333
+ MAX_STATE_BUF_ALLOC_SIZE * 2,
2334
+ );
2335
+
2336
+ // Each subsequent feed exceeds spare (512 after the previous
2337
+ // reserve+read), so the loop drains the leftover spare, hits 0,
2338
+ // reserves MAX_STATE_BUF_ALLOC_SIZE, and the allocator doubles.
2339
+ cursor.get_mut().extend_from_slice(&[123; 8192]);
2340
+ assert_eq!(
2341
+ stream.try_fill_buffer_for_tests(&mut cursor),
2342
+ Err(Error::Done)
2343
+ );
2344
+ assert_state_buf_props(
2345
+ &stream,
2346
+ LARGE_HEADER_LEN,
2347
+ 15872,
2348
+ MAX_STATE_BUF_ALLOC_SIZE * 4,
2349
+ );
2350
+
2351
+ cursor.get_mut().extend_from_slice(&[123; 16384]);
2352
+ assert_eq!(
2353
+ stream.try_fill_buffer_for_tests(&mut cursor),
2354
+ Err(Error::Done)
2355
+ );
2356
+ assert_state_buf_props(
2357
+ &stream,
2358
+ LARGE_HEADER_LEN,
2359
+ 32256,
2360
+ MAX_STATE_BUF_ALLOC_SIZE * 8,
2361
+ );
2362
+
2363
+ cursor.get_mut().extend_from_slice(&[123; 32768]);
2364
+ assert_eq!(
2365
+ stream.try_fill_buffer_for_tests(&mut cursor),
2366
+ Err(Error::Done)
2367
+ );
2368
+ assert_state_buf_props(
2369
+ &stream,
2370
+ LARGE_HEADER_LEN,
2371
+ 65024,
2372
+ MAX_STATE_BUF_ALLOC_SIZE * 16,
1593
2373
  );
2374
+
2375
+ cursor.get_mut().extend_from_slice(&[123; 65536]);
2376
+ assert_eq!(
2377
+ stream.try_fill_buffer_for_tests(&mut cursor),
2378
+ Err(Error::Done)
2379
+ );
2380
+ assert_state_buf_props(
2381
+ &stream,
2382
+ LARGE_HEADER_LEN,
2383
+ 130560,
2384
+ MAX_STATE_BUF_ALLOC_SIZE * 32,
2385
+ );
2386
+
2387
+ // Feed the remaining bytes to complete the frame.
2388
+ let remaining = LARGE_HEADER_LEN - 130560;
2389
+ cursor.get_mut().extend_from_slice(&vec![123; remaining]);
2390
+ assert_eq!(stream.try_fill_buffer_for_tests(&mut cursor), Ok(()));
2391
+ assert_state_buf_props(
2392
+ &stream,
2393
+ LARGE_HEADER_LEN,
2394
+ LARGE_HEADER_LEN,
2395
+ MAX_STATE_BUF_ALLOC_SIZE * 64,
2396
+ );
2397
+
2398
+ let header_block = vec![123; LARGE_HEADER_LEN];
2399
+ let hdrs = Frame::Headers {
2400
+ header_block: header_block.clone(),
2401
+ };
2402
+ assert_eq!(
2403
+ stream.try_consume_frame(),
2404
+ Ok((hdrs, LARGE_HEADER_LEN as u64))
2405
+ );
2406
+ assert_eq!(stream.state, State::FrameType);
2407
+
2408
+ assert_state_buf_props(&stream, 1, 0, MAX_STATE_BUF_ALLOC_SIZE * 64);
1594
2409
  }
1595
2410
  }