rwebtransport 0.1.0

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 (122) hide show
  1. package/Cargo.lock +666 -0
  2. package/Cargo.toml +31 -0
  3. package/LICENSE +202 -0
  4. package/NOTICE +41 -0
  5. package/README.md +550 -0
  6. package/crates/echo-server/Cargo.toml +20 -0
  7. package/crates/echo-server/src/main.rs +666 -0
  8. package/crates/native/Cargo.toml +23 -0
  9. package/crates/native/src/config.rs +129 -0
  10. package/crates/native/src/driver.rs +463 -0
  11. package/crates/native/src/lib.rs +821 -0
  12. package/crates/native/src/server.rs +718 -0
  13. package/crates/native/src/session.rs +1191 -0
  14. package/crates/native/src/tls.rs +96 -0
  15. package/crates/wtcore/Cargo.toml +15 -0
  16. package/crates/wtcore/src/h3.rs +226 -0
  17. package/crates/wtcore/src/lib.rs +9 -0
  18. package/dist/datagrams.d.ts +16 -0
  19. package/dist/errors.d.ts +10 -0
  20. package/dist/index.d.ts +7 -0
  21. package/dist/index.js +1512 -0
  22. package/dist/index.js.map +1 -0
  23. package/dist/index.mjs +1473 -0
  24. package/dist/index.mjs.map +1 -0
  25. package/dist/loader.d.ts +2 -0
  26. package/dist/native.d.ts +226 -0
  27. package/dist/server.d.ts +44 -0
  28. package/dist/streams.d.ts +14 -0
  29. package/dist/types.d.ts +24 -0
  30. package/dist/webtransport.d.ts +20 -0
  31. package/package.json +79 -0
  32. package/prebuilds/win32-x64/rwebtransport.node +0 -0
  33. package/scripts/bench.mjs +180 -0
  34. package/scripts/build.js +67 -0
  35. package/scripts/postinstall.js +67 -0
  36. package/scripts/setup-unix.sh +129 -0
  37. package/scripts/setup-windows.ps1 +229 -0
  38. package/vendor/quiche/AGENTS.md +75 -0
  39. package/vendor/quiche/COPYING +23 -0
  40. package/vendor/quiche/Cargo.lock +1212 -0
  41. package/vendor/quiche/Cargo.toml +215 -0
  42. package/vendor/quiche/README.md +466 -0
  43. package/vendor/quiche/examples/Makefile +46 -0
  44. package/vendor/quiche/examples/README.md +20 -0
  45. package/vendor/quiche/examples/cert-big.crt +90 -0
  46. package/vendor/quiche/examples/cert.crt +18 -0
  47. package/vendor/quiche/examples/cert.key +28 -0
  48. package/vendor/quiche/examples/client.c +343 -0
  49. package/vendor/quiche/examples/client.rs +281 -0
  50. package/vendor/quiche/examples/gen-certs.sh +15 -0
  51. package/vendor/quiche/examples/http3-client.c +473 -0
  52. package/vendor/quiche/examples/http3-client.rs +349 -0
  53. package/vendor/quiche/examples/http3-server.c +614 -0
  54. package/vendor/quiche/examples/http3-server.rs +680 -0
  55. package/vendor/quiche/examples/qpack-decode.rs +87 -0
  56. package/vendor/quiche/examples/qpack-encode.rs +88 -0
  57. package/vendor/quiche/examples/rootca.crt +21 -0
  58. package/vendor/quiche/examples/server.c +529 -0
  59. package/vendor/quiche/examples/server.rs +529 -0
  60. package/vendor/quiche/include/quiche.h +1282 -0
  61. package/vendor/quiche/quiche.svg +1 -0
  62. package/vendor/quiche/src/buffers.rs +105 -0
  63. package/vendor/quiche/src/build.rs +66 -0
  64. package/vendor/quiche/src/cid.rs +1079 -0
  65. package/vendor/quiche/src/crypto/boringssl.rs +373 -0
  66. package/vendor/quiche/src/crypto/mod.rs +671 -0
  67. package/vendor/quiche/src/dgram.rs +118 -0
  68. package/vendor/quiche/src/error.rs +263 -0
  69. package/vendor/quiche/src/ffi.rs +2290 -0
  70. package/vendor/quiche/src/flowcontrol.rs +246 -0
  71. package/vendor/quiche/src/frame.rs +2172 -0
  72. package/vendor/quiche/src/h3/AGENTS.md +54 -0
  73. package/vendor/quiche/src/h3/ffi.rs +442 -0
  74. package/vendor/quiche/src/h3/frame.rs +1404 -0
  75. package/vendor/quiche/src/h3/mod.rs +8223 -0
  76. package/vendor/quiche/src/h3/qpack/decoder.rs +288 -0
  77. package/vendor/quiche/src/h3/qpack/encoder.rs +235 -0
  78. package/vendor/quiche/src/h3/qpack/mod.rs +202 -0
  79. package/vendor/quiche/src/h3/qpack/static_table.rs +323 -0
  80. package/vendor/quiche/src/h3/stream.rs +1595 -0
  81. package/vendor/quiche/src/lib.rs +9556 -0
  82. package/vendor/quiche/src/minmax.rs +446 -0
  83. package/vendor/quiche/src/packet.rs +2334 -0
  84. package/vendor/quiche/src/path.rs +1374 -0
  85. package/vendor/quiche/src/pmtud.rs +652 -0
  86. package/vendor/quiche/src/rand.rs +64 -0
  87. package/vendor/quiche/src/range_buf.rs +186 -0
  88. package/vendor/quiche/src/ranges.rs +755 -0
  89. package/vendor/quiche/src/recovery/AGENTS.md +80 -0
  90. package/vendor/quiche/src/recovery/bandwidth.rs +565 -0
  91. package/vendor/quiche/src/recovery/bytes_in_flight.rs +179 -0
  92. package/vendor/quiche/src/recovery/congestion/cubic.rs +1038 -0
  93. package/vendor/quiche/src/recovery/congestion/delivery_rate.rs +514 -0
  94. package/vendor/quiche/src/recovery/congestion/hystart.rs +241 -0
  95. package/vendor/quiche/src/recovery/congestion/mod.rs +361 -0
  96. package/vendor/quiche/src/recovery/congestion/prr.rs +238 -0
  97. package/vendor/quiche/src/recovery/congestion/recovery.rs +1170 -0
  98. package/vendor/quiche/src/recovery/congestion/reno.rs +291 -0
  99. package/vendor/quiche/src/recovery/congestion/test_sender.rs +201 -0
  100. package/vendor/quiche/src/recovery/gcongestion/bbr/bandwidth_sampler.rs +1947 -0
  101. package/vendor/quiche/src/recovery/gcongestion/bbr/windowed_filter.rs +158 -0
  102. package/vendor/quiche/src/recovery/gcongestion/bbr.rs +37 -0
  103. package/vendor/quiche/src/recovery/gcongestion/bbr2/drain.rs +120 -0
  104. package/vendor/quiche/src/recovery/gcongestion/bbr2/mode.rs +318 -0
  105. package/vendor/quiche/src/recovery/gcongestion/bbr2/network_model.rs +784 -0
  106. package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_bw.rs +729 -0
  107. package/vendor/quiche/src/recovery/gcongestion/bbr2/probe_rtt.rs +175 -0
  108. package/vendor/quiche/src/recovery/gcongestion/bbr2/startup.rs +190 -0
  109. package/vendor/quiche/src/recovery/gcongestion/bbr2.rs +855 -0
  110. package/vendor/quiche/src/recovery/gcongestion/mod.rs +275 -0
  111. package/vendor/quiche/src/recovery/gcongestion/pacer.rs +294 -0
  112. package/vendor/quiche/src/recovery/gcongestion/recovery.rs +1384 -0
  113. package/vendor/quiche/src/recovery/mod.rs +3086 -0
  114. package/vendor/quiche/src/recovery/rtt.rs +152 -0
  115. package/vendor/quiche/src/stream/mod.rs +2210 -0
  116. package/vendor/quiche/src/stream/recv_buf.rs +1236 -0
  117. package/vendor/quiche/src/stream/send_buf.rs +849 -0
  118. package/vendor/quiche/src/test_utils.rs +681 -0
  119. package/vendor/quiche/src/tests.rs +12922 -0
  120. package/vendor/quiche/src/tls/boringssl.rs +375 -0
  121. package/vendor/quiche/src/tls/mod.rs +1245 -0
  122. package/vendor/quiche/src/transport_params.rs +628 -0
