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.
- package/Cargo.lock +153 -226
- package/Cargo.toml +5 -5
- package/README.md +4 -4
- package/crates/echo-server/src/bin/gen-test-cert.rs +1 -1
- package/crates/native/Cargo.toml +1 -1
- package/crates/native/src/config.rs +13 -1
- package/crates/native/src/driver.rs +249 -91
- package/crates/native/src/lib.rs +9 -10
- package/crates/native/src/parser_memory.rs +1 -0
- package/crates/native/src/server.rs +197 -182
- package/crates/native/src/session.rs +329 -177
- package/crates/native/src/test_support.rs +2 -2
- package/crates/wtcore/src/h3.rs +166 -10
- package/dist/index.js +92 -45
- package/dist/index.js.map +2 -2
- package/dist/index.mjs +92 -45
- package/dist/index.mjs.map +2 -2
- package/dist/native.d.ts +9 -4
- package/package.json +14 -11
- package/prebuilds/darwin-arm64/rwebtransport.node +0 -0
- package/prebuilds/linux-arm64/rwebtransport.node +0 -0
- package/prebuilds/linux-x64/rwebtransport.node +0 -0
- package/prebuilds/win32-x64/rwebtransport.node +0 -0
- package/scripts/build-linux-prebuilt.sh +46 -0
- package/scripts/build.js +10 -3
- package/vendor/quiche/AGENTS.md +10 -0
- package/vendor/quiche/Cargo.lock +239 -248
- package/vendor/quiche/Cargo.toml +23 -10
- package/vendor/quiche/examples/Makefile +4 -4
- package/vendor/quiche/examples/client.rs +10 -28
- package/vendor/quiche/examples/http3-client.rs +20 -34
- package/vendor/quiche/examples/http3-server.rs +47 -78
- package/vendor/quiche/examples/server.rs +19 -49
- package/vendor/quiche/include/quiche.h +35 -4
- package/vendor/quiche/src/build.rs +17 -0
- package/vendor/quiche/src/cid.rs +129 -61
- package/vendor/quiche/src/crypto/boringssl.rs +98 -86
- package/vendor/quiche/src/crypto/mod.rs +64 -77
- package/vendor/quiche/src/dgram.rs +2 -3
- package/vendor/quiche/src/error.rs +22 -20
- package/vendor/quiche/src/ffi.rs +558 -280
- package/vendor/quiche/src/flowcontrol.rs +0 -7
- package/vendor/quiche/src/frame.rs +134 -135
- package/vendor/quiche/src/h3/ffi.rs +73 -60
- package/vendor/quiche/src/h3/frame.rs +70 -90
- package/vendor/quiche/src/h3/mod.rs +1024 -593
- package/vendor/quiche/src/h3/qpack/decoder.rs +248 -34
- package/vendor/quiche/src/h3/qpack/dynamic_table.rs +859 -0
- package/vendor/quiche/src/h3/qpack/encoder.rs +14 -17
- package/vendor/quiche/src/h3/qpack/mod.rs +48 -0
- package/vendor/quiche/src/h3/qpack/static_table.rs +86 -73
- package/vendor/quiche/src/h3/stream.rs +1009 -194
- package/vendor/quiche/src/lib.rs +1346 -1195
- package/vendor/quiche/src/minmax.rs +2 -6
- package/vendor/quiche/src/packet.rs +420 -552
- package/vendor/quiche/src/path.rs +202 -72
- package/vendor/quiche/src/pmtud.rs +18 -16
- package/vendor/quiche/src/ranges.rs +184 -82
- package/vendor/quiche/src/recovery/AGENTS.md +5 -2
- package/vendor/quiche/src/recovery/bandwidth.rs +59 -40
- package/vendor/quiche/src/recovery/bytes_in_flight.rs +2 -2
- package/vendor/quiche/src/recovery/congestion/cubic.rs +38 -47
- package/vendor/quiche/src/recovery/congestion/delivery_rate.rs +54 -60
- package/vendor/quiche/src/recovery/congestion/hystart.rs +6 -10
- package/vendor/quiche/src/recovery/congestion/mod.rs +110 -42
- package/vendor/quiche/src/recovery/congestion/prr.rs +4 -1
- package/vendor/quiche/src/recovery/congestion/recovery.rs +91 -95
- package/vendor/quiche/src/recovery/congestion/reno.rs +17 -12
- package/vendor/quiche/src/recovery/congestion/test_sender.rs +8 -27
- package/vendor/quiche/src/recovery/gcongestion/bbr/bandwidth_sampler.rs +159 -247
- package/vendor/quiche/src/recovery/gcongestion/bbr/windowed_filter.rs +9 -14
- package/vendor/quiche/src/recovery/gcongestion/bbr2/drain.rs +18 -15
- package/vendor/quiche/src/recovery/gcongestion/bbr2/mode.rs +43 -28
- package/vendor/quiche/src/recovery/gcongestion/bbr2/network_model.rs +349 -76
- package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_bw.rs +147 -195
- package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_rtt.rs +29 -27
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min.rs +180 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min_tests.rs +221 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm.rs +395 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm_tests.rs +473 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/mod.rs +175 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/startup.rs +33 -26
- package/vendor/quiche/src/recovery/gcongestion/bbr2.rs +107 -60
- package/vendor/quiche/src/recovery/gcongestion/mod.rs +64 -11
- package/vendor/quiche/src/recovery/gcongestion/pacer.rs +34 -25
- package/vendor/quiche/src/recovery/gcongestion/recovery.rs +81 -86
- package/vendor/quiche/src/recovery/mod.rs +414 -173
- package/vendor/quiche/src/recovery/rtt.rs +8 -5
- package/vendor/quiche/src/stream/mod.rs +864 -133
- package/vendor/quiche/src/stream/recv_buf.rs +471 -172
- package/vendor/quiche/src/stream/send_buf.rs +338 -81
- package/vendor/quiche/src/test_utils.rs +78 -64
- package/vendor/quiche/src/tests.rs +2559 -1335
- package/vendor/quiche/src/tls/boringssl.rs +60 -63
- package/vendor/quiche/src/tls/mod.rs +146 -193
- 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(
|
|
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:
|
|
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
|
-
|
|
426
|
-
|
|
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
|
-
|
|
441
|
-
|
|
447
|
+
let (state, resize) = match self.frame_type {
|
|
448
|
+
Some(frame::DATA_FRAME_TYPE_ID) => (State::Data, false),
|
|
442
449
|
|
|
443
|
-
|
|
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
|
-
|
|
455
|
+
(State::FramePayload, true)
|
|
456
|
+
}
|
|
447
457
|
|
|
448
|
-
|
|
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
|
-
|
|
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,
|
|
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
|
-
|
|
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.
|
|
647
|
+
let read = match conn.stream_discard(self.id, len) {
|
|
470
648
|
Ok((len, fin)) => {
|
|
471
|
-
|
|
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
|
-
|
|
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
|
|
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
|
-
"{}
|
|
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
|
-
|
|
740
|
+
loop {
|
|
741
|
+
let spare_buf = self.spare_state_buf();
|
|
742
|
+
let spare_len = spare_buf.len();
|
|
579
743
|
|
|
580
|
-
|
|
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
|
-
|
|
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.
|
|
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 =
|
|
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,
|
|
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,
|
|
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,
|
|
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
|
-
|
|
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(
|
|
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,
|
|
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
|
-
|
|
785
|
-
|
|
786
|
-
|
|
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 =
|
|
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 =
|
|
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 =
|
|
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 =
|
|
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
|
-
|
|
1420
|
-
fn
|
|
1421
|
-
|
|
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
|
-
|
|
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
|
|
1436
|
-
|
|
1841
|
+
let mut d = vec![42; 20000];
|
|
1842
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
1437
1843
|
|
|
1438
|
-
//
|
|
1439
|
-
|
|
1440
|
-
|
|
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,
|
|
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
|
-
|
|
1463
|
-
|
|
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
|
|
1469
|
-
let
|
|
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
|
-
|
|
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
|
-
|
|
1475
|
-
assert_eq!(stream.state, State::FrameType);
|
|
1920
|
+
settings.to_bytes(&mut b).unwrap();
|
|
1476
1921
|
|
|
1477
|
-
|
|
1478
|
-
|
|
1479
|
-
|
|
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
|
-
|
|
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,
|
|
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
|
-
|
|
1496
|
-
|
|
1962
|
+
stream.set_frame_payload_len(frame_payload_len),
|
|
1963
|
+
Err(Error::ExcessiveLoad)
|
|
1497
1964
|
);
|
|
1498
1965
|
}
|
|
1499
1966
|
|
|
1500
1967
|
#[test]
|
|
1501
|
-
fn
|
|
1502
|
-
let
|
|
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
|
-
|
|
1517
|
-
|
|
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(
|
|
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,
|
|
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
|
-
|
|
1550
|
-
|
|
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
|
-
|
|
1554
|
-
|
|
1555
|
-
|
|
1556
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1574
|
-
|
|
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
|
-
//
|
|
1577
|
-
|
|
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,
|
|
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
|
-
|
|
1592
|
-
|
|
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
|
}
|