rwebtransport 0.2.2 → 0.2.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (99) hide show
  1. package/Cargo.lock +523 -140
  2. package/Cargo.toml +5 -5
  3. package/README.md +8 -4
  4. package/crates/echo-server/src/bin/gen-test-cert.rs +1 -1
  5. package/crates/native/Cargo.toml +2 -0
  6. package/crates/native/src/config.rs +69 -8
  7. package/crates/native/src/driver.rs +253 -90
  8. package/crates/native/src/lib.rs +80 -57
  9. package/crates/native/src/parser_memory.rs +203 -0
  10. package/crates/native/src/server.rs +215 -183
  11. package/crates/native/src/session.rs +1341 -243
  12. package/crates/native/src/test_support.rs +119 -0
  13. package/crates/wtcore/Cargo.toml +1 -0
  14. package/crates/wtcore/src/h3.rs +250 -46
  15. package/dist/index.js +218 -75
  16. package/dist/index.js.map +7 -1
  17. package/dist/index.mjs +214 -69
  18. package/dist/index.mjs.map +7 -1
  19. package/dist/native.d.ts +10 -4
  20. package/dist/server.d.ts +1 -0
  21. package/package.json +84 -78
  22. package/prebuilds/darwin-arm64/rwebtransport.node +0 -0
  23. package/prebuilds/linux-arm64/rwebtransport.node +0 -0
  24. package/prebuilds/linux-x64/rwebtransport.node +0 -0
  25. package/prebuilds/win32-x64/rwebtransport.node +0 -0
  26. package/scripts/build-linux-prebuilt.sh +46 -0
  27. package/scripts/build-ts.js +41 -0
  28. package/scripts/build.js +10 -3
  29. package/vendor/quiche/AGENTS.md +10 -0
  30. package/vendor/quiche/Cargo.lock +239 -248
  31. package/vendor/quiche/Cargo.toml +23 -10
  32. package/vendor/quiche/examples/Makefile +4 -4
  33. package/vendor/quiche/examples/client.rs +10 -28
  34. package/vendor/quiche/examples/http3-client.rs +20 -34
  35. package/vendor/quiche/examples/http3-server.rs +47 -78
  36. package/vendor/quiche/examples/server.rs +19 -49
  37. package/vendor/quiche/include/quiche.h +35 -4
  38. package/vendor/quiche/src/build.rs +17 -0
  39. package/vendor/quiche/src/cid.rs +129 -61
  40. package/vendor/quiche/src/crypto/boringssl.rs +98 -86
  41. package/vendor/quiche/src/crypto/mod.rs +64 -77
  42. package/vendor/quiche/src/dgram.rs +2 -3
  43. package/vendor/quiche/src/error.rs +22 -20
  44. package/vendor/quiche/src/ffi.rs +558 -280
  45. package/vendor/quiche/src/flowcontrol.rs +0 -7
  46. package/vendor/quiche/src/frame.rs +134 -135
  47. package/vendor/quiche/src/h3/ffi.rs +73 -60
  48. package/vendor/quiche/src/h3/frame.rs +70 -90
  49. package/vendor/quiche/src/h3/mod.rs +1024 -593
  50. package/vendor/quiche/src/h3/qpack/decoder.rs +248 -34
  51. package/vendor/quiche/src/h3/qpack/dynamic_table.rs +859 -0
  52. package/vendor/quiche/src/h3/qpack/encoder.rs +14 -17
  53. package/vendor/quiche/src/h3/qpack/mod.rs +48 -0
  54. package/vendor/quiche/src/h3/qpack/static_table.rs +86 -73
  55. package/vendor/quiche/src/h3/stream.rs +1009 -194
  56. package/vendor/quiche/src/lib.rs +1361 -1195
  57. package/vendor/quiche/src/minmax.rs +2 -6
  58. package/vendor/quiche/src/packet.rs +420 -552
  59. package/vendor/quiche/src/path.rs +202 -72
  60. package/vendor/quiche/src/pmtud.rs +18 -16
  61. package/vendor/quiche/src/ranges.rs +184 -82
  62. package/vendor/quiche/src/recovery/AGENTS.md +5 -2
  63. package/vendor/quiche/src/recovery/bandwidth.rs +59 -40
  64. package/vendor/quiche/src/recovery/bytes_in_flight.rs +2 -2
  65. package/vendor/quiche/src/recovery/congestion/cubic.rs +38 -47
  66. package/vendor/quiche/src/recovery/congestion/delivery_rate.rs +54 -60
  67. package/vendor/quiche/src/recovery/congestion/hystart.rs +6 -10
  68. package/vendor/quiche/src/recovery/congestion/mod.rs +110 -42
  69. package/vendor/quiche/src/recovery/congestion/prr.rs +4 -1
  70. package/vendor/quiche/src/recovery/congestion/recovery.rs +91 -95
  71. package/vendor/quiche/src/recovery/congestion/reno.rs +17 -12
  72. package/vendor/quiche/src/recovery/congestion/test_sender.rs +8 -27
  73. package/vendor/quiche/src/recovery/gcongestion/bbr/bandwidth_sampler.rs +159 -247
  74. package/vendor/quiche/src/recovery/gcongestion/bbr/windowed_filter.rs +9 -14
  75. package/vendor/quiche/src/recovery/gcongestion/bbr2/drain.rs +18 -15
  76. package/vendor/quiche/src/recovery/gcongestion/bbr2/mode.rs +43 -28
  77. package/vendor/quiche/src/recovery/gcongestion/bbr2/network_model.rs +349 -76
  78. package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_bw.rs +147 -195
  79. package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_rtt.rs +29 -27
  80. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min.rs +180 -0
  81. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min_tests.rs +221 -0
  82. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm.rs +395 -0
  83. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm_tests.rs +473 -0
  84. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/mod.rs +175 -0
  85. package/vendor/quiche/src/recovery/gcongestion/bbr2/startup.rs +33 -26
  86. package/vendor/quiche/src/recovery/gcongestion/bbr2.rs +107 -60
  87. package/vendor/quiche/src/recovery/gcongestion/mod.rs +64 -11
  88. package/vendor/quiche/src/recovery/gcongestion/pacer.rs +34 -25
  89. package/vendor/quiche/src/recovery/gcongestion/recovery.rs +81 -86
  90. package/vendor/quiche/src/recovery/mod.rs +414 -173
  91. package/vendor/quiche/src/recovery/rtt.rs +8 -5
  92. package/vendor/quiche/src/stream/mod.rs +864 -133
  93. package/vendor/quiche/src/stream/recv_buf.rs +476 -172
  94. package/vendor/quiche/src/stream/send_buf.rs +343 -81
  95. package/vendor/quiche/src/test_utils.rs +78 -64
  96. package/vendor/quiche/src/tests.rs +2559 -1335
  97. package/vendor/quiche/src/tls/boringssl.rs +60 -63
  98. package/vendor/quiche/src/tls/mod.rs +146 -193
  99. package/vendor/quiche/src/transport_params.rs +87 -103
