rwebtransport 0.2.2 → 0.2.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/Cargo.lock +523 -140
- package/Cargo.toml +5 -5
- package/README.md +8 -4
- package/crates/echo-server/src/bin/gen-test-cert.rs +1 -1
- package/crates/native/Cargo.toml +2 -0
- package/crates/native/src/config.rs +69 -8
- package/crates/native/src/driver.rs +253 -90
- package/crates/native/src/lib.rs +80 -57
- package/crates/native/src/parser_memory.rs +203 -0
- package/crates/native/src/server.rs +215 -183
- package/crates/native/src/session.rs +1341 -243
- package/crates/native/src/test_support.rs +119 -0
- package/crates/wtcore/Cargo.toml +1 -0
- package/crates/wtcore/src/h3.rs +250 -46
- package/dist/index.js +218 -75
- package/dist/index.js.map +7 -1
- package/dist/index.mjs +214 -69
- package/dist/index.mjs.map +7 -1
- package/dist/native.d.ts +10 -4
- package/dist/server.d.ts +1 -0
- package/package.json +84 -78
- package/prebuilds/darwin-arm64/rwebtransport.node +0 -0
- package/prebuilds/linux-arm64/rwebtransport.node +0 -0
- package/prebuilds/linux-x64/rwebtransport.node +0 -0
- package/prebuilds/win32-x64/rwebtransport.node +0 -0
- package/scripts/build-linux-prebuilt.sh +46 -0
- package/scripts/build-ts.js +41 -0
- package/scripts/build.js +10 -3
- package/vendor/quiche/AGENTS.md +10 -0
- package/vendor/quiche/Cargo.lock +239 -248
- package/vendor/quiche/Cargo.toml +23 -10
- package/vendor/quiche/examples/Makefile +4 -4
- package/vendor/quiche/examples/client.rs +10 -28
- package/vendor/quiche/examples/http3-client.rs +20 -34
- package/vendor/quiche/examples/http3-server.rs +47 -78
- package/vendor/quiche/examples/server.rs +19 -49
- package/vendor/quiche/include/quiche.h +35 -4
- package/vendor/quiche/src/build.rs +17 -0
- package/vendor/quiche/src/cid.rs +129 -61
- package/vendor/quiche/src/crypto/boringssl.rs +98 -86
- package/vendor/quiche/src/crypto/mod.rs +64 -77
- package/vendor/quiche/src/dgram.rs +2 -3
- package/vendor/quiche/src/error.rs +22 -20
- package/vendor/quiche/src/ffi.rs +558 -280
- package/vendor/quiche/src/flowcontrol.rs +0 -7
- package/vendor/quiche/src/frame.rs +134 -135
- package/vendor/quiche/src/h3/ffi.rs +73 -60
- package/vendor/quiche/src/h3/frame.rs +70 -90
- package/vendor/quiche/src/h3/mod.rs +1024 -593
- package/vendor/quiche/src/h3/qpack/decoder.rs +248 -34
- package/vendor/quiche/src/h3/qpack/dynamic_table.rs +859 -0
- package/vendor/quiche/src/h3/qpack/encoder.rs +14 -17
- package/vendor/quiche/src/h3/qpack/mod.rs +48 -0
- package/vendor/quiche/src/h3/qpack/static_table.rs +86 -73
- package/vendor/quiche/src/h3/stream.rs +1009 -194
- package/vendor/quiche/src/lib.rs +1361 -1195
- package/vendor/quiche/src/minmax.rs +2 -6
- package/vendor/quiche/src/packet.rs +420 -552
- package/vendor/quiche/src/path.rs +202 -72
- package/vendor/quiche/src/pmtud.rs +18 -16
- package/vendor/quiche/src/ranges.rs +184 -82
- package/vendor/quiche/src/recovery/AGENTS.md +5 -2
- package/vendor/quiche/src/recovery/bandwidth.rs +59 -40
- package/vendor/quiche/src/recovery/bytes_in_flight.rs +2 -2
- package/vendor/quiche/src/recovery/congestion/cubic.rs +38 -47
- package/vendor/quiche/src/recovery/congestion/delivery_rate.rs +54 -60
- package/vendor/quiche/src/recovery/congestion/hystart.rs +6 -10
- package/vendor/quiche/src/recovery/congestion/mod.rs +110 -42
- package/vendor/quiche/src/recovery/congestion/prr.rs +4 -1
- package/vendor/quiche/src/recovery/congestion/recovery.rs +91 -95
- package/vendor/quiche/src/recovery/congestion/reno.rs +17 -12
- package/vendor/quiche/src/recovery/congestion/test_sender.rs +8 -27
- package/vendor/quiche/src/recovery/gcongestion/bbr/bandwidth_sampler.rs +159 -247
- package/vendor/quiche/src/recovery/gcongestion/bbr/windowed_filter.rs +9 -14
- package/vendor/quiche/src/recovery/gcongestion/bbr2/drain.rs +18 -15
- package/vendor/quiche/src/recovery/gcongestion/bbr2/mode.rs +43 -28
- package/vendor/quiche/src/recovery/gcongestion/bbr2/network_model.rs +349 -76
- package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_bw.rs +147 -195
- package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_rtt.rs +29 -27
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min.rs +180 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/global_min_tests.rs +221 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm.rs +395 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/hmm_tests.rs +473 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/rtt_jump_detector/mod.rs +175 -0
- package/vendor/quiche/src/recovery/gcongestion/bbr2/startup.rs +33 -26
- package/vendor/quiche/src/recovery/gcongestion/bbr2.rs +107 -60
- package/vendor/quiche/src/recovery/gcongestion/mod.rs +64 -11
- package/vendor/quiche/src/recovery/gcongestion/pacer.rs +34 -25
- package/vendor/quiche/src/recovery/gcongestion/recovery.rs +81 -86
- package/vendor/quiche/src/recovery/mod.rs +414 -173
- package/vendor/quiche/src/recovery/rtt.rs +8 -5
- package/vendor/quiche/src/stream/mod.rs +864 -133
- package/vendor/quiche/src/stream/recv_buf.rs +476 -172
- package/vendor/quiche/src/stream/send_buf.rs +343 -81
- package/vendor/quiche/src/test_utils.rs +78 -64
- package/vendor/quiche/src/tests.rs +2559 -1335
- package/vendor/quiche/src/tls/boringssl.rs +60 -63
- package/vendor/quiche/src/tls/mod.rs +146 -193
- package/vendor/quiche/src/transport_params.rs +87 -103
|
@@ -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,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.
|
|
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;
|
|
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
|
|
504
|
-
///
|
|
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
|
|
516
|
-
pub fn
|
|
517
|
-
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
|
|
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
|
-
|
|
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.
|
|
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.
|
|
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.
|
|
806
|
+
assert_eq!(send.buffered_bytes, 9);
|
|
586
807
|
|
|
587
808
|
assert!(send.write(second, true).is_ok());
|
|
588
|
-
assert_eq!(send.
|
|
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.
|
|
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.
|
|
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.
|
|
829
|
+
assert_eq!(send.buffered_bytes, 9);
|
|
609
830
|
|
|
610
831
|
assert!(send.write(second, true).is_ok());
|
|
611
|
-
assert_eq!(send.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
935
|
+
assert_eq!(send.buffered_bytes, 0);
|
|
715
936
|
|
|
716
937
|
assert_eq!(send.write(second, true), Ok(0));
|
|
717
|
-
assert_eq!(send.
|
|
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.
|
|
943
|
+
assert_eq!(send.buffered_bytes, 5);
|
|
723
944
|
|
|
724
945
|
assert_eq!(send.write(second, true), Ok(0));
|
|
725
|
-
assert_eq!(send.
|
|
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.
|
|
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.
|
|
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.
|
|
967
|
+
assert_eq!(send.buffered_bytes, 4);
|
|
747
968
|
|
|
748
969
|
assert_eq!(send.write(second, true), Ok(6));
|
|
749
|
-
assert_eq!(send.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
1004
|
+
assert_eq!(send.buffered_bytes, 9);
|
|
784
1005
|
|
|
785
1006
|
assert!(send.write(&[], true).is_ok());
|
|
786
|
-
assert_eq!(send.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
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
|
}
|