qualia_core_db/net/qdnf/frame/
decode.rs1use 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
8pub 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 }
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
76pub 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}