@@ -14,6 +14,7 @@ use std::net::SocketAddr;
14
14
  use std::sync::atomic::Ordering;
15
15
  use std::sync::mpsc::Receiver;
16
16
  use std::sync::Arc;
17
+ use std::time::{Duration, Instant};
17
18
 
18
19
  use mio::net::UdpSocket;
19
20
  use mio::{Events, Interest, Poll};
@@ -21,20 +22,22 @@ use mio::{Events, Interest, Poll};
21
22
  use wtcore::h3;
22
23
 
23
24
  use crate::config::build_server_config;
24
- use crate::driver::{DriverShared, SOCKET_TOKEN};
25
- use crate::session::{Ev, WtSession};
25
+ use crate::driver::{
26
+ is_udp_port_unreachable, DriverShared, MAX_INFLIGHT_BATCHES, MAX_RECV_PER_WAKE,
27
+ MAX_RECV_UDP_PAYLOAD, SOCKET_TOKEN,
28
+ };
29
+ use crate::parser_memory::ParserMemory;
30
+ use crate::session::{Ev, ReceiveBudget, WtSession};
26
31
 
27
32
  const LOCAL_CONN_ID_LEN: usize = 16;
28
- const MAX_INFLIGHT_BATCHES: i64 = 128;
29
33
 
30
- /// Hard cap on concurrent QUIC connections so a hostile client (or spoofed
31
- /// source addresses) cannot grow the connection table without bound.
32
- const MAX_CONNECTIONS: usize = 16_384;
34
+ /// Cap live transport state, including incomplete handshakes and draining connections.
35
+ const MAX_CONNECTIONS: usize = 256;
36
+ const SESSION_SETUP_TIMEOUT: Duration = Duration::from_secs(10);
33
37
 
