use super::types::{ContainerKind, ElementType, Tag, Width, read_le_i64, read_le_u64};
use crate::error::{Error, ErrorCode, Result, bail};
pub const MAX_DEPTH: usize = 16;
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub enum Value<'a> {
Signed(i64),
Unsigned(u64),
Bool(bool),
Float(f32),
Double(f64),
Utf8(&'a str),
Octets(&'a [u8]),
Null,
Container(ContainerKind),
EndOfContainer,
}
impl Value<'_> {
#[must_use]
pub const fn is_null(self) -> bool {
matches!(self, Self::Null)
}
#[must_use]
pub const fn container(self) -> Option<ContainerKind> {
match self {
Self::Container(k) => Some(k),
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Element<'a> {
pub tag: Tag,
pub value: Value<'a>,
}
impl<'a> Element<'a> {
pub fn unsigned(&self) -> Result<u64> {
match self.value {
Value::Unsigned(v) => Ok(v),
_ => Err(Error::new(ErrorCode::TlvWrongType)),
}
}
pub fn signed(&self) -> Result<i64> {
match self.value {
Value::Signed(v) => Ok(v),
_ => Err(Error::new(ErrorCode::TlvWrongType)),
}
}
pub fn bool(&self) -> Result<bool> {
match self.value {
Value::Bool(v) => Ok(v),
_ => Err(Error::new(ErrorCode::TlvWrongType)),
}
}
pub fn utf8(&self) -> Result<&'a str> {
match self.value {
Value::Utf8(v) => Ok(v),
_ => Err(Error::new(ErrorCode::TlvWrongType)),
}
}
pub fn octets(&self) -> Result<&'a [u8]> {
match self.value {
Value::Octets(v) => Ok(v),
_ => Err(Error::new(ErrorCode::TlvWrongType)),
}
}
}
#[derive(Debug, Clone)]
pub struct TlvReader<'a> {
buf: &'a [u8],
pos: usize,
stack: [ContainerKind; MAX_DEPTH],
depth: usize,
top_level_done: bool,
many: bool,
started_inside: bool,
}
impl<'a> TlvReader<'a> {
#[must_use]
pub const fn new(buf: &'a [u8]) -> Self {
Self {
buf,
pos: 0,
stack: [ContainerKind::Structure; MAX_DEPTH],
depth: 0,
top_level_done: false,
many: false,
started_inside: false,
}
}
#[must_use]
pub const fn new_in(buf: &'a [u8], container: ContainerKind) -> Self {
Self {
buf,
pos: 0,
stack: [container; MAX_DEPTH],
depth: 1,
top_level_done: false,
many: false,
started_inside: true,
}
}
#[must_use]
pub const fn new_members(buf: &'a [u8], container: ContainerKind) -> Self {
Self {
buf,
pos: 0,
stack: [container; MAX_DEPTH],
depth: 1,
top_level_done: false,
many: true,
started_inside: true,
}
}
#[must_use]
pub const fn position(&self) -> usize {
self.pos
}
#[must_use]
pub const fn depth(&self) -> usize {
self.depth
}
#[must_use]
pub fn remaining(&self) -> &'a [u8] {
self.buf.get(self.pos..).unwrap_or(&[])
}
#[must_use]
pub const fn is_empty(&self) -> bool {
self.pos >= self.buf.len()
}
fn take(&mut self, n: usize) -> Result<&'a [u8]> {
let end = self
.pos
.checked_add(n)
.ok_or(Error::new(ErrorCode::TlvTruncated))?;
let Some(slice) = self.buf.get(self.pos..end) else {
bail!(TlvTruncated)
};
self.pos = end;
Ok(slice)
}
const fn base_depth(&self) -> usize {
if self.started_inside { 1 } else { 0 }
}
fn current_container(&self) -> Option<ContainerKind> {
self.depth
.checked_sub(1)
.and_then(|i| self.stack.get(i))
.copied()
}
fn check_tag(&self, tag: Tag) -> Result<()> {
match self.current_container() {
None => {
if tag.context().is_some() {
bail!(TlvInvalidTag)
}
}
Some(ContainerKind::Structure) => {
if tag.is_anonymous() {
bail!(TlvInvalidTag)
}
}
Some(ContainerKind::Array) => {
if !tag.is_anonymous() {
bail!(TlvInvalidTag)
}
}
Some(ContainerKind::List) => {}
}
Ok(())
}
pub fn next_element(&mut self) -> Result<Option<Element<'a>>> {
if self.is_empty() {
return Ok(None);
}
if self.top_level_done && !self.many && self.depth == self.base_depth() {
bail!(TlvContainerMismatch)
}
let control = {
let b = self.take(1)?;
let Some(&c) = b.first() else {
bail!(TlvTruncated)
};
c
};
let element_type = ElementType::from_bits(control)?;
if matches!(element_type, ElementType::EndOfContainer) {
if control != 0x18 {
bail!(TlvInvalidControl)
}
let Some(new_depth) = self.depth.checked_sub(1) else {
bail!(TlvContainerMismatch)
};
if new_depth < self.base_depth() {
bail!(TlvContainerMismatch)
}
self.depth = new_depth;
if self.depth == self.base_depth() {
self.top_level_done = true;
}
return Ok(Some(Element {
tag: Tag::Anonymous,
value: Value::EndOfContainer,
}));
}
let (tag, tag_len) = Tag::decode(control, self.remaining())?;
self.pos = self
.pos
.checked_add(tag_len)
.ok_or(Error::new(ErrorCode::TlvTruncated))?;
self.check_tag(tag)?;
let value = match element_type {
ElementType::SignedInt(w) => Value::Signed(read_le_i64(self.take(w.octets())?)?),
ElementType::UnsignedInt(w) => Value::Unsigned(read_le_u64(self.take(w.octets())?)?),
ElementType::Bool(v) => Value::Bool(v),
ElementType::Float => {
let raw = read_le_u64(self.take(4)?)?;
let Ok(bits) = u32::try_from(raw) else {
bail!(TlvOutOfRange)
};
Value::Float(f32::from_bits(bits))
}
ElementType::Double => Value::Double(f64::from_bits(read_le_u64(self.take(8)?)?)),
ElementType::Utf8(w) => {
let bytes = self.take_string(w)?;
match core::str::from_utf8(bytes) {
Ok(s) => Value::Utf8(s),
Err(_) => bail!(TlvInvalidUtf8),
}
}
ElementType::Octets(w) => Value::Octets(self.take_string(w)?),
ElementType::Null => Value::Null,
ElementType::Structure | ElementType::Array | ElementType::List => {
let kind = match element_type {
ElementType::Structure => ContainerKind::Structure,
ElementType::Array => ContainerKind::Array,
_ => ContainerKind::List,
};
let Some(slot) = self.stack.get_mut(self.depth) else {
bail!(TlvDepthExceeded)
};
*slot = kind;
self.depth = self
.depth
.checked_add(1)
.ok_or(Error::new(ErrorCode::TlvDepthExceeded))?;
Value::Container(kind)
}
ElementType::EndOfContainer => bail!(TlvInvalidControl),
};
if self.depth == self.base_depth() {
self.top_level_done = true;
}
Ok(Some(Element { tag, value }))
}
fn take_string(&mut self, w: Width) -> Result<&'a [u8]> {
let len = read_le_u64(self.take(w.octets())?)?;
let Ok(len) = usize::try_from(len) else {
bail!(TlvTruncated)
};
self.take(len)
}
pub fn skip_container(&mut self) -> Result<()> {
let Some(target) = self.depth.checked_sub(1) else {
bail!(TlvContainerMismatch)
};
while self.depth > target {
if self.next_element()?.is_none() {
bail!(TlvContainerMismatch)
}
}
Ok(())
}
pub fn slice_from(&self, start: usize) -> Result<&'a [u8]> {
self.buf
.get(start..self.pos)
.ok_or(Error::new(ErrorCode::TlvTruncated))
}
pub fn skip_value(&mut self, element: &Element<'a>) -> Result<()> {
if element.value.container().is_some() {
self.skip_container()?;
}
Ok(())
}
pub fn finish(&self) -> Result<()> {
if self.depth != self.base_depth() {
bail!(TlvContainerMismatch)
}
if !self.top_level_done {
bail!(TlvTruncated)
}
if !self.is_empty() {
bail!(TlvContainerMismatch)
}
Ok(())
}
pub fn validate(buf: &'a [u8]) -> Result<usize> {
let mut r = Self::new(buf);
let mut count = 0usize;
while r.next_element()?.is_some() {
count = count.saturating_add(1);
}
r.finish()?;
Ok(count)
}
}
#[cfg(test)]
#[allow(clippy::arithmetic_side_effects, clippy::indexing_slicing)]
mod tests {
use super::*;
fn one(buf: &[u8]) -> Element<'_> {
let mut r = TlvReader::new(buf);
r.next_element().expect("read").expect("an element")
}
#[test]
fn primitives_from_table_127() {
assert_eq!(one(&[0x08]).value, Value::Bool(false));
assert_eq!(one(&[0x09]).value, Value::Bool(true));
assert_eq!(one(&[0x00, 0x2a]).value, Value::Signed(42));
assert_eq!(one(&[0x00, 0xef]).value, Value::Signed(-17));
assert_eq!(one(&[0x04, 0x2a]).value, Value::Unsigned(42));
assert_eq!(one(&[0x01, 0x2a, 0x00]).value, Value::Signed(42));
assert_eq!(
one(&[0x02, 0xf0, 0x67, 0xfd, 0xff]).value,
Value::Signed(-170_000)
);
assert_eq!(
one(&[0x03, 0x00, 0x90, 0x2f, 0x50, 0x09, 0x00, 0x00, 0x00]).value,
Value::Signed(40_000_000_000)
);
assert_eq!(
one(&[0x0c, 0x06, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21]).value,
Value::Utf8("Hello!")
);
assert_eq!(
one(&[0x0c, 0x07, 0x54, 0x73, 0x63, 0x68, 0xc3, 0xbc, 0x73]).value,
Value::Utf8("Tschüs")
);
assert_eq!(
one(&[0x10, 0x05, 0x00, 0x01, 0x02, 0x03, 0x04]).value,
Value::Octets(&[0, 1, 2, 3, 4])
);
assert_eq!(one(&[0x14]).value, Value::Null);
assert_eq!(
one(&[0x0a, 0x00, 0x00, 0x00, 0x00]).value,
Value::Float(0.0)
);
assert_eq!(
one(&[0x0a, 0x33, 0x33, 0x8f, 0x41]).value,
Value::Float(17.9)
);
assert_eq!(
one(&[0x0a, 0x00, 0x00, 0x80, 0x7f]).value,
Value::Float(f32::INFINITY)
);
assert_eq!(
one(&[0x0b, 0x66, 0x66, 0x66, 0x66, 0x66, 0xe6, 0x31, 0x40]).value,
Value::Double(17.9)
);
}
#[test]
fn tags_from_table_129() {
assert_eq!(one(&[0x04, 0x2a]).tag, Tag::Anonymous);
{
let buf = [0x15, 0x24, 0x01, 0x2a, 0x18];
let mut r = TlvReader::new(&buf);
let _open = r.next_element().expect("read").expect("an element");
let member = r.next_element().expect("read").expect("an element");
assert_eq!(member.tag, Tag::Context(1));
assert_eq!(member.unsigned().expect("unsigned"), 42);
}
assert_eq!(one(&[0x44, 0x01, 0x00, 0x2a]).tag, Tag::Common(1));
assert_eq!(
one(&[0x64, 0xa0, 0x86, 0x01, 0x00, 0x2a]).tag,
Tag::Common(100_000)
);
assert_eq!(
one(&[0xc4, 0xf1, 0xff, 0xed, 0xde, 0x01, 0x00, 0x2a]).tag,
Tag::FullyQualified {
vendor: 0xFFF1,
profile: 0xDEED,
number: 1
}
);
assert_eq!(
one(&[0xe4, 0xf1, 0xff, 0xed, 0xde, 0xed, 0xfe, 0x55, 0xaa, 0x2a]).tag,
Tag::FullyQualified {
vendor: 0xFFF1,
profile: 0xDEED,
number: 0xAA55_FEED
}
);
}
#[test]
fn containers_from_table_128() {
assert_eq!(TlvReader::validate(&[0x15, 0x18]).unwrap(), 2);
assert_eq!(TlvReader::validate(&[0x16, 0x18]).unwrap(), 2);
assert_eq!(TlvReader::validate(&[0x17, 0x18]).unwrap(), 2);
assert_eq!(
TlvReader::validate(&[0x15, 0x20, 0x00, 0x2a, 0x20, 0x01, 0xef, 0x18]).unwrap(),
4
);
assert_eq!(
TlvReader::validate(&[
0x16, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x18
])
.unwrap(),
7
);
assert_eq!(
TlvReader::validate(&[
0x17, 0x00, 0x01, 0x20, 0x00, 0x2a, 0x00, 0x02, 0x00, 0x03, 0x20, 0x00, 0xef, 0x18
])
.unwrap(),
7
);
assert_eq!(
TlvReader::validate(&[
0x16, 0x00, 0x2a, 0x02, 0xf0, 0x67, 0xfd, 0xff, 0x15, 0x18, 0x0a, 0x33, 0x33, 0x8f,
0x41, 0x0c, 0x06, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21, 0x18
])
.unwrap(),
8
);
assert_eq!(
TlvReader::validate(&[
0xd5, 0xf1, 0xff, 0xed, 0xde, 0x01, 0x00, 0xc4, 0xf1, 0xff, 0xed, 0xde, 0x55, 0xaa,
0x2a, 0x18
])
.unwrap(),
3
);
}
#[test]
fn structure_members_may_not_be_anonymous() {
assert_eq!(
TlvReader::validate(&[0x15, 0x04, 0x2a, 0x18])
.unwrap_err()
.code(),
ErrorCode::TlvInvalidTag
);
}
#[test]
fn array_members_must_be_anonymous() {
assert_eq!(
TlvReader::validate(&[0x16, 0x24, 0x01, 0x2a, 0x18])
.unwrap_err()
.code(),
ErrorCode::TlvInvalidTag
);
}
#[test]
fn context_tag_may_not_be_outermost() {
assert_eq!(
TlvReader::validate(&[0x24, 0x01, 0x2a]).unwrap_err().code(),
ErrorCode::TlvInvalidTag
);
}
#[test]
fn end_of_container_must_have_zero_tag_control() {
assert_eq!(
TlvReader::validate(&[0x15, 0x38, 0x01]).unwrap_err().code(),
ErrorCode::TlvInvalidControl
);
}
#[test]
fn unbalanced_containers_are_refused() {
assert_eq!(
TlvReader::validate(&[0x15]).unwrap_err().code(),
ErrorCode::TlvContainerMismatch
);
assert_eq!(
TlvReader::validate(&[0x18]).unwrap_err().code(),
ErrorCode::TlvContainerMismatch
);
}
#[test]
fn only_one_top_level_element() {
assert_eq!(
TlvReader::validate(&[0x04, 0x2a, 0x04, 0x2b])
.unwrap_err()
.code(),
ErrorCode::TlvContainerMismatch
);
}
#[test]
fn truncation_is_an_error_not_a_panic() {
for cut in 1..8 {
let full = [0x0c, 0x06, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21];
let _ = TlvReader::validate(&full[..cut]);
}
assert_eq!(
TlvReader::validate(&[0x0c, 0x06, 0x48]).unwrap_err().code(),
ErrorCode::TlvTruncated
);
}
#[test]
fn invalid_utf8_is_refused() {
assert_eq!(
TlvReader::validate(&[0x0c, 0x02, 0xff, 0xfe])
.unwrap_err()
.code(),
ErrorCode::TlvInvalidUtf8
);
}
#[test]
fn depth_is_bounded() {
fn nested(levels: usize) -> heapless::Vec<u8, 128> {
let mut v = heapless::Vec::new();
for _ in 0..levels {
let _ = v.push(0x16);
}
for _ in 0..levels {
let _ = v.push(0x18);
}
v
}
assert!(
TlvReader::validate(&nested(MAX_DEPTH)).is_ok(),
"MAX_DEPTH levels must be readable"
);
assert_eq!(
TlvReader::validate(&nested(MAX_DEPTH + 1))
.unwrap_err()
.code(),
ErrorCode::TlvDepthExceeded
);
}
#[test]
fn skip_container_lands_after_the_end() {
let buf = [0x15, 0x24, 0x00, 0x2a, 0x24, 0x01, 0xef, 0x18];
let mut r = TlvReader::new(&buf);
let e = r.next_element().unwrap().unwrap();
assert_eq!(e.value, Value::Container(ContainerKind::Structure));
r.skip_container().unwrap();
assert!(r.is_empty());
r.finish().unwrap();
}
#[test]
fn a_huge_declared_length_is_truncation() {
let buf = [0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff];
assert_eq!(
TlvReader::validate(&buf).unwrap_err().code(),
ErrorCode::TlvTruncated
);
}
}