Skip to main content

qualia_core_db/net/qdnf/frame/
decode.rs

1//! Caller-buffered QFrame decoder. Untrusted input is never cast.
2
3use super::errors::FrameError;
4use super::header::{FrameHeader, BASE_HEADER_LEN, MAGIC, VERSION};
5use crate::net::qdnf::registries::{FrameType, NextProtocol};
6use crate::net::qdnf::types::{FlowId, LinkId, Sequence};
7
8/// Decode a complete frame from `src`. Returns `(header, payload_offset, payload_len)`.
9///
10/// On any failure, consumed bytes are zero and `out` views are invalid.
11pub fn decode_frame(src: &[u8]) -> Result<(FrameHeader, usize, usize), FrameError> {
12    if src.len() < BASE_HEADER_LEN {
13        return Err(FrameError::Truncated);
14    }
15    if src[0..4] != MAGIC {
16        return Err(FrameError::Malformed);
17    }
18    if src[4] != VERSION {
19        return Err(FrameError::Unsupported);
20    }
21    let frame_type = FrameType::from_u8(src[5])?;
22    let flags = u16::from_be_bytes([src[6], src[7]]);
23    let header_len = u16::from_be_bytes([src[8], src[9]]);
24    let payload_len = u16::from_be_bytes([src[10], src[11]]);
25    if header_len as usize != BASE_HEADER_LEN {
26        return Err(FrameError::Unsupported);
27    }
28    if src[14] != 0 || src[15] != 0 {
29        return Err(FrameError::Malformed);
30    }
31    let next_protocol = NextProtocol::from_u8(src[13])?;
32    let hop_limit = src[12];
33    if !frame_type.forwarded() && hop_limit != 0 {
34        return Err(FrameError::Malformed);
35    }
36
37    let mut source_link_id = LinkId::ZERO;
38    source_link_id.0.copy_from_slice(&src[16..32]);
39    let mut destination_link_id = LinkId::ZERO;
40    destination_link_id.0.copy_from_slice(&src[32..48]);
41    if frame_type == FrameType::DiscoveryBeacon && !destination_link_id.is_zero() {
42        // Discovery may use a group selector; zero dest is also permitted.
43    }
44    let mut flow_id = FlowId::ZERO;
45    flow_id.0.copy_from_slice(&src[48..56]);
46    let sequence = Sequence(u64::from_be_bytes([
47        src[56], src[57], src[58], src[59], src[60], src[61], src[62], src[63],
48    ]));
49    let mut header_tag = [0u8; 16];
50    header_tag.copy_from_slice(&src[64..80]);
51
52    let total = (header_len as usize)
53        .checked_add(payload_len as usize)
54        .ok_or(FrameError::Range)?;
55    if src.len() < total {
56        return Err(FrameError::Truncated);
57    }
58
59    let header = FrameHeader {
60        version: src[4],
61        frame_type,
62        flags,
63        header_len,
64        payload_len,
65        hop_limit,
66        next_protocol,
67        source_link_id,
68        destination_link_id,
69        flow_id,
70        sequence,
71        header_tag,
72    };
73    Ok((header, BASE_HEADER_LEN, payload_len as usize))
74}
75
76/// Copy payload into `out` after a successful `decode_frame`.
77pub fn copy_payload(
78    src: &[u8],
79    payload_offset: usize,
80    payload_len: usize,
81    out: &mut [u8],
82) -> Result<usize, FrameError> {
83    let end = payload_offset
84        .checked_add(payload_len)
85        .ok_or(FrameError::Range)?;
86    if src.len() < end {
87        return Err(FrameError::Truncated);
88    }
89    if out.len() < payload_len {
90        return Err(FrameError::Capacity);
91    }
92    if payload_len != 0 {
93        out[..payload_len].copy_from_slice(&src[payload_offset..end]);
94    }
95    Ok(payload_len)
96}
97
98#[cfg(test)]
99mod tests {
100    use super::*;
101    use crate::net::qdnf::frame::encode::encode_frame;
102    use crate::net::qdnf::registries::{FrameType, NextProtocol};
103
104    #[test]
105    fn round_trip_discovery() {
106        let mut header = FrameHeader::new(FrameType::DiscoveryBeacon, NextProtocol::QLink);
107        header.payload_len = 4;
108        let payload = [9u8, 8, 7, 6];
109        let mut wire = [0u8; 128];
110        let n = encode_frame(&header, &payload, &mut wire).unwrap();
111        let (decoded, off, len) = decode_frame(&wire[..n]).unwrap();
112        assert_eq!(decoded.frame_type, FrameType::DiscoveryBeacon);
113        let mut out = [0u8; 8];
114        copy_payload(&wire[..n], off, len, &mut out).unwrap();
115        assert_eq!(&out[..4], &payload);
116    }
117
118    #[test]
119    fn truncated_is_zero_consumed() {
120        let err = decode_frame(&[0u8; 16]).unwrap_err();
121        assert_eq!(err, FrameError::Truncated);
122        assert_eq!(err.consumed_on_failure(), 0);
123    }
124
125    #[test]
126    fn bad_magic_is_malformed() {
127        let mut buf = [0u8; 80];
128        buf[0..4].copy_from_slice(b"XXXX");
129        buf[4] = VERSION;
130        assert_eq!(decode_frame(&buf), Err(FrameError::Malformed));
131    }
132}