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