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.
- package/Cargo.lock +153 -226
- package/Cargo.toml +5 -5
- package/README.md +4 -4
- package/crates/echo-server/src/bin/gen-test-cert.rs +1 -1
- package/crates/native/Cargo.toml +1 -1
- package/crates/native/src/config.rs +13 -1
- package/crates/native/src/driver.rs +249 -91
- package/crates/native/src/lib.rs +9 -10
- package/crates/native/src/parser_memory.rs +1 -0
- package/crates/native/src/server.rs +197 -182
- package/crates/native/src/session.rs +329 -177
- package/crates/native/src/test_support.rs +2 -2
- package/crates/wtcore/src/h3.rs +166 -10
- package/dist/index.js +92 -45
- package/dist/index.js.map +2 -2
- package/dist/index.mjs +92 -45
- package/dist/index.mjs.map +2 -2
- package/dist/native.d.ts +9 -4
- package/package.json +14 -11
- package/prebuilds/darwin-arm64/rwebtransport.node +0 -0
- package/prebuilds/linux-arm64/rwebtransport.node +0 -0
- package/prebuilds/linux-x64/rwebtransport.node +0 -0
- package/prebuilds/win32-x64/rwebtransport.node +0 -0
- package/scripts/build-linux-prebuilt.sh +46 -0
- package/scripts/build.js +10 -3
- package/vendor/quiche/AGENTS.md +10 -0
- package/vendor/quiche/Cargo.lock +239 -248
- package/vendor/quiche/Cargo.toml +23 -10
- package/vendor/quiche/examples/Makefile +4 -4
- package/vendor/quiche/examples/client.rs +10 -28
- package/vendor/quiche/examples/http3-client.rs +20 -34
- package/vendor/quiche/examples/http3-server.rs +47 -78
- package/vendor/quiche/examples/server.rs +19 -49
- package/vendor/quiche/include/quiche.h +35 -4
- package/vendor/quiche/src/build.rs +17 -0
- package/vendor/quiche/src/cid.rs +129 -61
- package/vendor/quiche/src/crypto/boringssl.rs +98 -86
- package/vendor/quiche/src/crypto/mod.rs +64 -77
- package/vendor/quiche/src/dgram.rs +2 -3
- package/vendor/quiche/src/error.rs +22 -20
- package/vendor/quiche/src/ffi.rs +558 -280
- package/vendor/quiche/src/flowcontrol.rs +0 -7
- package/vendor/quiche/src/frame.rs +134 -135
- package/vendor/quiche/src/h3/ffi.rs +73 -60
- package/vendor/quiche/src/h3/frame.rs +70 -90
- package/vendor/quiche/src/h3/mod.rs +1024 -593
- package/vendor/quiche/src/h3/qpack/decoder.rs +248 -34
- package/vendor/quiche/src/h3/qpack/dynamic_table.rs +859 -0
- package/vendor/quiche/src/h3/qpack/encoder.rs +14 -17
- package/vendor/quiche/src/h3/qpack/mod.rs +48 -0
- package/vendor/quiche/src/h3/qpack/static_table.rs +86 -73
- package/vendor/quiche/src/h3/stream.rs +1009 -194
- package/vendor/quiche/src/lib.rs +1346 -1195
- package/vendor/quiche/src/minmax.rs +2 -6
- package/vendor/quiche/src/packet.rs +420 -552
- package/vendor/quiche/src/path.rs +202 -72
- package/vendor/quiche/src/pmtud.rs +18 -16
- package/vendor/quiche/src/ranges.rs +184 -82
- package/vendor/quiche/src/recovery/AGENTS.md +5 -2
- package/vendor/quiche/src/recovery/bandwidth.rs +59 -40
- package/vendor/quiche/src/recovery/bytes_in_flight.rs +2 -2
- package/vendor/quiche/src/recovery/congestion/cubic.rs +38 -47
- package/vendor/quiche/src/recovery/congestion/delivery_rate.rs +54 -60
- package/vendor/quiche/src/recovery/congestion/hystart.rs +6 -10
- package/vendor/quiche/src/recovery/congestion/mod.rs +110 -42
- package/vendor/quiche/src/recovery/congestion/prr.rs +4 -1
- package/vendor/quiche/src/recovery/congestion/recovery.rs +91 -95
- package/vendor/quiche/src/recovery/congestion/reno.rs +17 -12
- package/vendor/quiche/src/recovery/congestion/test_sender.rs +8 -27
- package/vendor/quiche/src/recovery/gcongestion/bbr/bandwidth_sampler.rs +159 -247
- package/vendor/quiche/src/recovery/gcongestion/bbr/windowed_filter.rs +9 -14
- package/vendor/quiche/src/recovery/gcongestion/bbr2/drain.rs +18 -15
- package/vendor/quiche/src/recovery/gcongestion/bbr2/mode.rs +43 -28
- package/vendor/quiche/src/recovery/gcongestion/bbr2/network_model.rs +349 -76
- package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_bw.rs +147 -195
- package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_rtt.rs +29 -27
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min.rs +180 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min_tests.rs +221 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm.rs +395 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm_tests.rs +473 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/mod.rs +175 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/startup.rs +33 -26
- package/vendor/quiche/src/recovery/gcongestion/bbr2.rs +107 -60
- package/vendor/quiche/src/recovery/gcongestion/mod.rs +64 -11
- package/vendor/quiche/src/recovery/gcongestion/pacer.rs +34 -25
- package/vendor/quiche/src/recovery/gcongestion/recovery.rs +81 -86
- package/vendor/quiche/src/recovery/mod.rs +414 -173
- package/vendor/quiche/src/recovery/rtt.rs +8 -5
- package/vendor/quiche/src/stream/mod.rs +864 -133
- package/vendor/quiche/src/stream/recv_buf.rs +471 -172
- package/vendor/quiche/src/stream/send_buf.rs +338 -81
- package/vendor/quiche/src/test_utils.rs +78 -64
- package/vendor/quiche/src/tests.rs +2559 -1335
- package/vendor/quiche/src/tls/boringssl.rs +60 -63
- package/vendor/quiche/src/tls/mod.rs +146 -193
- package/vendor/quiche/src/transport_params.rs +87 -103
|
@@ -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.
|
|
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
|
|
110
|
-
|
|
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
|
|
128
|
-
|
|
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,
|
|
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.
|
|
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
|
-
|
|
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
|
-
//
|
|
400
|
-
// range
|
|
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
|
-
|
|
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.
|
|
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.
|
|
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.
|
|
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(
|
|
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
|
|
509
|
-
///
|
|
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
|
|
521
|
-
pub fn
|
|
522
|
-
self.
|
|
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
|
-
|
|
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.
|
|
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.
|
|
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.
|
|
806
|
+
assert_eq!(send.buffered_bytes, 9);
|
|
591
807
|
|
|
592
808
|
assert!(send.write(second, true).is_ok());
|
|
593
|
-
assert_eq!(send.
|
|
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.
|
|
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.
|
|
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.
|
|
829
|
+
assert_eq!(send.buffered_bytes, 9);
|
|
614
830
|
|
|
615
831
|
assert!(send.write(second, true).is_ok());
|
|
616
|
-
assert_eq!(send.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
935
|
+
assert_eq!(send.buffered_bytes, 0);
|
|
720
936
|
|
|
721
937
|
assert_eq!(send.write(second, true), Ok(0));
|
|
722
|
-
assert_eq!(send.
|
|
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.
|
|
943
|
+
assert_eq!(send.buffered_bytes, 5);
|
|
728
944
|
|
|
729
945
|
assert_eq!(send.write(second, true), Ok(0));
|
|
730
|
-
assert_eq!(send.
|
|
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.
|
|
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.
|
|
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.
|
|
967
|
+
assert_eq!(send.buffered_bytes, 4);
|
|
752
968
|
|
|
753
969
|
assert_eq!(send.write(second, true), Ok(6));
|
|
754
|
-
assert_eq!(send.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
1004
|
+
assert_eq!(send.buffered_bytes, 9);
|
|
789
1005
|
|
|
790
1006
|
assert!(send.write(&[], true).is_ok());
|
|
791
|
-
assert_eq!(send.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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
|
}
|