rwebtransport 0.2.3 → 0.2.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (96) hide show
  1. package/Cargo.lock +153 -226
  2. package/Cargo.toml +5 -5
  3. package/README.md +4 -4
  4. package/crates/echo-server/src/bin/gen-test-cert.rs +1 -1
  5. package/crates/native/Cargo.toml +1 -1
  6. package/crates/native/src/config.rs +13 -1
  7. package/crates/native/src/driver.rs +249 -91
  8. package/crates/native/src/lib.rs +9 -10
  9. package/crates/native/src/parser_memory.rs +1 -0
  10. package/crates/native/src/server.rs +197 -182
  11. package/crates/native/src/session.rs +329 -177
  12. package/crates/native/src/test_support.rs +2 -2
  13. package/crates/wtcore/src/h3.rs +166 -10
  14. package/dist/index.js +92 -45
  15. package/dist/index.js.map +2 -2
  16. package/dist/index.mjs +92 -45
  17. package/dist/index.mjs.map +2 -2
  18. package/dist/native.d.ts +9 -4
  19. package/package.json +14 -11
  20. package/prebuilds/darwin-arm64/rwebtransport.node +0 -0
  21. package/prebuilds/linux-arm64/rwebtransport.node +0 -0
  22. package/prebuilds/linux-x64/rwebtransport.node +0 -0
  23. package/prebuilds/win32-x64/rwebtransport.node +0 -0
  24. package/scripts/build-linux-prebuilt.sh +46 -0
  25. package/scripts/build.js +10 -3
  26. package/vendor/quiche/AGENTS.md +10 -0
  27. package/vendor/quiche/Cargo.lock +239 -248
  28. package/vendor/quiche/Cargo.toml +23 -10
  29. package/vendor/quiche/examples/Makefile +4 -4
  30. package/vendor/quiche/examples/client.rs +10 -28
  31. package/vendor/quiche/examples/http3-client.rs +20 -34
  32. package/vendor/quiche/examples/http3-server.rs +47 -78
  33. package/vendor/quiche/examples/server.rs +19 -49
  34. package/vendor/quiche/include/quiche.h +35 -4
  35. package/vendor/quiche/src/build.rs +17 -0
  36. package/vendor/quiche/src/cid.rs +129 -61
  37. package/vendor/quiche/src/crypto/boringssl.rs +98 -86
  38. package/vendor/quiche/src/crypto/mod.rs +64 -77
  39. package/vendor/quiche/src/dgram.rs +2 -3
  40. package/vendor/quiche/src/error.rs +22 -20
  41. package/vendor/quiche/src/ffi.rs +558 -280
  42. package/vendor/quiche/src/flowcontrol.rs +0 -7
  43. package/vendor/quiche/src/frame.rs +134 -135
  44. package/vendor/quiche/src/h3/ffi.rs +73 -60
  45. package/vendor/quiche/src/h3/frame.rs +70 -90
  46. package/vendor/quiche/src/h3/mod.rs +1024 -593
  47. package/vendor/quiche/src/h3/qpack/decoder.rs +248 -34
  48. package/vendor/quiche/src/h3/qpack/dynamic_table.rs +859 -0
  49. package/vendor/quiche/src/h3/qpack/encoder.rs +14 -17
  50. package/vendor/quiche/src/h3/qpack/mod.rs +48 -0
  51. package/vendor/quiche/src/h3/qpack/static_table.rs +86 -73
  52. package/vendor/quiche/src/h3/stream.rs +1009 -194
  53. package/vendor/quiche/src/lib.rs +1346 -1195
  54. package/vendor/quiche/src/minmax.rs +2 -6
  55. package/vendor/quiche/src/packet.rs +420 -552
  56. package/vendor/quiche/src/path.rs +202 -72
  57. package/vendor/quiche/src/pmtud.rs +18 -16
  58. package/vendor/quiche/src/ranges.rs +184 -82
  59. package/vendor/quiche/src/recovery/AGENTS.md +5 -2
  60. package/vendor/quiche/src/recovery/bandwidth.rs +59 -40
  61. package/vendor/quiche/src/recovery/bytes_in_flight.rs +2 -2
  62. package/vendor/quiche/src/recovery/congestion/cubic.rs +38 -47
  63. package/vendor/quiche/src/recovery/congestion/delivery_rate.rs +54 -60
  64. package/vendor/quiche/src/recovery/congestion/hystart.rs +6 -10
  65. package/vendor/quiche/src/recovery/congestion/mod.rs +110 -42
  66. package/vendor/quiche/src/recovery/congestion/prr.rs +4 -1
  67. package/vendor/quiche/src/recovery/congestion/recovery.rs +91 -95
  68. package/vendor/quiche/src/recovery/congestion/reno.rs +17 -12
  69. package/vendor/quiche/src/recovery/congestion/test_sender.rs +8 -27
  70. package/vendor/quiche/src/recovery/gcongestion/bbr/bandwidth_sampler.rs +159 -247
  71. package/vendor/quiche/src/recovery/gcongestion/bbr/windowed_filter.rs +9 -14
  72. package/vendor/quiche/src/recovery/gcongestion/bbr2/drain.rs +18 -15
  73. package/vendor/quiche/src/recovery/gcongestion/bbr2/mode.rs +43 -28
  74. package/vendor/quiche/src/recovery/gcongestion/bbr2/network_model.rs +349 -76
  75. package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_bw.rs +147 -195
  76. package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_rtt.rs +29 -27
  77. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min.rs +180 -0
  78. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min_tests.rs +221 -0
  79. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm.rs +395 -0
  80. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm_tests.rs +473 -0
  81. package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/mod.rs +175 -0
  82. package/vendor/quiche/src/recovery/gcongestion/bbr2/startup.rs +33 -26
  83. package/vendor/quiche/src/recovery/gcongestion/bbr2.rs +107 -60
  84. package/vendor/quiche/src/recovery/gcongestion/mod.rs +64 -11
  85. package/vendor/quiche/src/recovery/gcongestion/pacer.rs +34 -25
  86. package/vendor/quiche/src/recovery/gcongestion/recovery.rs +81 -86
  87. package/vendor/quiche/src/recovery/mod.rs +414 -173
  88. package/vendor/quiche/src/recovery/rtt.rs +8 -5
  89. package/vendor/quiche/src/stream/mod.rs +864 -133
  90. package/vendor/quiche/src/stream/recv_buf.rs +471 -172
  91. package/vendor/quiche/src/stream/send_buf.rs +338 -81
  92. package/vendor/quiche/src/test_utils.rs +78 -64
  93. package/vendor/quiche/src/tests.rs +2559 -1335
  94. package/vendor/quiche/src/tls/boringssl.rs +60 -63
  95. package/vendor/quiche/src/tls/mod.rs +146 -193
  96. package/vendor/quiche/src/transport_params.rs +87 -103