@@ -0,0 +1,1374 @@
1
+ // Copyright (C) 2022, Cloudflare, Inc.
2
+ // All rights reserved.
3
+ //
4
+ // Redistribution and use in source and binary forms, with or without
5
+ // modification, are permitted provided that the following conditions are
6
+ // met:
7
+ //
8
+ // * Redistributions of source code must retain the above copyright notice,
9
+ // this list of conditions and the following disclaimer.
10
+ //
11
+ // * Redistributions in binary form must reproduce the above copyright
12
+ // notice, this list of conditions and the following disclaimer in the
13
+ // documentation and/or other materials provided with the distribution.
14
+ //
15
+ // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
16
+ // IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17
+ // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18
+ // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
19
+ // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20
+ // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21
+ // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22
+ // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23
+ // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24
+ // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25
+ // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
+
27
+ use std::collections::BTreeMap;
28
+ use std::collections::VecDeque;
29
+
30
+ use std::net::SocketAddr;
31
+
32
+ use std::time::Duration;
33
+ use std::time::Instant;
34
+
35
+ use smallvec::SmallVec;
36
+
37
+ use slab::Slab;
38
+
39
+ use crate::Config;
40
+ use crate::Error;
41
+ use crate::Result;
42
+ use crate::StartupExit;
43
+
44
+ use crate::pmtud;
45
+ use crate::recovery;
46
+ use crate::recovery::Bandwidth;
47
+ use crate::recovery::HandshakeStatus;
48
+ use crate::recovery::OnLossDetectionTimeoutOutcome;
49
+ use crate::recovery::RecoveryOps;
50
+
51
+ /// The different states of the path validation.
52
+ #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
53
+ pub enum PathState {
54
+ /// The path failed its validation.
55
+ Failed,
56
+
57
+ /// The path exists, but no path validation has been performed.
58
+ Unknown,
59
+
60
+ /// The path is under validation.
61
+ Validating,
62
+
63
+ /// The remote address has been validated, but not the path MTU.
64
+ ValidatingMTU,
65
+
66
+ /// The path has been validated.
67
+ Validated,
68
+ }
69
+
70
+ impl PathState {
71
+ #[cfg(feature = "ffi")]
72
+ pub fn to_c(self) -> libc::ssize_t {
73
+ match self {
74
+ PathState::Failed => -1,
75
+ PathState::Unknown => 0,
76
+ PathState::Validating => 1,
77
+ PathState::ValidatingMTU => 2,
78
+ PathState::Validated => 3,
79
+ }
80
+ }
81
+ }
82
+
83
+ /// A path-specific event.
84
+ #[derive(Clone, Debug, PartialEq, Eq)]
85
+ pub enum PathEvent {
86
+ /// A new network path (local address, peer address) has been seen on a
87
+ /// received packet. Note that this event is only triggered for servers, as
88
+ /// the client is responsible from initiating new paths. The application may
89
+ /// then probe this new path, if desired.
90
+ New(SocketAddr, SocketAddr),
91
+
92
+ /// The related network path between local `SocketAddr` and peer
93
+ /// `SocketAddr` has been validated.
94
+ Validated(SocketAddr, SocketAddr),
95
+
96
+ /// The related network path between local `SocketAddr` and peer
97
+ /// `SocketAddr` failed to be validated. This network path will not be used
98
+ /// anymore, unless the application requests probing this path again.
99
+ FailedValidation(SocketAddr, SocketAddr),
100
+
101
+ /// The related network path between local `SocketAddr` and peer
102
+ /// `SocketAddr` has been closed and is now unusable on this connection.
103
+ Closed(SocketAddr, SocketAddr),
104
+
105
+ /// The stack observes that the Source Connection ID with the given sequence
106
+ /// number, initially used by the peer over the first pair of `SocketAddr`s,
107
+ /// is now reused over the second pair of `SocketAddr`s.
108
+ ReusedSourceConnectionId(
109
+ u64,
110
+ (SocketAddr, SocketAddr),
111
+ (SocketAddr, SocketAddr),
112
+ ),
113
+
114
+ /// The connection observed that the peer migrated over the network path
115
+ /// denoted by the pair of `SocketAddr`, i.e., non-probing packets have been
116
+ /// received on this network path. This is a server side only event.
117
+ ///
118
+ /// Note that this event is only raised if the path has been validated.
119
+ PeerMigrated(SocketAddr, SocketAddr),
120
+ }
121
+
122
+ /// A network path on which QUIC packets can be sent.
123
+ #[derive(Debug)]
124
+ pub struct Path {
125
+ /// The local address.
126
+ local_addr: SocketAddr,
127
+
128
+ /// The remote address.
129
+ peer_addr: SocketAddr,
130
+
131
+ /// Source CID sequence number used over that path.
132
+ pub active_scid_seq: Option<u64>,
133
+
134
+ /// Destination CID sequence number used over that path.
135
+ pub active_dcid_seq: Option<u64>,
136
+
137
+ /// The current validation state of the path.
138
+ state: PathState,
139
+
140
+ /// Is this path used to send non-probing packets.
141
+ active: bool,
142
+
143
+ /// Loss recovery and congestion control state.
144
+ pub recovery: recovery::Recovery,
145
+
146
+ /// Path MTU discovery state. None if PMTUD is disabled on the path.
147
+ pub pmtud: Option<pmtud::Pmtud>,
148
+
149
+ /// Pending challenge data with the size of the packet containing them and
150
+ /// when they were sent.
151
+ in_flight_challenges: VecDeque<([u8; 8], usize, Instant)>,
152
+
153
+ /// The maximum challenge size that got acknowledged.
154
+ max_challenge_size: usize,
155
+
156
+ /// Number of consecutive (spaced by at least 1 RTT) probing packets lost.
157
+ probing_lost: usize,
158
+
159
+ /// Last instant when a probing packet got lost.
160
+ last_probe_lost_time: Option<Instant>,
161
+
162
+ /// Received challenge data.
163
+ received_challenges: VecDeque<[u8; 8]>,
164
+
165
+ /// Max length of received challenges queue.
166
+ received_challenges_max_len: usize,
167
+
168
+ /// Number of packets sent on this path.
169
+ pub sent_count: usize,
170
+
171
+ /// Number of packets received on this path.
172
+ pub recv_count: usize,
173
+
174
+ /// Total number of packets sent with data retransmitted from this path.
175
+ pub retrans_count: usize,
176
+
177
+ /// Total number of times PTO (probe timeout) fired.
178
+ ///
179
+ /// Loss usually happens in a burst so the number of packets lost will
180
+ /// depend on the volume of inflight packets at the time of loss (which
181
+ /// can be arbitrary). PTO count measures the number of loss events and
182
+ /// provides a normalized loss metric.
183
+ pub total_pto_count: usize,
184
+
185
+ /// Number of DATAGRAM frames sent on this path.
186
+ pub dgram_sent_count: usize,
187
+
188
+ /// Number of DATAGRAM frames marked lost on this path.
189
+ pub dgram_lost_count: usize,
190
+
191
+ /// Number of DATAGRAM frames received on this path.
192
+ pub dgram_recv_count: usize,
193
+
194
+ /// Total number of sent bytes over this path.
195
+ pub sent_bytes: u64,
196
+
197
+ /// Total number of bytes received over this path.
198
+ pub recv_bytes: u64,
199
+
200
+ /// Total number of bytes retransmitted from this path.
201
+ /// This counts only STREAM and CRYPTO data.
202
+ pub stream_retrans_bytes: u64,
203
+
204
+ /// Total number of bytes the server can send before the peer's address
205
+ /// is verified.
206
+ pub max_send_bytes: usize,
207
+
208
+ /// Whether the peer's address has been verified.
209
+ pub verified_peer_address: bool,
210
+
211
+ /// Whether the peer has verified our address.
212
+ pub peer_verified_local_address: bool,
213
+
214
+ /// Does it requires sending PATH_CHALLENGE?
215
+ challenge_requested: bool,
216
+
217
+ /// Whether the failure of this path was notified.
218
+ failure_notified: bool,
219
+
220
+ /// Whether the connection tries to migrate to this path, but it still needs
221
+ /// to be validated.
222
+ migrating: bool,
223
+
224
+ /// Whether or not we should force eliciting of an ACK (e.g. via PING frame)
225
+ pub needs_ack_eliciting: bool,
226
+ }
227
+
228
+ impl Path {
229
+ /// Create a new Path instance with the provided addresses, the remaining of
230
+ /// the fields being set to their default value.
231
+ pub fn new(
232
+ local_addr: SocketAddr, peer_addr: SocketAddr,
233
+ recovery_config: &recovery::RecoveryConfig,
234
+ path_challenge_recv_max_queue_len: usize, is_initial: bool,
235
+ config: Option<&Config>,
236
+ ) -> Self {
237
+ let (state, active_scid_seq, active_dcid_seq) = if is_initial {
238
+ (PathState::Validated, Some(0), Some(0))
239
+ } else {
240
+ (PathState::Unknown, None, None)
241
+ };
242
+
243
+ let pmtud = config.and_then(|c| {
244
+ if c.pmtud {
245
+ let maximum_supported_mtu: usize = std::cmp::min(
246
+ // if the max_udp_payload_size doesn't fit into a usize, then
247
+ // max_send_udp_payload_size must be smaller so use that
248
+ c.local_transport_params
249
+ .max_udp_payload_size
250
+ .try_into()
251
+ .unwrap_or(c.max_send_udp_payload_size),
252
+ c.max_send_udp_payload_size,
253
+ );
254
+ Some(pmtud::Pmtud::new(maximum_supported_mtu, c.pmtud_max_probes))
255
+ } else {
256
+ None
257
+ }
258
+ });
259
+
260
+ Self {
261
+ local_addr,
262
+ peer_addr,
263
+ active_scid_seq,
264
+ active_dcid_seq,
265
+ state,
266
+ active: false,
267
+ recovery: recovery::Recovery::new_with_config(recovery_config),
268
+ pmtud,
269
+ in_flight_challenges: VecDeque::new(),
270
+ max_challenge_size: 0,
271
+ probing_lost: 0,
272
+ last_probe_lost_time: None,
273
+ received_challenges: VecDeque::with_capacity(
274
+ path_challenge_recv_max_queue_len,
275
+ ),
276
+ received_challenges_max_len: path_challenge_recv_max_queue_len,
277
+ sent_count: 0,
278
+ recv_count: 0,
279
+ retrans_count: 0,
280
+ total_pto_count: 0,
281
+ dgram_sent_count: 0,
282
+ dgram_lost_count: 0,
283
+ dgram_recv_count: 0,
284
+ sent_bytes: 0,
285
+ recv_bytes: 0,
286
+ stream_retrans_bytes: 0,
287
+ max_send_bytes: 0,
288
+ verified_peer_address: false,
289
+ peer_verified_local_address: false,
290
+ challenge_requested: false,
291
+ failure_notified: false,
292
+ migrating: false,
293
+ needs_ack_eliciting: false,
294
+ }
295
+ }
296
+
297
+ /// Returns the local address on which this path operates.
298
+ #[inline]
299
+ pub fn local_addr(&self) -> SocketAddr {
300
+ self.local_addr
301
+ }
302
+
303
+ /// Returns the peer address on which this path operates.
304
+ #[inline]
305
+ pub fn peer_addr(&self) -> SocketAddr {
306
+ self.peer_addr
307
+ }
308
+
309
+ /// Returns whether the path is working (i.e., not failed).
310
+ #[inline]
311
+ fn working(&self) -> bool {
312
+ self.state > PathState::Failed
313
+ }
314
+
315
+ /// Returns whether the path is active.
316
+ #[inline]
317
+ pub fn active(&self) -> bool {
318
+ self.active && self.working() && self.active_dcid_seq.is_some()
319
+ }
320
+
321
+ /// Returns whether the path can be used to send non-probing packets.
322
+ #[inline]
323
+ pub fn usable(&self) -> bool {
324
+ self.active() ||
325
+ (self.state == PathState::Validated &&
326
+ self.active_dcid_seq.is_some())
327
+ }
328
+
329
+ /// Returns whether the path is unused.
330
+ #[inline]
331
+ fn unused(&self) -> bool {
332
+ // FIXME: we should check that there is nothing in the sent queue.
333
+ !self.active() && self.active_dcid_seq.is_none()
334
+ }
335
+
336
+ /// Returns whether the path requires sending a probing packet.
337
+ #[inline]
338
+ pub fn probing_required(&self) -> bool {
339
+ !self.received_challenges.is_empty() || self.validation_requested()
340
+ }
341
+
342
+ /// Promotes the path to the provided state only if the new state is greater
343
+ /// than the current one.
344
+ fn promote_to(&mut self, state: PathState) {
345
+ if self.state < state {
346
+ self.state = state;
347
+ }
348
+ }
349
+
350
+ /// Returns whether the path is validated.
351
+ #[inline]
352
+ pub fn validated(&self) -> bool {
353
+ self.state == PathState::Validated
354
+ }
355
+
356
+ /// Returns whether this path failed its validation.
357
+ #[inline]
358
+ fn validation_failed(&self) -> bool {
359
+ self.state == PathState::Failed
360
+ }
361
+
362
+ // Returns whether this path is under path validation process.
363
+ #[inline]
364
+ pub fn under_validation(&self) -> bool {
365
+ matches!(self.state, PathState::Validating | PathState::ValidatingMTU)
366
+ }
367
+
368
+ /// Requests path validation.
369
+ #[inline]
370
+ pub fn request_validation(&mut self) {
371
+ self.challenge_requested = true;
372
+ }
373
+
374
+ /// Returns whether a validation is requested.
375
+ #[inline]
376
+ pub fn validation_requested(&self) -> bool {
377
+ self.challenge_requested
378
+ }
379
+
380
+ pub fn should_send_pmtu_probe(
381
+ &mut self, hs_confirmed: bool, hs_done: bool, out_len: usize,
382
+ is_closing: bool, frames_empty: bool,
383
+ ) -> bool {
384
+ let Some(pmtud) = self.pmtud.as_mut() else {
385
+ return false;
386
+ };
387
+
388
+ (hs_confirmed && hs_done) &&
389
+ self.recovery.cwnd_available() > pmtud.get_probe_size() &&
390
+ out_len >= pmtud.get_probe_size() &&
391
+ pmtud.should_probe() &&
392
+ !is_closing &&
393
+ frames_empty
394
+ }
395
+
396
+ pub fn on_challenge_sent(&mut self) {
397
+ self.promote_to(PathState::Validating);
398
+ self.challenge_requested = false;
399
+ }
400
+
401
+ /// Handles the sending of PATH_CHALLENGE.
402
+ pub fn add_challenge_sent(
403
+ &mut self, data: [u8; 8], pkt_size: usize, sent_time: Instant,
404
+ ) {
405
+ self.on_challenge_sent();
406
+ self.in_flight_challenges
407
+ .push_back((data, pkt_size, sent_time));
408
+ }
409
+
410
+ pub fn on_challenge_received(&mut self, data: [u8; 8]) {
411
+ // Discard challenges that would cause us to queue more than we want.
412
+ if self.received_challenges.len() == self.received_challenges_max_len {
413
+ return;
414
+ }
415
+
416
+ self.received_challenges.push_back(data);
417
+ self.peer_verified_local_address = true;
418
+ }
419
+
420
+ pub fn has_pending_challenge(&self, data: [u8; 8]) -> bool {
421
+ self.in_flight_challenges.iter().any(|(d, ..)| *d == data)
422
+ }
423
+
424
+ /// Returns whether the path is now validated.
425
+ pub fn on_response_received(&mut self, data: [u8; 8]) -> bool {
426
+ self.verified_peer_address = true;
427
+ self.probing_lost = 0;
428
+
429
+ let mut challenge_size = 0;
430
+ self.in_flight_challenges.retain(|(d, s, _)| {
431
+ if *d == data {
432
+ challenge_size = *s;
433
+ false
434
+ } else {
435
+ true
436
+ }
437
+ });
438
+
439
+ // The 4-tuple is reachable, but we didn't check Path MTU yet.
440
+ self.promote_to(PathState::ValidatingMTU);
441
+
442
+ self.max_challenge_size =
443
+ std::cmp::max(self.max_challenge_size, challenge_size);
444
+
445
+ if self.state == PathState::ValidatingMTU {
446
+ if self.max_challenge_size >= crate::MIN_CLIENT_INITIAL_LEN {
447
+ // Path MTU is sufficient for QUIC traffic.
448
+ self.promote_to(PathState::Validated);
449
+ return true;
450
+ }
451
+
452
+ // If the MTU was not validated, probe again.
453
+ self.request_validation();
454
+ }
455
+
456
+ false
457
+ }
458
+
459
+ fn on_failed_validation(&mut self) {
460
+ self.state = PathState::Failed;
461
+ self.active = false;
462
+ }
463
+
464
+ #[inline]
465
+ pub fn pop_received_challenge(&mut self) -> Option<[u8; 8]> {
466
+ self.received_challenges.pop_front()
467
+ }
468
+
469
+ pub fn on_loss_detection_timeout(
470
+ &mut self, handshake_status: HandshakeStatus, now: Instant,
471
+ is_server: bool, trace_id: &str,
472
+ ) -> OnLossDetectionTimeoutOutcome {
473
+ let outcome = self.recovery.on_loss_detection_timeout(
474
+ handshake_status,
475
+ now,
476
+ trace_id,
477
+ );
478
+
479
+ let mut lost_probe_time = None;
480
+ self.in_flight_challenges.retain(|(_, _, sent_time)| {
481
+ if *sent_time <= now {
482
+ if lost_probe_time.is_none() {
483
+ lost_probe_time = Some(*sent_time);
484
+ }
485
+ false
486
+ } else {
487
+ true
488
+ }
489
+ });
490
+
491
+ // If we lost probing packets, check if the path failed
492
+ // validation.
493
+ if let Some(lost_probe_time) = lost_probe_time {
494
+ self.last_probe_lost_time = match self.last_probe_lost_time {
495
+ Some(last) => {
496
+ // Count a loss if at least 1-RTT happened.
497
+ if lost_probe_time - last >= self.recovery.rtt() {
498
+ self.probing_lost += 1;
499
+ Some(lost_probe_time)
500
+ } else {
501
+ Some(last)
502
+ }
503
+ },
504
+ None => {
505
+ self.probing_lost += 1;
506
+ Some(lost_probe_time)
507
+ },
508
+ };
509
+ // As a server, if requesting a challenge is not
510
+ // possible due to the amplification attack, declare the
511
+ // validation as failed.
512
+ if self.probing_lost >= crate::MAX_PROBING_TIMEOUTS ||
513
+ (is_server && self.max_send_bytes < crate::MIN_PROBING_SIZE)
514
+ {
515
+ self.on_failed_validation();
516
+ } else {
517
+ self.request_validation();
518
+ }
519
+ }
520
+
521
+ // Track PTO timeout event
522
+ self.total_pto_count += 1;
523
+
524
+ outcome
525
+ }
526
+
527
+ /// Returns true if the path's recovery module hasn't processed any non-ACK
528
+ /// packets, and it is still OK to fully reinitialize the recovery module to
529
+ /// pickup changes to congestion control config.
530
+ pub fn can_reinit_recovery(&self) -> bool {
531
+ // The recovery module can be reinitialized until the connection attempts
532
+ // to send a packet with inflight data. The congestion
533
+ // controller doesn't track anything interesting until inflight
534
+ // data is sent. Handshake ACKs may be sent prior to arrival of
535
+ // the full ClientHello, but the send of ACK only packets
536
+ // shouldn't prevent the reinit of the recovery module.
537
+ self.recovery.bytes_in_flight() == 0 &&
538
+ self.recovery.bytes_in_flight_duration() == Duration::ZERO
539
+ }
540
+
541
+ pub fn reinit_recovery(
542
+ &mut self, recovery_config: &recovery::RecoveryConfig,
543
+ ) {
544
+ self.recovery = recovery::Recovery::new_with_config(recovery_config)
545
+ }
546
+
547
+ pub fn stats(&self) -> PathStats {
548
+ let pmtu = match self.pmtud.as_ref().map(|p| p.get_current_mtu()) {
549
+ Some(v) => v,
550
+
551
+ None => self.recovery.max_datagram_size(),
552
+ };
553
+
554
+ PathStats {
555
+ local_addr: self.local_addr,
556
+ peer_addr: self.peer_addr,
557
+ validation_state: self.state,
558
+ active: self.active,
559
+ recv: self.recv_count,
560
+ sent: self.sent_count,
561
+ lost: self.recovery.lost_count(),
562
+ retrans: self.retrans_count,
563
+ total_pto_count: self.total_pto_count,
564
+ dgram_recv: self.dgram_recv_count,
565
+ dgram_sent: self.dgram_sent_count,
566
+ dgram_lost: self.dgram_lost_count,
567
+ rtt: self.recovery.rtt(),
568
+ min_rtt: self.recovery.min_rtt(),
569
+ max_rtt: self.recovery.max_rtt(),
570
+ rttvar: self.recovery.rttvar(),
571
+ cwnd: self.recovery.cwnd(),
572
+ sent_bytes: self.sent_bytes,
573
+ recv_bytes: self.recv_bytes,
574
+ lost_bytes: self.recovery.bytes_lost(),
575
+ stream_retrans_bytes: self.stream_retrans_bytes,
576
+ pmtu,
577
+ delivery_rate: self.recovery.delivery_rate().to_bytes_per_second(),
578
+ max_bandwidth: self
579
+ .recovery
580
+ .max_bandwidth()
581
+ .map(Bandwidth::to_bytes_per_second),
582
+ startup_exit: self.recovery.startup_exit(),
583
+ }
584
+ }
585
+
586
+ pub fn bytes_in_flight_duration(&self) -> Duration {
587
+ self.recovery.bytes_in_flight_duration()
588
+ }
589
+ }
590
+
591
+ /// An iterator over SocketAddr.
592
+ #[derive(Default)]
593
+ pub struct SocketAddrIter {
594
+ pub(crate) sockaddrs: SmallVec<[SocketAddr; 8]>,
595
+ pub(crate) index: usize,
596
+ }
597
+
598
+ impl Iterator for SocketAddrIter {
599
+ type Item = SocketAddr;
600
+
601
+ #[inline]
602
+ fn next(&mut self) -> Option<Self::Item> {
603
+ let v = self.sockaddrs.get(self.index)?;
604
+ self.index += 1;
605
+ Some(*v)
606
+ }
607
+ }
608
+
609
+ impl ExactSizeIterator for SocketAddrIter {
610
+ #[inline]
611
+ fn len(&self) -> usize {
612
+ self.sockaddrs.len() - self.index
613
+ }
614
+ }
615
+
616
+ /// All path-related information.
617
+ pub struct PathMap {
618
+ /// The paths of the connection. Each of them has an internal identifier
619
+ /// that is used by `addrs_to_paths` and `ConnectionEntry`.
620
+ paths: Slab<Path>,
621
+
622
+ /// The maximum number of concurrent paths allowed.
623
+ max_concurrent_paths: usize,
624
+
625
+ /// The mapping from the (local `SocketAddr`, peer `SocketAddr`) to the
626
+ /// `Path` structure identifier.
627
+ addrs_to_paths: BTreeMap<(SocketAddr, SocketAddr), usize>,
628
+
629
+ /// Path-specific events to be notified to the application.
630
+ events: VecDeque<PathEvent>,
631
+
632
+ /// Whether this manager serves a connection as a server.
633
+ is_server: bool,
634
+ }
635
+
636
+ impl PathMap {
637
+ /// Creates a new `PathMap` with the initial provided `path` and a
638
+ /// capacity limit.
639
+ pub fn new(
640
+ mut initial_path: Path, max_concurrent_paths: usize, is_server: bool,
641
+ ) -> Self {
642
+ let mut paths = Slab::with_capacity(1); // most connections only have one path
643
+ let mut addrs_to_paths = BTreeMap::new();
644
+
645
+ let local_addr = initial_path.local_addr;
646
+ let peer_addr = initial_path.peer_addr;
647
+
648
+ // As it is the first path, it is active by default.
649
+ initial_path.active = true;
650
+
651
+ let active_path_id = paths.insert(initial_path);
652
+ addrs_to_paths.insert((local_addr, peer_addr), active_path_id);
653
+
654
+ Self {
655
+ paths,
656
+ max_concurrent_paths,
657
+ addrs_to_paths,
658
+ events: VecDeque::new(),
659
+ is_server,
660
+ }
661
+ }
662
+
663
+ /// Gets an immutable reference to the path identified by `path_id`. If the
664
+ /// provided `path_id` does not identify any current `Path`, returns an
665
+ /// [`InvalidState`].
666
+ ///
667
+ /// [`InvalidState`]: enum.Error.html#variant.InvalidState
668
+ #[inline]
669
+ pub fn get(&self, path_id: usize) -> Result<&Path> {
670
+ self.paths.get(path_id).ok_or(Error::InvalidState)
671
+ }
672
+
673
+ /// Gets a mutable reference to the path identified by `path_id`. If the
674
+ /// provided `path_id` does not identify any current `Path`, returns an
675
+ /// [`InvalidState`].
676
+ ///
677
+ /// [`InvalidState`]: enum.Error.html#variant.InvalidState
678
+ #[inline]
679
+ pub fn get_mut(&mut self, path_id: usize) -> Result<&mut Path> {
680
+ self.paths.get_mut(path_id).ok_or(Error::InvalidState)
681
+ }
682
+
683
+ #[inline]
684
+ /// Gets an immutable reference to the active path with the value of the
685
+ /// lowest identifier. If there is no active path, returns `None`.
686
+ pub fn get_active_with_pid(&self) -> Option<(usize, &Path)> {
687
+ self.paths.iter().find(|(_, p)| p.active())
688
+ }
689
+
690
+ /// Gets an immutable reference to the active path with the lowest
691
+ /// identifier. If there is no active path, returns an [`InvalidState`].
692
+ ///
693
+ /// [`InvalidState`]: enum.Error.html#variant.InvalidState
694
+ #[inline]
695
+ pub fn get_active(&self) -> Result<&Path> {
696
+ self.get_active_with_pid()
697
+ .map(|(_, p)| p)
698
+ .ok_or(Error::InvalidState)
699
+ }
700
+
701
+ /// Gets the lowest active path identifier. If there is no active path,
702
+ /// returns an [`InvalidState`].
703
+ ///
704
+ /// [`InvalidState`]: enum.Error.html#variant.InvalidState
705
+ #[inline]
706
+ pub fn get_active_path_id(&self) -> Result<usize> {
707
+ self.get_active_with_pid()
708
+ .map(|(pid, _)| pid)
709
+ .ok_or(Error::InvalidState)
710
+ }
711
+
712
+ /// Gets an mutable reference to the active path with the lowest identifier.
713
+ /// If there is no active path, returns an [`InvalidState`].
714
+ ///
715
+ /// [`InvalidState`]: enum.Error.html#variant.InvalidState
716
+ #[inline]
717
+ pub fn get_active_mut(&mut self) -> Result<&mut Path> {
718
+ self.paths
719
+ .iter_mut()
720
+ .map(|(_, p)| p)
721
+ .find(|p| p.active())
722
+ .ok_or(Error::InvalidState)
723
+ }
724
+
725
+ /// Returns an iterator over all existing paths.
726
+ #[inline]
727
+ pub fn iter(&self) -> slab::Iter<'_, Path> {
728
+ self.paths.iter()
729
+ }
730
+
731
+ /// Returns a mutable iterator over all existing paths.
732
+ #[inline]
733
+ pub fn iter_mut(&mut self) -> slab::IterMut<'_, Path> {
734
+ self.paths.iter_mut()
735
+ }
736
+
737
+ /// Returns the number of existing paths.
738
+ #[inline]
739
+ pub fn len(&self) -> usize {
740
+ self.paths.len()
741
+ }
742
+
743
+ /// Returns the `Path` identifier related to the provided `addrs`.
744
+ #[inline]
745
+ pub fn path_id_from_addrs(
746
+ &self, addrs: &(SocketAddr, SocketAddr),
747
+ ) -> Option<usize> {
748
+ self.addrs_to_paths.get(addrs).copied()
749
+ }
750
+
751
+ /// Checks if creating a new path will not exceed the current `self.paths`
752
+ /// capacity. If yes, this method tries to remove one unused path. If it
753
+ /// fails to do so, returns [`Done`].
754
+ ///
755
+ /// [`Done`]: enum.Error.html#variant.Done
756
+ fn make_room_for_new_path(&mut self) -> Result<()> {
757
+ if self.paths.len() < self.max_concurrent_paths {
758
+ return Ok(());
759
+ }
760
+
761
+ let (pid_to_remove, _) = self
762
+ .paths
763
+ .iter()
764
+ .find(|(_, p)| p.unused())
765
+ .ok_or(Error::Done)?;
766
+
767
+ let path = self.paths.remove(pid_to_remove);
768
+ self.addrs_to_paths
769
+ .remove(&(path.local_addr, path.peer_addr));
770
+
771
+ self.notify_event(PathEvent::Closed(path.local_addr, path.peer_addr));
772
+
773
+ Ok(())
774
+ }
775
+
776
+ /// Records the provided `Path` and returns its assigned identifier.
777
+ ///
778
+ /// On success, this method takes care of creating a notification to the
779
+ /// serving application, if it serves a server-side connection.
780
+ ///
781
+ /// If there are already `max_concurrent_paths` currently recorded, this
782
+ /// method tries to remove an unused `Path` first. If it fails to do so,
783
+ /// it returns [`Done`].
784
+ ///
785
+ /// [`Done`]: enum.Error.html#variant.Done
786
+ pub fn insert_path(&mut self, path: Path, is_server: bool) -> Result<usize> {
787
+ self.make_room_for_new_path()?;
788
+
789
+ let local_addr = path.local_addr;
790
+ let peer_addr = path.peer_addr;
791
+
792
+ let pid = self.paths.insert(path);
793
+ self.addrs_to_paths.insert((local_addr, peer_addr), pid);
794
+
795
+ // Notifies the application if we are in server mode.
796
+ if is_server {
797
+ self.notify_event(PathEvent::New(local_addr, peer_addr));
798
+ }
799
+
800
+ Ok(pid)
801
+ }
802
+
803
+ /// Notifies a path event to the application served by the connection.
804
+ pub fn notify_event(&mut self, ev: PathEvent) {
805
+ self.events.push_back(ev);
806
+ }
807
+
808
+ /// Gets the first path event to be notified to the application.
809
+ pub fn pop_event(&mut self) -> Option<PathEvent> {
810
+ self.events.pop_front()
811
+ }
812
+
813
+ /// Notifies all failed validations to the application.
814
+ pub fn notify_failed_validations(&mut self) {
815
+ let validation_failed = self
816
+ .paths
817
+ .iter_mut()
818
+ .filter(|(_, p)| p.validation_failed() && !p.failure_notified);
819
+
820
+ for (_, p) in validation_failed {
821
+ self.events.push_back(PathEvent::FailedValidation(
822
+ p.local_addr,
823
+ p.peer_addr,
824
+ ));
825
+
826
+ p.failure_notified = true;
827
+ }
828
+ }
829
+
830
+ /// Finds a path candidate to be active and returns its identifier.
831
+ pub fn find_candidate_path(&self) -> Option<usize> {
832
+ // TODO: also consider unvalidated paths if there are no more validated.
833
+ self.paths
834
+ .iter()
835
+ .find(|(_, p)| p.usable())
836
+ .map(|(pid, _)| pid)
837
+ }
838
+
839
+ /// Handles incoming PATH_RESPONSE data.
840
+ pub fn on_response_received(&mut self, data: [u8; 8]) -> Result<()> {
841
+ let active_pid = self.get_active_path_id()?;
842
+
843
+ let challenge_pending =
844
+ self.iter_mut().find(|(_, p)| p.has_pending_challenge(data));
845
+
846
+ if let Some((pid, p)) = challenge_pending {
847
+ if p.on_response_received(data) {
848
+ let local_addr = p.local_addr;
849
+ let peer_addr = p.peer_addr;
850
+ let was_migrating = p.migrating;
851
+
852
+ p.migrating = false;
853
+
854
+ // Notifies the application.
855
+ self.notify_event(PathEvent::Validated(local_addr, peer_addr));
856
+
857
+ // If this path was the candidate for migration, notifies the
858
+ // application.
859
+ if pid == active_pid && was_migrating {
860
+ self.notify_event(PathEvent::PeerMigrated(
861
+ local_addr, peer_addr,
862
+ ));
863
+ }
864
+ }
865
+ }
866
+ Ok(())
867
+ }
868
+
869
+ /// Sets the path with identifier 'path_id' to be active.
870
+ ///
871
+ /// There can be exactly one active path on which non-probing packets can be
872
+ /// sent. If another path is marked as active, it will be superseded by the
873
+ /// one having `path_id` as identifier.
874
+ ///
875
+ /// A server should always ensure that the active path is validated. If it
876
+ /// is already the case, it notifies the application that the connection
877
+ /// migrated. Otherwise, it triggers a path validation and defers the
878
+ /// notification once it is actually validated.
879
+ pub fn set_active_path(&mut self, path_id: usize) -> Result<()> {
880
+ let is_server = self.is_server;
881
+
882
+ if let Ok(old_active_path) = self.get_active_mut() {
883
+ old_active_path.active = false;
884
+ }
885
+
886
+ let new_active_path = self.get_mut(path_id)?;
887
+ new_active_path.active = true;
888
+
889
+ if is_server {
890
+ if new_active_path.validated() {
891
+ let local_addr = new_active_path.local_addr();
892
+ let peer_addr = new_active_path.peer_addr();
893
+
894
+ self.notify_event(PathEvent::PeerMigrated(local_addr, peer_addr));
895
+ } else {
896
+ new_active_path.migrating = true;
897
+
898
+ // Requests path validation if needed.
899
+ if !new_active_path.under_validation() {
900
+ new_active_path.request_validation();
901
+ }
902
+ }
903
+ }
904
+
905
+ Ok(())
906
+ }
907
+
908
+ /// Configures path MTU discovery on all existing paths.
909
+ pub fn set_discover_pmtu_on_existing_paths(
910
+ &mut self, discover: bool, max_send_udp_payload_size: usize,
911
+ pmtud_max_probes: u8,
912
+ ) {
913
+ for (_, path) in self.paths.iter_mut() {
914
+ path.pmtud = if discover {
915
+ Some(pmtud::Pmtud::new(
916
+ max_send_udp_payload_size,
917
+ pmtud_max_probes,
918
+ ))
919
+ } else {
920
+ None
921
+ };
922
+ }
923
+ }
924
+ }
925
+
926
+ /// Statistics about the path of a connection.
927
+ ///
928
+ /// A connection’s path statistics can be collected using the [`path_stats()`]
929
+ /// method.
930
+ ///
931
+ /// [`path_stats()`]: struct.Connection.html#method.path_stats
932
+ #[derive(Clone)]
933
+ #[non_exhaustive]
934
+ pub struct PathStats {
935
+ /// The local address of the path.
936
+ pub local_addr: SocketAddr,
937
+
938
+ /// The peer address of the path.
939
+ pub peer_addr: SocketAddr,
940
+
941
+ /// The path validation state.
942
+ pub validation_state: PathState,
943
+
944
+ /// Whether the path is marked as active.
945
+ pub active: bool,
946
+
947
+ /// The number of QUIC packets received.
948
+ pub recv: usize,
949
+
950
+ /// The number of QUIC packets sent.
951
+ pub sent: usize,
952
+
953
+ /// The number of QUIC packets that were lost.
954
+ pub lost: usize,
955
+
956
+ /// The number of sent QUIC packets with retransmitted data.
957
+ pub retrans: usize,
958
+
959
+ /// The number of times PTO (probe timeout) fired.
960
+ ///
961
+ /// Loss usually happens in a burst so the number of packets lost will
962
+ /// depend on the volume of inflight packets at the time of loss (which
963
+ /// can be arbitrary). PTO count measures the number of loss events and
964
+ /// provides a normalized loss metric.
965
+ pub total_pto_count: usize,
966
+
967
+ /// The number of DATAGRAM frames received.
968
+ pub dgram_recv: usize,
969
+
970
+ /// The number of DATAGRAM frames sent.
971
+ pub dgram_sent: usize,
972
+
973
+ /// The number of DATAGRAM frames lost.
974
+ pub dgram_lost: usize,
975
+
976
+ /// The estimated round-trip time of the connection.
977
+ pub rtt: Duration,
978
+
979
+ /// The minimum round-trip time observed.
980
+ pub min_rtt: Option<Duration>,
981
+
982
+ /// The maximum round-trip time observed.
983
+ pub max_rtt: Option<Duration>,
984
+
985
+ /// The estimated round-trip time variation in samples using a mean
986
+ /// variation.
987
+ pub rttvar: Duration,
988
+
989
+ /// The size of the connection's congestion window in bytes.
990
+ pub cwnd: usize,
991
+
992
+ /// The number of sent bytes.
993
+ pub sent_bytes: u64,
994
+
995
+ /// The number of received bytes.
996
+ pub recv_bytes: u64,
997
+
998
+ /// The number of bytes lost.
999
+ pub lost_bytes: u64,
1000
+
1001
+ /// The number of stream bytes retransmitted.
1002
+ pub stream_retrans_bytes: u64,
1003
+
1004
+ /// The current PMTU for the connection.
1005
+ pub pmtu: usize,
1006
+
1007
+ /// The most recent data delivery rate estimate in bytes/s.
1008
+ ///
1009
+ /// Note that this value could be inaccurate if the application does not
1010
+ /// respect pacing hints (see [`SendInfo.at`] and [Pacing] for more
1011
+ /// details).
1012
+ ///
1013
+ /// [`SendInfo.at`]: struct.SendInfo.html#structfield.at
1014
+ /// [Pacing]: index.html#pacing
1015
+ pub delivery_rate: u64,
1016
+
1017
+ /// The maximum bandwidth estimate for the connection in bytes/s.
1018
+ ///
1019
+ /// Note: not all congestion control algorithms provide this metric;
1020
+ /// it is currently only implemented for bbr2_gcongestion.
1021
+ pub max_bandwidth: Option<u64>,
1022
+
1023
+ /// Statistics from when a CCA first exited the startup phase.
1024
+ pub startup_exit: Option<StartupExit>,
1025
+ }
1026
+
1027
+ impl std::fmt::Debug for PathStats {
1028
+ #[inline]
1029
+ fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1030
+ write!(
1031
+ f,
1032
+ "local_addr={:?} peer_addr={:?} ",
1033
+ self.local_addr, self.peer_addr,
1034
+ )?;
1035
+ write!(
1036
+ f,
1037
+ "validation_state={:?} active={} ",
1038
+ self.validation_state, self.active,
1039
+ )?;
1040
+ write!(
1041
+ f,
1042
+ "recv={} sent={} lost={} retrans={} rtt={:?} min_rtt={:?} rttvar={:?} cwnd={}",
1043
+ self.recv, self.sent, self.lost, self.retrans, self.rtt, self.min_rtt, self.rttvar, self.cwnd,
1044
+ )?;
1045
+
1046
+ write!(
1047
+ f,
1048
+ " sent_bytes={} recv_bytes={} lost_bytes={}",
1049
+ self.sent_bytes, self.recv_bytes, self.lost_bytes,
1050
+ )?;
1051
+
1052
+ write!(
1053
+ f,
1054
+ " stream_retrans_bytes={} pmtu={} delivery_rate={}",
1055
+ self.stream_retrans_bytes, self.pmtu, self.delivery_rate,
1056
+ )
1057
+ }
1058
+ }
1059
+
1060
+ #[cfg(test)]
1061
+ mod tests {
1062
+ use crate::rand;
1063
+ use crate::MIN_CLIENT_INITIAL_LEN;
1064
+
1065
+ use crate::recovery::RecoveryConfig;
1066
+ use crate::Config;
1067
+
1068
+ use super::*;
1069
+
1070
+ #[test]
1071
+ fn path_validation_limited_mtu() {
1072
+ let client_addr = "127.0.0.1:1234".parse().unwrap();
1073
+ let client_addr_2 = "127.0.0.1:5678".parse().unwrap();
1074
+ let server_addr = "127.0.0.1:4321".parse().unwrap();
1075
+
1076
+ let config = Config::new(crate::PROTOCOL_VERSION).unwrap();
1077
+ let recovery_config = RecoveryConfig::from_config(&config);
1078
+
1079
+ let path = Path::new(
1080
+ client_addr,
1081
+ server_addr,
1082
+ &recovery_config,
1083
+ config.path_challenge_recv_max_queue_len,
1084
+ true,
1085
+ None,
1086
+ );
1087
+ let mut path_mgr = PathMap::new(path, 2, false);
1088
+
1089
+ let probed_path = Path::new(
1090
+ client_addr_2,
1091
+ server_addr,
1092
+ &recovery_config,
1093
+ config.path_challenge_recv_max_queue_len,
1094
+ false,
1095
+ None,
1096
+ );
1097
+ path_mgr.insert_path(probed_path, false).unwrap();
1098
+
1099
+ let pid = path_mgr
1100
+ .path_id_from_addrs(&(client_addr_2, server_addr))
1101
+ .unwrap();
1102
+ path_mgr.get_mut(pid).unwrap().request_validation();
1103
+ assert!(path_mgr.get_mut(pid).unwrap().validation_requested());
1104
+ assert!(path_mgr.get_mut(pid).unwrap().probing_required());
1105
+
1106
+ // Fake sending of PathChallenge in a packet of MIN_CLIENT_INITIAL_LEN - 1
1107
+ // bytes.
1108
+ let data = rand::rand_u64().to_be_bytes();
1109
+ path_mgr.get_mut(pid).unwrap().add_challenge_sent(
1110
+ data,
1111
+ MIN_CLIENT_INITIAL_LEN - 1,
1112
+ Instant::now(),
1113
+ );
1114
+
1115
+ assert!(!path_mgr.get_mut(pid).unwrap().validation_requested());
1116
+ assert!(!path_mgr.get_mut(pid).unwrap().probing_required());
1117
+ assert!(path_mgr.get_mut(pid).unwrap().under_validation());
1118
+ assert!(!path_mgr.get_mut(pid).unwrap().validated());
1119
+ assert_eq!(path_mgr.get_mut(pid).unwrap().state, PathState::Validating);
1120
+ assert_eq!(path_mgr.pop_event(), None);
1121
+
1122
+ // Receives the response. The path is reachable, but the MTU is not
1123
+ // validated yet.
1124
+ path_mgr.on_response_received(data).unwrap();
1125
+
1126
+ assert!(path_mgr.get_mut(pid).unwrap().validation_requested());
1127
+ assert!(path_mgr.get_mut(pid).unwrap().probing_required());
1128
+ assert!(path_mgr.get_mut(pid).unwrap().under_validation());
1129
+ assert!(!path_mgr.get_mut(pid).unwrap().validated());
1130
+ assert_eq!(
1131
+ path_mgr.get_mut(pid).unwrap().state,
1132
+ PathState::ValidatingMTU
1133
+ );
1134
+ assert_eq!(path_mgr.pop_event(), None);
1135
+
1136
+ // Fake sending of PathChallenge in a packet of MIN_CLIENT_INITIAL_LEN
1137
+ // bytes.
1138
+ let data = rand::rand_u64().to_be_bytes();
1139
+ path_mgr.get_mut(pid).unwrap().add_challenge_sent(
1140
+ data,
1141
+ MIN_CLIENT_INITIAL_LEN,
1142
+ Instant::now(),
1143
+ );
1144
+
1145
+ path_mgr.on_response_received(data).unwrap();
1146
+
1147
+ assert!(!path_mgr.get_mut(pid).unwrap().validation_requested());
1148
+ assert!(!path_mgr.get_mut(pid).unwrap().probing_required());
1149
+ assert!(!path_mgr.get_mut(pid).unwrap().under_validation());
1150
+ assert!(path_mgr.get_mut(pid).unwrap().validated());
1151
+ assert_eq!(path_mgr.get_mut(pid).unwrap().state, PathState::Validated);
1152
+ assert_eq!(
1153
+ path_mgr.pop_event(),
1154
+ Some(PathEvent::Validated(client_addr_2, server_addr))
1155
+ );
1156
+ }
1157
+
1158
+ #[test]
1159
+ fn multiple_probes() {
1160
+ let client_addr = "127.0.0.1:1234".parse().unwrap();
1161
+ let server_addr = "127.0.0.1:4321".parse().unwrap();
1162
+
1163
+ let config = Config::new(crate::PROTOCOL_VERSION).unwrap();
1164
+ let recovery_config = RecoveryConfig::from_config(&config);
1165
+
1166
+ let path = Path::new(
1167
+ client_addr,
1168
+ server_addr,
1169
+ &recovery_config,
1170
+ config.path_challenge_recv_max_queue_len,
1171
+ true,
1172
+ None,
1173
+ );
1174
+ let mut client_path_mgr = PathMap::new(path, 2, false);
1175
+ let mut server_path = Path::new(
1176
+ server_addr,
1177
+ client_addr,
1178
+ &recovery_config,
1179
+ config.path_challenge_recv_max_queue_len,
1180
+ false,
1181
+ None,
1182
+ );
1183
+
1184
+ let client_pid = client_path_mgr
1185
+ .path_id_from_addrs(&(client_addr, server_addr))
1186
+ .unwrap();
1187
+
1188
+ // First probe.
1189
+ let data = rand::rand_u64().to_be_bytes();
1190
+
1191
+ client_path_mgr
1192
+ .get_mut(client_pid)
1193
+ .unwrap()
1194
+ .add_challenge_sent(data, MIN_CLIENT_INITIAL_LEN, Instant::now());
1195
+
1196
+ // Second probe.
1197
+ let data_2 = rand::rand_u64().to_be_bytes();
1198
+
1199
+ client_path_mgr
1200
+ .get_mut(client_pid)
1201
+ .unwrap()
1202
+ .add_challenge_sent(data_2, MIN_CLIENT_INITIAL_LEN, Instant::now());
1203
+ assert_eq!(
1204
+ client_path_mgr
1205
+ .get(client_pid)
1206
+ .unwrap()
1207
+ .in_flight_challenges
1208
+ .len(),
1209
+ 2
1210
+ );
1211
+
1212
+ // If we receive multiple challenges, we can store them.
1213
+ server_path.on_challenge_received(data);
1214
+ assert_eq!(server_path.received_challenges.len(), 1);
1215
+ server_path.on_challenge_received(data_2);
1216
+ assert_eq!(server_path.received_challenges.len(), 2);
1217
+
1218
+ // Response for first probe.
1219
+ client_path_mgr.on_response_received(data).unwrap();
1220
+ assert_eq!(
1221
+ client_path_mgr
1222
+ .get(client_pid)
1223
+ .unwrap()
1224
+ .in_flight_challenges
1225
+ .len(),
1226
+ 1
1227
+ );
1228
+
1229
+ // Response for second probe.
1230
+ client_path_mgr.on_response_received(data_2).unwrap();
1231
+ assert_eq!(
1232
+ client_path_mgr
1233
+ .get(client_pid)
1234
+ .unwrap()
1235
+ .in_flight_challenges
1236
+ .len(),
1237
+ 0
1238
+ );
1239
+ }
1240
+
1241
+ #[test]
1242
+ fn too_many_probes() {
1243
+ let client_addr = "127.0.0.1:1234".parse().unwrap();
1244
+ let server_addr = "127.0.0.1:4321".parse().unwrap();
1245
+
1246
+ // Default to DEFAULT_MAX_PATH_CHALLENGE_RX_QUEUE_LEN
1247
+ let config = Config::new(crate::PROTOCOL_VERSION).unwrap();
1248
+ let recovery_config = RecoveryConfig::from_config(&config);
1249
+
1250
+ let path = Path::new(
1251
+ client_addr,
1252
+ server_addr,
1253
+ &recovery_config,
1254
+ config.path_challenge_recv_max_queue_len,
1255
+ true,
1256
+ None,
1257
+ );
1258
+ let mut client_path_mgr = PathMap::new(path, 2, false);
1259
+ let mut server_path = Path::new(
1260
+ server_addr,
1261
+ client_addr,
1262
+ &recovery_config,
1263
+ config.path_challenge_recv_max_queue_len,
1264
+ false,
1265
+ None,
1266
+ );
1267
+
1268
+ let client_pid = client_path_mgr
1269
+ .path_id_from_addrs(&(client_addr, server_addr))
1270
+ .unwrap();
1271
+
1272
+ // First probe.
1273
+ let data = rand::rand_u64().to_be_bytes();
1274
+
1275
+ client_path_mgr
1276
+ .get_mut(client_pid)
1277
+ .unwrap()
1278
+ .add_challenge_sent(data, MIN_CLIENT_INITIAL_LEN, Instant::now());
1279
+
1280
+ // Second probe.
1281
+ let data_2 = rand::rand_u64().to_be_bytes();
1282
+
1283
+ client_path_mgr
1284
+ .get_mut(client_pid)
1285
+ .unwrap()
1286
+ .add_challenge_sent(data_2, MIN_CLIENT_INITIAL_LEN, Instant::now());
1287
+ assert_eq!(
1288
+ client_path_mgr
1289
+ .get(client_pid)
1290
+ .unwrap()
1291
+ .in_flight_challenges
1292
+ .len(),
1293
+ 2
1294
+ );
1295
+
1296
+ // Third probe.
1297
+ let data_3 = rand::rand_u64().to_be_bytes();
1298
+
1299
+ client_path_mgr
1300
+ .get_mut(client_pid)
1301
+ .unwrap()
1302
+ .add_challenge_sent(data_3, MIN_CLIENT_INITIAL_LEN, Instant::now());
1303
+ assert_eq!(
1304
+ client_path_mgr
1305
+ .get(client_pid)
1306
+ .unwrap()
1307
+ .in_flight_challenges
1308
+ .len(),
1309
+ 3
1310
+ );
1311
+
1312
+ // Fourth probe.
1313
+ let data_4 = rand::rand_u64().to_be_bytes();
1314
+
1315
+ client_path_mgr
1316
+ .get_mut(client_pid)
1317
+ .unwrap()
1318
+ .add_challenge_sent(data_4, MIN_CLIENT_INITIAL_LEN, Instant::now());
1319
+ assert_eq!(
1320
+ client_path_mgr
1321
+ .get(client_pid)
1322
+ .unwrap()
1323
+ .in_flight_challenges
1324
+ .len(),
1325
+ 4
1326
+ );
1327
+
1328
+ // If we receive multiple challenges, we can store them up to our queue
1329
+ // size.
1330
+ server_path.on_challenge_received(data);
1331
+ assert_eq!(server_path.received_challenges.len(), 1);
1332
+ server_path.on_challenge_received(data_2);
1333
+ assert_eq!(server_path.received_challenges.len(), 2);
1334
+ server_path.on_challenge_received(data_3);
1335
+ assert_eq!(server_path.received_challenges.len(), 3);
1336
+ server_path.on_challenge_received(data_4);
1337
+ assert_eq!(server_path.received_challenges.len(), 3);
1338
+
1339
+ // Response for first probe.
1340
+ client_path_mgr.on_response_received(data).unwrap();
1341
+ assert_eq!(
1342
+ client_path_mgr
1343
+ .get(client_pid)
1344
+ .unwrap()
1345
+ .in_flight_challenges
1346
+ .len(),
1347
+ 3
1348
+ );
1349
+
1350
+ // Response for second probe.
1351
+ client_path_mgr.on_response_received(data_2).unwrap();
1352
+ assert_eq!(
1353
+ client_path_mgr
1354
+ .get(client_pid)
1355
+ .unwrap()
1356
+ .in_flight_challenges
1357
+ .len(),
1358
+ 2
1359
+ );
1360
+
1361
+ // Response for third probe.
1362
+ client_path_mgr.on_response_received(data_3).unwrap();
1363
+ assert_eq!(
1364
+ client_path_mgr
1365
+ .get(client_pid)
1366
+ .unwrap()
1367
+ .in_flight_challenges
1368
+ .len(),
1369
+ 1
1370
+ );
1371
+
1372
+ // There will never be a response for fourth probe...
1373
+ }
1374
+ }