#![no_std]
#![deny(missing_docs)]
extern crate alloc;
use alloc::vec::Vec;
pub mod error_registry;
pub mod field;
pub mod fwd;
pub mod path;
pub mod structured;
pub mod tlv_builders;
pub use error_registry::{
error_code, error_raw_code, error_string, parse_error, status_errors, status_ok,
status_with_errors, Disposition, ErrCode, ErrorId, ParsedError, Severity,
};
pub use field::{
encode_field, field_tlv, parse_field, parse_field_tlv, FieldLevel, FieldMode, MAX_FIELD_DEPTH,
};
pub use fwd::{
decode_fwd, encode_fwd, encode_fwd_bytes, parse_fwd_tlv, reply_error_code, reply_error_path,
FieldSel, FwdRequest, ParsedFwd,
};
pub use tlv_builders::{
name, path_ref, path_ref_element, subscriber, text_name, validate_segment, value, value_opts,
value_u16, value_u32, value_u64, value_u8, BuildError, PathRefElement, ValueOptions,
MAX_PATH_BYTES, MAX_SEGMENTS, MAX_SEGMENT_BYTES,
};
pub mod type_code {
pub const VALUE: u8 = 0x01;
pub const NAME: u8 = 0x02;
pub const DESCRIPTION: u8 = 0x03;
pub const SUBSCRIBER: u8 = 0x04;
pub const PATH: u8 = 0x06;
pub const POINT: u8 = 0x07;
pub const ERROR: u8 = 0x08;
pub const STATUS: u8 = 0x09;
pub const ACL: u8 = 0x0a;
pub const SETTINGS: u8 = 0x0b;
pub const TIME: u8 = 0x0c;
pub const ROUTER: u8 = 0x0d;
pub const SPEC: u8 = 0x0e;
pub const FWD: u8 = 0x0f;
pub const FIELD: u8 = 0x10;
pub const PATH_REF: u8 = 0x14;
}
pub const PATH_REF_ELEMENT_BYTES: usize = 8;
pub const MAX_PATH_REF_ELEMENTS: usize = 255;
fn path_ref_body_valid(pl: bool, ll: bool, body_len: u64) -> bool {
!pl && !ll
&& body_len.is_multiple_of(PATH_REF_ELEMENT_BYTES as u64)
&& body_len <= (MAX_PATH_REF_ELEMENTS * PATH_REF_ELEMENT_BYTES) as u64
}
const RESERVED_MASK: u8 = 0b1000_0001;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Error {
FrameTruncated,
FrameInvalid,
FrameCrcFail,
TlvNestingTooDeep,
}
impl Error {
pub const fn name(self) -> &'static str {
match self {
Error::FrameTruncated => "FRAME_TRUNCATED",
Error::FrameInvalid => "FRAME_INVALID",
Error::FrameCrcFail => "FRAME_CRC_FAIL",
Error::TlvNestingTooDeep => "TLV_NESTING_TOO_DEEP",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Opt {
pub pl: bool,
pub ts: bool,
pub cr: bool,
pub ll: bool,
pub cw: bool,
pub tf: bool,
}
impl Opt {
pub const fn decode(b: u8) -> Opt {
Opt {
pl: b & 0x40 != 0,
ts: b & 0x20 != 0,
cr: b & 0x10 != 0,
ll: b & 0x08 != 0,
cw: b & 0x04 != 0,
tf: b & 0x02 != 0,
}
}
pub const fn encode(self) -> u8 {
(if self.pl { 0x40 } else { 0 })
| (if self.ts { 0x20 } else { 0 })
| (if self.cr { 0x10 } else { 0 })
| (if self.ll { 0x08 } else { 0 })
| (if self.cw { 0x04 } else { 0 })
| (if self.tf { 0x02 } else { 0 })
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Timestamp {
pub relative: bool,
pub value: i64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CrcWidth {
Crc32c,
Crc16Ccitt,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Crc {
pub width: CrcWidth,
pub value: u32,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Trailer {
pub ts: Option<Timestamp>,
pub crc: Option<Crc>,
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct Tlv {
pub type_code: u8,
pub opt: Opt,
pub payload: Vec<u8>,
pub children: Vec<Tlv>,
pub trailer: Option<Trailer>,
}
pub fn crc32c(data: &[u8]) -> u32 {
let mut c: u32 = 0xFFFF_FFFF;
for &b in data {
let mut x = (c ^ b as u32) & 0xFF;
for _ in 0..8 {
x = if x & 1 != 0 {
0x82F6_3B78 ^ (x >> 1)
} else {
x >> 1
};
}
c = x ^ (c >> 8);
}
c ^ 0xFFFF_FFFF
}
pub fn crc16_ccitt(data: &[u8]) -> u16 {
let mut c: u16 = 0xFFFF;
for &b in data {
let idx = (((c >> 8) as u8) ^ b) as u16;
let mut t = idx << 8;
for _ in 0..8 {
t = if t & 0x8000 != 0 {
(t << 1) ^ 0x1021
} else {
t << 1
};
}
c = t ^ (c << 8);
}
c
}
fn read_le(b: &[u8], off: usize, n: usize) -> u64 {
let mut v: u64 = 0;
let mut i = 0;
while i < n {
v |= (b[off + i] as u64) << (8 * i);
i += 1;
}
v
}
fn write_le(out: &mut Vec<u8>, v: u64, n: usize) {
let mut i = 0;
while i < n {
out.push(((v >> (8 * i)) & 0xFF) as u8);
i += 1;
}
}
fn parse_one(buf: &[u8]) -> Result<(Tlv, usize, &[u8]), Error> {
if buf.len() < 4 {
return Err(Error::FrameTruncated);
}
let type_b = buf[0];
let opt_b = buf[1];
if type_b == 0x00 {
return Err(Error::FrameInvalid);
}
if opt_b & RESERVED_MASK != 0 {
return Err(Error::FrameInvalid);
}
let opt = Opt::decode(opt_b);
let header = if opt.ll { 6 } else { 4 };
if buf.len() < header {
return Err(Error::FrameTruncated);
}
let length = read_le(buf, 2, if opt.ll { 4 } else { 2 });
if type_b == type_code::PATH_REF && !path_ref_body_valid(opt.pl, opt.ll, length) {
return Err(Error::FrameInvalid);
}
let ts_size = if opt.ts {
if opt.tf {
4u64
} else {
8u64
}
} else {
0
};
let crc_size = if opt.cr {
if opt.cw {
2u64
} else {
4u64
}
} else {
0
};
let total = header as u64 + length + ts_size + crc_size;
if (buf.len() as u64) < total {
return Err(Error::FrameTruncated);
}
let length = length as usize;
let ts_size = ts_size as usize;
let total = total as usize;
let mut tlv = Tlv {
type_code: type_b,
opt,
..Tlv::default()
};
let payload = &buf[header..header + length];
if opt.ts || opt.cr {
let mut trailer = Trailer::default();
if opt.ts {
let value = if opt.tf {
(read_le(buf, header + length, 4) as u32) as i32 as i64
} else {
read_le(buf, header + length, 8) as i64
};
trailer.ts = Some(Timestamp {
relative: opt.tf,
value,
});
}
if opt.cr {
let covered = &buf[header..header + length + ts_size];
let crc_off = header + length + ts_size;
if opt.cw {
let value = read_le(buf, crc_off, 2) as u16;
if crc16_ccitt(covered) != value {
return Err(Error::FrameCrcFail);
}
trailer.crc = Some(Crc {
width: CrcWidth::Crc16Ccitt,
value: value as u32,
});
} else {
let value = read_le(buf, crc_off, 4) as u32;
if crc32c(covered) != value {
return Err(Error::FrameCrcFail);
}
trailer.crc = Some(Crc {
width: CrcWidth::Crc32c,
value,
});
}
}
tlv.trailer = Some(trailer);
}
let children: &[u8] = if opt.pl {
payload } else {
tlv.payload.extend_from_slice(payload);
&[]
};
Ok((tlv, total, children))
}
struct Open<'a> {
node: Tlv,
payload: &'a [u8],
pos: usize,
total: usize,
}
pub fn decode(input: &[u8]) -> Result<Tlv, Error> {
let (root_node, root_total, root_children) = parse_one(input)?;
if root_total != input.len() {
return Err(Error::FrameInvalid); }
if !root_node.opt.pl {
return Ok(root_node); }
let mut stack: Vec<Open> = Vec::new();
stack.push(Open {
node: root_node,
payload: root_children,
pos: 0,
total: root_total,
});
loop {
let top = stack.last().unwrap();
if top.pos == top.payload.len() {
let done = stack.pop().unwrap();
match stack.last_mut() {
None => return Ok(done.node),
Some(parent) => {
parent.pos += done.total;
parent.node.children.push(done.node);
}
}
continue;
}
let (payload, pos) = {
let top = stack.last().unwrap();
(top.payload, top.pos)
};
let (child_node, child_total, child_children) = parse_one(&payload[pos..])?;
if child_node.opt.pl {
stack.push(Open {
node: child_node,
payload: child_children,
pos: 0,
total: child_total,
});
} else {
let parent = stack.last_mut().unwrap();
parent.pos += child_total;
parent.node.children.push(child_node);
}
}
}
pub fn encode(tlv: &Tlv) -> Vec<u8> {
if tlv.type_code == type_code::PATH_REF
&& !path_ref_body_valid(tlv.opt.pl, tlv.opt.ll, tlv.payload.len() as u64)
{
return Vec::new();
}
let mut body: Vec<u8> = Vec::new();
if tlv.opt.pl {
for child in &tlv.children {
let cb = encode(child);
if cb.is_empty() {
return Vec::new();
}
body.extend_from_slice(&cb);
}
} else {
body.extend_from_slice(&tlv.payload);
}
let mut out: Vec<u8> = Vec::new();
out.push(tlv.type_code);
out.push(tlv.opt.encode());
write_le(&mut out, body.len() as u64, if tlv.opt.ll { 4 } else { 2 });
out.extend_from_slice(&body);
let mut ts_bytes: Vec<u8> = Vec::new();
if tlv.opt.ts {
let t = match &tlv.trailer {
Some(tr) if tr.ts.is_some() => tr.ts.unwrap(),
_ => Timestamp {
relative: tlv.opt.tf,
value: 0,
},
};
if tlv.opt.tf {
write_le(&mut ts_bytes, (t.value as i32 as u32) as u64, 4);
} else {
write_le(&mut ts_bytes, t.value as u64, 8);
}
out.extend_from_slice(&ts_bytes);
}
if tlv.opt.cr {
let mut covered = body;
covered.extend_from_slice(&ts_bytes);
if tlv.opt.cw {
write_le(&mut out, crc16_ccitt(&covered) as u64, 2);
} else {
write_le(&mut out, crc32c(&covered) as u64, 4);
}
}
out
}