net-wire 0.1.0

Allocation-free no_std wire views and codecs for network protocols.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! RFC 9000 PATH_CHALLENGE and PATH_RESPONSE frame parsing.

use super::super::varint::QuicVarInt;
use super::parse::{QuicFrameField, QuicFrameParseError};

/// A checked borrowed RFC 9000 PATH_CHALLENGE frame view.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct QuicPathChallengeFrame<'a> {
    bytes: &'a [u8],
    frame_type: QuicVarInt<'a>,
    data: &'a [u8; 8],
}

impl<'a> QuicPathChallengeFrame<'a> {
    /// Returns the exact encoded frame bytes.
    pub const fn as_bytes(self) -> &'a [u8] {
        self.bytes
    }

    /// Returns the exact encoded frame-type variable integer.
    pub const fn frame_type(self) -> QuicVarInt<'a> {
        self.frame_type
    }

    /// Returns the opaque path-validation data.
    pub const fn data(self) -> &'a [u8; 8] {
        self.data
    }
}

/// A checked borrowed RFC 9000 PATH_RESPONSE frame view.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct QuicPathResponseFrame<'a> {
    bytes: &'a [u8],
    frame_type: QuicVarInt<'a>,
    data: &'a [u8; 8],
}

impl<'a> QuicPathResponseFrame<'a> {
    /// Returns the exact encoded frame bytes.
    pub const fn as_bytes(self) -> &'a [u8] {
        self.bytes
    }

    /// Returns the exact encoded frame-type variable integer.
    pub const fn frame_type(self) -> QuicVarInt<'a> {
        self.frame_type
    }

    /// Returns the opaque path-validation data.
    pub const fn data(self) -> &'a [u8; 8] {
        self.data
    }
}

pub(super) fn parse_path_challenge<'a>(
    bytes: &'a [u8],
    frame_type: QuicVarInt<'a>,
    offset: usize,
) -> Result<(QuicPathChallengeFrame<'a>, &'a [u8]), QuicFrameParseError> {
    let parsed = parse_path_data(bytes, frame_type, offset)?;
    Ok((
        QuicPathChallengeFrame {
            bytes: parsed.bytes,
            frame_type,
            data: parsed.data,
        },
        parsed.suffix,
    ))
}

pub(super) fn parse_path_response<'a>(
    bytes: &'a [u8],
    frame_type: QuicVarInt<'a>,
    offset: usize,
) -> Result<(QuicPathResponseFrame<'a>, &'a [u8]), QuicFrameParseError> {
    let parsed = parse_path_data(bytes, frame_type, offset)?;
    Ok((
        QuicPathResponseFrame {
            bytes: parsed.bytes,
            frame_type,
            data: parsed.data,
        },
        parsed.suffix,
    ))
}

struct ParsedPathData<'a> {
    bytes: &'a [u8],
    data: &'a [u8; 8],
    suffix: &'a [u8],
}

fn parse_path_data<'a>(
    bytes: &'a [u8],
    frame_type: QuicVarInt<'a>,
    offset: usize,
) -> Result<ParsedPathData<'a>, QuicFrameParseError> {
    let data_start = frame_type.byte_len();
    let input = &bytes[data_start..];
    let Some((data, suffix)) = input.split_first_chunk::<8>() else {
        return Err(QuicFrameParseError::IncompleteBytes {
            field: QuicFrameField::PathData,
            offset: offset + data_start,
            required: 8,
            available: input.len(),
        });
    };
    let frame_len = bytes.len() - suffix.len();
    Ok(ParsedPathData {
        bytes: &bytes[..frame_len],
        data,
        suffix,
    })
}