@@ -66,7 +66,7 @@ impl<F: BufFactory> SendReserve<'_, F> {
66
66
  inner.data.push_back(buf);
67
67
 
68
68
  inner.off += len as u64;
69
- inner.len += len as u64;
69
+ inner.buffered_bytes += len as u64;
70
70
  self.reserved -= len;
71
71
 
72
72
  Ok(())
@@ -79,6 +79,51 @@ impl<F: BufFactory> Drop for SendReserve<'_, F> {
79
79
  }
80
80
  }
81
81
 
82
+ /// A received STOP_SENDING error and its application notification state.
83
+ #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
84
+ pub(crate) enum PeerStopSendingState {
85
+ /// No STOP_SENDING has been received.
86
+ #[default]
87
+ NotReceived,
88
+
89
+ /// STOP_SENDING was received but has not been reported to the application.
90
+ NotReported(u64),
91
+
92
+ /// STOP_SENDING was reported; retain its code for subsequent write errors.
93
+ Reported(u64),
94
+ }
95
+
96
+ impl PeerStopSendingState {
97
+ /// Returns whether a STOP_SENDING has been received, regardless of
98
+ /// delivery.
99
+ pub(crate) fn is_stopped(self) -> bool {
100
+ match self {
101
+ Self::NotReceived => false,
102
+ Self::NotReported(_) | Self::Reported(_) => true,
103
+ }
104
+ }
105
+
106
+ /// Returns the peer's error without consuming its application notification.
107
+ fn check_not_stopped(self) -> Result<()> {
108
+ match self {
109
+ Self::NotReceived => Ok(()),
110
+ Self::NotReported(code) | Self::Reported(code) => Err(Error::StreamStopped(code)),
111
+ }
112
+ }
113
+
114
+ /// Records application delivery and retains the code for later errors.
115
+ fn report(&mut self) -> Result<()> {
116
+ match *self {
117
+ Self::NotReceived => Ok(()),
118
+ Self::NotReported(code) => {
119
+ *self = Self::Reported(code);
120
+ Err(Error::StreamStopped(code))
121
+ }
122
+ Self::Reported(code) => Err(Error::StreamStopped(code)),
123
+ }
124
+ }
125
+ }
126
+
82
127
  /// Send-side stream buffer.
83
128
  ///
84
129
  /// Stream data scheduled to be sent to the peer is buffered in a list of data
@@ -106,8 +151,12 @@ where
106
151
  /// retransmissions.
107
152
  emit_off: u64,
108
153
 
109
- /// The amount of data currently buffered.
110
- len: u64,
154
+ /// The number of bytes buffered and ready to be emitted to the peer.
155
+ ///
156
+ /// This includes fresh data that has not yet been sent, as well as data
157
+ /// marked for retransmission. It excludes data that has been emitted but
158
+ /// not yet acknowledged (in-flight data).
159
+ buffered_bytes: u64,
111
160
 
112
161
  /// The maximum offset we are allowed to send to the peer.
113
162
  max_data: u64,
@@ -118,14 +167,24 @@ where
118
167
  /// The final stream offset written to the stream, if any.
119
168
  fin_off: Option<u64>,
120
169
 
170
+ /// Whether a STREAM frame carrying FIN has been acknowledged.
171
+ fin_acked: bool,
172
+
173
+ /// Whether a RESET_STREAM frame has been acknowledged, or is not needed
174
+ /// because the send side was already complete when it was reset.
175
+ reset_acked: bool,
176
+
121
177
  /// Whether the stream's send-side has been shut down.
122
178
  shutdown: bool,
123
179
 
180
+ /// When set, resets retain and retransmit this prefix.
181
+ pub(crate) reliable_reset_size: Option<u64>,
182
+
124
183
  /// Ranges of data offsets that have been acked.
125
184
  acked: ranges::RangeSet,
126
185
 
127
- /// The error code received via STOP_SENDING.
128
- error: Option<u64>,
186
+ /// The STOP_SENDING error and whether it was returned to the application.
187
+ peer_stop_sending: PeerStopSendingState,
129
188
  }