34
- /// Maximum UDP packets read per event-loop wake before yielding to the rest of
35
- /// the loop (timeouts, commands, reaping). Bounds per-wake work so a sustained
36
- /// inbound flood cannot starve `Shutdown` handling or idle-connection reaping.
37
- const MAX_RECV_PER_WAKE: usize = 1024;
38
+ /// Aggregate allocation capacity of HTTP/3, classification and capsule parser
39
+ /// buffers across all connections, including handshakes and draining sessions.
40
+ const MAX_PARSER_MEMORY: usize = 64 * 1024 * 1024;
38
41
 
39
42
  /// Everything the server thread needs to start listening.
40
43
  pub struct ServerSetup {
@@ -160,7 +163,8 @@ struct ServerConn {
160
163
  conn: quiche::Connection,
161
164
  session: WtSession,
162
165
  session_id: u64,
163
- closed_emitted: bool,
166
+ setup_deadline: Option<Instant>,
167
+ max_datagram_size: usize,
164
168
  }
165
169
 
166
170
  /// Server thread entry point, wrapped in a panic boundary.
@@ -197,10 +201,17 @@ const TOKEN_TAG_LEN: usize = 16;
197
201
  /// token is bound to. A spoofed source can never receive the Retry, and the tag
198
202
  /// is keyed by a per-process secret it does not know, so it cannot forge one.
199
203
  fn addr_identity(src: &SocketAddr) -> Vec<u8> {
200
- let mut id = match src.ip() {
201
- std::net::IpAddr::V4(a) => a.octets().to_vec(),
202
- std::net::IpAddr::V6(a) => a.octets().to_vec(),
203
- };
204
+ let mut id = Vec::with_capacity(19);
205
+ match src.ip() {
206
+ std::net::IpAddr::V4(a) => {
207
+ id.push(4);
208
+ id.extend_from_slice(&a.octets());
209
+ }
210
+ std::net::IpAddr::V6(a) => {
211
+ id.push(6);
212
+ id.extend_from_slice(&a.octets());
213
+ }
214
+ }
204
215
  id.extend_from_slice(&src.port().to_be_bytes());
205
216
  id
206
217
  }
@@ -231,85 +242,55 @@ fn hmac_sha256(secret: &[u8], data: &[u8]) -> [u8; 32] {
231
242
  boring::sha::sha256(&outer)
232
243
  }
233
244
 
234
- /// Constant-time byte comparison so token validation does not leak the tag via
235
- /// timing.
236
- fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
237
- if a.len() != b.len() {
238
- return false;
239
- }
240
- let mut diff = 0u8;
241
- for (x, y) in a.iter().zip(b.iter()) {
242
- diff |= x ^ y;
243
- }
244
- diff == 0
245
+ struct RetryTokens {
246
+ secret: [u8; 32],
247
+ started: Instant,
245
248
  }
246
249
 
247
- /// Mint a stateless Retry token that authenticates the client's source address
248
- /// and carries the original destination connection id. The token is
249
- /// `b"rwt1" || orig_dcid || HMAC(secret, addr || orig_dcid)[..16]`. Because the
250
- /// tag is keyed by a secret known only to this process, a spoofed source cannot
251
- /// forge a token it never received, which is what makes the Retry actually
252
- /// prevent source-address spoofing (reflection) and state exhaustion rather than
253
- /// just being a formality.
254
- fn mint_token(secret: &[u8], orig_dcid: &[u8], src: &SocketAddr) -> Vec<u8> {
255
- let mut mac_input = addr_identity(src);
256
- mac_input.extend_from_slice(orig_dcid);
257
- let tag = hmac_sha256(secret, &mac_input);
258
- let mut token = Vec::with_capacity(4 + orig_dcid.len() + TOKEN_TAG_LEN);
259
- token.extend_from_slice(b"rwt1");
260
- token.extend_from_slice(orig_dcid);
261
- token.extend_from_slice(&tag[..TOKEN_TAG_LEN]);
262
- token
263
- }
250
+ impl RetryTokens {
251
+ const TTL: Duration = Duration::from_secs(10);
264
252
 
265
- /// Validate a Retry token against `src` and recover the original destination
266
- /// connection id. Fails closed on any mismatch (forged/replayed/truncated).
267
- fn validate_token<'a>(
268
- secret: &[u8],
269
- src: &SocketAddr,
270
- token: &'a [u8],
271
- ) -> Option<quiche::ConnectionId<'a>> {
272
- let rest = token.strip_prefix(b"rwt1")?;
273
- if rest.len() < TOKEN_TAG_LEN {
274
- return None;
275
- }
276
- let (orig_dcid, tag) = rest.split_at(rest.len() - TOKEN_TAG_LEN);
277
- let mut mac_input = addr_identity(src);
278
- mac_input.extend_from_slice(orig_dcid);
279
- let expected = hmac_sha256(secret, &mac_input);
280
- if !constant_time_eq(&expected[..TOKEN_TAG_LEN], tag) {
281
- return None;
253
+ /// Authenticate the timestamp and original DCID, binding the token to both
254
+ /// the source address and the DCID that this Retry issued.
255
+ fn tag(&self, src: &SocketAddr, retry_scid: &[u8], body: &[u8]) -> [u8; 32] {
256
+ let mut input = addr_identity(src);
257
+ input.extend_from_slice(retry_scid);
258
+ input.extend_from_slice(body);
259
+ hmac_sha256(&self.secret, &input)
282
260
  }
283
- Some(quiche::ConnectionId::from_ref(orig_dcid))
284
- }
285
261
 
286
- /// A per-process random secret keying the Retry-token HMAC. Regenerated on every
287
- /// start, so tokens are unforgeable and do not survive a restart.
288
- fn random_secret() -> [u8; 32] {
289
- let mut b = [0u8; 32];
290
- if getrandom::getrandom(&mut b).is_err() {
291
- let seed: u128 = std::time::SystemTime::now()
292
- .duration_since(std::time::UNIX_EPOCH)
293
- .map(|d| d.as_nanos())
294
- .unwrap_or(0);
295
- let s = seed.to_le_bytes();
296
- for (i, slot) in b.iter_mut().enumerate() {
297
- *slot = s[i % s.len()];
298
- }
262
+ fn mint(&self, src: &SocketAddr, retry_scid: &[u8], orig_dcid: &[u8]) -> Vec<u8> {
263
+ let mut token = self.started.elapsed().as_secs().to_be_bytes().to_vec();
264
+ token.extend_from_slice(orig_dcid);
265
+ token.extend_from_slice(&self.tag(src, retry_scid, &token)[..TOKEN_TAG_LEN]);
266
+ token
299
267
  }
300
- b
301
- }
302
268
 
303
- fn random_scid() -> [u8; LOCAL_CONN_ID_LEN] {
304
- let mut b = [0u8; LOCAL_CONN_ID_LEN];
305
- if getrandom::getrandom(&mut b).is_err() {
306
- let seed: u128 = std::time::SystemTime::now()
307
- .duration_since(std::time::UNIX_EPOCH)
308
- .map(|d| d.as_nanos())
309
- .unwrap_or(0);
310
- b.copy_from_slice(&seed.to_le_bytes());
269
+ fn validate<'a>(
270
+ &self,
271
+ src: &SocketAddr,
272
+ retry_scid: &[u8],
273
+ token: &'a [u8],
274
+ ) -> Option<quiche::ConnectionId<'a>> {
275
+ const TIMESTAMP_LEN: usize = size_of::<u64>();
276
+ if retry_scid.len() != LOCAL_CONN_ID_LEN
277
+ || !(TIMESTAMP_LEN + 8 + TOKEN_TAG_LEN
278
+ ..=TIMESTAMP_LEN + quiche::MAX_CONN_ID_LEN + TOKEN_TAG_LEN)
279
+ .contains(&token.len())
280
+ {
281
+ return None;
282
+ }
283
+ let (body, tag) = token.split_at(token.len() - TOKEN_TAG_LEN);
284
+ let (issued, orig_dcid) = body.split_at(TIMESTAMP_LEN);
285
+ let issued = u64::from_be_bytes(issued.try_into().ok()?);
286
+ let age = self.started.elapsed().as_secs().checked_sub(issued)?;
287
+ if age > Self::TTL.as_secs()
288
+ || !boring::memcmp::eq(&self.tag(src, retry_scid, body)[..TOKEN_TAG_LEN], tag)
289
+ {
290
+ return None;
291
+ }
292
+ Some(quiche::ConnectionId::from_ref(orig_dcid))
311
293
  }
312
- b
313
294
  }
314
295
 
315
296
  fn run_inner(
@@ -319,7 +300,12 @@ fn run_inner(
319
300
  sink: &dyn ServerEventSink,
320
301
  shared: &Arc<DriverShared>,
321
302
  ) {
322
- let bind: SocketAddr = match format!("{}:{}", setup.host, setup.port).parse() {
303
+ let bind: SocketAddr = match setup
304
+ .host
305
+ .trim_matches(['[', ']'])
306
+ .parse::<std::net::IpAddr>()
307
+ .map(|ip| SocketAddr::new(ip, setup.port))
308
+ {
323
309
  Ok(a) => a,
324
310
  Err(e) => {
325
311
  sink.emit(vec![ServerMsg::ServerError(format!(
@@ -357,6 +343,17 @@ fn run_inner(
357
343
  return;
358
344
  }
359
345
 
346
+ let mut secret = [0; 32];
347
+ if let Err(e) = getrandom::fill(&mut secret) {
348
+ sink.emit(vec![ServerMsg::ServerError(format!(
349
+ "Retry key generation: {e}"
350
+ ))]);
351
+ return;
352
+ }
353
+ let tokens = RetryTokens {
354
+ secret,
355
+ started: Instant::now(),
356
+ };
360
357
  sink.emit(vec![ServerMsg::Listening(local_addr.port())]);
361
358
 
362
359
  let mut events = Events::with_capacity(1024);
@@ -367,33 +364,53 @@ fn run_inner(
367
364
  let mut routing: HashMap<Vec<u8>, Vec<u8>> = HashMap::new();
368
365
  let mut sessions: HashMap<u64, Vec<u8>> = HashMap::new();
369
366
  let mut next_session_id: u64 = 1;
367
+ let parser_memory = ParserMemory::new(MAX_PARSER_MEMORY);
370
368
 
371
- // Per-process secret keying the stateless Retry token (see mint_token).
372
- let token_secret = random_secret();
369
+ let mut udp_pending = false;
370
+ let mut read_pending = false;
371
+ let mut next_connection: usize = 0;
373
372
 
374
373
  loop {
375
- let timeout = clients.values().filter_map(|c| c.conn.timeout()).min();
376
- if poll.poll(&mut events, timeout).is_err() {
377
- continue;
374
+ let can_read = shared.inflight.load(Ordering::Relaxed) < MAX_INFLIGHT_BATCHES;
375
+ let timeout = if udp_pending || (read_pending && can_read) {
376
+ Some(Duration::ZERO)
377
+ } else {
378
+ let now = Instant::now();
379
+ clients
380
+ .values()
381
+ .flat_map(|c| {
382
+ [
383
+ c.conn.timeout(),
384
+ c.setup_deadline.map(|d| d.saturating_duration_since(now)),
385
+ ]
386
+ })
387
+ .flatten()
388
+ .min()
389
+ };
390
+ if let Err(e) = poll.poll(&mut events, timeout) {
391
+ if e.kind() == std::io::ErrorKind::Interrupted {
392
+ continue;
393
+ }
394
+ sink.emit(vec![ServerMsg::ServerError(format!("poll error: {e}"))]);
395
+ return;
378
396
  }
379
397
 
380
398
  let mut out: Vec<ServerMsg> = Vec::new();
381
399
 
382
400
  // 1. Read datagrams and route them, up to a per-wake budget so a flood
383
401
  // cannot starve the rest of the loop (commands, timeouts, reaping).
384
- let mut got_packet = false;
385
402
  let mut budget = MAX_RECV_PER_WAKE;
386
- loop {
387
- if budget == 0 {
388
- break;
389
- }
403
+ while budget > 0 {
390
404
  budget -= 1;
391
405
  let (len, from) = match socket.recv_from(&mut recv_buf) {
392
406
  Ok(v) => v,
393
407
  Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
408
+ Err(ref e) if is_udp_port_unreachable(e) => continue,
394
409
  Err(_) => break,
395
410
  };
396
- got_packet = true;
411
+ if len > MAX_RECV_UDP_PAYLOAD {
412
+ continue;
413
+ }
397
414
  let pkt = &mut recv_buf[..len];
398
415
  let hdr = match quiche::Header::from_slice(pkt, LOCAL_CONN_ID_LEN) {
399
416
  Ok(h) => h,
@@ -403,11 +420,17 @@ fn run_inner(
403
420
  let scid = match routing.get(&hdr.dcid.to_vec()).cloned() {
404
421
  Some(s) => s,
405
422
  None => {
406
- if hdr.ty != quiche::Type::Initial {
423
+ if hdr.ty != quiche::Type::Initial
424
+ || len < 1200
425
+ || !quiche::version_is_supported(hdr.version)
426
+ || hdr.dcid.len() < 8
427
+ {
407
428
  continue;
408
429
  }
409
430
  // Cap concurrent connections to bound memory under a flood.
410
- if clients.len() >= MAX_CONNECTIONS {
431
+ if clients.len() >= MAX_CONNECTIONS
432
+ || shared.inflight.load(Ordering::Relaxed) >= MAX_INFLIGHT_BATCHES
433
+ {
411
434
  continue;
412
435
  }
413
436
 
@@ -416,9 +439,12 @@ fn run_inner(
416
439
  // No address validation yet: reply with a stateless Retry.
417
440
  // We create no connection state (and do not amplify) for a
418
441
  // source that has not proven it owns its address.
419
- let new_scid = random_scid();
442
+ let mut new_scid = [0; LOCAL_CONN_ID_LEN];
443
+ if getrandom::fill(&mut new_scid).is_err() {
444
+ continue;
445
+ }
420
446
  let new_scid_id = quiche::ConnectionId::from_ref(&new_scid);
421
- let retry_token = mint_token(&token_secret, &hdr.dcid, &from);
447
+ let retry_token = tokens.mint(&from, &new_scid, &hdr.dcid);
422
448
  if let Ok(len) = quiche::retry(
423
449
  &hdr.scid,
424
450
  &hdr.dcid,
@@ -434,7 +460,7 @@ fn run_inner(
434
460
 
435
461
  // The client echoed a Retry token: validate it before we
436
462
  // allocate any connection state.
437
- let Some(odcid) = validate_token(&token_secret, &from, token) else {
463
+ let Some(odcid) = tokens.validate(&from, &hdr.dcid, token) else {
438
464
  continue;
439
465
  };
440
466
  // Our Retry SCID, echoed back as this Initial's DCID.
@@ -460,9 +486,11 @@ fn run_inner(
460
486
  setup.supported_protocols.clone(),
461
487
  setup.allowed_origins.clone(),
462
488
  setup.response_headers.clone(),
489
+ parser_memory.clone(),
463
490
  ),
464
491
  session_id,
465
- closed_emitted: false,
492
+ setup_deadline: Some(Instant::now() + SESSION_SETUP_TIMEOUT),
493
+ max_datagram_size: 0,
466
494
  },
467
495
  );
468
496
  key
@@ -477,13 +505,24 @@ fn run_inner(
477
505
  let _ = server.conn.recv(pkt, info);
478
506
  }
479
507
  }
508
+ udp_pending = budget == 0;
480
509
 
481
510
  // 2. Fire elapsed timeouts for every connection. quiche's on_timeout is a
482
511
  // no-op unless a timer is actually due, and it must run even while packets
483
512
  // keep arriving so idle/half-open connections are reaped under a flood.
484
- let _ = got_packet;
513
+ let now = Instant::now();
485
514
  for server in clients.values_mut() {
486
515
  server.conn.on_timeout();
516
+ if server
517
+ .setup_deadline
518
+ .is_some_and(|deadline| now >= deadline)
519
+ {
520
+ // The deadline covers both QUIC handshake and Extended CONNECT.
521
+ server.setup_deadline = None;
522
+ let _ = server
523
+ .conn
524
+ .close(true, h3::H3_NO_ERROR, b"session setup timed out");
525
+ }
487
526
  }
488
527
 
489
528
  // 3. Drain commands.
@@ -504,20 +543,34 @@ fn run_inner(
504
543
  }
505
544
 
506
545
  // 4. Drive every connection.
507
- let backpressured = shared.inflight.load(Ordering::Relaxed) >= MAX_INFLIGHT_BATCHES;
508
- for server in clients.values_mut() {
546
+ let can_read = shared.inflight.load(Ordering::Relaxed) < MAX_INFLIGHT_BATCHES;
547
+ let mut budget = ReceiveBudget::new();
548
+ let mut ordered: Vec<_> = clients.values_mut().collect();
549
+ let start = next_connection.checked_rem(ordered.len()).unwrap_or(0);
550
+ ordered.rotate_left(start);
551
+ read_pending = false;
552
+ for (index, server) in ordered.into_iter().enumerate() {
553
+ if server.conn.is_closed() || server.conn.local_error().is_some() {
554
+ flush_send(&mut server.conn, &socket, &mut send_buf);
555
+ continue;
556
+ }
509
557
  let mut evs: Vec<Ev> = Vec::new();
510
558
  if server.conn.is_established() {
511
- server.session.on_established();
512
- }
513
- if !backpressured {
514
- server.session.on_datagrams(&mut server.conn, &mut evs);
559
+ server
560
+ .session
561
+ .on_established(server.conn.reliable_stream_reset_negotiated());
515
562
  }
516
- let readable: Vec<u64> = server.conn.readable().collect();
517
- for id in readable {
563
+ if can_read && !budget.exhausted() {
518
564
  server
519
565
  .session
520
- .on_readable(&mut server.conn, id, backpressured, &mut evs);
566
+ .read_pending(&mut server.conn, &mut budget, &mut evs);
567
+ if budget.exhausted() {
568
+ next_connection = start + index + 1;
569
+ read_pending = true;
570
+ }
571
+ }
572
+ if server.session.is_ready() {
573
+ server.setup_deadline = None;
521
574
  }
522
575
  server.session.flush(&mut server.conn, &mut evs);
523
576
 
@@ -529,13 +582,18 @@ fn run_inner(
529
582
  let _ = server.conn.close(true, h3::H3_NO_ERROR, b"");
530
583
  }
531
584
 
532
- if let Some(sz) = server.conn.dgram_max_writable_len() {
533
- shared
534
- .max_datagram_size
535
- .store(sz.saturating_sub(1), Ordering::Relaxed);
585
+ if server.session.is_ready() && !server.session.is_closed() {
586
+ let size = server.session.max_datagram_size(&server.conn);
587
+ if size != server.max_datagram_size {
588
+ server.max_datagram_size = size;
589
+ evs.push(Ev::DatagramSize(size));
590
+ }
536
591
  }
537
592
 
538
593
  for ev in evs {
594
+ if std::env::var_os("RWT_DEBUG").is_some() && matches!(ev, Ev::Error(_)) {
595
+ eprintln!("[rwt-server] {ev:?}");
596
+ }
539
597
  out.push(ServerMsg::Session(server.session_id, ev));
540
598
  }
541
599
 
@@ -544,24 +602,21 @@ fn run_inner(
544
602
 
545
603
  // 5. Reap closed connections (emit a final Closed for the session).
546
604
  for server in clients.values_mut() {
547
- if server.conn.is_closed() && !server.closed_emitted {
548
- server.closed_emitted = true;
549
- if !server.session.is_closed() {
550
- let mut evs = Vec::new();
551
- if let Some((code, reason)) = server.session.local_close_info() {
552
- // Locally initiated graceful WebTransport close: surface the
553
- // WT code/reason (the wire close used H3_NO_ERROR).
554
- server.session.mark_closed(&mut evs, code, reason, false);
555
- } else {
556
- let (code, reason, remote, err) = closure_info(&server.conn);
557
- if let Some(msg) = err {
558
- evs.push(Ev::Error(msg));
559
- }
560
- server.session.mark_closed(&mut evs, code, reason, remote);
561
- }
562
- for ev in evs {
563
- out.push(ServerMsg::Session(server.session_id, ev));
605
+ if server.conn.is_closed() && server.session.is_ready() && !server.session.is_closed() {
606
+ let mut evs = Vec::new();
607
+ if let Some((code, reason)) = server.session.local_close_info() {
608
+ // Locally initiated graceful WebTransport close: surface the
609
+ // WT code/reason (the wire close used H3_NO_ERROR).
610
+ server.session.mark_closed(&mut evs, code, reason, false);
611
+ } else {
612
+ let (code, reason, remote, err) = closure_info(&server.conn);
613
+ if let Some(msg) = err {
614
+ evs.push(Ev::Error(msg));
564
615
  }
616
+ server.session.mark_closed(&mut evs, code, reason, remote);
617
+ }
618
+ for ev in evs {
619
+ out.push(ServerMsg::Session(server.session_id, ev));
565
620
  }
566
621
  }
567
622
  }
@@ -648,7 +703,7 @@ fn apply_command(
648
703
  context,
649
704
  length,
650
705
  ..
651
- } => evs.push(crate::session::build_keying_material(
706
+ } => evs.push(server.session.build_keying_material(
652
707
  &mut server.conn,
653
708
  request_id,
654
709
  &label,
@@ -742,54 +797,31 @@ mod tests {
742
797
  }
743
798
 
744
799
  #[test]
745
- fn token_roundtrip_recovers_dcid() {
746
- let secret = [7u8; 32];
747
- let dcid = b"\x11\x22\x33\x44\x55\x66\x77\x88";
800
+ fn retry_token_authenticates_address_and_connection() {
801
+ let mut tokens = RetryTokens {
802
+ secret: [7; 32],
803
+ started: Instant::now(),
804
+ };
748
805
  let src = addr("192.0.2.10:4433");
749
- let token = mint_token(&secret, dcid, &src);
750
- let recovered = validate_token(&secret, &src, &token).expect("valid token");
751
- assert_eq!(recovered.as_ref(), &dcid[..]);
752
- }
753
-
754
- #[test]
755
- fn token_rejected_for_different_source_address() {
756
- let secret = [7u8; 32];
757
- let dcid = b"abcdefghij";
758
- let token = mint_token(&secret, dcid, &addr("192.0.2.10:4433"));
759
- // Spoofed source IP: the whole point of the Retry.
760
- assert!(validate_token(&secret, &addr("192.0.2.11:4433"), &token).is_none());
761
- // Same IP, different port: still not the address the token was minted for.
762
- assert!(validate_token(&secret, &addr("192.0.2.10:5555"), &token).is_none());
763
- }
764
-
765
- #[test]
766
- fn token_rejected_under_a_different_secret() {
767
- let dcid = b"abcdefghij";
768
- let src = addr("198.51.100.7:443");
769
- let token = mint_token(&[1u8; 32], dcid, &src);
770
- // A server that restarted (new secret) rejects the stale token.
771
- assert!(validate_token(&[2u8; 32], &src, &token).is_none());
772
- }
773
-
774
- #[test]
775
- fn forged_and_truncated_tokens_are_rejected() {
776
- let secret = [9u8; 32];
777
- let src = addr("198.51.100.7:443");
778
- // Attacker who does not know the secret guesses the layout with a zero tag.
779
- let mut forged = Vec::new();
780
- forged.extend_from_slice(b"rwt1");
781
- forged.extend_from_slice(b"deadbeefdcid");
782
- forged.extend_from_slice(&[0u8; TOKEN_TAG_LEN]);
783
- assert!(validate_token(&secret, &src, &forged).is_none());
784
- // Too short to hold a tag, wrong prefix, empty.
785
- assert!(validate_token(&secret, &src, b"rwt1short").is_none());
786
- assert!(validate_token(&secret, &src, b"nope").is_none());
787
- assert!(validate_token(&secret, &src, b"").is_none());
788
- // A valid token with a single tag byte flipped.
789
- let mut token = mint_token(&secret, b"abcdefghij", &src);
790
- let last = token.len() - 1;
791
- token[last] ^= 0xff;
792
- assert!(validate_token(&secret, &src, &token).is_none());
806
+ let dcid = b"original id";
807
+ let scid = [42; LOCAL_CONN_ID_LEN];
808
+ let token = tokens.mint(&src, &scid, dcid);
809
+ assert_eq!(tokens.validate(&src, &scid, &token).unwrap().as_ref(), dcid);
810
+ assert!(tokens
811
+ .validate(&addr("192.0.2.11:4433"), &scid, &token)
812
+ .is_none());
813
+ assert!(tokens
814
+ .validate(&addr("192.0.2.10:1234"), &scid, &token)
815
+ .is_none());
816
+ assert!(tokens
817
+ .validate(&src, &[41; LOCAL_CONN_ID_LEN], &token)
818
+ .is_none());
819
+ assert!(tokens.validate(&src, &scid, &token[..7]).is_none());
820
+ let mut altered = token.clone();
821
+ *altered.last_mut().unwrap() ^= 1;
822
+ assert!(tokens.validate(&src, &scid, &altered).is_none());
823
+ tokens.started -= RetryTokens::TTL + Duration::from_secs(1);
824
+ assert!(tokens.validate(&src, &scid, &token).is_none());
793
825
  }
794
826
 
795
827
  #[test]