pub fn parse_initial(packet: &[u8]) -> Result<InitialHeader<'_>, Error>Expand description
Parse a QUIC Long Header Initial packet from a raw datagram.
Only the header fields are extracted; no decryption is performed. The
returned InitialHeader borrows directly from packet.
ยงErrors
Returns an error when the packet is too short, is not a long-header Initial packet, or contains a connection ID length exceeding 20 bytes.
Examples found in repository?
examples/parse_header.rs (line 13)
8fn main() {
9 // A minimal QUIC v1 Initial packet (truncated payload).
10 // In practice this would come from a UDP socket.
11 let packet: Vec<u8> = build_sample_initial();
12
13 match quic_parser::parse_initial(&packet) {
14 Ok(header) => {
15 println!("QUIC Initial packet parsed successfully");
16 println!(" version: {:#010x}", header.version);
17 println!(" dcid: {}", hex(header.dcid));
18 println!(" scid: {}", hex(header.scid));
19 println!(" token length: {}", header.token.len());
20 println!(" payload size: {} bytes", header.payload.len());
21 }
22 Err(e) => {
23 eprintln!("parse error: {e}");
24 }
25 }
26
27 // Peek at the DCID without a full parse.
28 if let Some(dcid) = quic_parser::peek_long_header_dcid(&packet) {
29 println!(" peeked dcid: {}", hex(dcid));
30 }
31}More examples
examples/decrypt_initial.rs (line 14)
10fn main() {
11 // RFC 9001 Appendix A.2 client Initial packet (complete, 1200 bytes).
12 let packet = rfc9001_client_initial();
13
14 let header = match quic_parser::parse_initial(&packet) {
15 Ok(h) => h,
16 Err(e) => {
17 eprintln!("header parse error: {e}");
18 return;
19 }
20 };
21
22 println!("Parsed header:");
23 println!(" version: {:#010x}", header.version);
24 println!(" dcid: {}", hex(header.dcid));
25 println!(" scid: {}", hex(header.scid));
26 println!(" payload: {} bytes", header.payload.len());
27
28 let decrypted = match quic_parser::decrypt_initial(&packet, &header) {
29 Ok(d) => d,
30 Err(e) => {
31 eprintln!("decryption error: {e}");
32 return;
33 }
34 };
35
36 println!("Decrypted {} bytes of frame data", decrypted.len());
37
38 let frames = match quic_parser::parse_crypto_frames(&decrypted) {
39 Ok(f) => f,
40 Err(e) => {
41 eprintln!("frame parse error: {e}");
42 return;
43 }
44 };
45
46 println!("Found {} CRYPTO frame(s)", frames.len());
47 for (i, f) in frames.iter().enumerate() {
48 println!(" frame {i}: offset={}, len={}", f.offset, f.data.len());
49 }
50
51 let stream = quic_parser::reassemble_crypto_stream(&frames);
52 println!("Reassembled crypto stream: {} bytes", stream.len());
53
54 if stream.len() >= 6 {
55 let msg_type = stream[0];
56 let length = u32::from_be_bytes([0, stream[1], stream[2], stream[3]]);
57 let tls_version = u16::from_be_bytes([stream[4], stream[5]]);
58 println!("TLS handshake: type={msg_type:#04x} length={length} version={tls_version:#06x}");
59 }
60}