rwebtransport 0.1.0
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 +666 -0
- package/Cargo.toml +31 -0
- package/LICENSE +202 -0
- package/NOTICE +41 -0
- package/README.md +550 -0
- package/crates/echo-server/Cargo.toml +20 -0
- package/crates/echo-server/src/main.rs +666 -0
- package/crates/native/Cargo.toml +23 -0
- package/crates/native/src/config.rs +129 -0
- package/crates/native/src/driver.rs +463 -0
- package/crates/native/src/lib.rs +821 -0
- package/crates/native/src/server.rs +718 -0
- package/crates/native/src/session.rs +1191 -0
- package/crates/native/src/tls.rs +96 -0
- package/crates/wtcore/Cargo.toml +15 -0
- package/crates/wtcore/src/h3.rs +226 -0
- package/crates/wtcore/src/lib.rs +9 -0
- package/dist/datagrams.d.ts +16 -0
- package/dist/errors.d.ts +10 -0
- package/dist/index.d.ts +7 -0
- package/dist/index.js +1512 -0
- package/dist/index.js.map +1 -0
- package/dist/index.mjs +1473 -0
- package/dist/index.mjs.map +1 -0
- package/dist/loader.d.ts +2 -0
- package/dist/native.d.ts +226 -0
- package/dist/server.d.ts +44 -0
- package/dist/streams.d.ts +14 -0
- package/dist/types.d.ts +24 -0
- package/dist/webtransport.d.ts +20 -0
- package/package.json +79 -0
- package/prebuilds/win32-x64/rwebtransport.node +0 -0
- package/scripts/bench.mjs +180 -0
- package/scripts/build.js +67 -0
- package/scripts/postinstall.js +67 -0
- package/scripts/setup-unix.sh +129 -0
- package/scripts/setup-windows.ps1 +229 -0
- package/vendor/quiche/AGENTS.md +75 -0
- package/vendor/quiche/COPYING +23 -0
- package/vendor/quiche/Cargo.lock +1212 -0
- package/vendor/quiche/Cargo.toml +215 -0
- package/vendor/quiche/README.md +466 -0
- package/vendor/quiche/examples/Makefile +46 -0
- package/vendor/quiche/examples/README.md +20 -0
- package/vendor/quiche/examples/cert-big.crt +90 -0
- package/vendor/quiche/examples/cert.crt +18 -0
- package/vendor/quiche/examples/cert.key +28 -0
- package/vendor/quiche/examples/client.c +343 -0
- package/vendor/quiche/examples/client.rs +281 -0
- package/vendor/quiche/examples/gen-certs.sh +15 -0
- package/vendor/quiche/examples/http3-client.c +473 -0
- package/vendor/quiche/examples/http3-client.rs +349 -0
- package/vendor/quiche/examples/http3-server.c +614 -0
- package/vendor/quiche/examples/http3-server.rs +680 -0
- package/vendor/quiche/examples/qpack-decode.rs +87 -0
- package/vendor/quiche/examples/qpack-encode.rs +88 -0
- package/vendor/quiche/examples/rootca.crt +21 -0
- package/vendor/quiche/examples/server.c +529 -0
- package/vendor/quiche/examples/server.rs +529 -0
- package/vendor/quiche/include/quiche.h +1282 -0
- package/vendor/quiche/quiche.svg +1 -0
- package/vendor/quiche/src/buffers.rs +105 -0
- package/vendor/quiche/src/build.rs +66 -0
- package/vendor/quiche/src/cid.rs +1079 -0
- package/vendor/quiche/src/crypto/boringssl.rs +373 -0
- package/vendor/quiche/src/crypto/mod.rs +671 -0
- package/vendor/quiche/src/dgram.rs +118 -0
- package/vendor/quiche/src/error.rs +263 -0
- package/vendor/quiche/src/ffi.rs +2290 -0
- package/vendor/quiche/src/flowcontrol.rs +246 -0
- package/vendor/quiche/src/frame.rs +2172 -0
- package/vendor/quiche/src/h3/AGENTS.md +54 -0
- package/vendor/quiche/src/h3/ffi.rs +442 -0
- package/vendor/quiche/src/h3/frame.rs +1404 -0
- package/vendor/quiche/src/h3/mod.rs +8223 -0
- package/vendor/quiche/src/h3/qpack/decoder.rs +288 -0
- package/vendor/quiche/src/h3/qpack/encoder.rs +235 -0
- package/vendor/quiche/src/h3/qpack/mod.rs +202 -0
- package/vendor/quiche/src/h3/qpack/static_table.rs +323 -0
- package/vendor/quiche/src/h3/stream.rs +1595 -0
- package/vendor/quiche/src/lib.rs +9556 -0
- package/vendor/quiche/src/minmax.rs +446 -0
- package/vendor/quiche/src/packet.rs +2334 -0
- package/vendor/quiche/src/path.rs +1374 -0
- package/vendor/quiche/src/pmtud.rs +652 -0
- package/vendor/quiche/src/rand.rs +64 -0
- package/vendor/quiche/src/range_buf.rs +186 -0
- package/vendor/quiche/src/ranges.rs +755 -0
- package/vendor/quiche/src/recovery/AGENTS.md +80 -0
- package/vendor/quiche/src/recovery/bandwidth.rs +565 -0
- package/vendor/quiche/src/recovery/bytes_in_flight.rs +179 -0
- package/vendor/quiche/src/recovery/congestion/cubic.rs +1038 -0
- package/vendor/quiche/src/recovery/congestion/delivery_rate.rs +514 -0
- package/vendor/quiche/src/recovery/congestion/hystart.rs +241 -0
- package/vendor/quiche/src/recovery/congestion/mod.rs +361 -0
- package/vendor/quiche/src/recovery/congestion/prr.rs +238 -0
- package/vendor/quiche/src/recovery/congestion/recovery.rs +1170 -0
- package/vendor/quiche/src/recovery/congestion/reno.rs +291 -0
- package/vendor/quiche/src/recovery/congestion/test_sender.rs +201 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr/bandwidth_sampler.rs +1947 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr/windowed_filter.rs +158 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr.rs +37 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/drain.rs +120 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/mode.rs +318 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/network_model.rs +784 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_bw.rs +729 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_rtt.rs +175 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/startup.rs +190 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2.rs +855 -0
- package/vendor/quiche/src/recovery/gcongestion/mod.rs +275 -0
- package/vendor/quiche/src/recovery/gcongestion/pacer.rs +294 -0
- package/vendor/quiche/src/recovery/gcongestion/recovery.rs +1384 -0
- package/vendor/quiche/src/recovery/mod.rs +3086 -0
- package/vendor/quiche/src/recovery/rtt.rs +152 -0
- package/vendor/quiche/src/stream/mod.rs +2210 -0
- package/vendor/quiche/src/stream/recv_buf.rs +1236 -0
- package/vendor/quiche/src/stream/send_buf.rs +849 -0
- package/vendor/quiche/src/test_utils.rs +681 -0
- package/vendor/quiche/src/tests.rs +12922 -0
- package/vendor/quiche/src/tls/boringssl.rs +375 -0
- package/vendor/quiche/src/tls/mod.rs +1245 -0
- package/vendor/quiche/src/transport_params.rs +628 -0
|
@@ -0,0 +1,1595 @@
|
|
|
1
|
+
// Copyright (C) 2019, Cloudflare, Inc.
|
|
2
|
+
// All rights reserved.
|
|
3
|
+
//
|
|
4
|
+
// Redistribution and use in source and binary forms, with or without
|
|
5
|
+
// modification, are permitted provided that the following conditions are
|
|
6
|
+
// met:
|
|
7
|
+
//
|
|
8
|
+
// * Redistributions of source code must retain the above copyright notice,
|
|
9
|
+
// this list of conditions and the following disclaimer.
|
|
10
|
+
//
|
|
11
|
+
// * Redistributions in binary form must reproduce the above copyright
|
|
12
|
+
// notice, this list of conditions and the following disclaimer in the
|
|
13
|
+
// documentation and/or other materials provided with the distribution.
|
|
14
|
+
//
|
|
15
|
+
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
|
|
16
|
+
// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
|
17
|
+
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
18
|
+
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
19
|
+
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
20
|
+
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
21
|
+
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
22
|
+
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
23
|
+
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
24
|
+
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
25
|
+
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
26
|
+
|
|
27
|
+
use crate::buffers::BufFactory;
|
|
28
|
+
|
|
29
|
+
use super::Error;
|
|
30
|
+
use super::Result;
|
|
31
|
+
|
|
32
|
+
use super::frame;
|
|
33
|
+
|
|
34
|
+
pub const HTTP3_CONTROL_STREAM_TYPE_ID: u64 = 0x0;
|
|
35
|
+
pub const HTTP3_PUSH_STREAM_TYPE_ID: u64 = 0x1;
|
|
36
|
+
pub const QPACK_ENCODER_STREAM_TYPE_ID: u64 = 0x2;
|
|
37
|
+
pub const QPACK_DECODER_STREAM_TYPE_ID: u64 = 0x3;
|
|
38
|
+
|
|
39
|
+
const MAX_STATE_BUF_SIZE: usize = (1 << 24) - 1;
|
|
40
|
+
|
|
41
|
+
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
42
|
+
pub enum Type {
|
|
43
|
+
Control,
|
|
44
|
+
Request,
|
|
45
|
+
Push,
|
|
46
|
+
QpackEncoder,
|
|
47
|
+
QpackDecoder,
|
|
48
|
+
Unknown,
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
impl Type {
|
|
52
|
+
#[cfg(feature = "qlog")]
|
|
53
|
+
pub fn to_qlog(self) -> qlog::events::http3::StreamType {
|
|
54
|
+
match self {
|
|
55
|
+
Type::Control => qlog::events::http3::StreamType::Control,
|
|
56
|
+
Type::Request => qlog::events::http3::StreamType::Request,
|
|
57
|
+
Type::Push => qlog::events::http3::StreamType::Push,
|
|
58
|
+
Type::QpackEncoder => qlog::events::http3::StreamType::QpackEncode,
|
|
59
|
+
Type::QpackDecoder => qlog::events::http3::StreamType::QpackDecode,
|
|
60
|
+
Type::Unknown => qlog::events::http3::StreamType::Unknown,
|
|
61
|
+
}
|
|
62
|
+
}
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
66
|
+
pub enum State {
|
|
67
|
+
/// Reading the stream's type.
|
|
68
|
+
StreamType,
|
|
69
|
+
|
|
70
|
+
/// Reading the stream's current frame's type.
|
|
71
|
+
FrameType,
|
|
72
|
+
|
|
73
|
+
/// Reading the stream's current frame's payload length.
|
|
74
|
+
FramePayloadLen,
|
|
75
|
+
|
|
76
|
+
/// Reading the stream's current frame's payload.
|
|
77
|
+
FramePayload,
|
|
78
|
+
|
|
79
|
+
/// Reading DATA payload.
|
|
80
|
+
Data,
|
|
81
|
+
|
|
82
|
+
/// Reading the push ID.
|
|
83
|
+
PushId,
|
|
84
|
+
|
|
85
|
+
/// Reading a QPACK instruction.
|
|
86
|
+
QpackInstruction,
|
|
87
|
+
|
|
88
|
+
/// Reading and discarding data.
|
|
89
|
+
Drain,
|
|
90
|
+
|
|
91
|
+
/// All data has been read.
|
|
92
|
+
Finished,
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
impl Type {
|
|
96
|
+
pub fn deserialize(v: u64) -> Result<Type> {
|
|
97
|
+
match v {
|
|
98
|
+
HTTP3_CONTROL_STREAM_TYPE_ID => Ok(Type::Control),
|
|
99
|
+
HTTP3_PUSH_STREAM_TYPE_ID => Ok(Type::Push),
|
|
100
|
+
QPACK_ENCODER_STREAM_TYPE_ID => Ok(Type::QpackEncoder),
|
|
101
|
+
QPACK_DECODER_STREAM_TYPE_ID => Ok(Type::QpackDecoder),
|
|
102
|
+
|
|
103
|
+
_ => Ok(Type::Unknown),
|
|
104
|
+
}
|
|
105
|
+
}
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
/// An HTTP/3 stream.
|
|
109
|
+
///
|
|
110
|
+
/// This maintains the HTTP/3 state for streams of any type (control, request,
|
|
111
|
+
/// QPACK, ...).
|
|
112
|
+
///
|
|
113
|
+
/// A number of bytes, depending on the current stream's state, is read from the
|
|
114
|
+
/// transport stream into the HTTP/3 stream's "state buffer". This intermediate
|
|
115
|
+
/// buffering is required due to the fact that data read from the transport
|
|
116
|
+
/// might not be complete (e.g. a varint might be split across multiple QUIC
|
|
117
|
+
/// packets).
|
|
118
|
+
///
|
|
119
|
+
/// When enough data to complete the current state has been buffered, it is
|
|
120
|
+
/// consumed from the state buffer and the stream is transitioned to the next
|
|
121
|
+
/// state (see `State` for a list of possible states).
|
|
122
|
+
#[derive(Debug)]
|
|
123
|
+
pub struct Stream {
|
|
124
|
+
/// The corresponding transport stream's ID.
|
|
125
|
+
id: u64,
|
|
126
|
+
|
|
127
|
+
/// The stream's type (if known).
|
|
128
|
+
ty: Option<Type>,
|
|
129
|
+
|
|
130
|
+
/// The current stream state.
|
|
131
|
+
state: State,
|
|
132
|
+
|
|
133
|
+
/// The buffer holding partial data for the current state.
|
|
134
|
+
state_buf: Vec<u8>,
|
|
135
|
+
|
|
136
|
+
/// The expected amount of bytes required to complete the state.
|
|
137
|
+
state_len: usize,
|
|
138
|
+
|
|
139
|
+
/// The write offset in the state buffer, that is, how many bytes have
|
|
140
|
+
/// already been read from the transport for the current state. When
|
|
141
|
+
/// it reaches `stream_len` the state can be completed.
|
|
142
|
+
state_off: usize,
|
|
143
|
+
|
|
144
|
+
/// The type of the frame currently being parsed.
|
|
145
|
+
frame_type: Option<u64>,
|
|
146
|
+
|
|
147
|
+
/// Whether the stream was created locally, or by the peer.
|
|
148
|
+
is_local: bool,
|
|
149
|
+
|
|
150
|
+
/// Whether the stream has been remotely initialized.
|
|
151
|
+
remote_initialized: bool,
|
|
152
|
+
|
|
153
|
+
/// Whether the stream has been locally initialized.
|
|
154
|
+
local_initialized: bool,
|
|
155
|
+
|
|
156
|
+
/// Whether the local send-side of the stream has finished.
|
|
157
|
+
local_finished: bool,
|
|
158
|
+
|
|
159
|
+
/// Whether a `Data` event has been triggered for this stream.
|
|
160
|
+
data_event_triggered: bool,
|
|
161
|
+
|
|
162
|
+
/// The last `PRIORITY_UPDATE` frame encoded field value, if any.
|
|
163
|
+
last_priority_update: Option<Vec<u8>>,
|
|
164
|
+
|
|
165
|
+
/// The count of HEADERS frames that have been received.
|
|
166
|
+
headers_received_count: usize,
|
|
167
|
+
|
|
168
|
+
/// Whether a DATA frame has been received.
|
|
169
|
+
data_received: bool,
|
|
170
|
+
|
|
171
|
+
/// Whether a trailing HEADER field has been sent.
|
|
172
|
+
trailers_sent: bool,
|
|
173
|
+
|
|
174
|
+
/// Whether a trailing HEADER field has been received.
|
|
175
|
+
trailers_received: bool,
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
impl Stream {
|
|
179
|
+
/// Creates a new HTTP/3 stream.
|
|
180
|
+
///
|
|
181
|
+
/// The `is_local` parameter indicates whether the stream was created by the
|
|
182
|
+
/// local endpoint, or by the peer.
|
|
183
|
+
pub fn new(id: u64, is_local: bool) -> Stream {
|
|
184
|
+
let (ty, state) = if crate::stream::is_bidi(id) {
|
|
185
|
+
// All bidirectional streams are "request" streams, so we don't
|
|
186
|
+
// need to read the stream type.
|
|
187
|
+
(Some(Type::Request), State::FrameType)
|
|
188
|
+
} else {
|
|
189
|
+
// The stream's type is yet to be determined.
|
|
190
|
+
(None, State::StreamType)
|
|
191
|
+
};
|
|
192
|
+
|
|
193
|
+
Stream {
|
|
194
|
+
id,
|
|
195
|
+
ty,
|
|
196
|
+
|
|
197
|
+
state,
|
|
198
|
+
|
|
199
|
+
// Pre-allocate a buffer to avoid multiple tiny early allocations.
|
|
200
|
+
state_buf: vec![0; 16],
|
|
201
|
+
|
|
202
|
+
// Expect one byte for the initial state, to parse the initial
|
|
203
|
+
// varint length.
|
|
204
|
+
state_len: 1,
|
|
205
|
+
state_off: 0,
|
|
206
|
+
|
|
207
|
+
frame_type: None,
|
|
208
|
+
|
|
209
|
+
is_local,
|
|
210
|
+
|
|
211
|
+
remote_initialized: false,
|
|
212
|
+
|
|
213
|
+
local_initialized: false,
|
|
214
|
+
local_finished: false,
|
|
215
|
+
|
|
216
|
+
data_event_triggered: false,
|
|
217
|
+
|
|
218
|
+
last_priority_update: None,
|
|
219
|
+
|
|
220
|
+
headers_received_count: 0,
|
|
221
|
+
|
|
222
|
+
data_received: false,
|
|
223
|
+
|
|
224
|
+
trailers_sent: false,
|
|
225
|
+
trailers_received: false,
|
|
226
|
+
}
|
|
227
|
+
}
|
|
228
|
+
|
|
229
|
+
pub fn ty(&self) -> Option<Type> {
|
|
230
|
+
self.ty
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
pub fn state(&self) -> State {
|
|
234
|
+
self.state
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
/// Sets the stream's type and transitions to the next state.
|
|
238
|
+
pub fn set_ty(&mut self, ty: Type) -> Result<()> {
|
|
239
|
+
assert_eq!(self.state, State::StreamType);
|
|
240
|
+
|
|
241
|
+
self.ty = Some(ty);
|
|
242
|
+
|
|
243
|
+
let state = match ty {
|
|
244
|
+
Type::Control | Type::Request => State::FrameType,
|
|
245
|
+
|
|
246
|
+
Type::Push => State::PushId,
|
|
247
|
+
|
|
248
|
+
Type::QpackEncoder | Type::QpackDecoder => {
|
|
249
|
+
self.remote_initialized = true;
|
|
250
|
+
|
|
251
|
+
State::QpackInstruction
|
|
252
|
+
},
|
|
253
|
+
|
|
254
|
+
Type::Unknown => State::Drain,
|
|
255
|
+
};
|
|
256
|
+
|
|
257
|
+
self.state_transition(state, 1, true)?;
|
|
258
|
+
|
|
259
|
+
Ok(())
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
/// Sets the push ID and transitions to the next state.
|
|
263
|
+
pub fn set_push_id(&mut self, _id: u64) -> Result<()> {
|
|
264
|
+
assert_eq!(self.state, State::PushId);
|
|
265
|
+
|
|
266
|
+
// TODO: implement push ID.
|
|
267
|
+
|
|
268
|
+
self.state_transition(State::FrameType, 1, true)?;
|
|
269
|
+
|
|
270
|
+
Ok(())
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
/// Sets the frame type and transitions to the next state.
|
|
274
|
+
pub fn set_frame_type(&mut self, ty: u64) -> Result<()> {
|
|
275
|
+
assert_eq!(self.state, State::FrameType);
|
|
276
|
+
|
|
277
|
+
// Only expect frames on Control, Request and Push streams.
|
|
278
|
+
match self.ty {
|
|
279
|
+
Some(Type::Control) => {
|
|
280
|
+
// Control stream starts uninitialized and only SETTINGS is
|
|
281
|
+
// accepted in that state. Other frames cause an error. Once
|
|
282
|
+
// initialized, no more SETTINGS are permitted.
|
|
283
|
+
match (ty, self.remote_initialized) {
|
|
284
|
+
// Initialize control stream.
|
|
285
|
+
(frame::SETTINGS_FRAME_TYPE_ID, false) =>
|
|
286
|
+
self.remote_initialized = true,
|
|
287
|
+
|
|
288
|
+
// Non-SETTINGS frames not allowed on control stream
|
|
289
|
+
// before initialization.
|
|
290
|
+
(_, false) => return Err(Error::MissingSettings),
|
|
291
|
+
|
|
292
|
+
// Additional SETTINGS frame.
|
|
293
|
+
(frame::SETTINGS_FRAME_TYPE_ID, true) =>
|
|
294
|
+
return Err(Error::FrameUnexpected),
|
|
295
|
+
|
|
296
|
+
// Frames that can't be received on control stream
|
|
297
|
+
// after initialization.
|
|
298
|
+
(frame::DATA_FRAME_TYPE_ID, true) =>
|
|
299
|
+
return Err(Error::FrameUnexpected),
|
|
300
|
+
|
|
301
|
+
(frame::HEADERS_FRAME_TYPE_ID, true) =>
|
|
302
|
+
return Err(Error::FrameUnexpected),
|
|
303
|
+
|
|
304
|
+
(frame::PUSH_PROMISE_FRAME_TYPE_ID, true) =>
|
|
305
|
+
return Err(Error::FrameUnexpected),
|
|
306
|
+
|
|
307
|
+
// All other frames are ignored after initialization.
|
|
308
|
+
(_, true) => (),
|
|
309
|
+
}
|
|
310
|
+
},
|
|
311
|
+
|
|
312
|
+
Some(Type::Request) => {
|
|
313
|
+
self.validate_request_frame_type(ty)?;
|
|
314
|
+
},
|
|
315
|
+
|
|
316
|
+
Some(Type::Push) => {
|
|
317
|
+
match ty {
|
|
318
|
+
// Frames that can never be received on request streams.
|
|
319
|
+
frame::CANCEL_PUSH_FRAME_TYPE_ID =>
|
|
320
|
+
return Err(Error::FrameUnexpected),
|
|
321
|
+
|
|
322
|
+
frame::SETTINGS_FRAME_TYPE_ID =>
|
|
323
|
+
return Err(Error::FrameUnexpected),
|
|
324
|
+
|
|
325
|
+
frame::PUSH_PROMISE_FRAME_TYPE_ID =>
|
|
326
|
+
return Err(Error::FrameUnexpected),
|
|
327
|
+
|
|
328
|
+
frame::GOAWAY_FRAME_TYPE_ID =>
|
|
329
|
+
return Err(Error::FrameUnexpected),
|
|
330
|
+
|
|
331
|
+
frame::MAX_PUSH_FRAME_TYPE_ID =>
|
|
332
|
+
return Err(Error::FrameUnexpected),
|
|
333
|
+
|
|
334
|
+
_ => (),
|
|
335
|
+
}
|
|
336
|
+
},
|
|
337
|
+
|
|
338
|
+
_ => return Err(Error::FrameUnexpected),
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
self.frame_type = Some(ty);
|
|
342
|
+
|
|
343
|
+
self.state_transition(State::FramePayloadLen, 1, true)?;
|
|
344
|
+
|
|
345
|
+
Ok(())
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
/// Validates a frame type received on a request stream and advances the
|
|
349
|
+
/// request-stream HTTP message phase tracking accordingly.
|
|
350
|
+
///
|
|
351
|
+
/// Request streams start uninitialized and only HEADERS is accepted. After
|
|
352
|
+
/// initialization, DATA and HEADERS frames may be acceptable, depending on
|
|
353
|
+
/// the HTTP message phase (informational/final headers, body, trailers).
|
|
354
|
+
/// Receiving any other known frame type on a request stream is always an
|
|
355
|
+
/// error per RFC 9114, regardless of which endpoint opened the stream.
|
|
356
|
+
///
|
|
357
|
+
/// HTTP message phase bookkeeping (`remote_initialized`, `data_received`,
|
|
358
|
+
/// `trailers_received`) only applies to peer-initiated streams, since it
|
|
359
|
+
/// tracks the receive direction.
|
|
360
|
+
fn validate_request_frame_type(&mut self, ty: u64) -> Result<()> {
|
|
361
|
+
// Frames that are never valid on a request stream, regardless of which
|
|
362
|
+
// endpoint opened it.
|
|
363
|
+
if matches!(
|
|
364
|
+
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
|
|
371
|
+
) {
|
|
372
|
+
return Err(Error::FrameUnexpected);
|
|
373
|
+
}
|
|
374
|
+
|
|
375
|
+
// HTTP message phase bookkeeping only applies to peer-initiated
|
|
376
|
+
// streams, since it tracks the receive direction.
|
|
377
|
+
if self.is_local {
|
|
378
|
+
return Ok(());
|
|
379
|
+
}
|
|
380
|
+
|
|
381
|
+
match (ty, self.remote_initialized) {
|
|
382
|
+
(frame::HEADERS_FRAME_TYPE_ID, false) => {
|
|
383
|
+
self.remote_initialized = true;
|
|
384
|
+
},
|
|
385
|
+
|
|
386
|
+
(frame::DATA_FRAME_TYPE_ID, false) =>
|
|
387
|
+
return Err(Error::FrameUnexpected),
|
|
388
|
+
|
|
389
|
+
(frame::HEADERS_FRAME_TYPE_ID, true) => {
|
|
390
|
+
if self.trailers_received {
|
|
391
|
+
return Err(Error::FrameUnexpected);
|
|
392
|
+
}
|
|
393
|
+
|
|
394
|
+
if self.data_received {
|
|
395
|
+
self.trailers_received = true;
|
|
396
|
+
}
|
|
397
|
+
},
|
|
398
|
+
|
|
399
|
+
(frame::DATA_FRAME_TYPE_ID, true) => {
|
|
400
|
+
if self.trailers_received {
|
|
401
|
+
return Err(Error::FrameUnexpected);
|
|
402
|
+
}
|
|
403
|
+
|
|
404
|
+
self.data_received = true;
|
|
405
|
+
},
|
|
406
|
+
|
|
407
|
+
// All other frames can be ignored regardless of stream state.
|
|
408
|
+
_ => (),
|
|
409
|
+
}
|
|
410
|
+
|
|
411
|
+
Ok(())
|
|
412
|
+
}
|
|
413
|
+
|
|
414
|
+
// Returns the stream's current frame type, if any
|
|
415
|
+
pub fn frame_type(&self) -> Option<u64> {
|
|
416
|
+
self.frame_type
|
|
417
|
+
}
|
|
418
|
+
|
|
419
|
+
/// Sets the frame's payload length and transitions to the next state.
|
|
420
|
+
pub fn set_frame_payload_len(&mut self, len: u64) -> Result<()> {
|
|
421
|
+
assert_eq!(self.state, State::FramePayloadLen);
|
|
422
|
+
|
|
423
|
+
// 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
|
+
}
|
|
439
|
+
|
|
440
|
+
(State::FramePayload, true)
|
|
441
|
+
},
|
|
442
|
+
|
|
443
|
+
_ => (State::FramePayload, true),
|
|
444
|
+
};
|
|
445
|
+
|
|
446
|
+
self.state_transition(state, len as usize, resize)?;
|
|
447
|
+
|
|
448
|
+
return Ok(());
|
|
449
|
+
}
|
|
450
|
+
|
|
451
|
+
Err(Error::InternalError)
|
|
452
|
+
}
|
|
453
|
+
|
|
454
|
+
/// Tries to fill the state buffer by reading data from the corresponding
|
|
455
|
+
/// transport stream.
|
|
456
|
+
///
|
|
457
|
+
/// When not enough data can be read to complete the state, this returns
|
|
458
|
+
/// `Error::Done`.
|
|
459
|
+
pub fn try_fill_buffer<F: BufFactory>(
|
|
460
|
+
&mut self, conn: &mut crate::Connection<F>,
|
|
461
|
+
) -> Result<()> {
|
|
462
|
+
// If no bytes are required to be read, return early.
|
|
463
|
+
if self.state_buffer_complete() {
|
|
464
|
+
return Ok(());
|
|
465
|
+
}
|
|
466
|
+
|
|
467
|
+
let buf = &mut self.state_buf[self.state_off..self.state_len];
|
|
468
|
+
|
|
469
|
+
let read = match conn.stream_recv(self.id, buf) {
|
|
470
|
+
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
|
+
{
|
|
480
|
+
super::close_conn_critical_stream(conn)?;
|
|
481
|
+
}
|
|
482
|
+
|
|
483
|
+
len
|
|
484
|
+
},
|
|
485
|
+
|
|
486
|
+
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
|
+
) {
|
|
494
|
+
super::close_conn_critical_stream(conn)?;
|
|
495
|
+
}
|
|
496
|
+
|
|
497
|
+
return Err(e.into());
|
|
498
|
+
},
|
|
499
|
+
|
|
500
|
+
Err(e) => {
|
|
501
|
+
// The stream is not readable anymore, so re-arm the Data event.
|
|
502
|
+
if e == crate::Error::Done {
|
|
503
|
+
self.reset_data_event();
|
|
504
|
+
}
|
|
505
|
+
|
|
506
|
+
return Err(e.into());
|
|
507
|
+
},
|
|
508
|
+
};
|
|
509
|
+
|
|
510
|
+
trace!(
|
|
511
|
+
"{} read {} bytes on stream {}",
|
|
512
|
+
conn.trace_id(),
|
|
513
|
+
read,
|
|
514
|
+
self.id,
|
|
515
|
+
);
|
|
516
|
+
|
|
517
|
+
self.state_off += read;
|
|
518
|
+
|
|
519
|
+
if !self.state_buffer_complete() {
|
|
520
|
+
self.reset_data_event();
|
|
521
|
+
|
|
522
|
+
return Err(Error::Done);
|
|
523
|
+
}
|
|
524
|
+
|
|
525
|
+
Ok(())
|
|
526
|
+
}
|
|
527
|
+
|
|
528
|
+
/// Initialize the local part of the stream.
|
|
529
|
+
pub fn initialize_local(&mut self) {
|
|
530
|
+
self.local_initialized = true
|
|
531
|
+
}
|
|
532
|
+
|
|
533
|
+
/// Whether the stream has been locally initialized.
|
|
534
|
+
pub fn local_initialized(&self) -> bool {
|
|
535
|
+
self.local_initialized
|
|
536
|
+
}
|
|
537
|
+
|
|
538
|
+
/// Finish the local part of the stream.
|
|
539
|
+
pub fn finish_local(&mut self) {
|
|
540
|
+
self.local_finished = true
|
|
541
|
+
}
|
|
542
|
+
|
|
543
|
+
/// Whether the local send-side of the stream has finished.
|
|
544
|
+
pub fn local_finished(&self) -> bool {
|
|
545
|
+
self.local_finished
|
|
546
|
+
}
|
|
547
|
+
|
|
548
|
+
pub fn increment_headers_received(&mut self) {
|
|
549
|
+
self.headers_received_count =
|
|
550
|
+
self.headers_received_count.saturating_add(1);
|
|
551
|
+
}
|
|
552
|
+
|
|
553
|
+
pub fn headers_received_count(&self) -> usize {
|
|
554
|
+
self.headers_received_count
|
|
555
|
+
}
|
|
556
|
+
|
|
557
|
+
pub fn mark_trailers_sent(&mut self) {
|
|
558
|
+
self.trailers_sent = true;
|
|
559
|
+
}
|
|
560
|
+
|
|
561
|
+
pub fn trailers_sent(&self) -> bool {
|
|
562
|
+
self.trailers_sent
|
|
563
|
+
}
|
|
564
|
+
|
|
565
|
+
/// Tries to fill the state buffer by reading data from the given cursor.
|
|
566
|
+
///
|
|
567
|
+
/// This is intended to replace `try_fill_buffer()` in tests, in order to
|
|
568
|
+
/// avoid having to setup a transport connection.
|
|
569
|
+
#[cfg(test)]
|
|
570
|
+
fn try_fill_buffer_for_tests(
|
|
571
|
+
&mut self, stream: &mut std::io::Cursor<Vec<u8>>,
|
|
572
|
+
) -> Result<()> {
|
|
573
|
+
// If no bytes are required to be read, return early
|
|
574
|
+
if self.state_buffer_complete() {
|
|
575
|
+
return Ok(());
|
|
576
|
+
}
|
|
577
|
+
|
|
578
|
+
let buf = &mut self.state_buf[self.state_off..self.state_len];
|
|
579
|
+
|
|
580
|
+
let read = std::io::Read::read(stream, buf).unwrap();
|
|
581
|
+
|
|
582
|
+
self.state_off += read;
|
|
583
|
+
|
|
584
|
+
if !self.state_buffer_complete() {
|
|
585
|
+
return Err(Error::Done);
|
|
586
|
+
}
|
|
587
|
+
|
|
588
|
+
Ok(())
|
|
589
|
+
}
|
|
590
|
+
|
|
591
|
+
/// Tries to parse a varint (including length) from the state buffer.
|
|
592
|
+
pub fn try_consume_varint(&mut self) -> Result<u64> {
|
|
593
|
+
if self.state_off == 1 {
|
|
594
|
+
self.state_len = octets::varint_parse_len(self.state_buf[0]);
|
|
595
|
+
self.state_buf.resize(self.state_len, 0);
|
|
596
|
+
}
|
|
597
|
+
|
|
598
|
+
// Return early if we don't have enough data in the state buffer to
|
|
599
|
+
// parse the whole varint.
|
|
600
|
+
if !self.state_buffer_complete() {
|
|
601
|
+
return Err(Error::Done);
|
|
602
|
+
}
|
|
603
|
+
|
|
604
|
+
let varint = octets::Octets::with_slice(&self.state_buf).get_varint()?;
|
|
605
|
+
|
|
606
|
+
Ok(varint)
|
|
607
|
+
}
|
|
608
|
+
|
|
609
|
+
/// Tries to parse a frame from the state buffer.
|
|
610
|
+
///
|
|
611
|
+
/// If successful, returns the `frame::Frame` and the payload length.
|
|
612
|
+
pub fn try_consume_frame(&mut self) -> Result<(frame::Frame, u64)> {
|
|
613
|
+
debug_assert_eq!(self.state, State::FramePayload);
|
|
614
|
+
// Processing a frame other than DATA, so re-arm the Data event.
|
|
615
|
+
self.reset_data_event();
|
|
616
|
+
|
|
617
|
+
let payload_len = self.state_len as u64;
|
|
618
|
+
|
|
619
|
+
// 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
|
+
)?;
|
|
625
|
+
|
|
626
|
+
self.state_transition(State::FrameType, 1, true)?;
|
|
627
|
+
|
|
628
|
+
Ok((frame, payload_len))
|
|
629
|
+
}
|
|
630
|
+
|
|
631
|
+
/// Tries to read DATA payload from the transport stream.
|
|
632
|
+
pub fn try_consume_data<F: BufFactory, OUT: bytes::BufMut>(
|
|
633
|
+
&mut self, conn: &mut crate::Connection<F>, out: OUT,
|
|
634
|
+
) -> Result<(usize, bool)> {
|
|
635
|
+
debug_assert_eq!(self.state, State::Data);
|
|
636
|
+
let out = out.limit(self.state_len - self.state_off);
|
|
637
|
+
|
|
638
|
+
let (len, fin) = match conn.stream_recv_buf(self.id, out) {
|
|
639
|
+
Ok(v) => v,
|
|
640
|
+
|
|
641
|
+
Err(e) => {
|
|
642
|
+
// The stream is not readable anymore, so re-arm the Data event.
|
|
643
|
+
if e == crate::Error::Done {
|
|
644
|
+
self.reset_data_event();
|
|
645
|
+
}
|
|
646
|
+
|
|
647
|
+
return Err(e.into());
|
|
648
|
+
},
|
|
649
|
+
};
|
|
650
|
+
|
|
651
|
+
self.state_off += len;
|
|
652
|
+
debug_assert!(self.state_len >= self.state_off);
|
|
653
|
+
|
|
654
|
+
// The stream is not readable anymore, so re-arm the Data event.
|
|
655
|
+
if !conn.stream_readable(self.id) {
|
|
656
|
+
self.reset_data_event();
|
|
657
|
+
}
|
|
658
|
+
|
|
659
|
+
if self.state_buffer_complete() {
|
|
660
|
+
self.state_transition(State::FrameType, 1, true)?;
|
|
661
|
+
}
|
|
662
|
+
|
|
663
|
+
Ok((len, fin))
|
|
664
|
+
}
|
|
665
|
+
|
|
666
|
+
/// Marks the stream as finished.
|
|
667
|
+
pub fn finished(&mut self) {
|
|
668
|
+
let _ = self.state_transition(State::Finished, 0, false);
|
|
669
|
+
}
|
|
670
|
+
|
|
671
|
+
/// Tries to read DATA payload from the given cursor.
|
|
672
|
+
///
|
|
673
|
+
/// This is intended to replace `try_consume_data()` in tests, in order to
|
|
674
|
+
/// avoid having to setup a transport connection.
|
|
675
|
+
#[cfg(test)]
|
|
676
|
+
fn try_consume_data_for_tests(
|
|
677
|
+
&mut self, stream: &mut std::io::Cursor<Vec<u8>>, out: &mut [u8],
|
|
678
|
+
) -> Result<usize> {
|
|
679
|
+
let left = std::cmp::min(out.len(), self.state_len - self.state_off);
|
|
680
|
+
|
|
681
|
+
let len = std::io::Read::read(stream, &mut out[..left]).unwrap();
|
|
682
|
+
|
|
683
|
+
self.state_off += len;
|
|
684
|
+
|
|
685
|
+
if self.state_buffer_complete() {
|
|
686
|
+
self.state_transition(State::FrameType, 1, true)?;
|
|
687
|
+
}
|
|
688
|
+
|
|
689
|
+
Ok(len)
|
|
690
|
+
}
|
|
691
|
+
|
|
692
|
+
/// Tries to update the data triggered state for the stream.
|
|
693
|
+
///
|
|
694
|
+
/// This returns `true` if a Data event was not already triggered before
|
|
695
|
+
/// the last reset, and updates the state. Returns `false` otherwise.
|
|
696
|
+
pub fn try_trigger_data_event(&mut self) -> bool {
|
|
697
|
+
if self.data_event_triggered {
|
|
698
|
+
return false;
|
|
699
|
+
}
|
|
700
|
+
|
|
701
|
+
self.data_event_triggered = true;
|
|
702
|
+
|
|
703
|
+
true
|
|
704
|
+
}
|
|
705
|
+
|
|
706
|
+
/// Resets the data triggered state.
|
|
707
|
+
fn reset_data_event(&mut self) {
|
|
708
|
+
self.data_event_triggered = false;
|
|
709
|
+
}
|
|
710
|
+
|
|
711
|
+
/// Set the last priority update for the stream.
|
|
712
|
+
pub fn set_last_priority_update(&mut self, priority_update: Option<Vec<u8>>) {
|
|
713
|
+
self.last_priority_update = priority_update;
|
|
714
|
+
}
|
|
715
|
+
|
|
716
|
+
/// Take the last priority update and leave `None` in its place.
|
|
717
|
+
pub fn take_last_priority_update(&mut self) -> Option<Vec<u8>> {
|
|
718
|
+
self.last_priority_update.take()
|
|
719
|
+
}
|
|
720
|
+
|
|
721
|
+
/// Returns `true` if there is a priority update.
|
|
722
|
+
pub fn has_last_priority_update(&self) -> bool {
|
|
723
|
+
self.last_priority_update.is_some()
|
|
724
|
+
}
|
|
725
|
+
|
|
726
|
+
/// Returns true if the state buffer has enough data to complete the state.
|
|
727
|
+
fn state_buffer_complete(&self) -> bool {
|
|
728
|
+
self.state_off == self.state_len
|
|
729
|
+
}
|
|
730
|
+
|
|
731
|
+
/// Transitions the stream to a new state, and optionally resets the state
|
|
732
|
+
/// buffer.
|
|
733
|
+
fn state_transition(
|
|
734
|
+
&mut self, new_state: State, expected_len: usize, resize: bool,
|
|
735
|
+
) -> Result<()> {
|
|
736
|
+
// Some states don't need the state buffer, so don't resize it if not
|
|
737
|
+
// necessary.
|
|
738
|
+
if resize {
|
|
739
|
+
// A peer can influence the size of the state buffer (e.g. with the
|
|
740
|
+
// payload size of a GREASE frame), so we need to limit the maximum
|
|
741
|
+
// size to avoid DoS.
|
|
742
|
+
if expected_len > MAX_STATE_BUF_SIZE {
|
|
743
|
+
return Err(Error::ExcessiveLoad);
|
|
744
|
+
}
|
|
745
|
+
|
|
746
|
+
self.state_buf.resize(expected_len, 0);
|
|
747
|
+
}
|
|
748
|
+
|
|
749
|
+
self.state = new_state;
|
|
750
|
+
self.state_off = 0;
|
|
751
|
+
self.state_len = expected_len;
|
|
752
|
+
|
|
753
|
+
Ok(())
|
|
754
|
+
}
|
|
755
|
+
}
|
|
756
|
+
|
|
757
|
+
#[cfg(test)]
|
|
758
|
+
mod tests {
|
|
759
|
+
use crate::h3::frame::*;
|
|
760
|
+
|
|
761
|
+
use super::*;
|
|
762
|
+
|
|
763
|
+
fn open_uni(b: &mut octets::OctetsMut, ty: u64) -> Result<Stream> {
|
|
764
|
+
let stream = <Stream>::new(2, false);
|
|
765
|
+
assert_eq!(stream.state, State::StreamType);
|
|
766
|
+
|
|
767
|
+
b.put_varint(ty)?;
|
|
768
|
+
|
|
769
|
+
Ok(stream)
|
|
770
|
+
}
|
|
771
|
+
|
|
772
|
+
fn parse_uni(
|
|
773
|
+
stream: &mut Stream, ty: u64, cursor: &mut std::io::Cursor<Vec<u8>>,
|
|
774
|
+
) -> Result<()> {
|
|
775
|
+
stream.try_fill_buffer_for_tests(cursor)?;
|
|
776
|
+
|
|
777
|
+
let stream_ty = stream.try_consume_varint()?;
|
|
778
|
+
assert_eq!(stream_ty, ty);
|
|
779
|
+
stream.set_ty(Type::deserialize(stream_ty).unwrap())?;
|
|
780
|
+
|
|
781
|
+
Ok(())
|
|
782
|
+
}
|
|
783
|
+
|
|
784
|
+
fn parse_skip_frame(
|
|
785
|
+
stream: &mut Stream, cursor: &mut std::io::Cursor<Vec<u8>>,
|
|
786
|
+
) -> Result<()> {
|
|
787
|
+
// Parse the frame type.
|
|
788
|
+
stream.try_fill_buffer_for_tests(cursor)?;
|
|
789
|
+
|
|
790
|
+
let frame_ty = stream.try_consume_varint()?;
|
|
791
|
+
|
|
792
|
+
stream.set_frame_type(frame_ty)?;
|
|
793
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
794
|
+
|
|
795
|
+
// Parse the frame payload length.
|
|
796
|
+
stream.try_fill_buffer_for_tests(cursor)?;
|
|
797
|
+
|
|
798
|
+
let frame_payload_len = stream.try_consume_varint()?;
|
|
799
|
+
stream.set_frame_payload_len(frame_payload_len)?;
|
|
800
|
+
assert_eq!(stream.state, State::FramePayload);
|
|
801
|
+
|
|
802
|
+
// Parse the frame payload.
|
|
803
|
+
stream.try_fill_buffer_for_tests(cursor)?;
|
|
804
|
+
|
|
805
|
+
stream.try_consume_frame()?;
|
|
806
|
+
assert_eq!(stream.state, State::FrameType);
|
|
807
|
+
|
|
808
|
+
Ok(())
|
|
809
|
+
}
|
|
810
|
+
|
|
811
|
+
#[test]
|
|
812
|
+
/// Process incoming SETTINGS frame on control stream.
|
|
813
|
+
fn control_good() {
|
|
814
|
+
let mut d = vec![42; 40];
|
|
815
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
816
|
+
|
|
817
|
+
let raw_settings = vec![
|
|
818
|
+
(SETTINGS_MAX_FIELD_SECTION_SIZE, 0),
|
|
819
|
+
(SETTINGS_QPACK_MAX_TABLE_CAPACITY, 0),
|
|
820
|
+
(SETTINGS_QPACK_BLOCKED_STREAMS, 0),
|
|
821
|
+
];
|
|
822
|
+
|
|
823
|
+
let frame = Frame::Settings {
|
|
824
|
+
max_field_section_size: Some(0),
|
|
825
|
+
qpack_max_table_capacity: Some(0),
|
|
826
|
+
qpack_blocked_streams: Some(0),
|
|
827
|
+
connect_protocol_enabled: None,
|
|
828
|
+
h3_datagram: None,
|
|
829
|
+
grease: None,
|
|
830
|
+
additional_settings: None,
|
|
831
|
+
raw: Some(raw_settings),
|
|
832
|
+
};
|
|
833
|
+
|
|
834
|
+
let mut stream = open_uni(&mut b, HTTP3_CONTROL_STREAM_TYPE_ID).unwrap();
|
|
835
|
+
frame.to_bytes(&mut b).unwrap();
|
|
836
|
+
|
|
837
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
838
|
+
|
|
839
|
+
parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
|
|
840
|
+
.unwrap();
|
|
841
|
+
assert_eq!(stream.state, State::FrameType);
|
|
842
|
+
|
|
843
|
+
// Parse the SETTINGS frame type.
|
|
844
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
845
|
+
|
|
846
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
847
|
+
assert_eq!(frame_ty, SETTINGS_FRAME_TYPE_ID);
|
|
848
|
+
|
|
849
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
850
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
851
|
+
|
|
852
|
+
// Parse the SETTINGS frame payload length.
|
|
853
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
854
|
+
|
|
855
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
856
|
+
assert_eq!(frame_payload_len, 6);
|
|
857
|
+
stream.set_frame_payload_len(frame_payload_len).unwrap();
|
|
858
|
+
assert_eq!(stream.state, State::FramePayload);
|
|
859
|
+
|
|
860
|
+
// Parse the SETTINGS frame payload.
|
|
861
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
862
|
+
|
|
863
|
+
assert_eq!(stream.try_consume_frame(), Ok((frame, 6)));
|
|
864
|
+
assert_eq!(stream.state, State::FrameType);
|
|
865
|
+
}
|
|
866
|
+
|
|
867
|
+
#[test]
|
|
868
|
+
/// Process incoming empty SETTINGS frame on control stream.
|
|
869
|
+
fn control_empty_settings() {
|
|
870
|
+
let mut d = vec![42; 40];
|
|
871
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
872
|
+
|
|
873
|
+
let frame = Frame::Settings {
|
|
874
|
+
max_field_section_size: None,
|
|
875
|
+
qpack_max_table_capacity: None,
|
|
876
|
+
qpack_blocked_streams: None,
|
|
877
|
+
connect_protocol_enabled: None,
|
|
878
|
+
h3_datagram: None,
|
|
879
|
+
grease: None,
|
|
880
|
+
additional_settings: None,
|
|
881
|
+
raw: Some(vec![]),
|
|
882
|
+
};
|
|
883
|
+
|
|
884
|
+
let mut stream = open_uni(&mut b, HTTP3_CONTROL_STREAM_TYPE_ID).unwrap();
|
|
885
|
+
frame.to_bytes(&mut b).unwrap();
|
|
886
|
+
|
|
887
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
888
|
+
|
|
889
|
+
parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
|
|
890
|
+
.unwrap();
|
|
891
|
+
assert_eq!(stream.state, State::FrameType);
|
|
892
|
+
|
|
893
|
+
// Parse the SETTINGS frame type.
|
|
894
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
895
|
+
|
|
896
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
897
|
+
assert_eq!(frame_ty, SETTINGS_FRAME_TYPE_ID);
|
|
898
|
+
|
|
899
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
900
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
901
|
+
|
|
902
|
+
// Parse the SETTINGS frame payload length.
|
|
903
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
904
|
+
|
|
905
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
906
|
+
assert_eq!(frame_payload_len, 0);
|
|
907
|
+
stream.set_frame_payload_len(frame_payload_len).unwrap();
|
|
908
|
+
assert_eq!(stream.state, State::FramePayload);
|
|
909
|
+
|
|
910
|
+
// Parse the SETTINGS frame payload.
|
|
911
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
912
|
+
|
|
913
|
+
assert_eq!(stream.try_consume_frame(), Ok((frame, 0)));
|
|
914
|
+
assert_eq!(stream.state, State::FrameType);
|
|
915
|
+
}
|
|
916
|
+
|
|
917
|
+
#[test]
|
|
918
|
+
/// Process duplicate SETTINGS frame on control stream.
|
|
919
|
+
fn control_bad_multiple_settings() {
|
|
920
|
+
let mut d = vec![42; 40];
|
|
921
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
922
|
+
|
|
923
|
+
let raw_settings = vec![
|
|
924
|
+
(SETTINGS_MAX_FIELD_SECTION_SIZE, 0),
|
|
925
|
+
(SETTINGS_QPACK_MAX_TABLE_CAPACITY, 0),
|
|
926
|
+
(SETTINGS_QPACK_BLOCKED_STREAMS, 0),
|
|
927
|
+
];
|
|
928
|
+
|
|
929
|
+
let frame = Frame::Settings {
|
|
930
|
+
max_field_section_size: Some(0),
|
|
931
|
+
qpack_max_table_capacity: Some(0),
|
|
932
|
+
qpack_blocked_streams: Some(0),
|
|
933
|
+
connect_protocol_enabled: None,
|
|
934
|
+
h3_datagram: None,
|
|
935
|
+
grease: None,
|
|
936
|
+
additional_settings: None,
|
|
937
|
+
raw: Some(raw_settings),
|
|
938
|
+
};
|
|
939
|
+
|
|
940
|
+
let mut stream = open_uni(&mut b, HTTP3_CONTROL_STREAM_TYPE_ID).unwrap();
|
|
941
|
+
frame.to_bytes(&mut b).unwrap();
|
|
942
|
+
frame.to_bytes(&mut b).unwrap();
|
|
943
|
+
|
|
944
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
945
|
+
|
|
946
|
+
parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
|
|
947
|
+
.unwrap();
|
|
948
|
+
assert_eq!(stream.state, State::FrameType);
|
|
949
|
+
|
|
950
|
+
// Parse the SETTINGS frame type.
|
|
951
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
952
|
+
|
|
953
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
954
|
+
assert_eq!(frame_ty, SETTINGS_FRAME_TYPE_ID);
|
|
955
|
+
|
|
956
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
957
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
958
|
+
|
|
959
|
+
// Parse the SETTINGS frame payload length.
|
|
960
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
961
|
+
|
|
962
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
963
|
+
assert_eq!(frame_payload_len, 6);
|
|
964
|
+
stream.set_frame_payload_len(frame_payload_len).unwrap();
|
|
965
|
+
assert_eq!(stream.state, State::FramePayload);
|
|
966
|
+
|
|
967
|
+
// Parse the SETTINGS frame payload.
|
|
968
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
969
|
+
|
|
970
|
+
assert_eq!(stream.try_consume_frame(), Ok((frame, 6)));
|
|
971
|
+
assert_eq!(stream.state, State::FrameType);
|
|
972
|
+
|
|
973
|
+
// Parse the second SETTINGS frame type.
|
|
974
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
975
|
+
|
|
976
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
977
|
+
assert_eq!(stream.set_frame_type(frame_ty), Err(Error::FrameUnexpected));
|
|
978
|
+
}
|
|
979
|
+
|
|
980
|
+
#[test]
|
|
981
|
+
/// Process other frame before SETTINGS frame on control stream.
|
|
982
|
+
fn control_bad_late_settings() {
|
|
983
|
+
let mut d = vec![42; 40];
|
|
984
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
985
|
+
|
|
986
|
+
let goaway = Frame::GoAway { id: 0 };
|
|
987
|
+
|
|
988
|
+
let raw_settings = vec![
|
|
989
|
+
(SETTINGS_MAX_FIELD_SECTION_SIZE, 0),
|
|
990
|
+
(SETTINGS_QPACK_MAX_TABLE_CAPACITY, 0),
|
|
991
|
+
(SETTINGS_QPACK_BLOCKED_STREAMS, 0),
|
|
992
|
+
];
|
|
993
|
+
|
|
994
|
+
let settings = Frame::Settings {
|
|
995
|
+
max_field_section_size: Some(0),
|
|
996
|
+
qpack_max_table_capacity: Some(0),
|
|
997
|
+
qpack_blocked_streams: Some(0),
|
|
998
|
+
connect_protocol_enabled: None,
|
|
999
|
+
h3_datagram: None,
|
|
1000
|
+
grease: None,
|
|
1001
|
+
additional_settings: None,
|
|
1002
|
+
raw: Some(raw_settings),
|
|
1003
|
+
};
|
|
1004
|
+
|
|
1005
|
+
let mut stream = open_uni(&mut b, HTTP3_CONTROL_STREAM_TYPE_ID).unwrap();
|
|
1006
|
+
goaway.to_bytes(&mut b).unwrap();
|
|
1007
|
+
settings.to_bytes(&mut b).unwrap();
|
|
1008
|
+
|
|
1009
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
1010
|
+
|
|
1011
|
+
parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
|
|
1012
|
+
.unwrap();
|
|
1013
|
+
assert_eq!(stream.state, State::FrameType);
|
|
1014
|
+
|
|
1015
|
+
// Parse GOAWAY.
|
|
1016
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1017
|
+
|
|
1018
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1019
|
+
assert_eq!(stream.set_frame_type(frame_ty), Err(Error::MissingSettings));
|
|
1020
|
+
}
|
|
1021
|
+
|
|
1022
|
+
#[test]
|
|
1023
|
+
/// Process not-allowed frame on control stream.
|
|
1024
|
+
fn control_bad_frame() {
|
|
1025
|
+
let mut d = vec![42; 40];
|
|
1026
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
1027
|
+
|
|
1028
|
+
let header_block = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
|
|
1029
|
+
let hdrs = Frame::Headers { header_block };
|
|
1030
|
+
|
|
1031
|
+
let raw_settings = vec![
|
|
1032
|
+
(SETTINGS_MAX_FIELD_SECTION_SIZE, 0),
|
|
1033
|
+
(SETTINGS_QPACK_MAX_TABLE_CAPACITY, 0),
|
|
1034
|
+
(SETTINGS_QPACK_BLOCKED_STREAMS, 0),
|
|
1035
|
+
(33, 33),
|
|
1036
|
+
];
|
|
1037
|
+
|
|
1038
|
+
let settings = Frame::Settings {
|
|
1039
|
+
max_field_section_size: Some(0),
|
|
1040
|
+
qpack_max_table_capacity: Some(0),
|
|
1041
|
+
qpack_blocked_streams: Some(0),
|
|
1042
|
+
connect_protocol_enabled: None,
|
|
1043
|
+
h3_datagram: None,
|
|
1044
|
+
grease: None,
|
|
1045
|
+
additional_settings: None,
|
|
1046
|
+
raw: Some(raw_settings),
|
|
1047
|
+
};
|
|
1048
|
+
|
|
1049
|
+
let mut stream = open_uni(&mut b, HTTP3_CONTROL_STREAM_TYPE_ID).unwrap();
|
|
1050
|
+
settings.to_bytes(&mut b).unwrap();
|
|
1051
|
+
hdrs.to_bytes(&mut b).unwrap();
|
|
1052
|
+
|
|
1053
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
1054
|
+
|
|
1055
|
+
parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
|
|
1056
|
+
.unwrap();
|
|
1057
|
+
assert_eq!(stream.state, State::FrameType);
|
|
1058
|
+
|
|
1059
|
+
// Parse first SETTINGS frame.
|
|
1060
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1061
|
+
|
|
1062
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1063
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
1064
|
+
|
|
1065
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1066
|
+
|
|
1067
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
1068
|
+
stream.set_frame_payload_len(frame_payload_len).unwrap();
|
|
1069
|
+
|
|
1070
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1071
|
+
|
|
1072
|
+
assert!(stream.try_consume_frame().is_ok());
|
|
1073
|
+
|
|
1074
|
+
// Parse HEADERS.
|
|
1075
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1076
|
+
|
|
1077
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1078
|
+
assert_eq!(stream.set_frame_type(frame_ty), Err(Error::FrameUnexpected));
|
|
1079
|
+
}
|
|
1080
|
+
|
|
1081
|
+
#[test]
|
|
1082
|
+
fn request_no_data() {
|
|
1083
|
+
let mut stream = <Stream>::new(0, false);
|
|
1084
|
+
|
|
1085
|
+
assert_eq!(stream.ty, Some(Type::Request));
|
|
1086
|
+
assert_eq!(stream.state, State::FrameType);
|
|
1087
|
+
|
|
1088
|
+
assert_eq!(stream.try_consume_varint(), Err(Error::Done));
|
|
1089
|
+
}
|
|
1090
|
+
|
|
1091
|
+
#[test]
|
|
1092
|
+
fn request_good() {
|
|
1093
|
+
let mut stream = <Stream>::new(0, false);
|
|
1094
|
+
|
|
1095
|
+
let mut d = vec![42; 128];
|
|
1096
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
1097
|
+
|
|
1098
|
+
let header_block = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
|
|
1099
|
+
let payload = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
|
|
1100
|
+
let hdrs = Frame::Headers { header_block };
|
|
1101
|
+
let data = Frame::Data {
|
|
1102
|
+
payload: payload.clone(),
|
|
1103
|
+
};
|
|
1104
|
+
|
|
1105
|
+
hdrs.to_bytes(&mut b).unwrap();
|
|
1106
|
+
data.to_bytes(&mut b).unwrap();
|
|
1107
|
+
|
|
1108
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
1109
|
+
|
|
1110
|
+
// Parse the HEADERS frame type.
|
|
1111
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1112
|
+
|
|
1113
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1114
|
+
assert_eq!(frame_ty, HEADERS_FRAME_TYPE_ID);
|
|
1115
|
+
|
|
1116
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
1117
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
1118
|
+
|
|
1119
|
+
// Parse the HEADERS frame payload length.
|
|
1120
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1121
|
+
|
|
1122
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
1123
|
+
assert_eq!(frame_payload_len, 12);
|
|
1124
|
+
|
|
1125
|
+
stream.set_frame_payload_len(frame_payload_len).unwrap();
|
|
1126
|
+
assert_eq!(stream.state, State::FramePayload);
|
|
1127
|
+
|
|
1128
|
+
// Parse the HEADERS frame.
|
|
1129
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1130
|
+
|
|
1131
|
+
assert_eq!(stream.try_consume_frame(), Ok((hdrs, 12)));
|
|
1132
|
+
assert_eq!(stream.state, State::FrameType);
|
|
1133
|
+
|
|
1134
|
+
// Parse the DATA frame type.
|
|
1135
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1136
|
+
|
|
1137
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1138
|
+
assert_eq!(frame_ty, DATA_FRAME_TYPE_ID);
|
|
1139
|
+
|
|
1140
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
1141
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
1142
|
+
|
|
1143
|
+
// Parse the DATA frame payload length.
|
|
1144
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1145
|
+
|
|
1146
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
1147
|
+
assert_eq!(frame_payload_len, 12);
|
|
1148
|
+
|
|
1149
|
+
stream.set_frame_payload_len(frame_payload_len).unwrap();
|
|
1150
|
+
assert_eq!(stream.state, State::Data);
|
|
1151
|
+
|
|
1152
|
+
// Parse the DATA payload.
|
|
1153
|
+
let mut recv_buf = vec![0; payload.len()];
|
|
1154
|
+
assert_eq!(
|
|
1155
|
+
stream.try_consume_data_for_tests(&mut cursor, &mut recv_buf),
|
|
1156
|
+
Ok(payload.len())
|
|
1157
|
+
);
|
|
1158
|
+
assert_eq!(payload, recv_buf);
|
|
1159
|
+
|
|
1160
|
+
assert_eq!(stream.state, State::FrameType);
|
|
1161
|
+
}
|
|
1162
|
+
|
|
1163
|
+
#[test]
|
|
1164
|
+
fn push_good() {
|
|
1165
|
+
let mut d = vec![42; 128];
|
|
1166
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
1167
|
+
|
|
1168
|
+
let header_block = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
|
|
1169
|
+
let payload = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
|
|
1170
|
+
let hdrs = Frame::Headers { header_block };
|
|
1171
|
+
let data = Frame::Data {
|
|
1172
|
+
payload: payload.clone(),
|
|
1173
|
+
};
|
|
1174
|
+
|
|
1175
|
+
let mut stream = open_uni(&mut b, HTTP3_PUSH_STREAM_TYPE_ID).unwrap();
|
|
1176
|
+
b.put_varint(1).unwrap();
|
|
1177
|
+
hdrs.to_bytes(&mut b).unwrap();
|
|
1178
|
+
data.to_bytes(&mut b).unwrap();
|
|
1179
|
+
|
|
1180
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
1181
|
+
|
|
1182
|
+
parse_uni(&mut stream, HTTP3_PUSH_STREAM_TYPE_ID, &mut cursor).unwrap();
|
|
1183
|
+
assert_eq!(stream.state, State::PushId);
|
|
1184
|
+
|
|
1185
|
+
// Parse push ID.
|
|
1186
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1187
|
+
|
|
1188
|
+
let push_id = stream.try_consume_varint().unwrap();
|
|
1189
|
+
assert_eq!(push_id, 1);
|
|
1190
|
+
|
|
1191
|
+
stream.set_push_id(push_id).unwrap();
|
|
1192
|
+
assert_eq!(stream.state, State::FrameType);
|
|
1193
|
+
|
|
1194
|
+
// Parse the HEADERS frame type.
|
|
1195
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1196
|
+
|
|
1197
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1198
|
+
assert_eq!(frame_ty, HEADERS_FRAME_TYPE_ID);
|
|
1199
|
+
|
|
1200
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
1201
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
1202
|
+
|
|
1203
|
+
// Parse the HEADERS frame payload length.
|
|
1204
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1205
|
+
|
|
1206
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
1207
|
+
assert_eq!(frame_payload_len, 12);
|
|
1208
|
+
|
|
1209
|
+
stream.set_frame_payload_len(frame_payload_len).unwrap();
|
|
1210
|
+
assert_eq!(stream.state, State::FramePayload);
|
|
1211
|
+
|
|
1212
|
+
// Parse the HEADERS frame.
|
|
1213
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1214
|
+
|
|
1215
|
+
assert_eq!(stream.try_consume_frame(), Ok((hdrs, 12)));
|
|
1216
|
+
assert_eq!(stream.state, State::FrameType);
|
|
1217
|
+
|
|
1218
|
+
// Parse the DATA frame type.
|
|
1219
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1220
|
+
|
|
1221
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1222
|
+
assert_eq!(frame_ty, DATA_FRAME_TYPE_ID);
|
|
1223
|
+
|
|
1224
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
1225
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
1226
|
+
|
|
1227
|
+
// Parse the DATA frame payload length.
|
|
1228
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1229
|
+
|
|
1230
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
1231
|
+
assert_eq!(frame_payload_len, 12);
|
|
1232
|
+
|
|
1233
|
+
stream.set_frame_payload_len(frame_payload_len).unwrap();
|
|
1234
|
+
assert_eq!(stream.state, State::Data);
|
|
1235
|
+
|
|
1236
|
+
// Parse the DATA payload.
|
|
1237
|
+
let mut recv_buf = vec![0; payload.len()];
|
|
1238
|
+
assert_eq!(
|
|
1239
|
+
stream.try_consume_data_for_tests(&mut cursor, &mut recv_buf),
|
|
1240
|
+
Ok(payload.len())
|
|
1241
|
+
);
|
|
1242
|
+
assert_eq!(payload, recv_buf);
|
|
1243
|
+
|
|
1244
|
+
assert_eq!(stream.state, State::FrameType);
|
|
1245
|
+
}
|
|
1246
|
+
|
|
1247
|
+
#[test]
|
|
1248
|
+
fn grease() {
|
|
1249
|
+
let mut d = vec![42; 20];
|
|
1250
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
1251
|
+
|
|
1252
|
+
let mut stream = open_uni(&mut b, 33).unwrap();
|
|
1253
|
+
|
|
1254
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
1255
|
+
|
|
1256
|
+
// Parse stream type.
|
|
1257
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1258
|
+
|
|
1259
|
+
let stream_ty = stream.try_consume_varint().unwrap();
|
|
1260
|
+
assert_eq!(stream_ty, 33);
|
|
1261
|
+
stream
|
|
1262
|
+
.set_ty(Type::deserialize(stream_ty).unwrap())
|
|
1263
|
+
.unwrap();
|
|
1264
|
+
assert_eq!(stream.state, State::Drain);
|
|
1265
|
+
}
|
|
1266
|
+
|
|
1267
|
+
#[test]
|
|
1268
|
+
fn data_before_headers() {
|
|
1269
|
+
let mut stream = <Stream>::new(0, false);
|
|
1270
|
+
|
|
1271
|
+
let mut d = vec![42; 128];
|
|
1272
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
1273
|
+
|
|
1274
|
+
let data = Frame::Data {
|
|
1275
|
+
payload: vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
|
|
1276
|
+
};
|
|
1277
|
+
|
|
1278
|
+
data.to_bytes(&mut b).unwrap();
|
|
1279
|
+
|
|
1280
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
1281
|
+
|
|
1282
|
+
// Parse the DATA frame type.
|
|
1283
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1284
|
+
|
|
1285
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1286
|
+
assert_eq!(frame_ty, DATA_FRAME_TYPE_ID);
|
|
1287
|
+
|
|
1288
|
+
assert_eq!(stream.set_frame_type(frame_ty), Err(Error::FrameUnexpected));
|
|
1289
|
+
}
|
|
1290
|
+
|
|
1291
|
+
#[test]
|
|
1292
|
+
fn additional_headers() {
|
|
1293
|
+
let mut stream = Stream::new(0, false);
|
|
1294
|
+
|
|
1295
|
+
let mut d = vec![42; 128];
|
|
1296
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
1297
|
+
|
|
1298
|
+
let header_block = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
|
|
1299
|
+
let payload = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
|
|
1300
|
+
let info_hdrs = Frame::Headers {
|
|
1301
|
+
header_block: header_block.clone(),
|
|
1302
|
+
};
|
|
1303
|
+
let non_info_hdrs = Frame::Headers {
|
|
1304
|
+
header_block: header_block.clone(),
|
|
1305
|
+
};
|
|
1306
|
+
let trailers = Frame::Headers { header_block };
|
|
1307
|
+
let data = Frame::Data {
|
|
1308
|
+
payload: payload.clone(),
|
|
1309
|
+
};
|
|
1310
|
+
|
|
1311
|
+
info_hdrs.to_bytes(&mut b).unwrap();
|
|
1312
|
+
non_info_hdrs.to_bytes(&mut b).unwrap();
|
|
1313
|
+
data.to_bytes(&mut b).unwrap();
|
|
1314
|
+
trailers.to_bytes(&mut b).unwrap();
|
|
1315
|
+
|
|
1316
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
1317
|
+
|
|
1318
|
+
// Parse the HEADERS frame type.
|
|
1319
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1320
|
+
|
|
1321
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1322
|
+
assert_eq!(frame_ty, HEADERS_FRAME_TYPE_ID);
|
|
1323
|
+
|
|
1324
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
1325
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
1326
|
+
|
|
1327
|
+
// Parse the HEADERS frame payload length.
|
|
1328
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1329
|
+
|
|
1330
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
1331
|
+
assert_eq!(frame_payload_len, 12);
|
|
1332
|
+
|
|
1333
|
+
stream.set_frame_payload_len(frame_payload_len).unwrap();
|
|
1334
|
+
assert_eq!(stream.state, State::FramePayload);
|
|
1335
|
+
|
|
1336
|
+
// Parse the HEADERS frame.
|
|
1337
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1338
|
+
|
|
1339
|
+
assert_eq!(stream.try_consume_frame(), Ok((info_hdrs, 12)));
|
|
1340
|
+
assert_eq!(stream.state, State::FrameType);
|
|
1341
|
+
|
|
1342
|
+
// Parse the non-info HEADERS frame type.
|
|
1343
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1344
|
+
|
|
1345
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1346
|
+
assert_eq!(frame_ty, HEADERS_FRAME_TYPE_ID);
|
|
1347
|
+
|
|
1348
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
1349
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
1350
|
+
|
|
1351
|
+
// Parse the HEADERS frame payload length.
|
|
1352
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1353
|
+
|
|
1354
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
1355
|
+
assert_eq!(frame_payload_len, 12);
|
|
1356
|
+
|
|
1357
|
+
stream.set_frame_payload_len(frame_payload_len).unwrap();
|
|
1358
|
+
assert_eq!(stream.state, State::FramePayload);
|
|
1359
|
+
|
|
1360
|
+
// Parse the HEADERS frame.
|
|
1361
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1362
|
+
|
|
1363
|
+
assert_eq!(stream.try_consume_frame(), Ok((non_info_hdrs, 12)));
|
|
1364
|
+
assert_eq!(stream.state, State::FrameType);
|
|
1365
|
+
|
|
1366
|
+
// Parse the DATA frame type.
|
|
1367
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1368
|
+
|
|
1369
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1370
|
+
assert_eq!(frame_ty, DATA_FRAME_TYPE_ID);
|
|
1371
|
+
|
|
1372
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
1373
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
1374
|
+
|
|
1375
|
+
// Parse the DATA frame payload length.
|
|
1376
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1377
|
+
|
|
1378
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
1379
|
+
assert_eq!(frame_payload_len, 12);
|
|
1380
|
+
|
|
1381
|
+
stream.set_frame_payload_len(frame_payload_len).unwrap();
|
|
1382
|
+
assert_eq!(stream.state, State::Data);
|
|
1383
|
+
|
|
1384
|
+
// Parse the DATA payload.
|
|
1385
|
+
let mut recv_buf = vec![0; payload.len()];
|
|
1386
|
+
assert_eq!(
|
|
1387
|
+
stream.try_consume_data_for_tests(&mut cursor, &mut recv_buf),
|
|
1388
|
+
Ok(payload.len())
|
|
1389
|
+
);
|
|
1390
|
+
assert_eq!(payload, recv_buf);
|
|
1391
|
+
|
|
1392
|
+
assert_eq!(stream.state, State::FrameType);
|
|
1393
|
+
|
|
1394
|
+
// Parse the trailing HEADERS frame type.
|
|
1395
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1396
|
+
|
|
1397
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1398
|
+
assert_eq!(frame_ty, HEADERS_FRAME_TYPE_ID);
|
|
1399
|
+
|
|
1400
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
1401
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
1402
|
+
|
|
1403
|
+
// Parse the HEADERS frame payload length.
|
|
1404
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1405
|
+
|
|
1406
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
1407
|
+
assert_eq!(frame_payload_len, 12);
|
|
1408
|
+
|
|
1409
|
+
stream.set_frame_payload_len(frame_payload_len).unwrap();
|
|
1410
|
+
assert_eq!(stream.state, State::FramePayload);
|
|
1411
|
+
|
|
1412
|
+
// Parse the HEADERS frame.
|
|
1413
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1414
|
+
|
|
1415
|
+
assert_eq!(stream.try_consume_frame(), Ok((trailers, 12)));
|
|
1416
|
+
assert_eq!(stream.state, State::FrameType);
|
|
1417
|
+
}
|
|
1418
|
+
|
|
1419
|
+
#[test]
|
|
1420
|
+
fn zero_length_goaway() {
|
|
1421
|
+
let mut d = vec![42; 128];
|
|
1422
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
1423
|
+
|
|
1424
|
+
let frame = Frame::Settings {
|
|
1425
|
+
max_field_section_size: None,
|
|
1426
|
+
qpack_max_table_capacity: None,
|
|
1427
|
+
qpack_blocked_streams: None,
|
|
1428
|
+
connect_protocol_enabled: None,
|
|
1429
|
+
h3_datagram: None,
|
|
1430
|
+
grease: None,
|
|
1431
|
+
additional_settings: None,
|
|
1432
|
+
raw: Some(vec![]),
|
|
1433
|
+
};
|
|
1434
|
+
|
|
1435
|
+
let mut stream = open_uni(&mut b, HTTP3_CONTROL_STREAM_TYPE_ID).unwrap();
|
|
1436
|
+
frame.to_bytes(&mut b).unwrap();
|
|
1437
|
+
|
|
1438
|
+
// Write a 0-length payload frame.
|
|
1439
|
+
b.put_varint(GOAWAY_FRAME_TYPE_ID).unwrap();
|
|
1440
|
+
b.put_varint(0).unwrap();
|
|
1441
|
+
|
|
1442
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
1443
|
+
|
|
1444
|
+
parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
|
|
1445
|
+
.unwrap();
|
|
1446
|
+
|
|
1447
|
+
// Skip SETTINGS frame type.
|
|
1448
|
+
parse_skip_frame(&mut stream, &mut cursor).unwrap();
|
|
1449
|
+
|
|
1450
|
+
// Parse frame type.
|
|
1451
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1452
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1453
|
+
assert_eq!(frame_ty, GOAWAY_FRAME_TYPE_ID);
|
|
1454
|
+
|
|
1455
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
1456
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
1457
|
+
|
|
1458
|
+
// Parse frame payload length.
|
|
1459
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1460
|
+
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
|
+
);
|
|
1465
|
+
}
|
|
1466
|
+
|
|
1467
|
+
#[test]
|
|
1468
|
+
fn zero_length_push_promise() {
|
|
1469
|
+
let mut d = vec![42; 128];
|
|
1470
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
1471
|
+
|
|
1472
|
+
let mut stream = <Stream>::new(0, false);
|
|
1473
|
+
|
|
1474
|
+
assert_eq!(stream.ty, Some(Type::Request));
|
|
1475
|
+
assert_eq!(stream.state, State::FrameType);
|
|
1476
|
+
|
|
1477
|
+
// Write a 0-length payload frame.
|
|
1478
|
+
b.put_varint(PUSH_PROMISE_FRAME_TYPE_ID).unwrap();
|
|
1479
|
+
b.put_varint(0).unwrap();
|
|
1480
|
+
|
|
1481
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
1482
|
+
|
|
1483
|
+
// Parse frame type.
|
|
1484
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1485
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1486
|
+
assert_eq!(frame_ty, PUSH_PROMISE_FRAME_TYPE_ID);
|
|
1487
|
+
|
|
1488
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
1489
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
1490
|
+
|
|
1491
|
+
// Parse frame payload length.
|
|
1492
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1493
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
1494
|
+
assert_eq!(
|
|
1495
|
+
Err(Error::FrameError),
|
|
1496
|
+
stream.set_frame_payload_len(frame_payload_len)
|
|
1497
|
+
);
|
|
1498
|
+
}
|
|
1499
|
+
|
|
1500
|
+
#[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 {
|
|
1506
|
+
max_field_section_size: None,
|
|
1507
|
+
qpack_max_table_capacity: None,
|
|
1508
|
+
qpack_blocked_streams: None,
|
|
1509
|
+
connect_protocol_enabled: None,
|
|
1510
|
+
h3_datagram: None,
|
|
1511
|
+
grease: None,
|
|
1512
|
+
additional_settings: None,
|
|
1513
|
+
raw: Some(vec![]),
|
|
1514
|
+
};
|
|
1515
|
+
|
|
1516
|
+
let mut stream = open_uni(&mut b, HTTP3_CONTROL_STREAM_TYPE_ID).unwrap();
|
|
1517
|
+
frame.to_bytes(&mut b).unwrap();
|
|
1518
|
+
|
|
1519
|
+
// Write a 0-length payload frame.
|
|
1520
|
+
b.put_varint(CANCEL_PUSH_FRAME_TYPE_ID).unwrap();
|
|
1521
|
+
b.put_varint(0).unwrap();
|
|
1522
|
+
|
|
1523
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
1524
|
+
|
|
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
|
+
// Parse frame type.
|
|
1532
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1533
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1534
|
+
assert_eq!(frame_ty, CANCEL_PUSH_FRAME_TYPE_ID);
|
|
1535
|
+
|
|
1536
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
1537
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
1538
|
+
|
|
1539
|
+
// Parse frame payload length.
|
|
1540
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1541
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
1542
|
+
assert_eq!(
|
|
1543
|
+
Err(Error::FrameError),
|
|
1544
|
+
stream.set_frame_payload_len(frame_payload_len)
|
|
1545
|
+
);
|
|
1546
|
+
}
|
|
1547
|
+
|
|
1548
|
+
#[test]
|
|
1549
|
+
fn zero_length_max_push_id() {
|
|
1550
|
+
let mut d = vec![42; 128];
|
|
1551
|
+
let mut b = octets::OctetsMut::with_slice(&mut d);
|
|
1552
|
+
|
|
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![]),
|
|
1562
|
+
};
|
|
1563
|
+
|
|
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();
|
|
1570
|
+
|
|
1571
|
+
let mut cursor = std::io::Cursor::new(d);
|
|
1572
|
+
|
|
1573
|
+
parse_uni(&mut stream, HTTP3_CONTROL_STREAM_TYPE_ID, &mut cursor)
|
|
1574
|
+
.unwrap();
|
|
1575
|
+
|
|
1576
|
+
// Skip SETTINGS frame type.
|
|
1577
|
+
parse_skip_frame(&mut stream, &mut cursor).unwrap();
|
|
1578
|
+
|
|
1579
|
+
// Parse frame type.
|
|
1580
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1581
|
+
let frame_ty = stream.try_consume_varint().unwrap();
|
|
1582
|
+
assert_eq!(frame_ty, MAX_PUSH_FRAME_TYPE_ID);
|
|
1583
|
+
|
|
1584
|
+
stream.set_frame_type(frame_ty).unwrap();
|
|
1585
|
+
assert_eq!(stream.state, State::FramePayloadLen);
|
|
1586
|
+
|
|
1587
|
+
// Parse frame payload length.
|
|
1588
|
+
stream.try_fill_buffer_for_tests(&mut cursor).unwrap();
|
|
1589
|
+
let frame_payload_len = stream.try_consume_varint().unwrap();
|
|
1590
|
+
assert_eq!(
|
|
1591
|
+
Err(Error::FrameError),
|
|
1592
|
+
stream.set_frame_payload_len(frame_payload_len)
|
|
1593
|
+
);
|
|
1594
|
+
}
|
|
1595
|
+
}
|