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
116
117

//! RFC 9000 CRYPTO frame parsing.

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

const MAX_CRYPTO_RANGE_END: u64 = (1 << 62) - 1;

/// A checked borrowed RFC 9000 CRYPTO frame view.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct QuicCryptoFrame<'a> {
    bytes: &'a [u8],
    frame_type: QuicVarInt<'a>,
    offset: QuicVarInt<'a>,
    length: QuicVarInt<'a>,
    crypto_data: &'a [u8],
}

impl<'a> QuicCryptoFrame<'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 exact encoded CRYPTO offset variable integer.
    pub const fn offset(self) -> QuicVarInt<'a> {
        self.offset
    }

    /// Returns the exact encoded CRYPTO data-length variable integer.
    pub const fn length(self) -> QuicVarInt<'a> {
        self.length
    }

    /// Returns the exact borrowed CRYPTO data bytes, which may be empty.
    pub const fn crypto_data(self) -> &'a [u8] {
        self.crypto_data
    }
}

pub(super) fn parse_crypto<'a>(
    bytes: &'a [u8],
    frame_type: QuicVarInt<'a>,
    offset: usize,
) -> Result<(QuicCryptoFrame<'a>, &'a [u8]), QuicFrameParseError> {
    let offset_start = frame_type.byte_len();
    let offset_offset = offset + offset_start;
    let crypto_offset =
        QuicVarInt::parse(&bytes[offset_start..]).map_err(|error| QuicFrameParseError::Field {
            field: QuicFrameField::CryptoOffset,
            offset: offset_offset,
            error,
        })?;

    let length_start = offset_start + crypto_offset.byte_len();
    let length_offset = offset + length_start;
    let length =
        QuicVarInt::parse(&bytes[length_start..]).map_err(|error| QuicFrameParseError::Field {
            field: QuicFrameField::CryptoLength,
            offset: length_offset,
            error,
        })?;

    let range_end = crypto_offset.value().checked_add(length.value());
    if range_end.is_none_or(|end| end > MAX_CRYPTO_RANGE_END) {
        return Err(QuicFrameParseError::FieldRangeOutOfRange {
            field: QuicFrameField::CryptoOffset,
            offset: offset_offset,
            start: crypto_offset.value(),
            length: length.value(),
            maximum: MAX_CRYPTO_RANGE_END,
        });
    }

    let length_value = length.value();
    let length_usize =
        usize::try_from(length_value).map_err(|_| QuicFrameParseError::LengthNotRepresentable {
            field: QuicFrameField::CryptoLength,
            offset: length_offset,
            value: length_value,
        })?;
    // Each parsed variable integer is at most eight bytes wide.
    let data_start = length_start + length.byte_len();
    let data_offset = offset + data_start;
    let data_end =
        data_start
            .checked_add(length_usize)
            .ok_or(QuicFrameParseError::LengthOverflow {
                field: QuicFrameField::CryptoData,
                offset: data_offset,
                length: length_usize,
            })?;
    let available = bytes.len() - data_start;
    if available < length_usize {
        return Err(QuicFrameParseError::IncompleteBytes {
            field: QuicFrameField::CryptoData,
            offset: data_offset,
            required: length_usize,
            available,
        });
    }

    Ok((
        QuicCryptoFrame {
            bytes: &bytes[..data_end],
            frame_type,
            offset: crypto_offset,
            length,
            crypto_data: &bytes[data_start..data_end],
        },
        &bytes[data_end..],
    ))
}