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,2172 @@
1
+ // Copyright (C) 2018-2019, 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::convert::TryInto;
28
+
29
+ use crate::Error;
30
+ use crate::Result;
31
+
32
+ use crate::packet;
33
+ use crate::range_buf::RangeBuf;
34
+ use crate::ranges;
35
+
36
+ #[cfg(feature = "qlog")]
37
+ use qlog::events::quic::AckRange;
38
+ #[cfg(feature = "qlog")]
39
+ use qlog::events::quic::ErrorSpace;
40
+ #[cfg(feature = "qlog")]
41
+ use qlog::events::quic::QuicFrame;
42
+ #[cfg(feature = "qlog")]
43
+ use qlog::events::quic::StreamType;
44
+
45
+ pub const MAX_CRYPTO_OVERHEAD: usize = 8;
46
+ pub const MAX_DGRAM_OVERHEAD: usize = 2;
47
+ pub const MAX_STREAM_OVERHEAD: usize = 12;
48
+ pub const MAX_STREAM_SIZE: u64 = 1 << 62;
49
+
50
+ #[derive(Clone, Debug, PartialEq, Eq)]
51
+ pub struct EcnCounts {
52
+ ect0_count: u64,
53
+ ect1_count: u64,
54
+ ecn_ce_count: u64,
55
+ }
56
+
57
+ #[derive(Clone, PartialEq, Eq)]
58
+ pub enum Frame {
59
+ Padding {
60
+ len: usize,
61
+ },
62
+
63
+ Ping {
64
+ // Attach metadata to the Ping frame. This doesn't appear on the wire,
65
+ // but does tell us if this frame was part of a PMTUD probe and how
66
+ // large the probe was. This will only show up on sent frames and be
67
+ // None otherwise. This is the total size of the QUIC packet in the
68
+ // probe.
69
+ mtu_probe: Option<usize>,
70
+ },
71
+
72
+ ACK {
73
+ ack_delay: u64,
74
+ ranges: ranges::RangeSet,
75
+ ecn_counts: Option<EcnCounts>,
76
+ },
77
+
78
+ ResetStream {
79
+ stream_id: u64,
80
+ error_code: u64,
81
+ final_size: u64,
82
+ },
83
+
84
+ StopSending {
85
+ stream_id: u64,
86
+ error_code: u64,
87
+ },
88
+
89
+ Crypto {
90
+ data: RangeBuf,
91
+ },
92
+
93
+ CryptoHeader {
94
+ offset: u64,
95
+ length: usize,
96
+ },
97
+
98
+ NewToken {
99
+ token: Vec<u8>,
100
+ },
101
+
102
+ Stream {
103
+ stream_id: u64,
104
+ data: RangeBuf,
105
+ },
106
+
107
+ StreamHeader {
108
+ stream_id: u64,
109
+ offset: u64,
110
+ length: usize,
111
+ fin: bool,
112
+ },
113
+
114
+ MaxData {
115
+ max: u64,
116
+ },
117
+
118
+ MaxStreamData {
119
+ stream_id: u64,
120
+ max: u64,
121
+ },
122
+
123
+ MaxStreamsBidi {
124
+ max: u64,
125
+ },
126
+
127
+ MaxStreamsUni {
128
+ max: u64,
129
+ },
130
+
131
+ DataBlocked {
132
+ limit: u64,
133
+ },
134
+
135
+ StreamDataBlocked {
136
+ stream_id: u64,
137
+ limit: u64,
138
+ },
139
+
140
+ StreamsBlockedBidi {
141
+ limit: u64,
142
+ },
143
+
144
+ StreamsBlockedUni {
145
+ limit: u64,
146
+ },
147
+
148
+ NewConnectionId {
149
+ seq_num: u64,
150
+ retire_prior_to: u64,
151
+ conn_id: Vec<u8>,
152
+ reset_token: [u8; 16],
153
+ },
154
+
155
+ RetireConnectionId {
156
+ seq_num: u64,
157
+ },
158
+
159
+ PathChallenge {
160
+ data: [u8; 8],
161
+ },
162
+
163
+ PathResponse {
164
+ data: [u8; 8],
165
+ },
166
+
167
+ ConnectionClose {
168
+ error_code: u64,
169
+ frame_type: u64,
170
+ reason: Vec<u8>,
171
+ },
172
+
173
+ ApplicationClose {
174
+ error_code: u64,
175
+ reason: Vec<u8>,
176
+ },
177
+
178
+ HandshakeDone,
179
+
180
+ Datagram {
181
+ data: Vec<u8>,
182
+ },
183
+
184
+ DatagramHeader {
185
+ length: usize,
186
+ },
187
+ }
188
+
189
+ impl Frame {
190
+ pub fn from_bytes(
191
+ b: &mut octets::Octets, pkt: packet::Type,
192
+ ) -> Result<Frame> {
193
+ let frame_type = b.get_varint()?;
194
+
195
+ let frame = match frame_type {
196
+ 0x00 => {
197
+ let mut len = 1;
198
+
199
+ while b.peek_u8() == Ok(0x00) {
200
+ b.get_u8()?;
201
+
202
+ len += 1;
203
+ }
204
+
205
+ Frame::Padding { len }
206
+ },
207
+
208
+ 0x01 => Frame::Ping { mtu_probe: None },
209
+
210
+ 0x02..=0x03 => parse_ack_frame(frame_type, b)?,
211
+
212
+ 0x04 => Frame::ResetStream {
213
+ stream_id: b.get_varint()?,
214
+ error_code: b.get_varint()?,
215
+ final_size: b.get_varint()?,
216
+ },
217
+
218
+ 0x05 => Frame::StopSending {
219
+ stream_id: b.get_varint()?,
220
+ error_code: b.get_varint()?,
221
+ },
222
+
223
+ 0x06 => {
224
+ let offset = b.get_varint()?;
225
+ let data = b.get_bytes_with_varint_length()?;
226
+ let data = <RangeBuf>::from(data.as_ref(), offset, false);
227
+
228
+ Frame::Crypto { data }
229
+ },
230
+
231
+ 0x07 => {
232
+ let len = b.get_varint()?;
233
+ if len == 0 {
234
+ return Err(Error::InvalidFrame);
235
+ }
236
+
237
+ Frame::NewToken {
238
+ token: b.get_bytes(len as usize)?.to_vec(),
239
+ }
240
+ },
241
+
242
+ 0x08..=0x0f => parse_stream_frame(frame_type, b)?,
243
+
244
+ 0x10 => Frame::MaxData {
245
+ max: b.get_varint()?,
246
+ },
247
+
248
+ 0x11 => Frame::MaxStreamData {
249
+ stream_id: b.get_varint()?,
250
+ max: b.get_varint()?,
251
+ },
252
+
253
+ 0x12 => Frame::MaxStreamsBidi {
254
+ max: b.get_varint()?,
255
+ },
256
+
257
+ 0x13 => Frame::MaxStreamsUni {
258
+ max: b.get_varint()?,
259
+ },
260
+
261
+ 0x14 => Frame::DataBlocked {
262
+ limit: b.get_varint()?,
263
+ },
264
+
265
+ 0x15 => Frame::StreamDataBlocked {
266
+ stream_id: b.get_varint()?,
267
+ limit: b.get_varint()?,
268
+ },
269
+
270
+ 0x16 => Frame::StreamsBlockedBidi {
271
+ limit: b.get_varint()?,
272
+ },
273
+
274
+ 0x17 => Frame::StreamsBlockedUni {
275
+ limit: b.get_varint()?,
276
+ },
277
+
278
+ 0x18 => {
279
+ let seq_num = b.get_varint()?;
280
+ let retire_prior_to = b.get_varint()?;
281
+ let conn_id_len = b.get_u8()?;
282
+
283
+ if !(1..=packet::MAX_CID_LEN).contains(&conn_id_len) {
284
+ return Err(Error::InvalidFrame);
285
+ }
286
+
287
+ Frame::NewConnectionId {
288
+ seq_num,
289
+ retire_prior_to,
290
+ conn_id: b.get_bytes(conn_id_len as usize)?.to_vec(),
291
+ reset_token: b
292
+ .get_bytes(16)?
293
+ .buf()
294
+ .try_into()
295
+ .map_err(|_| Error::BufferTooShort)?,
296
+ }
297
+ },
298
+
299
+ 0x19 => Frame::RetireConnectionId {
300
+ seq_num: b.get_varint()?,
301
+ },
302
+
303
+ 0x1a => Frame::PathChallenge {
304
+ data: b
305
+ .get_bytes(8)?
306
+ .buf()
307
+ .try_into()
308
+ .map_err(|_| Error::BufferTooShort)?,
309
+ },
310
+
311
+ 0x1b => Frame::PathResponse {
312
+ data: b
313
+ .get_bytes(8)?
314
+ .buf()
315
+ .try_into()
316
+ .map_err(|_| Error::BufferTooShort)?,
317
+ },
318
+
319
+ 0x1c => Frame::ConnectionClose {
320
+ error_code: b.get_varint()?,
321
+ frame_type: b.get_varint()?,
322
+ reason: b.get_bytes_with_varint_length()?.to_vec(),
323
+ },
324
+
325
+ 0x1d => Frame::ApplicationClose {
326
+ error_code: b.get_varint()?,
327
+ reason: b.get_bytes_with_varint_length()?.to_vec(),
328
+ },
329
+
330
+ 0x1e => Frame::HandshakeDone,
331
+
332
+ 0x30 | 0x31 => parse_datagram_frame(frame_type, b)?,
333
+
334
+ _ => return Err(Error::InvalidFrame),
335
+ };
336
+
337
+ let allowed = match (pkt, &frame) {
338
+ // PADDING and PING are allowed on all packet types.
339
+ (_, Frame::Padding { .. }) | (_, Frame::Ping { .. }) => true,
340
+
341
+ // ACK, CRYPTO, HANDSHAKE_DONE, NEW_TOKEN, PATH_RESPONSE, and
342
+ // RETIRE_CONNECTION_ID can't be sent on 0-RTT packets.
343
+ (packet::Type::ZeroRTT, Frame::ACK { .. }) => false,
344
+ (packet::Type::ZeroRTT, Frame::Crypto { .. }) => false,
345
+ (packet::Type::ZeroRTT, Frame::HandshakeDone) => false,
346
+ (packet::Type::ZeroRTT, Frame::NewToken { .. }) => false,
347
+ (packet::Type::ZeroRTT, Frame::PathResponse { .. }) => false,
348
+ (packet::Type::ZeroRTT, Frame::RetireConnectionId { .. }) => false,
349
+ (packet::Type::ZeroRTT, Frame::ConnectionClose { .. }) => false,
350
+
351
+ // ACK, CRYPTO and CONNECTION_CLOSE can be sent on all other packet
352
+ // types.
353
+ (_, Frame::ACK { .. }) => true,
354
+ (_, Frame::Crypto { .. }) => true,
355
+ (_, Frame::ConnectionClose { .. }) => true,
356
+
357
+ // All frames are allowed on 0-RTT and 1-RTT packets.
358
+ (packet::Type::Short, _) => true,
359
+ (packet::Type::ZeroRTT, _) => true,
360
+
361
+ // All other cases are forbidden.
362
+ (..) => false,
363
+ };
364
+
365
+ if !allowed {
366
+ return Err(Error::InvalidPacket);
367
+ }
368
+
369
+ Ok(frame)
370
+ }
371
+
372
+ pub fn to_bytes(&self, b: &mut octets::OctetsMut) -> Result<usize> {
373
+ let before = b.cap();
374
+
375
+ match self {
376
+ Frame::Padding { len } => {
377
+ let mut left = *len;
378
+
379
+ while left > 0 {
380
+ b.put_varint(0x00)?;
381
+
382
+ left -= 1;
383
+ }
384
+ },
385
+
386
+ Frame::Ping { .. } => {
387
+ b.put_varint(0x01)?;
388
+ },
389
+
390
+ Frame::ACK {
391
+ ack_delay,
392
+ ranges,
393
+ ecn_counts,
394
+ } => {
395
+ if ecn_counts.is_none() {
396
+ b.put_varint(0x02)?;
397
+ } else {
398
+ b.put_varint(0x03)?;
399
+ }
400
+
401
+ let mut it = ranges.iter().rev();
402
+
403
+ let first = it.next().unwrap();
404
+ let ack_block = (first.end - 1) - first.start;
405
+
406
+ b.put_varint(first.end - 1)?;
407
+ b.put_varint(*ack_delay)?;
408
+ b.put_varint(it.len() as u64)?;
409
+ b.put_varint(ack_block)?;
410
+
411
+ let mut smallest_ack = first.start;
412
+
413
+ for block in it {
414
+ let gap = smallest_ack - block.end - 1;
415
+ let ack_block = (block.end - 1) - block.start;
416
+
417
+ b.put_varint(gap)?;
418
+ b.put_varint(ack_block)?;
419
+
420
+ smallest_ack = block.start;
421
+ }
422
+
423
+ if let Some(ecn) = ecn_counts {
424
+ b.put_varint(ecn.ect0_count)?;
425
+ b.put_varint(ecn.ect1_count)?;
426
+ b.put_varint(ecn.ecn_ce_count)?;
427
+ }
428
+ },
429
+
430
+ Frame::ResetStream {
431
+ stream_id,
432
+ error_code,
433
+ final_size,
434
+ } => {
435
+ b.put_varint(0x04)?;
436
+
437
+ b.put_varint(*stream_id)?;
438
+ b.put_varint(*error_code)?;
439
+ b.put_varint(*final_size)?;
440
+ },
441
+
442
+ Frame::StopSending {
443
+ stream_id,
444
+ error_code,
445
+ } => {
446
+ b.put_varint(0x05)?;
447
+
448
+ b.put_varint(*stream_id)?;
449
+ b.put_varint(*error_code)?;
450
+ },
451
+
452
+ Frame::Crypto { data } => {
453
+ encode_crypto_header(data.off(), data.len() as u64, b)?;
454
+
455
+ b.put_bytes(data)?;
456
+ },
457
+
458
+ Frame::CryptoHeader { .. } => (),
459
+
460
+ Frame::NewToken { token } => {
461
+ b.put_varint(0x07)?;
462
+
463
+ b.put_varint(token.len() as u64)?;
464
+ b.put_bytes(token)?;
465
+ },
466
+
467
+ Frame::Stream { stream_id, data } => {
468
+ encode_stream_header(
469
+ *stream_id,
470
+ data.off(),
471
+ data.len() as u64,
472
+ data.fin(),
473
+ b,
474
+ )?;
475
+
476
+ b.put_bytes(data)?;
477
+ },
478
+
479
+ Frame::StreamHeader { .. } => (),
480
+
481
+ Frame::MaxData { max } => {
482
+ b.put_varint(0x10)?;
483
+
484
+ b.put_varint(*max)?;
485
+ },
486
+
487
+ Frame::MaxStreamData { stream_id, max } => {
488
+ b.put_varint(0x11)?;
489
+
490
+ b.put_varint(*stream_id)?;
491
+ b.put_varint(*max)?;
492
+ },
493
+
494
+ Frame::MaxStreamsBidi { max } => {
495
+ b.put_varint(0x12)?;
496
+
497
+ b.put_varint(*max)?;
498
+ },
499
+
500
+ Frame::MaxStreamsUni { max } => {
501
+ b.put_varint(0x13)?;
502
+
503
+ b.put_varint(*max)?;
504
+ },
505
+
506
+ Frame::DataBlocked { limit } => {
507
+ b.put_varint(0x14)?;
508
+
509
+ b.put_varint(*limit)?;
510
+ },
511
+
512
+ Frame::StreamDataBlocked { stream_id, limit } => {
513
+ b.put_varint(0x15)?;
514
+
515
+ b.put_varint(*stream_id)?;
516
+ b.put_varint(*limit)?;
517
+ },
518
+
519
+ Frame::StreamsBlockedBidi { limit } => {
520
+ b.put_varint(0x16)?;
521
+
522
+ b.put_varint(*limit)?;
523
+ },
524
+
525
+ Frame::StreamsBlockedUni { limit } => {
526
+ b.put_varint(0x17)?;
527
+
528
+ b.put_varint(*limit)?;
529
+ },
530
+
531
+ Frame::NewConnectionId {
532
+ seq_num,
533
+ retire_prior_to,
534
+ conn_id,
535
+ reset_token,
536
+ } => {
537
+ b.put_varint(0x18)?;
538
+
539
+ b.put_varint(*seq_num)?;
540
+ b.put_varint(*retire_prior_to)?;
541
+ b.put_u8(conn_id.len() as u8)?;
542
+ b.put_bytes(conn_id.as_ref())?;
543
+ b.put_bytes(reset_token.as_ref())?;
544
+ },
545
+
546
+ Frame::RetireConnectionId { seq_num } => {
547
+ b.put_varint(0x19)?;
548
+
549
+ b.put_varint(*seq_num)?;
550
+ },
551
+
552
+ Frame::PathChallenge { data } => {
553
+ b.put_varint(0x1a)?;
554
+
555
+ b.put_bytes(data.as_ref())?;
556
+ },
557
+
558
+ Frame::PathResponse { data } => {
559
+ b.put_varint(0x1b)?;
560
+
561
+ b.put_bytes(data.as_ref())?;
562
+ },
563
+
564
+ Frame::ConnectionClose {
565
+ error_code,
566
+ frame_type,
567
+ reason,
568
+ } => {
569
+ b.put_varint(0x1c)?;
570
+
571
+ b.put_varint(*error_code)?;
572
+ b.put_varint(*frame_type)?;
573
+ b.put_varint(reason.len() as u64)?;
574
+ b.put_bytes(reason.as_ref())?;
575
+ },
576
+
577
+ Frame::ApplicationClose { error_code, reason } => {
578
+ b.put_varint(0x1d)?;
579
+
580
+ b.put_varint(*error_code)?;
581
+ b.put_varint(reason.len() as u64)?;
582
+ b.put_bytes(reason.as_ref())?;
583
+ },
584
+
585
+ Frame::HandshakeDone => {
586
+ b.put_varint(0x1e)?;
587
+ },
588
+
589
+ Frame::Datagram { data } => {
590
+ encode_dgram_header(data.len() as u64, b)?;
591
+
592
+ b.put_bytes(data.as_ref())?;
593
+ },
594
+
595
+ Frame::DatagramHeader { .. } => (),
596
+ }
597
+
598
+ Ok(before - b.cap())
599
+ }
600
+
601
+ pub fn wire_len(&self) -> usize {
602
+ match self {
603
+ Frame::Padding { len } => *len,
604
+
605
+ Frame::Ping { .. } => 1,
606
+
607
+ Frame::ACK {
608
+ ack_delay,
609
+ ranges,
610
+ ecn_counts,
611
+ } => {
612
+ let mut it = ranges.iter().rev();
613
+
614
+ let first = it.next().unwrap();
615
+ let ack_block = (first.end - 1) - first.start;
616
+
617
+ let mut len = 1 + // frame type
618
+ octets::varint_len(first.end - 1) + // largest_ack
619
+ octets::varint_len(*ack_delay) + // ack_delay
620
+ octets::varint_len(it.len() as u64) + // block_count
621
+ octets::varint_len(ack_block); // first_block
622
+
623
+ let mut smallest_ack = first.start;
624
+
625
+ for block in it {
626
+ let gap = smallest_ack - block.end - 1;
627
+ let ack_block = (block.end - 1) - block.start;
628
+
629
+ len += octets::varint_len(gap) + // gap
630
+ octets::varint_len(ack_block); // ack_block
631
+
632
+ smallest_ack = block.start;
633
+ }
634
+
635
+ if let Some(ecn) = ecn_counts {
636
+ len += octets::varint_len(ecn.ect0_count) +
637
+ octets::varint_len(ecn.ect1_count) +
638
+ octets::varint_len(ecn.ecn_ce_count);
639
+ }
640
+
641
+ len
642
+ },
643
+
644
+ Frame::ResetStream {
645
+ stream_id,
646
+ error_code,
647
+ final_size,
648
+ } => {
649
+ 1 + // frame type
650
+ octets::varint_len(*stream_id) + // stream_id
651
+ octets::varint_len(*error_code) + // error_code
652
+ octets::varint_len(*final_size) // final_size
653
+ },
654
+
655
+ Frame::StopSending {
656
+ stream_id,
657
+ error_code,
658
+ } => {
659
+ 1 + // frame type
660
+ octets::varint_len(*stream_id) + // stream_id
661
+ octets::varint_len(*error_code) // error_code
662
+ },
663
+
664
+ Frame::Crypto { data } => {
665
+ 1 + // frame type
666
+ octets::varint_len(data.off()) + // offset
667
+ 2 + // length, always encode as 2-byte varint
668
+ data.len() // data
669
+ },
670
+
671
+ Frame::CryptoHeader { offset, length, .. } => {
672
+ 1 + // frame type
673
+ octets::varint_len(*offset) + // offset
674
+ 2 + // length, always encode as 2-byte varint
675
+ length // data
676
+ },
677
+
678
+ Frame::NewToken { token } => {
679
+ 1 + // frame type
680
+ octets::varint_len(token.len() as u64) + // token length
681
+ token.len() // token
682
+ },
683
+
684
+ Frame::Stream { stream_id, data } => {
685
+ 1 + // frame type
686
+ octets::varint_len(*stream_id) + // stream_id
687
+ octets::varint_len(data.off()) + // offset
688
+ 2 + // length, always encode as 2-byte varint
689
+ data.len() // data
690
+ },
691
+
692
+ Frame::StreamHeader {
693
+ stream_id,
694
+ offset,
695
+ length,
696
+ ..
697
+ } => {
698
+ 1 + // frame type
699
+ octets::varint_len(*stream_id) + // stream_id
700
+ octets::varint_len(*offset) + // offset
701
+ 2 + // length, always encode as 2-byte varint
702
+ length // data
703
+ },
704
+
705
+ Frame::MaxData { max } => {
706
+ 1 + // frame type
707
+ octets::varint_len(*max) // max
708
+ },
709
+
710
+ Frame::MaxStreamData { stream_id, max } => {
711
+ 1 + // frame type
712
+ octets::varint_len(*stream_id) + // stream_id
713
+ octets::varint_len(*max) // max
714
+ },
715
+
716
+ Frame::MaxStreamsBidi { max } => {
717
+ 1 + // frame type
718
+ octets::varint_len(*max) // max
719
+ },
720
+
721
+ Frame::MaxStreamsUni { max } => {
722
+ 1 + // frame type
723
+ octets::varint_len(*max) // max
724
+ },
725
+
726
+ Frame::DataBlocked { limit } => {
727
+ 1 + // frame type
728
+ octets::varint_len(*limit) // limit
729
+ },
730
+
731
+ Frame::StreamDataBlocked { stream_id, limit } => {
732
+ 1 + // frame type
733
+ octets::varint_len(*stream_id) + // stream_id
734
+ octets::varint_len(*limit) // limit
735
+ },
736
+
737
+ Frame::StreamsBlockedBidi { limit } => {
738
+ 1 + // frame type
739
+ octets::varint_len(*limit) // limit
740
+ },
741
+
742
+ Frame::StreamsBlockedUni { limit } => {
743
+ 1 + // frame type
744
+ octets::varint_len(*limit) // limit
745
+ },
746
+
747
+ Frame::NewConnectionId {
748
+ seq_num,
749
+ retire_prior_to,
750
+ conn_id,
751
+ reset_token,
752
+ } => {
753
+ 1 + // frame type
754
+ octets::varint_len(*seq_num) + // seq_num
755
+ octets::varint_len(*retire_prior_to) + // retire_prior_to
756
+ 1 + // conn_id length
757
+ conn_id.len() + // conn_id
758
+ reset_token.len() // reset_token
759
+ },
760
+
761
+ Frame::RetireConnectionId { seq_num } => {
762
+ 1 + // frame type
763
+ octets::varint_len(*seq_num) // seq_num
764
+ },
765
+
766
+ Frame::PathChallenge { .. } => {
767
+ 1 + // frame type
768
+ 8 // data
769
+ },
770
+
771
+ Frame::PathResponse { .. } => {
772
+ 1 + // frame type
773
+ 8 // data
774
+ },
775
+
776
+ Frame::ConnectionClose {
777
+ frame_type,
778
+ error_code,
779
+ reason,
780
+ ..
781
+ } => {
782
+ 1 + // frame type
783
+ octets::varint_len(*error_code) + // error_code
784
+ octets::varint_len(*frame_type) + // frame_type
785
+ octets::varint_len(reason.len() as u64) + // reason_len
786
+ reason.len() // reason
787
+ },
788
+
789
+ Frame::ApplicationClose { reason, error_code } => {
790
+ 1 + // frame type
791
+ octets::varint_len(*error_code) + // error_code
792
+ octets::varint_len(reason.len() as u64) + // reason_len
793
+ reason.len() // reason
794
+ },
795
+
796
+ Frame::HandshakeDone => {
797
+ 1 // frame type
798
+ },
799
+
800
+ Frame::Datagram { data } => {
801
+ 1 + // frame type
802
+ 2 + // length, always encode as 2-byte varint
803
+ data.len() // data
804
+ },
805
+
806
+ Frame::DatagramHeader { length } => {
807
+ 1 + // frame type
808
+ 2 + // length, always encode as 2-byte varint
809
+ *length // data
810
+ },
811
+ }
812
+ }
813
+
814
+ pub fn ack_eliciting(&self) -> bool {
815
+ // Any other frame is ack-eliciting (note the `!`).
816
+ !matches!(
817
+ self,
818
+ Frame::Padding { .. } |
819
+ Frame::ACK { .. } |
820
+ Frame::ApplicationClose { .. } |
821
+ Frame::ConnectionClose { .. }
822
+ )
823
+ }
824
+
825
+ pub fn probing(&self) -> bool {
826
+ matches!(
827
+ self,
828
+ Frame::Padding { .. } |
829
+ Frame::NewConnectionId { .. } |
830
+ Frame::PathChallenge { .. } |
831
+ Frame::PathResponse { .. }
832
+ )
833
+ }
834
+
835
+ #[cfg(feature = "qlog")]
836
+ pub fn to_qlog(&self) -> QuicFrame {
837
+ use qlog::events::ConnectionClosedFrameError;
838
+ use qlog::events::RawInfo;
839
+
840
+ match self {
841
+ Frame::Padding { len } => QuicFrame::Padding {
842
+ raw: Some(Box::new(RawInfo {
843
+ length: None,
844
+ payload_length: Some(*len as u64),
845
+ data: None,
846
+ })),
847
+ },
848
+
849
+ Frame::Ping { .. } => QuicFrame::Ping { raw: None },
850
+
851
+ Frame::ACK {
852
+ ack_delay,
853
+ ranges,
854
+ ecn_counts,
855
+ } => {
856
+ let ack_ranges = ranges
857
+ .iter()
858
+ .map(|r| AckRange::new(r.start, r.end - 1))
859
+ .collect();
860
+
861
+ let (ect0, ect1, ce) = match ecn_counts {
862
+ Some(ecn) => (
863
+ Some(ecn.ect0_count),
864
+ Some(ecn.ect1_count),
865
+ Some(ecn.ecn_ce_count),
866
+ ),
867
+
868
+ None => (None, None, None),
869
+ };
870
+
871
+ QuicFrame::Ack {
872
+ ack_delay: Some(*ack_delay as f32 / 1000.0),
873
+ acked_ranges: Some(ack_ranges),
874
+ ect1,
875
+ ect0,
876
+ ce,
877
+ raw: None,
878
+ }
879
+ },
880
+
881
+ Frame::ResetStream {
882
+ stream_id,
883
+ error_code,
884
+ final_size,
885
+ } => QuicFrame::ResetStream {
886
+ stream_id: *stream_id,
887
+ error: qlog::events::ApplicationError::Unknown,
888
+ error_code: Some(*error_code),
889
+ final_size: *final_size,
890
+ raw: None,
891
+ },
892
+
893
+ Frame::StopSending {
894
+ stream_id,
895
+ error_code,
896
+ } => QuicFrame::StopSending {
897
+ stream_id: *stream_id,
898
+ error: qlog::events::ApplicationError::Unknown,
899
+ error_code: Some(*error_code),
900
+ raw: None,
901
+ },
902
+
903
+ Frame::Crypto { data } => QuicFrame::Crypto {
904
+ offset: data.off(),
905
+ raw: Some(Box::new(RawInfo {
906
+ length: None,
907
+ payload_length: Some(data.len() as u64),
908
+ data: None,
909
+ })),
910
+ },
911
+
912
+ Frame::CryptoHeader { offset, length } => QuicFrame::Crypto {
913
+ offset: *offset,
914
+ raw: Some(Box::new(RawInfo {
915
+ length: None,
916
+ payload_length: Some(*length as u64),
917
+ data: None,
918
+ })),
919
+ },
920
+
921
+ Frame::NewToken { token } => QuicFrame::NewToken {
922
+ token: qlog::Token {
923
+ // TODO: pick the token type some how
924
+ ty: Some(qlog::TokenType::Retry),
925
+ raw: Some(RawInfo {
926
+ data: qlog::HexSlice::maybe_string(Some(token))
927
+ .map(Box::new),
928
+ length: Some(token.len() as u64),
929
+ payload_length: None,
930
+ }),
931
+ details: None,
932
+ },
933
+ raw: None,
934
+ },
935
+
936
+ Frame::Stream { stream_id, data } => QuicFrame::Stream {
937
+ stream_id: *stream_id,
938
+ offset: Some(data.off()),
939
+ fin: data.fin().then_some(true),
940
+ raw: Some(Box::new(RawInfo {
941
+ length: None,
942
+ payload_length: Some(data.len() as u64),
943
+ data: None,
944
+ })),
945
+ },
946
+
947
+ Frame::StreamHeader {
948
+ stream_id,
949
+ offset,
950
+ length,
951
+ fin,
952
+ } => QuicFrame::Stream {
953
+ stream_id: *stream_id,
954
+ offset: Some(*offset),
955
+ fin: fin.then(|| true),
956
+ raw: Some(Box::new(RawInfo {
957
+ length: None,
958
+ payload_length: Some(*length as u64),
959
+ data: None,
960
+ })),
961
+ },
962
+
963
+ Frame::MaxData { max } => QuicFrame::MaxData {
964
+ maximum: *max,
965
+ raw: None,
966
+ },
967
+
968
+ Frame::MaxStreamData { stream_id, max } => QuicFrame::MaxStreamData {
969
+ stream_id: *stream_id,
970
+ maximum: *max,
971
+ raw: None,
972
+ },
973
+
974
+ Frame::MaxStreamsBidi { max } => QuicFrame::MaxStreams {
975
+ stream_type: StreamType::Bidirectional,
976
+ maximum: *max,
977
+ raw: None,
978
+ },
979
+
980
+ Frame::MaxStreamsUni { max } => QuicFrame::MaxStreams {
981
+ stream_type: StreamType::Unidirectional,
982
+ maximum: *max,
983
+ raw: None,
984
+ },
985
+
986
+ Frame::DataBlocked { limit } => QuicFrame::DataBlocked {
987
+ limit: *limit,
988
+ raw: None,
989
+ },
990
+
991
+ Frame::StreamDataBlocked { stream_id, limit } =>
992
+ QuicFrame::StreamDataBlocked {
993
+ stream_id: *stream_id,
994
+ limit: *limit,
995
+ raw: None,
996
+ },
997
+
998
+ Frame::StreamsBlockedBidi { limit } => QuicFrame::StreamsBlocked {
999
+ stream_type: StreamType::Bidirectional,
1000
+ limit: *limit,
1001
+ raw: None,
1002
+ },
1003
+
1004
+ Frame::StreamsBlockedUni { limit } => QuicFrame::StreamsBlocked {
1005
+ stream_type: StreamType::Unidirectional,
1006
+ limit: *limit,
1007
+ raw: None,
1008
+ },
1009
+
1010
+ Frame::NewConnectionId {
1011
+ seq_num,
1012
+ retire_prior_to,
1013
+ conn_id,
1014
+ reset_token,
1015
+ } => QuicFrame::NewConnectionId {
1016
+ sequence_number: *seq_num,
1017
+ retire_prior_to: *retire_prior_to,
1018
+ connection_id_length: Some(conn_id.len() as u8),
1019
+ connection_id: format!("{}", qlog::HexSlice::new(conn_id)),
1020
+ stateless_reset_token: qlog::HexSlice::maybe_string(Some(
1021
+ reset_token,
1022
+ )),
1023
+ raw: None,
1024
+ },
1025
+
1026
+ Frame::RetireConnectionId { seq_num } =>
1027
+ QuicFrame::RetireConnectionId {
1028
+ sequence_number: *seq_num,
1029
+ raw: None,
1030
+ },
1031
+
1032
+ Frame::PathChallenge { .. } => QuicFrame::PathChallenge {
1033
+ data: None,
1034
+ raw: None,
1035
+ },
1036
+
1037
+ Frame::PathResponse { .. } => QuicFrame::PathResponse {
1038
+ data: None,
1039
+ raw: None,
1040
+ },
1041
+
1042
+ Frame::ConnectionClose {
1043
+ error_code, reason, ..
1044
+ } => QuicFrame::ConnectionClose {
1045
+ // TODO: use actual variant not unknown
1046
+ error: Some(ConnectionClosedFrameError::TransportError(
1047
+ qlog::events::quic::TransportError::Unknown,
1048
+ )),
1049
+ error_space: Some(ErrorSpace::Transport),
1050
+ error_code: Some(*error_code),
1051
+ reason: Some(String::from_utf8_lossy(reason).into_owned()),
1052
+ reason_bytes: None,
1053
+ trigger_frame_type: None, // don't know trigger type
1054
+ },
1055
+
1056
+ Frame::ApplicationClose { error_code, reason } => {
1057
+ QuicFrame::ConnectionClose {
1058
+ error: Some(ConnectionClosedFrameError::ApplicationError(
1059
+ qlog::events::ApplicationError::Unknown,
1060
+ )),
1061
+ error_space: Some(ErrorSpace::Application),
1062
+ error_code: Some(*error_code),
1063
+ reason: Some(String::from_utf8_lossy(reason).into_owned()),
1064
+ reason_bytes: None,
1065
+ trigger_frame_type: None, // don't know trigger type
1066
+ }
1067
+ },
1068
+
1069
+ Frame::HandshakeDone => QuicFrame::HandshakeDone { raw: None },
1070
+
1071
+ Frame::Datagram { data } => QuicFrame::Datagram {
1072
+ raw: Some(Box::new(RawInfo {
1073
+ length: None,
1074
+ payload_length: Some(data.len() as u64),
1075
+ data: None,
1076
+ })),
1077
+ },
1078
+
1079
+ Frame::DatagramHeader { length } => QuicFrame::Datagram {
1080
+ raw: Some(Box::new(RawInfo {
1081
+ length: None,
1082
+ payload_length: Some(*length as u64),
1083
+ data: None,
1084
+ })),
1085
+ },
1086
+ }
1087
+ }
1088
+ }
1089
+
1090
+ impl std::fmt::Debug for Frame {
1091
+ fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1092
+ match self {
1093
+ Frame::Padding { len } => {
1094
+ write!(f, "PADDING len={len}")?;
1095
+ },
1096
+
1097
+ Frame::Ping { mtu_probe } => {
1098
+ write!(f, "PING mtu_probe={mtu_probe:?}")?;
1099
+ },
1100
+
1101
+ Frame::ACK {
1102
+ ack_delay,
1103
+ ranges,
1104
+ ecn_counts,
1105
+ } => {
1106
+ write!(
1107
+ f,
1108
+ "ACK delay={ack_delay} blocks={ranges:?} ecn_counts={ecn_counts:?}"
1109
+ )?;
1110
+ },
1111
+
1112
+ Frame::ResetStream {
1113
+ stream_id,
1114
+ error_code,
1115
+ final_size,
1116
+ } => {
1117
+ write!(
1118
+ f,
1119
+ "RESET_STREAM stream={stream_id} err={error_code:x} size={final_size}"
1120
+ )?;
1121
+ },
1122
+
1123
+ Frame::StopSending {
1124
+ stream_id,
1125
+ error_code,
1126
+ } => {
1127
+ write!(f, "STOP_SENDING stream={stream_id} err={error_code:x}")?;
1128
+ },
1129
+
1130
+ Frame::Crypto { data } => {
1131
+ write!(f, "CRYPTO off={} len={}", data.off(), data.len())?;
1132
+ },
1133
+
1134
+ Frame::CryptoHeader { offset, length } => {
1135
+ write!(f, "CRYPTO off={offset} len={length}")?;
1136
+ },
1137
+
1138
+ Frame::NewToken { token } => {
1139
+ write!(f, "NEW_TOKEN len={}", token.len())?;
1140
+ },
1141
+
1142
+ Frame::Stream { stream_id, data } => {
1143
+ write!(
1144
+ f,
1145
+ "STREAM id={} off={} len={} fin={}",
1146
+ stream_id,
1147
+ data.off(),
1148
+ data.len(),
1149
+ data.fin()
1150
+ )?;
1151
+ },
1152
+
1153
+ Frame::StreamHeader {
1154
+ stream_id,
1155
+ offset,
1156
+ length,
1157
+ fin,
1158
+ } => {
1159
+ write!(
1160
+ f,
1161
+ "STREAM id={stream_id} off={offset} len={length} fin={fin}"
1162
+ )?;
1163
+ },
1164
+
1165
+ Frame::MaxData { max } => {
1166
+ write!(f, "MAX_DATA max={max}")?;
1167
+ },
1168
+
1169
+ Frame::MaxStreamData { stream_id, max } => {
1170
+ write!(f, "MAX_STREAM_DATA stream={stream_id} max={max}")?;
1171
+ },
1172
+
1173
+ Frame::MaxStreamsBidi { max } => {
1174
+ write!(f, "MAX_STREAMS type=bidi max={max}")?;
1175
+ },
1176
+
1177
+ Frame::MaxStreamsUni { max } => {
1178
+ write!(f, "MAX_STREAMS type=uni max={max}")?;
1179
+ },
1180
+
1181
+ Frame::DataBlocked { limit } => {
1182
+ write!(f, "DATA_BLOCKED limit={limit}")?;
1183
+ },
1184
+
1185
+ Frame::StreamDataBlocked { stream_id, limit } => {
1186
+ write!(
1187
+ f,
1188
+ "STREAM_DATA_BLOCKED stream={stream_id} limit={limit}"
1189
+ )?;
1190
+ },
1191
+
1192
+ Frame::StreamsBlockedBidi { limit } => {
1193
+ write!(f, "STREAMS_BLOCKED type=bidi limit={limit}")?;
1194
+ },
1195
+
1196
+ Frame::StreamsBlockedUni { limit } => {
1197
+ write!(f, "STREAMS_BLOCKED type=uni limit={limit}")?;
1198
+ },
1199
+
1200
+ Frame::NewConnectionId {
1201
+ seq_num,
1202
+ retire_prior_to,
1203
+ conn_id,
1204
+ reset_token,
1205
+ } => {
1206
+ write!(
1207
+ f,
1208
+ "NEW_CONNECTION_ID seq_num={seq_num} retire_prior_to={retire_prior_to} conn_id={conn_id:02x?} reset_token={reset_token:02x?}",
1209
+ )?;
1210
+ },
1211
+
1212
+ Frame::RetireConnectionId { seq_num } => {
1213
+ write!(f, "RETIRE_CONNECTION_ID seq_num={seq_num}")?;
1214
+ },
1215
+
1216
+ Frame::PathChallenge { data } => {
1217
+ write!(f, "PATH_CHALLENGE data={data:02x?}")?;
1218
+ },
1219
+
1220
+ Frame::PathResponse { data } => {
1221
+ write!(f, "PATH_RESPONSE data={data:02x?}")?;
1222
+ },
1223
+
1224
+ Frame::ConnectionClose {
1225
+ error_code,
1226
+ frame_type,
1227
+ reason,
1228
+ } => {
1229
+ write!(
1230
+ f,
1231
+ "CONNECTION_CLOSE err={error_code:x} frame={frame_type:x} reason={reason:x?}"
1232
+ )?;
1233
+ },
1234
+
1235
+ Frame::ApplicationClose { error_code, reason } => {
1236
+ write!(
1237
+ f,
1238
+ "APPLICATION_CLOSE err={error_code:x} reason={reason:x?}"
1239
+ )?;
1240
+ },
1241
+
1242
+ Frame::HandshakeDone => {
1243
+ write!(f, "HANDSHAKE_DONE")?;
1244
+ },
1245
+
1246
+ Frame::Datagram { data } => {
1247
+ write!(f, "DATAGRAM len={}", data.len())?;
1248
+ },
1249
+
1250
+ Frame::DatagramHeader { length } => {
1251
+ write!(f, "DATAGRAM len={length}")?;
1252
+ },
1253
+ }
1254
+
1255
+ Ok(())
1256
+ }
1257
+ }
1258
+
1259
+ fn parse_ack_frame(ty: u64, b: &mut octets::Octets) -> Result<Frame> {
1260
+ let first = ty as u8;
1261
+
1262
+ let largest_ack = b.get_varint()?;
1263
+ let ack_delay = b.get_varint()?;
1264
+ let block_count = b.get_varint()?;
1265
+ let ack_block = b.get_varint()?;
1266
+
1267
+ if largest_ack < ack_block {
1268
+ return Err(Error::InvalidFrame);
1269
+ }
1270
+
1271
+ let mut smallest_ack = largest_ack - ack_block;
1272
+
1273
+ let mut ranges = ranges::RangeSet::default();
1274
+
1275
+ ranges.insert(smallest_ack..largest_ack + 1);
1276
+
1277
+ for _i in 0..block_count {
1278
+ let gap = b.get_varint()?;
1279
+
1280
+ if smallest_ack < 2 + gap {
1281
+ return Err(Error::InvalidFrame);
1282
+ }
1283
+
1284
+ let largest_ack = (smallest_ack - gap) - 2;
1285
+ let ack_block = b.get_varint()?;
1286
+
1287
+ if largest_ack < ack_block {
1288
+ return Err(Error::InvalidFrame);
1289
+ }
1290
+
1291
+ smallest_ack = largest_ack - ack_block;
1292
+
1293
+ ranges.insert(smallest_ack..largest_ack + 1);
1294
+ }
1295
+
1296
+ let ecn_counts = if first & 0x01 != 0 {
1297
+ let ecn = EcnCounts {
1298
+ ect0_count: b.get_varint()?,
1299
+ ect1_count: b.get_varint()?,
1300
+ ecn_ce_count: b.get_varint()?,
1301
+ };
1302
+
1303
+ Some(ecn)
1304
+ } else {
1305
+ None
1306
+ };
1307
+
1308
+ Ok(Frame::ACK {
1309
+ ack_delay,
1310
+ ranges,
1311
+ ecn_counts,
1312
+ })
1313
+ }
1314
+
1315
+ pub fn encode_crypto_header(
1316
+ offset: u64, length: u64, b: &mut octets::OctetsMut,
1317
+ ) -> Result<()> {
1318
+ b.put_varint(0x06)?;
1319
+
1320
+ b.put_varint(offset)?;
1321
+
1322
+ // Always encode length field as 2-byte varint.
1323
+ b.put_varint_with_len(length, 2)?;
1324
+
1325
+ Ok(())
1326
+ }
1327
+
1328
+ pub fn encode_stream_header(
1329
+ stream_id: u64, offset: u64, length: u64, fin: bool,
1330
+ b: &mut octets::OctetsMut,
1331
+ ) -> Result<()> {
1332
+ let mut ty: u8 = 0x08;
1333
+
1334
+ // Always encode offset.
1335
+ ty |= 0x04;
1336
+
1337
+ // Always encode length.
1338
+ ty |= 0x02;
1339
+
1340
+ if fin {
1341
+ ty |= 0x01;
1342
+ }
1343
+
1344
+ b.put_varint(u64::from(ty))?;
1345
+
1346
+ b.put_varint(stream_id)?;
1347
+ b.put_varint(offset)?;
1348
+
1349
+ // Always encode length field as 2-byte varint.
1350
+ b.put_varint_with_len(length, 2)?;
1351
+
1352
+ Ok(())
1353
+ }
1354
+
1355
+ pub fn encode_dgram_header(length: u64, b: &mut octets::OctetsMut) -> Result<()> {
1356
+ let mut ty: u8 = 0x30;
1357
+
1358
+ // Always encode length
1359
+ ty |= 0x01;
1360
+
1361
+ b.put_varint(u64::from(ty))?;
1362
+
1363
+ // Always encode length field as 2-byte varint.
1364
+ b.put_varint_with_len(length, 2)?;
1365
+
1366
+ Ok(())
1367
+ }
1368
+
1369
+ fn parse_stream_frame(ty: u64, b: &mut octets::Octets) -> Result<Frame> {
1370
+ let first = ty as u8;
1371
+
1372
+ let stream_id = b.get_varint()?;
1373
+
1374
+ let offset = if first & 0x04 != 0 {
1375
+ b.get_varint()?
1376
+ } else {
1377
+ 0
1378
+ };
1379
+
1380
+ let len = if first & 0x02 != 0 {
1381
+ b.get_varint()? as usize
1382
+ } else {
1383
+ b.cap()
1384
+ };
1385
+
1386
+ if offset + len as u64 >= MAX_STREAM_SIZE {
1387
+ return Err(Error::InvalidFrame);
1388
+ }
1389
+
1390
+ let fin = first & 0x01 != 0;
1391
+
1392
+ let data = b.get_bytes(len)?;
1393
+ let data = <RangeBuf>::from(data.as_ref(), offset, fin);
1394
+
1395
+ Ok(Frame::Stream { stream_id, data })
1396
+ }
1397
+
1398
+ fn parse_datagram_frame(ty: u64, b: &mut octets::Octets) -> Result<Frame> {
1399
+ let first = ty as u8;
1400
+
1401
+ let len = if first & 0x01 != 0 {
1402
+ b.get_varint()? as usize
1403
+ } else {
1404
+ b.cap()
1405
+ };
1406
+
1407
+ let data = b.get_bytes(len)?;
1408
+
1409
+ Ok(Frame::Datagram {
1410
+ data: Vec::from(data.buf()),
1411
+ })
1412
+ }
1413
+
1414
+ #[cfg(test)]
1415
+ mod tests {
1416
+ use super::*;
1417
+
1418
+ #[test]
1419
+ fn padding() {
1420
+ let mut d = [42; 128];
1421
+
1422
+ let frame = Frame::Padding { len: 128 };
1423
+
1424
+ let wire_len = {
1425
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1426
+ frame.to_bytes(&mut b).unwrap()
1427
+ };
1428
+
1429
+ assert_eq!(wire_len, 128);
1430
+
1431
+ let mut b = octets::Octets::with_slice(&d);
1432
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1433
+
1434
+ let mut b = octets::Octets::with_slice(&d);
1435
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_ok());
1436
+
1437
+ let mut b = octets::Octets::with_slice(&d);
1438
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1439
+
1440
+ let mut b = octets::Octets::with_slice(&d);
1441
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_ok());
1442
+ }
1443
+
1444
+ #[test]
1445
+ fn ping() {
1446
+ let mut d = [42; 128];
1447
+
1448
+ let frame = Frame::Ping { mtu_probe: None };
1449
+
1450
+ let wire_len = {
1451
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1452
+ frame.to_bytes(&mut b).unwrap()
1453
+ };
1454
+
1455
+ assert_eq!(wire_len, 1);
1456
+ assert_eq!(&d[..wire_len], [0x01_u8]);
1457
+
1458
+ let mut b = octets::Octets::with_slice(&d);
1459
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1460
+
1461
+ let mut b = octets::Octets::with_slice(&d);
1462
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1463
+
1464
+ let mut b = octets::Octets::with_slice(&d);
1465
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_ok());
1466
+
1467
+ let mut b = octets::Octets::with_slice(&d);
1468
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_ok());
1469
+ }
1470
+
1471
+ #[test]
1472
+ fn ack() {
1473
+ let mut d = [42; 128];
1474
+
1475
+ let mut ranges = ranges::RangeSet::default();
1476
+ ranges.insert(4..7);
1477
+ ranges.insert(9..12);
1478
+ ranges.insert(15..19);
1479
+ ranges.insert(3000..5000);
1480
+
1481
+ let frame = Frame::ACK {
1482
+ ack_delay: 874_656_534,
1483
+ ranges,
1484
+ ecn_counts: None,
1485
+ };
1486
+
1487
+ let wire_len = {
1488
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1489
+ frame.to_bytes(&mut b).unwrap()
1490
+ };
1491
+
1492
+ assert_eq!(wire_len, 17);
1493
+
1494
+ let mut b = octets::Octets::with_slice(&d);
1495
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1496
+
1497
+ let mut b = octets::Octets::with_slice(&d);
1498
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_ok());
1499
+
1500
+ let mut b = octets::Octets::with_slice(&d);
1501
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_err());
1502
+
1503
+ let mut b = octets::Octets::with_slice(&d);
1504
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_ok());
1505
+ }
1506
+
1507
+ #[test]
1508
+ fn ack_ecn() {
1509
+ let mut d = [42; 128];
1510
+
1511
+ let mut ranges = ranges::RangeSet::default();
1512
+ ranges.insert(4..7);
1513
+ ranges.insert(9..12);
1514
+ ranges.insert(15..19);
1515
+ ranges.insert(3000..5000);
1516
+
1517
+ let ecn_counts = Some(EcnCounts {
1518
+ ect0_count: 100,
1519
+ ect1_count: 200,
1520
+ ecn_ce_count: 300,
1521
+ });
1522
+
1523
+ let frame = Frame::ACK {
1524
+ ack_delay: 874_656_534,
1525
+ ranges,
1526
+ ecn_counts,
1527
+ };
1528
+
1529
+ let wire_len = {
1530
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1531
+ frame.to_bytes(&mut b).unwrap()
1532
+ };
1533
+
1534
+ assert_eq!(wire_len, 23);
1535
+
1536
+ let mut b = octets::Octets::with_slice(&d);
1537
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1538
+
1539
+ let mut b = octets::Octets::with_slice(&d);
1540
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_ok());
1541
+
1542
+ let mut b = octets::Octets::with_slice(&d);
1543
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_err());
1544
+
1545
+ let mut b = octets::Octets::with_slice(&d);
1546
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_ok());
1547
+ }
1548
+
1549
+ #[test]
1550
+ fn reset_stream() {
1551
+ let mut d = [42; 128];
1552
+
1553
+ let frame = Frame::ResetStream {
1554
+ stream_id: 123_213,
1555
+ error_code: 21_123_767,
1556
+ final_size: 21_123_767,
1557
+ };
1558
+
1559
+ let wire_len = {
1560
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1561
+ frame.to_bytes(&mut b).unwrap()
1562
+ };
1563
+
1564
+ assert_eq!(wire_len, 13);
1565
+
1566
+ let mut b = octets::Octets::with_slice(&d);
1567
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1568
+
1569
+ let mut b = octets::Octets::with_slice(&d);
1570
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1571
+
1572
+ let mut b = octets::Octets::with_slice(&d);
1573
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1574
+
1575
+ let mut b = octets::Octets::with_slice(&d);
1576
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1577
+ }
1578
+
1579
+ #[test]
1580
+ fn stop_sending() {
1581
+ let mut d = [42; 128];
1582
+
1583
+ let frame = Frame::StopSending {
1584
+ stream_id: 123_213,
1585
+ error_code: 15_352,
1586
+ };
1587
+
1588
+ let wire_len = {
1589
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1590
+ frame.to_bytes(&mut b).unwrap()
1591
+ };
1592
+
1593
+ assert_eq!(wire_len, 7);
1594
+
1595
+ let mut b = octets::Octets::with_slice(&d);
1596
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1597
+
1598
+ let mut b = octets::Octets::with_slice(&d);
1599
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1600
+
1601
+ let mut b = octets::Octets::with_slice(&d);
1602
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1603
+
1604
+ let mut b = octets::Octets::with_slice(&d);
1605
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1606
+ }
1607
+
1608
+ #[test]
1609
+ fn crypto() {
1610
+ let mut d = [42; 128];
1611
+
1612
+ let data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
1613
+
1614
+ let frame = Frame::Crypto {
1615
+ data: <RangeBuf>::from(&data, 1230976, false),
1616
+ };
1617
+
1618
+ let wire_len = {
1619
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1620
+ frame.to_bytes(&mut b).unwrap()
1621
+ };
1622
+
1623
+ assert_eq!(wire_len, 19);
1624
+
1625
+ let mut b = octets::Octets::with_slice(&d);
1626
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1627
+
1628
+ let mut b = octets::Octets::with_slice(&d);
1629
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_ok());
1630
+
1631
+ let mut b = octets::Octets::with_slice(&d);
1632
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_err());
1633
+
1634
+ let mut b = octets::Octets::with_slice(&d);
1635
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_ok());
1636
+ }
1637
+
1638
+ #[test]
1639
+ fn new_token() {
1640
+ let mut d = [42; 128];
1641
+
1642
+ let frame = Frame::NewToken {
1643
+ token: Vec::from("this is a token"),
1644
+ };
1645
+
1646
+ let wire_len = {
1647
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1648
+ frame.to_bytes(&mut b).unwrap()
1649
+ };
1650
+
1651
+ assert_eq!(wire_len, 17);
1652
+
1653
+ let mut b = octets::Octets::with_slice(&d);
1654
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1655
+
1656
+ let mut b = octets::Octets::with_slice(&d);
1657
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1658
+
1659
+ let mut b = octets::Octets::with_slice(&d);
1660
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_err());
1661
+
1662
+ let mut b = octets::Octets::with_slice(&d);
1663
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1664
+ }
1665
+
1666
+ #[test]
1667
+ fn stream() {
1668
+ let mut d = [42; 128];
1669
+
1670
+ let data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
1671
+
1672
+ let frame = Frame::Stream {
1673
+ stream_id: 32,
1674
+ data: <RangeBuf>::from(&data, 1230976, true),
1675
+ };
1676
+
1677
+ let wire_len = {
1678
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1679
+ frame.to_bytes(&mut b).unwrap()
1680
+ };
1681
+
1682
+ assert_eq!(wire_len, 20);
1683
+
1684
+ let mut b = octets::Octets::with_slice(&d);
1685
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1686
+
1687
+ let mut b = octets::Octets::with_slice(&d);
1688
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1689
+
1690
+ let mut b = octets::Octets::with_slice(&d);
1691
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1692
+
1693
+ let mut b = octets::Octets::with_slice(&d);
1694
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1695
+ }
1696
+
1697
+ #[test]
1698
+ fn stream_too_big() {
1699
+ let mut d = [42; 128];
1700
+
1701
+ let data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
1702
+
1703
+ let frame = Frame::Stream {
1704
+ stream_id: 32,
1705
+ data: <RangeBuf>::from(&data, MAX_STREAM_SIZE - 11, true),
1706
+ };
1707
+
1708
+ let wire_len = {
1709
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1710
+ frame.to_bytes(&mut b).unwrap()
1711
+ };
1712
+
1713
+ assert_eq!(wire_len, 24);
1714
+
1715
+ let mut b = octets::Octets::with_slice(&d);
1716
+ assert_eq!(
1717
+ Frame::from_bytes(&mut b, packet::Type::Short),
1718
+ Err(Error::InvalidFrame)
1719
+ );
1720
+ }
1721
+
1722
+ #[test]
1723
+ fn max_data() {
1724
+ let mut d = [42; 128];
1725
+
1726
+ let frame = Frame::MaxData { max: 128_318_273 };
1727
+
1728
+ let wire_len = {
1729
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1730
+ frame.to_bytes(&mut b).unwrap()
1731
+ };
1732
+
1733
+ assert_eq!(wire_len, 5);
1734
+
1735
+ let mut b = octets::Octets::with_slice(&d);
1736
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1737
+
1738
+ let mut b = octets::Octets::with_slice(&d);
1739
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1740
+
1741
+ let mut b = octets::Octets::with_slice(&d);
1742
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1743
+
1744
+ let mut b = octets::Octets::with_slice(&d);
1745
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1746
+ }
1747
+
1748
+ #[test]
1749
+ fn max_stream_data() {
1750
+ let mut d = [42; 128];
1751
+
1752
+ let frame = Frame::MaxStreamData {
1753
+ stream_id: 12_321,
1754
+ max: 128_318_273,
1755
+ };
1756
+
1757
+ let wire_len = {
1758
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1759
+ frame.to_bytes(&mut b).unwrap()
1760
+ };
1761
+
1762
+ assert_eq!(wire_len, 7);
1763
+
1764
+ let mut b = octets::Octets::with_slice(&d);
1765
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1766
+
1767
+ let mut b = octets::Octets::with_slice(&d);
1768
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1769
+
1770
+ let mut b = octets::Octets::with_slice(&d);
1771
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1772
+
1773
+ let mut b = octets::Octets::with_slice(&d);
1774
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1775
+ }
1776
+
1777
+ #[test]
1778
+ fn max_streams_bidi() {
1779
+ let mut d = [42; 128];
1780
+
1781
+ let frame = Frame::MaxStreamsBidi { max: 128_318_273 };
1782
+
1783
+ let wire_len = {
1784
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1785
+ frame.to_bytes(&mut b).unwrap()
1786
+ };
1787
+
1788
+ assert_eq!(wire_len, 5);
1789
+
1790
+ let mut b = octets::Octets::with_slice(&d);
1791
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1792
+
1793
+ let mut b = octets::Octets::with_slice(&d);
1794
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1795
+
1796
+ let mut b = octets::Octets::with_slice(&d);
1797
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1798
+
1799
+ let mut b = octets::Octets::with_slice(&d);
1800
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1801
+ }
1802
+
1803
+ #[test]
1804
+ fn max_streams_uni() {
1805
+ let mut d = [42; 128];
1806
+
1807
+ let frame = Frame::MaxStreamsUni { max: 128_318_273 };
1808
+
1809
+ let wire_len = {
1810
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1811
+ frame.to_bytes(&mut b).unwrap()
1812
+ };
1813
+
1814
+ assert_eq!(wire_len, 5);
1815
+
1816
+ let mut b = octets::Octets::with_slice(&d);
1817
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1818
+
1819
+ let mut b = octets::Octets::with_slice(&d);
1820
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1821
+
1822
+ let mut b = octets::Octets::with_slice(&d);
1823
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1824
+
1825
+ let mut b = octets::Octets::with_slice(&d);
1826
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1827
+ }
1828
+
1829
+ #[test]
1830
+ fn data_blocked() {
1831
+ let mut d = [42; 128];
1832
+
1833
+ let frame = Frame::DataBlocked { limit: 128_318_273 };
1834
+
1835
+ let wire_len = {
1836
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1837
+ frame.to_bytes(&mut b).unwrap()
1838
+ };
1839
+
1840
+ assert_eq!(wire_len, 5);
1841
+
1842
+ let mut b = octets::Octets::with_slice(&d);
1843
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1844
+
1845
+ let mut b = octets::Octets::with_slice(&d);
1846
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1847
+
1848
+ let mut b = octets::Octets::with_slice(&d);
1849
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1850
+
1851
+ let mut b = octets::Octets::with_slice(&d);
1852
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1853
+ }
1854
+
1855
+ #[test]
1856
+ fn stream_data_blocked() {
1857
+ let mut d = [42; 128];
1858
+
1859
+ let frame = Frame::StreamDataBlocked {
1860
+ stream_id: 12_321,
1861
+ limit: 128_318_273,
1862
+ };
1863
+
1864
+ let wire_len = {
1865
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1866
+ frame.to_bytes(&mut b).unwrap()
1867
+ };
1868
+
1869
+ assert_eq!(wire_len, 7);
1870
+
1871
+ let mut b = octets::Octets::with_slice(&d);
1872
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1873
+
1874
+ let mut b = octets::Octets::with_slice(&d);
1875
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1876
+
1877
+ let mut b = octets::Octets::with_slice(&d);
1878
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1879
+
1880
+ let mut b = octets::Octets::with_slice(&d);
1881
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1882
+ }
1883
+
1884
+ #[test]
1885
+ fn streams_blocked_bidi() {
1886
+ let mut d = [42; 128];
1887
+
1888
+ let frame = Frame::StreamsBlockedBidi { limit: 128_318_273 };
1889
+
1890
+ let wire_len = {
1891
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1892
+ frame.to_bytes(&mut b).unwrap()
1893
+ };
1894
+
1895
+ assert_eq!(wire_len, 5);
1896
+
1897
+ let mut b = octets::Octets::with_slice(&d);
1898
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1899
+
1900
+ let mut b = octets::Octets::with_slice(&d);
1901
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1902
+
1903
+ let mut b = octets::Octets::with_slice(&d);
1904
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1905
+
1906
+ let mut b = octets::Octets::with_slice(&d);
1907
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1908
+ }
1909
+
1910
+ #[test]
1911
+ fn streams_blocked_uni() {
1912
+ let mut d = [42; 128];
1913
+
1914
+ let frame = Frame::StreamsBlockedUni { limit: 128_318_273 };
1915
+
1916
+ let wire_len = {
1917
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1918
+ frame.to_bytes(&mut b).unwrap()
1919
+ };
1920
+
1921
+ assert_eq!(wire_len, 5);
1922
+
1923
+ let mut b = octets::Octets::with_slice(&d);
1924
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1925
+
1926
+ let mut b = octets::Octets::with_slice(&d);
1927
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1928
+
1929
+ let mut b = octets::Octets::with_slice(&d);
1930
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1931
+
1932
+ let mut b = octets::Octets::with_slice(&d);
1933
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1934
+ }
1935
+
1936
+ #[test]
1937
+ fn new_connection_id() {
1938
+ let mut d = [42; 128];
1939
+
1940
+ let frame = Frame::NewConnectionId {
1941
+ seq_num: 123_213,
1942
+ retire_prior_to: 122_211,
1943
+ conn_id: vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
1944
+ reset_token: [0x42; 16],
1945
+ };
1946
+
1947
+ let wire_len = {
1948
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1949
+ frame.to_bytes(&mut b).unwrap()
1950
+ };
1951
+
1952
+ assert_eq!(wire_len, 41);
1953
+
1954
+ let mut b = octets::Octets::with_slice(&d);
1955
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1956
+
1957
+ let mut b = octets::Octets::with_slice(&d);
1958
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
1959
+
1960
+ let mut b = octets::Octets::with_slice(&d);
1961
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1962
+
1963
+ let mut b = octets::Octets::with_slice(&d);
1964
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1965
+ }
1966
+
1967
+ #[test]
1968
+ fn retire_connection_id() {
1969
+ let mut d = [42; 128];
1970
+
1971
+ let frame = Frame::RetireConnectionId { seq_num: 123_213 };
1972
+
1973
+ let wire_len = {
1974
+ let mut b = octets::OctetsMut::with_slice(&mut d);
1975
+ frame.to_bytes(&mut b).unwrap()
1976
+ };
1977
+
1978
+ assert_eq!(wire_len, 5);
1979
+
1980
+ let mut b = octets::Octets::with_slice(&d);
1981
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
1982
+
1983
+ let mut b = octets::Octets::with_slice(&d);
1984
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
1985
+
1986
+ let mut b = octets::Octets::with_slice(&d);
1987
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_err());
1988
+
1989
+ let mut b = octets::Octets::with_slice(&d);
1990
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
1991
+ }
1992
+
1993
+ #[test]
1994
+ fn path_challenge() {
1995
+ let mut d = [42; 128];
1996
+
1997
+ let frame = Frame::PathChallenge {
1998
+ data: [1, 2, 3, 4, 5, 6, 7, 8],
1999
+ };
2000
+
2001
+ let wire_len = {
2002
+ let mut b = octets::OctetsMut::with_slice(&mut d);
2003
+ frame.to_bytes(&mut b).unwrap()
2004
+ };
2005
+
2006
+ assert_eq!(wire_len, 9);
2007
+
2008
+ let mut b = octets::Octets::with_slice(&d);
2009
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
2010
+
2011
+ let mut b = octets::Octets::with_slice(&d);
2012
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
2013
+
2014
+ let mut b = octets::Octets::with_slice(&d);
2015
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
2016
+
2017
+ let mut b = octets::Octets::with_slice(&d);
2018
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
2019
+ }
2020
+
2021
+ #[test]
2022
+ fn path_response() {
2023
+ let mut d = [42; 128];
2024
+
2025
+ let frame = Frame::PathResponse {
2026
+ data: [1, 2, 3, 4, 5, 6, 7, 8],
2027
+ };
2028
+
2029
+ let wire_len = {
2030
+ let mut b = octets::OctetsMut::with_slice(&mut d);
2031
+ frame.to_bytes(&mut b).unwrap()
2032
+ };
2033
+
2034
+ assert_eq!(wire_len, 9);
2035
+
2036
+ let mut b = octets::Octets::with_slice(&d);
2037
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
2038
+
2039
+ let mut b = octets::Octets::with_slice(&d);
2040
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
2041
+
2042
+ let mut b = octets::Octets::with_slice(&d);
2043
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_err());
2044
+
2045
+ let mut b = octets::Octets::with_slice(&d);
2046
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
2047
+ }
2048
+
2049
+ #[test]
2050
+ fn connection_close() {
2051
+ let mut d = [42; 128];
2052
+
2053
+ let frame = Frame::ConnectionClose {
2054
+ error_code: 0xbeef,
2055
+ frame_type: 523_423,
2056
+ reason: vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
2057
+ };
2058
+
2059
+ let wire_len = {
2060
+ let mut b = octets::OctetsMut::with_slice(&mut d);
2061
+ frame.to_bytes(&mut b).unwrap()
2062
+ };
2063
+
2064
+ assert_eq!(wire_len, 22);
2065
+
2066
+ let mut b = octets::Octets::with_slice(&d);
2067
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
2068
+
2069
+ let mut b = octets::Octets::with_slice(&d);
2070
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_ok());
2071
+
2072
+ let mut b = octets::Octets::with_slice(&d);
2073
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_err());
2074
+
2075
+ let mut b = octets::Octets::with_slice(&d);
2076
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_ok());
2077
+ }
2078
+
2079
+ #[test]
2080
+ fn application_close() {
2081
+ let mut d = [42; 128];
2082
+
2083
+ let frame = Frame::ApplicationClose {
2084
+ error_code: 0xbeef,
2085
+ reason: vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
2086
+ };
2087
+
2088
+ let wire_len = {
2089
+ let mut b = octets::OctetsMut::with_slice(&mut d);
2090
+ frame.to_bytes(&mut b).unwrap()
2091
+ };
2092
+
2093
+ assert_eq!(wire_len, 18);
2094
+
2095
+ let mut b = octets::Octets::with_slice(&d);
2096
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
2097
+
2098
+ let mut b = octets::Octets::with_slice(&d);
2099
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
2100
+
2101
+ let mut b = octets::Octets::with_slice(&d);
2102
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
2103
+
2104
+ let mut b = octets::Octets::with_slice(&d);
2105
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
2106
+ }
2107
+
2108
+ #[test]
2109
+ fn handshake_done() {
2110
+ let mut d = [42; 128];
2111
+
2112
+ let frame = Frame::HandshakeDone;
2113
+
2114
+ let wire_len = {
2115
+ let mut b = octets::OctetsMut::with_slice(&mut d);
2116
+ frame.to_bytes(&mut b).unwrap()
2117
+ };
2118
+
2119
+ assert_eq!(wire_len, 1);
2120
+
2121
+ let mut b = octets::Octets::with_slice(&d);
2122
+ assert_eq!(Frame::from_bytes(&mut b, packet::Type::Short), Ok(frame));
2123
+
2124
+ let mut b = octets::Octets::with_slice(&d);
2125
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
2126
+
2127
+ let mut b = octets::Octets::with_slice(&d);
2128
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_err());
2129
+
2130
+ let mut b = octets::Octets::with_slice(&d);
2131
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
2132
+ }
2133
+
2134
+ #[test]
2135
+ fn datagram() {
2136
+ let mut d = [42; 128];
2137
+
2138
+ let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
2139
+
2140
+ let frame = Frame::Datagram { data: data.clone() };
2141
+
2142
+ let wire_len = {
2143
+ let mut b = octets::OctetsMut::with_slice(&mut d);
2144
+ frame.to_bytes(&mut b).unwrap()
2145
+ };
2146
+
2147
+ assert_eq!(wire_len, 15);
2148
+
2149
+ let mut b = octets::Octets::with_slice(&d);
2150
+ assert_eq!(
2151
+ Frame::from_bytes(&mut b, packet::Type::Short),
2152
+ Ok(frame.clone())
2153
+ );
2154
+
2155
+ let mut b = octets::Octets::with_slice(&d);
2156
+ assert!(Frame::from_bytes(&mut b, packet::Type::Initial).is_err());
2157
+
2158
+ let mut b = octets::Octets::with_slice(&d);
2159
+ assert!(Frame::from_bytes(&mut b, packet::Type::ZeroRTT).is_ok());
2160
+
2161
+ let mut b = octets::Octets::with_slice(&d);
2162
+ assert!(Frame::from_bytes(&mut b, packet::Type::Handshake).is_err());
2163
+
2164
+ let frame_data = match &frame {
2165
+ Frame::Datagram { data } => data.clone(),
2166
+
2167
+ _ => unreachable!(),
2168
+ };
2169
+
2170
+ assert_eq!(frame_data, data);
2171
+ }
2172
+ }