130
189
 
131
190
  impl<F: BufFactory> SendBuf<F> {
@@ -138,9 +197,7 @@ impl<F: BufFactory> SendBuf<F> {
138
197
  }
139
198
 
140
199
  /// Try to reserve the required number of bytes to be sent
141
- fn reserve_for_write(
142
- &mut self, mut len: usize, mut fin: bool,
143
- ) -> Result<SendReserve<'_, F>> {
200
+ fn reserve_for_write(&mut self, mut len: usize, mut fin: bool) -> Result<SendReserve<'_, F>> {
144
201
  let max_off = self.off + len as u64;
145
202
 
146
203
  // Get the stream send capacity. This will return an error if the stream
@@ -211,7 +268,10 @@ impl<F: BufFactory> SendBuf<F> {
211
268
  /// (this may be lower than the size of the input buffer, in case of partial
212
269
  /// writes, in which case the unwritten buffer is also returned).
213
270
  pub fn append_buf(
214
- &mut self, mut data: F::Buf, cap: usize, fin: bool,
271
+ &mut self,
272
+ mut data: F::Buf,
273
+ cap: usize,
274
+ fin: bool,
215
275
  ) -> Result<(usize, Option<F::Buf>)>
216
276
  where
217
277
  F::Buf: BufSplit,
@@ -223,8 +283,7 @@ impl<F: BufFactory> SendBuf<F> {
223
283
  return Ok((0, Some(data)));
224
284
  }
225
285
 
226
- let remainder =
227
- (reserve.reserved < len).then(|| data.split_at(reserve.reserved));
286
+ let remainder = (reserve.reserved < len).then(|| data.split_at(reserve.reserved));
228
287
 
229
288
  let ret = reserve.reserved;
230
289
 
@@ -243,10 +302,10 @@ impl<F: BufFactory> SendBuf<F> {
243
302
  while out_len > 0 {
244
303
  let off_front = self.off_front();
245
304
 
246
- if self.is_empty() ||
247
- off_front >= self.off ||
248
- off_front != next_off ||
249
- off_front >= self.max_data
305
+ if self.is_empty()
306
+ || off_front >= self.off
307
+ || off_front != next_off
308
+ || off_front >= self.max_data
250
309
  {
251
310
  break;
252
311
  }
@@ -269,7 +328,7 @@ impl<F: BufFactory> SendBuf<F> {
269
328
  let out_pos = (next_off - out_off) as usize;
270
329
  out[out_pos..out_pos + buf_len].copy_from_slice(&buf[..buf_len]);
271
330
 
272
- self.len -= buf_len as u64;
331
+ self.buffered_bytes -= buf_len as u64;
273
332
 
274
333
  out_len -= buf_len;
275
334
 
@@ -291,7 +350,7 @@ impl<F: BufFactory> SendBuf<F> {
291
350
  // This is more efficient than tracking `fin` using the range buffers
292
351
  // themselves, and lets us avoid queueing empty buffers just so we can
293
352
  // propagate the final size.
294
- let fin = self.fin_off == Some(next_off);
353
+ let fin = !self.is_reset() && self.fin_off == Some(next_off);
295
354
 
296
355
  // Record the largest offset that has been sent so we can accurately
297
356
  // report final_size
@@ -320,17 +379,31 @@ impl<F: BufFactory> SendBuf<F> {
320
379
  self.acked.insert(off..off + len as u64);
321
380
  }
322
381
 
323
- pub fn ack_and_drop(&mut self, off: u64, len: usize) {
382
+ /// Marks the stream's final size as acknowledged by the peer.
383
+ pub(crate) fn ack_fin(&mut self) {
384
+ self.fin_acked = true;
385
+ }
386
+
387
+ /// Marks the stream's reset as acknowledged by the peer.
388
+ pub(crate) fn ack_reset_stream(&mut self) {
389
+ self.reset_acked = true;
390
+ }
391
+
392
+ pub(crate) fn reset_acknowledged(&self) -> bool {
393
+ self.reset_acked
394
+ }
395
+
396
+ pub fn ack_and_drop(&mut self, off: u64, len: usize) -> usize {
324
397
  self.ack(off, len);
325
398
 
326
399
  let ack_off = self.ack_off();
327
400
 
328
401
  if self.data.is_empty() {
329
- return;
402
+ return 0;
330
403
  }
331
404
 
332
405
  if off > ack_off {
333
- return;
406
+ return 0;
334
407
  }
335
408
 
336
409
  let mut drop_until = None;
@@ -354,27 +427,44 @@ impl<F: BufFactory> SendBuf<F> {
354
427
  }
355
428
 
356
429
  if let Some(drop) = drop_until {
430
+ // Calculate the total length of buffers being dropped and subtract
431
+ // from buffered_bytes.
432
+ let dropped_len: u64 = (0..=drop).map(|i| self.data[i].len() as u64).sum();
433
+ self.buffered_bytes = self.buffered_bytes.saturating_sub(dropped_len);
434
+
357
435
  self.data.drain(..=drop);
358
436
 
359
437
  // When a buffer is marked for retransmission, but then acked before
360
438
  // it could be retransmitted, we might end up decreasing the SendBuf
361
439
  // position too much, so make sure that doesn't happen.
362
440
  self.pos = self.pos.saturating_sub(drop + 1);
441
+
442
+ dropped_len as usize
443
+ } else {
444
+ 0
363
445
  }
364
446
  }
365
447
 
366
- pub fn retransmit(&mut self, off: u64, len: usize) {
367
- let max_off = off + len as u64;
448
+ pub fn retransmit(&mut self, off: u64, len: usize) -> usize {
449
+ let mut max_off = off + len as u64;
450
+ if self.is_reset() {
451
+ max_off = max_off.min(self.reliable_reset_size.unwrap_or(0));
452
+ if max_off <= off {
453
+ return 0;
454
+ }
455
+ }
368
456
  let ack_off = self.ack_off();
369
457
 
370
458
  if self.data.is_empty() {
371
- return;
459
+ return 0;
372
460
  }
373
461
 
374
462
  if max_off <= ack_off {
375
- return;
463
+ return 0;
376
464
  }
377
465
 
466
+ let mut total_retransmitted = 0;
467
+
378
468
  for i in 0..self.data.len() {
379
469
  let buf = &mut self.data[i];
380
470
 
@@ -396,8 +486,8 @@ impl<F: BufFactory> SendBuf<F> {
396
486
 
397
487
  let prev_pos = buf.pos;
398
488
 
399
- // Reduce the buffer's position (expand the buffer) if the retransmit
400
- // range is past the buffer's starting offset.
489
+ // Expand the buffer by moving its position back when the retransmit
490
+ // range starts after the buffer offset.
401
491
  buf.pos = if off > buf.off && off <= buf.max_off() {
402
492
  cmp::min(buf.pos, buf.start + (off - buf.off) as usize)
403
493
  } else {
@@ -406,16 +496,45 @@ impl<F: BufFactory> SendBuf<F> {
406
496
 
407
497
  self.pos = cmp::min(self.pos, i);
408
498
 
409
- self.len += (prev_pos - buf.pos) as u64;
499
+ let retransmitted = (prev_pos - buf.pos) as u64;
500
+ self.buffered_bytes += retransmitted;
501
+ total_retransmitted += retransmitted;
410
502
 
411
503
  if let Some(b) = new_buf {
412
504
  self.data.insert(i + 1, b);
413
505
  }
414
506
  }
507
+
508
+ total_retransmitted as usize
415
509
  }
416
510
 
417
511
  /// Resets the stream at the current offset and clears all buffered data.
418
512
  pub fn reset(&mut self) -> (u64, u64) {
513
+ // A send side whose data and FIN were already acknowledged needs no
514
+ // RESET_STREAM and stays complete. This must run before the caller
515
+ // marks the stream as stopped or shut down.
516
+ self.reset_acked |= self.is_complete();
517
+
518
+ if let Some(reliable) = self.reliable_reset_size {
519
+ let final_size = self.emit_off.max(reliable);
520
+ let unsent = self.off.saturating_sub(final_size);
521
+ while let Some(buf) = self.data.back_mut() {
522
+ if buf.off >= reliable {
523
+ self.data.pop_back();
524
+ continue;
525
+ }
526
+ if buf.max_off() > reliable {
527
+ let _ = buf.split_off((reliable - buf.off) as usize);
528
+ }
529
+ break;
530
+ }
531
+ self.pos = self.pos.min(self.data.len());
532
+ self.buffered_bytes = self.data.iter().map(|buf| buf.len() as u64).sum();
533
+ self.fin_off = Some(final_size);
534
+ self.off = final_size;
535
+ return (final_size, unsent);
536
+ }
537
+
419
538
  let unsent_off = cmp::max(self.off_front(), self.emit_off);
420
539
  let unsent_len = self.off_back().saturating_sub(unsent_off);
421
540
 
@@ -429,7 +548,7 @@ impl<F: BufFactory> SendBuf<F> {
429
548
  self.ack(0, self.off as usize);
430
549
 
431
550
  self.pos = 0;
432
- self.len = 0;
551
+ self.buffered_bytes = 0;
433
552
 
434
553
  (self.emit_off, unsent_len)
435
554
  }
@@ -438,26 +557,40 @@ impl<F: BufFactory> SendBuf<F> {
438
557
  ///
439
558
  /// Calling this again after the first time has no effect.
440
559
  pub fn stop(&mut self, error_code: u64) -> Result<(u64, u64)> {
441
- if self.error.is_some() {
560
+ if self.peer_stop_sending.is_stopped()
561
+ || (self.shutdown && self.reliable_reset_size.is_some())
562
+ {
442
563
  return Err(Error::Done);
443
564
  }
444
565
 
445
566
  let (max_off, unsent) = self.reset();
446
567
 
447
- self.error = Some(error_code);
568
+ self.peer_stop_sending = PeerStopSendingState::NotReported(error_code);
448
569
 
449
570
  Ok((max_off, unsent))
450
571
  }
451
572
 
452
573
  /// Shuts down sending data.
453
574
  pub fn shutdown(&mut self) -> Result<(u64, u64)> {
454
- if self.shutdown {
575
+ if self.shutdown
576
+ || (self.peer_stop_sending.is_stopped() && self.reliable_reset_size.is_some())
577
+ {
455
578
  return Err(Error::Done);
456
579
  }
457
580
 
581
+ let (max_off, unsent) = self.reset();
582
+
458
583
  self.shutdown = true;
459
584
 
460
- Ok(self.reset())
585
+ Ok((max_off, unsent))
586
+ }
587
+
588
+ /// Seeds send offsets without buffering the preceding data.
589
+ #[cfg(test)]
590
+ pub fn seed_offsets_for_test(&mut self, off: u64) {
591
+ assert!(self.data.is_empty());
592
+ self.off = off;
593
+ self.emit_off = off;
461
594
  }
462
595
 
463
596
  /// Returns the final offset after FIN or a reset.
@@ -486,6 +619,11 @@ impl<F: BufFactory> SendBuf<F> {
486
619
  self.off
487
620
  }
488
621
 
622
+ /// Returns true if the next call to [`Self::emit`] will emit an empty FIN.
623
+ pub fn empty_fin_next(&self) -> bool {
624
+ self.fin_off == Some(self.off_front())
625
+ }
626
+
489
627
  /// The maximum offset we are allowed to send to the peer.
490
628
  pub fn max_off(&self) -> u64 {
491
629
  self.max_data
@@ -505,11 +643,15 @@ impl<F: BufFactory> SendBuf<F> {
505
643
 
506
644
  /// Returns true if the send-side of the stream is complete.
507
645
  ///
508
- /// This happens when the stream's send final size is known, and the peer
509
- /// has already acked all stream data up to that point.
646
+ /// This happens when the peer has acknowledged the stream's final size and
647
+ /// all stream data up to that point, or has acknowledged RESET_STREAM.
510
648
  pub fn is_complete(&self) -> bool {
649
+ if self.is_reset() {
650
+ return self.reset_acked && self.ack_off() >= self.reliable_reset_size.unwrap_or(0);
651
+ }
652
+
511
653
  if let Some(fin_off) = self.fin_off {
512
- if self.acked == (0..fin_off) {
654
+ if self.fin_acked && self.acked == (0..fin_off) {
513
655
  return true;
514
656
  }
515
657
  }
@@ -517,9 +659,9 @@ impl<F: BufFactory> SendBuf<F> {
517
659
  false
518
660
  }
519
661
 
520
- /// Returns true if the stream was stopped before completion.
521
- pub fn is_stopped(&self) -> bool {
522
- self.error.is_some()
662
+ /// Returns the received STOP_SENDING error's notification state.
663
+ pub(crate) fn peer_stop_sending_state(&self) -> PeerStopSendingState {
664
+ self.peer_stop_sending
523
665
  }
524
666
 
525
667
  /// Returns true if the stream was shut down.
@@ -527,6 +669,16 @@ impl<F: BufFactory> SendBuf<F> {
527
669
  self.shutdown
528
670
  }
529
671
 
672
+ /// Returns true if the send side was shut down by the application or
673
+ /// stopped by the peer.
674
+ pub(crate) fn is_reset(&self) -> bool {
675
+ self.shutdown || self.peer_stop_sending.is_stopped()
676
+ }
677
+
678
+ pub(crate) fn can_send_data(&self) -> bool {
679
+ !self.is_reset() || self.reliable_reset_size.is_some()
680
+ }
681
+
530
682
  /// Returns true if there is no data.
531
683
  pub fn is_empty(&self) -> bool {
532
684
  self.data.is_empty()
@@ -546,30 +698,94 @@ impl<F: BufFactory> SendBuf<F> {
546
698
  /// Returns the outgoing flow control capacity.
547
699
  pub fn cap(&self) -> Result<usize> {
548
700
  // The stream was stopped, so return the error code instead.
549
- if let Some(e) = self.error {
550
- return Err(Error::StreamStopped(e));
551
- }
701
+ self.peer_stop_sending.check_not_stopped()?;
552
702
 
553
703
  Ok((self.max_data - self.off) as usize)
554
704
  }
555
705
 
706
+ /// Returns capacity, reporting a received STOP_SENDING to the application.
707
+ /// Internal writability checks use `cap()` without consuming notification.
708
+ pub fn cap_and_report_stop_sending(&mut self) -> Result<usize> {
709
+ self.peer_stop_sending.report()?;
710
+ self.cap()
711
+ }
712
+
556
713
  /// Returns the number of separate buffers stored.
557
714
  #[allow(dead_code)]
558
715
  pub fn bufs_count(&self) -> usize {
559
716
  self.data.len()
560
717
  }
718
+
719
+ /// Returns the number of bytes ready to be emitted to the peer.
720
+ ///
721
+ /// This includes fresh data that has not yet been sent, as well as data
722
+ /// marked for retransmission. It excludes data that has been emitted but
723
+ /// not yet acknowledged (in-flight data).
724
+ pub fn buffered_bytes(&self) -> u64 {
725
+ self.buffered_bytes
726
+ }
561
727
  }
562
728
 
563
729
  #[cfg(test)]
564
730
  mod tests {
731
+ use rstest::rstest;
732
+
733
+ #[test]
734
+ fn reliable_reset_retransmits_prefix_only_and_waits_for_ack() {
735
+ let mut send = <SendBuf>::new(20);
736
+ send.reliable_reset_size = Some(3);
737
+ assert_eq!(send.write(b"abcdef", false), Ok(6));
738
+ assert_eq!(send.emit(&mut [0; 6]), Ok((6, false)));
739
+ assert_eq!(send.shutdown(), Ok((6, 0)));
740
+ send.ack_reset_stream();
741
+ assert!(!send.is_complete());
742
+ assert_eq!(send.retransmit(0, 6), 3);
743
+ let mut data = [0; 6];
744
+ assert_eq!(send.emit(&mut data), Ok((3, false)));
745
+ assert_eq!(&data[..3], b"abc");
746
+ send.ack_and_drop(0, 3);
747
+ assert!(send.is_complete());
748
+ }
749
+
565
750
  use super::*;
566
751
 
752
+ #[rstest]
753
+ fn reset_waits_for_ack(
754
+ #[values(true, false)] local_reset: bool,
755
+ #[values(true, false)] acked_before_reset: bool,
756
+ ) {
757
+ let mut send = <SendBuf>::new(15);
758
+ let mut out = [0; 5];
759
+ assert_eq!(send.write(b"hello", true), Ok(5));
760
+ assert_eq!(send.emit(&mut out), Ok((5, true)));
761
+
762
+ if acked_before_reset {
763
+ send.ack_and_drop(0, 5);
764
+ send.ack_fin();
765
+ }
766
+
767
+ let result = if local_reset {
768
+ send.shutdown()
769
+ } else {
770
+ send.stop(42)
771
+ };
772
+ assert_eq!(result, Ok((5, 0)));
773
+ assert_eq!(send.is_complete(), acked_before_reset);
774
+
775
+ send.ack_and_drop(0, 5);
776
+ send.ack_fin();
777
+ assert_eq!(send.is_complete(), acked_before_reset);
778
+
779
+ send.ack_reset_stream();
780
+ assert!(send.is_complete());
781
+ }
782
+
567
783
  #[test]
568
784
  fn empty_write() {
569
785
  let mut buf = [0; 5];
570
786
 
571
787
  let mut send = <SendBuf>::new(u64::MAX);
572
- assert_eq!(send.len, 0);
788
+ assert_eq!(send.buffered_bytes, 0);
573
789
 
574
790
  let (written, fin) = send.emit(&mut buf).unwrap();
575
791
  assert_eq!(written, 0);
@@ -581,22 +797,22 @@ mod tests {
581
797
  let mut buf = [0; 128];
582
798
 
583
799
  let mut send = <SendBuf>::new(u64::MAX);
584
- assert_eq!(send.len, 0);
800
+ assert_eq!(send.buffered_bytes, 0);
585
801
 
586
802
  let first = b"something";
587
803
  let second = b"helloworld";
588
804
 
589
805
  assert!(send.write(first, false).is_ok());
590
- assert_eq!(send.len, 9);
806
+ assert_eq!(send.buffered_bytes, 9);
591
807
 
592
808
  assert!(send.write(second, true).is_ok());
593
- assert_eq!(send.len, 19);
809
+ assert_eq!(send.buffered_bytes, 19);
594
810
 
595
811
  let (written, fin) = send.emit(&mut buf[..128]).unwrap();
596
812
  assert_eq!(written, 19);
597
813
  assert!(fin);
598
814
  assert_eq!(&buf[..written], b"somethinghelloworld");
599
- assert_eq!(send.len, 0);
815
+ assert_eq!(send.buffered_bytes, 0);
600
816
  }
601
817
 
602
818
  #[test]
@@ -604,16 +820,16 @@ mod tests {
604
820
  let mut buf = [0; 10];
605
821
 
606
822
  let mut send = <SendBuf>::new(u64::MAX);
607
- assert_eq!(send.len, 0);
823
+ assert_eq!(send.buffered_bytes, 0);
608
824
 
609
825
  let first = b"something";
610
826
  let second = b"helloworld";
611
827
 
612
828
  assert!(send.write(first, false).is_ok());
613
- assert_eq!(send.len, 9);
829
+ assert_eq!(send.buffered_bytes, 9);
614
830
 
615
831
  assert!(send.write(second, true).is_ok());
616
- assert_eq!(send.len, 19);
832
+ assert_eq!(send.buffered_bytes, 19);
617
833
 
618
834
  assert_eq!(send.off_front(), 0);
619
835
 
@@ -621,7 +837,7 @@ mod tests {
621
837
  assert_eq!(written, 10);
622
838
  assert!(!fin);
623
839
  assert_eq!(&buf[..written], b"somethingh");
624
- assert_eq!(send.len, 9);
840
+ assert_eq!(send.buffered_bytes, 9);
625
841
 
626
842
  assert_eq!(send.off_front(), 10);
627
843
 
@@ -629,7 +845,7 @@ mod tests {
629
845
  assert_eq!(written, 5);
630
846
  assert!(!fin);
631
847
  assert_eq!(&buf[..written], b"ellow");
632
- assert_eq!(send.len, 4);
848
+ assert_eq!(send.buffered_bytes, 4);
633
849
 
634
850
  assert_eq!(send.off_front(), 15);
635
851
 
@@ -637,7 +853,7 @@ mod tests {
637
853
  assert_eq!(written, 4);
638
854
  assert!(fin);
639
855
  assert_eq!(&buf[..written], b"orld");
640
- assert_eq!(send.len, 0);
856
+ assert_eq!(send.buffered_bytes, 0);
641
857
 
642
858
  assert_eq!(send.off_front(), 19);
643
859
  }
@@ -647,7 +863,7 @@ mod tests {
647
863
  let mut buf = [0; 15];
648
864
 
649
865
  let mut send = <SendBuf>::new(u64::MAX);
650
- assert_eq!(send.len, 0);
866
+ assert_eq!(send.buffered_bytes, 0);
651
867
  assert_eq!(send.off_front(), 0);
652
868
 
653
869
  let first = b"something";
@@ -659,49 +875,49 @@ mod tests {
659
875
  assert!(send.write(second, true).is_ok());
660
876
  assert_eq!(send.off_front(), 0);
661
877
 
662
- assert_eq!(send.len, 19);
878
+ assert_eq!(send.buffered_bytes, 19);
663
879
 
664
880
  let (written, fin) = send.emit(&mut buf[..4]).unwrap();
665
881
  assert_eq!(written, 4);
666
882
  assert!(!fin);
667
883
  assert_eq!(&buf[..written], b"some");
668
- assert_eq!(send.len, 15);
884
+ assert_eq!(send.buffered_bytes, 15);
669
885
  assert_eq!(send.off_front(), 4);
670
886
 
671
887
  let (written, fin) = send.emit(&mut buf[..5]).unwrap();
672
888
  assert_eq!(written, 5);
673
889
  assert!(!fin);
674
890
  assert_eq!(&buf[..written], b"thing");
675
- assert_eq!(send.len, 10);
891
+ assert_eq!(send.buffered_bytes, 10);
676
892
  assert_eq!(send.off_front(), 9);
677
893
 
678
894
  let (written, fin) = send.emit(&mut buf[..5]).unwrap();
679
895
  assert_eq!(written, 5);
680
896
  assert!(!fin);
681
897
  assert_eq!(&buf[..written], b"hello");
682
- assert_eq!(send.len, 5);
898
+ assert_eq!(send.buffered_bytes, 5);
683
899
  assert_eq!(send.off_front(), 14);
684
900
 
685
901
  send.retransmit(4, 5);
686
- assert_eq!(send.len, 10);
902
+ assert_eq!(send.buffered_bytes, 10);
687
903
  assert_eq!(send.off_front(), 4);
688
904
 
689
905
  send.retransmit(0, 4);
690
- assert_eq!(send.len, 14);
906
+ assert_eq!(send.buffered_bytes, 14);
691
907
  assert_eq!(send.off_front(), 0);
692
908
 
693
909
  let (written, fin) = send.emit(&mut buf[..11]).unwrap();
694
910
  assert_eq!(written, 9);
695
911
  assert!(!fin);
696
912
  assert_eq!(&buf[..written], b"something");
697
- assert_eq!(send.len, 5);
913
+ assert_eq!(send.buffered_bytes, 5);
698
914
  assert_eq!(send.off_front(), 14);
699
915
 
700
916
  let (written, fin) = send.emit(&mut buf[..11]).unwrap();
701
917
  assert_eq!(written, 5);
702
918
  assert!(fin);
703
919
  assert_eq!(&buf[..written], b"world");
704
- assert_eq!(send.len, 0);
920
+ assert_eq!(send.buffered_bytes, 0);
705
921
  assert_eq!(send.off_front(), 19);
706
922
  }
707
923
 
@@ -710,24 +926,24 @@ mod tests {
710
926
  let mut buf = [0; 10];
711
927
 
712
928
  let mut send = <SendBuf>::default();
713
- assert_eq!(send.len, 0);
929
+ assert_eq!(send.buffered_bytes, 0);
714
930
 
715
931
  let first = b"something";
716
932
  let second = b"helloworld";
717
933
 
718
934
  assert_eq!(send.write(first, false), Ok(0));
719
- assert_eq!(send.len, 0);
935
+ assert_eq!(send.buffered_bytes, 0);
720
936
 
721
937
  assert_eq!(send.write(second, true), Ok(0));
722
- assert_eq!(send.len, 0);
938
+ assert_eq!(send.buffered_bytes, 0);
723
939
 
724
940
  send.update_max_data(5);
725
941
 
726
942
  assert_eq!(send.write(first, false), Ok(5));
727
- assert_eq!(send.len, 5);
943
+ assert_eq!(send.buffered_bytes, 5);
728
944
 
729
945
  assert_eq!(send.write(second, true), Ok(0));
730
- assert_eq!(send.len, 5);
946
+ assert_eq!(send.buffered_bytes, 5);
731
947
 
732
948
  assert_eq!(send.off_front(), 0);
733
949
 
@@ -735,7 +951,7 @@ mod tests {
735
951
  assert_eq!(written, 5);
736
952
  assert!(!fin);
737
953
  assert_eq!(&buf[..written], b"somet");
738
- assert_eq!(send.len, 0);
954
+ assert_eq!(send.buffered_bytes, 0);
739
955
 
740
956
  assert_eq!(send.off_front(), 5);
741
957
 
@@ -743,15 +959,15 @@ mod tests {
743
959
  assert_eq!(written, 0);
744
960
  assert!(!fin);
745
961
  assert_eq!(&buf[..written], b"");
746
- assert_eq!(send.len, 0);
962
+ assert_eq!(send.buffered_bytes, 0);
747
963
 
748
964
  send.update_max_data(15);
749
965
 
750
966
  assert_eq!(send.write(&first[5..], false), Ok(4));
751
- assert_eq!(send.len, 4);
967
+ assert_eq!(send.buffered_bytes, 4);
752
968
 
753
969
  assert_eq!(send.write(second, true), Ok(6));
754
- assert_eq!(send.len, 10);
970
+ assert_eq!(send.buffered_bytes, 10);
755
971
 
756
972
  assert_eq!(send.off_front(), 5);
757
973
 
@@ -759,12 +975,12 @@ mod tests {
759
975
  assert_eq!(written, 10);
760
976
  assert!(!fin);
761
977
  assert_eq!(&buf[..10], b"hinghellow");
762
- assert_eq!(send.len, 0);
978
+ assert_eq!(send.buffered_bytes, 0);
763
979
 
764
980
  send.update_max_data(25);
765
981
 
766
982
  assert_eq!(send.write(&second[6..], true), Ok(4));
767
- assert_eq!(send.len, 4);
983
+ assert_eq!(send.buffered_bytes, 4);
768
984
 
769
985
  assert_eq!(send.off_front(), 15);
770
986
 
@@ -772,7 +988,7 @@ mod tests {
772
988
  assert_eq!(written, 4);
773
989
  assert!(fin);
774
990
  assert_eq!(&buf[..written], b"orld");
775
- assert_eq!(send.len, 0);
991
+ assert_eq!(send.buffered_bytes, 0);
776
992
  }
777
993
 
778
994
  #[test]
@@ -780,15 +996,15 @@ mod tests {
780
996
  let mut buf = [0; 10];
781
997
 
782
998
  let mut send = <SendBuf>::new(u64::MAX);
783
- assert_eq!(send.len, 0);
999
+ assert_eq!(send.buffered_bytes, 0);
784
1000
 
785
1001
  let first = b"something";
786
1002
 
787
1003
  assert!(send.write(first, false).is_ok());
788
- assert_eq!(send.len, 9);
1004
+ assert_eq!(send.buffered_bytes, 9);
789
1005
 
790
1006
  assert!(send.write(&[], true).is_ok());
791
- assert_eq!(send.len, 9);
1007
+ assert_eq!(send.buffered_bytes, 9);
792
1008
 
793
1009
  assert_eq!(send.off_front(), 0);
794
1010
 
@@ -796,7 +1012,7 @@ mod tests {
796
1012
  assert_eq!(written, 9);
797
1013
  assert!(fin);
798
1014
  assert_eq!(&buf[..written], b"something");
799
- assert_eq!(send.len, 0);
1015
+ assert_eq!(send.buffered_bytes, 0);
800
1016
  }
801
1017
 
802
1018
  /// Check SendBuf::len calculation on a retransmit case
@@ -805,7 +1021,7 @@ mod tests {
805
1021
  let mut buf = [0; 15];
806
1022
 
807
1023
  let mut send = <SendBuf>::new(u64::MAX);
808
- assert_eq!(send.len, 0);
1024
+ assert_eq!(send.buffered_bytes, 0);
809
1025
  assert_eq!(send.off_front(), 0);
810
1026
 
811
1027
  let first = b"something";
@@ -813,17 +1029,17 @@ mod tests {
813
1029
  assert!(send.write(first, false).is_ok());
814
1030
  assert_eq!(send.off_front(), 0);
815
1031
 
816
- assert_eq!(send.len, 9);
1032
+ assert_eq!(send.buffered_bytes, 9);
817
1033
 
818
1034
  let (written, fin) = send.emit(&mut buf[..4]).unwrap();
819
1035
  assert_eq!(written, 4);
820
1036
  assert!(!fin);
821
1037
  assert_eq!(&buf[..written], b"some");
822
- assert_eq!(send.len, 5);
1038
+ assert_eq!(send.buffered_bytes, 5);
823
1039
  assert_eq!(send.off_front(), 4);
824
1040
 
825
1041
  send.retransmit(3, 5);
826
- assert_eq!(send.len, 6);
1042
+ assert_eq!(send.buffered_bytes, 6);
827
1043
  assert_eq!(send.off_front(), 3);
828
1044
  }
829
1045
 
@@ -851,4 +1067,45 @@ mod tests {
851
1067
  assert_eq!(fin_off, 50);
852
1068
  assert_eq!(unsent, 0);
853
1069
  }
1070
+
1071
+ #[test]
1072
+ fn peer_stop_sending_notification_lifecycle() {
1073
+ let mut send = <SendBuf>::new(100);
1074
+ assert_eq!(send.cap_and_report_stop_sending(), Ok(100));
1075
+ assert_eq!(
1076
+ send.peer_stop_sending_state(),
1077
+ PeerStopSendingState::NotReceived
1078
+ );
1079
+
1080
+ send.stop(0).unwrap();
1081
+ assert_eq!(
1082
+ send.peer_stop_sending_state(),
1083
+ PeerStopSendingState::NotReported(0)
1084
+ );
1085
+ assert_eq!(send.cap(), Err(Error::StreamStopped(0)));
1086
+ assert_eq!(
1087
+ send.peer_stop_sending_state(),
1088
+ PeerStopSendingState::NotReported(0)
1089
+ );
1090
+ assert_eq!(
1091
+ send.cap_and_report_stop_sending(),
1092
+ Err(Error::StreamStopped(0))
1093
+ );
1094
+ assert_eq!(
1095
+ send.cap_and_report_stop_sending(),
1096
+ Err(Error::StreamStopped(0))
1097
+ );
1098
+ assert_eq!(
1099
+ send.peer_stop_sending_state(),
1100
+ PeerStopSendingState::Reported(0)
1101
+ );
1102
+ // Reporting preserves the code for subsequent writes and duplicate
1103
+ // STOP_SENDING must not replace it or create another notification.
1104
+ assert_eq!(send.stop(42), Err(Error::Done));
1105
+ assert_eq!(send.cap(), Err(Error::StreamStopped(0)));
1106
+ assert_eq!(
1107
+ send.peer_stop_sending_state(),
1108
+ PeerStopSendingState::Reported(0)
1109
+ );
1110
+ }
854
1111
  }