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
@@ -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,45 @@ 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;
594
+ }
595
+
596
+ /// Returns the final offset after FIN or a reset.
597
+ pub fn final_size(&self) -> Option<u64> {
598
+ self.fin_off
461
599
  }
462
600
 
463
601
  /// Returns the largest offset of data buffered.
@@ -481,6 +619,11 @@ impl<F: BufFactory> SendBuf<F> {
481
619
  self.off
482
620
  }
483
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
+
484
627
  /// The maximum offset we are allowed to send to the peer.
485
628
  pub fn max_off(&self) -> u64 {
486
629
  self.max_data
@@ -500,11 +643,15 @@ impl<F: BufFactory> SendBuf<F> {
500
643
 
501
644
  /// Returns true if the send-side of the stream is complete.
502
645
  ///
503
- /// This happens when the stream's send final size is known, and the peer
504
- /// 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.
505
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
+
506
653
  if let Some(fin_off) = self.fin_off {
507
- if self.acked == (0..fin_off) {
654
+ if self.fin_acked && self.acked == (0..fin_off) {
508
655
  return true;
509
656
  }
510
657
  }
@@ -512,9 +659,9 @@ impl<F: BufFactory> SendBuf<F> {
512
659
  false
513
660
  }
514
661
 
515
- /// Returns true if the stream was stopped before completion.
516
- pub fn is_stopped(&self) -> bool {
517
- 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
518
665
  }
519
666
 
520
667
  /// Returns true if the stream was shut down.
@@ -522,6 +669,16 @@ impl<F: BufFactory> SendBuf<F> {
522
669
  self.shutdown
523
670
  }
524
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
+
525
682
  /// Returns true if there is no data.
526
683
  pub fn is_empty(&self) -> bool {
527
684
  self.data.is_empty()
@@ -541,30 +698,94 @@ impl<F: BufFactory> SendBuf<F> {
541
698
  /// Returns the outgoing flow control capacity.
542
699
  pub fn cap(&self) -> Result<usize> {
543
700
  // The stream was stopped, so return the error code instead.
544
- if let Some(e) = self.error {
545
- return Err(Error::StreamStopped(e));
546
- }
701
+ self.peer_stop_sending.check_not_stopped()?;
547
702
 
548
703
  Ok((self.max_data - self.off) as usize)
549
704
  }
550
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
+
551
713
  /// Returns the number of separate buffers stored.
552
714
  #[allow(dead_code)]
553
715
  pub fn bufs_count(&self) -> usize {
554
716
  self.data.len()
555
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
+ }
556
727
  }
557
728
 
558
729
  #[cfg(test)]
559
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
+
560
750
  use super::*;
561
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
+
562
783
  #[test]
563
784
  fn empty_write() {
564
785
  let mut buf = [0; 5];
565
786
 
566
787
  let mut send = <SendBuf>::new(u64::MAX);
567
- assert_eq!(send.len, 0);
788
+ assert_eq!(send.buffered_bytes, 0);
568
789
 
569
790
  let (written, fin) = send.emit(&mut buf).unwrap();
570
791
  assert_eq!(written, 0);
@@ -576,22 +797,22 @@ mod tests {
576
797
  let mut buf = [0; 128];
577
798
 
578
799
  let mut send = <SendBuf>::new(u64::MAX);
579
- assert_eq!(send.len, 0);
800
+ assert_eq!(send.buffered_bytes, 0);
580
801
 
581
802
  let first = b"something";
582
803
  let second = b"helloworld";
583
804
 
584
805
  assert!(send.write(first, false).is_ok());
585
- assert_eq!(send.len, 9);
806
+ assert_eq!(send.buffered_bytes, 9);
586
807
 
587
808
  assert!(send.write(second, true).is_ok());
588
- assert_eq!(send.len, 19);
809
+ assert_eq!(send.buffered_bytes, 19);
589
810
 
590
811
  let (written, fin) = send.emit(&mut buf[..128]).unwrap();
591
812
  assert_eq!(written, 19);
592
813
  assert!(fin);
593
814
  assert_eq!(&buf[..written], b"somethinghelloworld");
594
- assert_eq!(send.len, 0);
815
+ assert_eq!(send.buffered_bytes, 0);
595
816
  }
596
817
 
597
818
  #[test]
@@ -599,16 +820,16 @@ mod tests {
599
820
  let mut buf = [0; 10];
600
821
 
601
822
  let mut send = <SendBuf>::new(u64::MAX);
602
- assert_eq!(send.len, 0);
823
+ assert_eq!(send.buffered_bytes, 0);
603
824
 
604
825
  let first = b"something";
605
826
  let second = b"helloworld";
606
827
 
607
828
  assert!(send.write(first, false).is_ok());
608
- assert_eq!(send.len, 9);
829
+ assert_eq!(send.buffered_bytes, 9);
609
830
 
610
831
  assert!(send.write(second, true).is_ok());
611
- assert_eq!(send.len, 19);
832
+ assert_eq!(send.buffered_bytes, 19);
612
833
 
613
834
  assert_eq!(send.off_front(), 0);
614
835
 
@@ -616,7 +837,7 @@ mod tests {
616
837
  assert_eq!(written, 10);
617
838
  assert!(!fin);
618
839
  assert_eq!(&buf[..written], b"somethingh");
619
- assert_eq!(send.len, 9);
840
+ assert_eq!(send.buffered_bytes, 9);
620
841
 
621
842
  assert_eq!(send.off_front(), 10);
622
843
 
@@ -624,7 +845,7 @@ mod tests {
624
845
  assert_eq!(written, 5);
625
846
  assert!(!fin);
626
847
  assert_eq!(&buf[..written], b"ellow");
627
- assert_eq!(send.len, 4);
848
+ assert_eq!(send.buffered_bytes, 4);
628
849
 
629
850
  assert_eq!(send.off_front(), 15);
630
851
 
@@ -632,7 +853,7 @@ mod tests {
632
853
  assert_eq!(written, 4);
633
854
  assert!(fin);
634
855
  assert_eq!(&buf[..written], b"orld");
635
- assert_eq!(send.len, 0);
856
+ assert_eq!(send.buffered_bytes, 0);
636
857
 
637
858
  assert_eq!(send.off_front(), 19);
638
859
  }
@@ -642,7 +863,7 @@ mod tests {
642
863
  let mut buf = [0; 15];
643
864
 
644
865
  let mut send = <SendBuf>::new(u64::MAX);
645
- assert_eq!(send.len, 0);
866
+ assert_eq!(send.buffered_bytes, 0);
646
867
  assert_eq!(send.off_front(), 0);
647
868
 
648
869
  let first = b"something";
@@ -654,49 +875,49 @@ mod tests {
654
875
  assert!(send.write(second, true).is_ok());
655
876
  assert_eq!(send.off_front(), 0);
656
877
 
657
- assert_eq!(send.len, 19);
878
+ assert_eq!(send.buffered_bytes, 19);
658
879
 
659
880
  let (written, fin) = send.emit(&mut buf[..4]).unwrap();
660
881
  assert_eq!(written, 4);
661
882
  assert!(!fin);
662
883
  assert_eq!(&buf[..written], b"some");
663
- assert_eq!(send.len, 15);
884
+ assert_eq!(send.buffered_bytes, 15);
664
885
  assert_eq!(send.off_front(), 4);
665
886
 
666
887
  let (written, fin) = send.emit(&mut buf[..5]).unwrap();
667
888
  assert_eq!(written, 5);
668
889
  assert!(!fin);
669
890
  assert_eq!(&buf[..written], b"thing");
670
- assert_eq!(send.len, 10);
891
+ assert_eq!(send.buffered_bytes, 10);
671
892
  assert_eq!(send.off_front(), 9);
672
893
 
673
894
  let (written, fin) = send.emit(&mut buf[..5]).unwrap();
674
895
  assert_eq!(written, 5);
675
896
  assert!(!fin);
676
897
  assert_eq!(&buf[..written], b"hello");
677
- assert_eq!(send.len, 5);
898
+ assert_eq!(send.buffered_bytes, 5);
678
899
  assert_eq!(send.off_front(), 14);
679
900
 
680
901
  send.retransmit(4, 5);
681
- assert_eq!(send.len, 10);
902
+ assert_eq!(send.buffered_bytes, 10);
682
903
  assert_eq!(send.off_front(), 4);
683
904
 
684
905
  send.retransmit(0, 4);
685
- assert_eq!(send.len, 14);
906
+ assert_eq!(send.buffered_bytes, 14);
686
907
  assert_eq!(send.off_front(), 0);
687
908
 
688
909
  let (written, fin) = send.emit(&mut buf[..11]).unwrap();
689
910
  assert_eq!(written, 9);
690
911
  assert!(!fin);
691
912
  assert_eq!(&buf[..written], b"something");
692
- assert_eq!(send.len, 5);
913
+ assert_eq!(send.buffered_bytes, 5);
693
914
  assert_eq!(send.off_front(), 14);
694
915
 
695
916
  let (written, fin) = send.emit(&mut buf[..11]).unwrap();
696
917
  assert_eq!(written, 5);
697
918
  assert!(fin);
698
919
  assert_eq!(&buf[..written], b"world");
699
- assert_eq!(send.len, 0);
920
+ assert_eq!(send.buffered_bytes, 0);
700
921
  assert_eq!(send.off_front(), 19);
701
922
  }
702
923
 
@@ -705,24 +926,24 @@ mod tests {
705
926
  let mut buf = [0; 10];
706
927
 
707
928
  let mut send = <SendBuf>::default();
708
- assert_eq!(send.len, 0);
929
+ assert_eq!(send.buffered_bytes, 0);
709
930
 
710
931
  let first = b"something";
711
932
  let second = b"helloworld";
712
933
 
713
934
  assert_eq!(send.write(first, false), Ok(0));
714
- assert_eq!(send.len, 0);
935
+ assert_eq!(send.buffered_bytes, 0);
715
936
 
716
937
  assert_eq!(send.write(second, true), Ok(0));
717
- assert_eq!(send.len, 0);
938
+ assert_eq!(send.buffered_bytes, 0);
718
939
 
719
940
  send.update_max_data(5);
720
941
 
721
942
  assert_eq!(send.write(first, false), Ok(5));
722
- assert_eq!(send.len, 5);
943
+ assert_eq!(send.buffered_bytes, 5);
723
944
 
724
945
  assert_eq!(send.write(second, true), Ok(0));
725
- assert_eq!(send.len, 5);
946
+ assert_eq!(send.buffered_bytes, 5);
726
947
 
727
948
  assert_eq!(send.off_front(), 0);
728
949
 
@@ -730,7 +951,7 @@ mod tests {
730
951
  assert_eq!(written, 5);
731
952
  assert!(!fin);
732
953
  assert_eq!(&buf[..written], b"somet");
733
- assert_eq!(send.len, 0);
954
+ assert_eq!(send.buffered_bytes, 0);
734
955
 
735
956
  assert_eq!(send.off_front(), 5);
736
957
 
@@ -738,15 +959,15 @@ mod tests {
738
959
  assert_eq!(written, 0);
739
960
  assert!(!fin);
740
961
  assert_eq!(&buf[..written], b"");
741
- assert_eq!(send.len, 0);
962
+ assert_eq!(send.buffered_bytes, 0);
742
963
 
743
964
  send.update_max_data(15);
744
965
 
745
966
  assert_eq!(send.write(&first[5..], false), Ok(4));
746
- assert_eq!(send.len, 4);
967
+ assert_eq!(send.buffered_bytes, 4);
747
968
 
748
969
  assert_eq!(send.write(second, true), Ok(6));
749
- assert_eq!(send.len, 10);
970
+ assert_eq!(send.buffered_bytes, 10);
750
971
 
751
972
  assert_eq!(send.off_front(), 5);
752
973
 
@@ -754,12 +975,12 @@ mod tests {
754
975
  assert_eq!(written, 10);
755
976
  assert!(!fin);
756
977
  assert_eq!(&buf[..10], b"hinghellow");
757
- assert_eq!(send.len, 0);
978
+ assert_eq!(send.buffered_bytes, 0);
758
979
 
759
980
  send.update_max_data(25);
760
981
 
761
982
  assert_eq!(send.write(&second[6..], true), Ok(4));
762
- assert_eq!(send.len, 4);
983
+ assert_eq!(send.buffered_bytes, 4);
763
984
 
764
985
  assert_eq!(send.off_front(), 15);
765
986
 
@@ -767,7 +988,7 @@ mod tests {
767
988
  assert_eq!(written, 4);
768
989
  assert!(fin);
769
990
  assert_eq!(&buf[..written], b"orld");
770
- assert_eq!(send.len, 0);
991
+ assert_eq!(send.buffered_bytes, 0);
771
992
  }
772
993
 
773
994
  #[test]
@@ -775,15 +996,15 @@ mod tests {
775
996
  let mut buf = [0; 10];
776
997
 
777
998
  let mut send = <SendBuf>::new(u64::MAX);
778
- assert_eq!(send.len, 0);
999
+ assert_eq!(send.buffered_bytes, 0);
779
1000
 
780
1001
  let first = b"something";
781
1002
 
782
1003
  assert!(send.write(first, false).is_ok());
783
- assert_eq!(send.len, 9);
1004
+ assert_eq!(send.buffered_bytes, 9);
784
1005
 
785
1006
  assert!(send.write(&[], true).is_ok());
786
- assert_eq!(send.len, 9);
1007
+ assert_eq!(send.buffered_bytes, 9);
787
1008
 
788
1009
  assert_eq!(send.off_front(), 0);
789
1010
 
@@ -791,7 +1012,7 @@ mod tests {
791
1012
  assert_eq!(written, 9);
792
1013
  assert!(fin);
793
1014
  assert_eq!(&buf[..written], b"something");
794
- assert_eq!(send.len, 0);
1015
+ assert_eq!(send.buffered_bytes, 0);
795
1016
  }
796
1017
 
797
1018
  /// Check SendBuf::len calculation on a retransmit case
@@ -800,7 +1021,7 @@ mod tests {
800
1021
  let mut buf = [0; 15];
801
1022
 
802
1023
  let mut send = <SendBuf>::new(u64::MAX);
803
- assert_eq!(send.len, 0);
1024
+ assert_eq!(send.buffered_bytes, 0);
804
1025
  assert_eq!(send.off_front(), 0);
805
1026
 
806
1027
  let first = b"something";
@@ -808,17 +1029,17 @@ mod tests {
808
1029
  assert!(send.write(first, false).is_ok());
809
1030
  assert_eq!(send.off_front(), 0);
810
1031
 
811
- assert_eq!(send.len, 9);
1032
+ assert_eq!(send.buffered_bytes, 9);
812
1033
 
813
1034
  let (written, fin) = send.emit(&mut buf[..4]).unwrap();
814
1035
  assert_eq!(written, 4);
815
1036
  assert!(!fin);
816
1037
  assert_eq!(&buf[..written], b"some");
817
- assert_eq!(send.len, 5);
1038
+ assert_eq!(send.buffered_bytes, 5);
818
1039
  assert_eq!(send.off_front(), 4);
819
1040
 
820
1041
  send.retransmit(3, 5);
821
- assert_eq!(send.len, 6);
1042
+ assert_eq!(send.buffered_bytes, 6);
822
1043
  assert_eq!(send.off_front(), 3);
823
1044
  }
824
1045
 
@@ -846,4 +1067,45 @@ mod tests {
846
1067
  assert_eq!(fin_off, 50);
847
1068
  assert_eq!(unsent, 0);
848
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
+ }
849
1111
  }