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