use crate::decode::{Decoder, SKIP_LIMIT};
use crate::error::Error as E;
use crate::head::{self, Major};
#[derive(Clone, Copy)]
struct Frame {
left: usize,
map: bool,
prev_key: Option<(usize, usize)>,
}
pub fn check(input: &[u8]) -> Result<(), E> {
let mut d = Decoder::new(input);
walk_item(&mut d)?;
match d.is_empty() {
true => Ok(()),
false => Err(E::TRUNCATED),
}
}
pub fn check_all(input: &[u8]) -> Result<(), E> {
let mut d = Decoder::new(input);
while !d.is_empty() {
walk_item(&mut d)?;
}
Ok(())
}
fn walk_item(d: &mut Decoder<'_>) -> Result<(), E> {
let mut stack = [Frame { left: 0, map: false, prev_key: None }; SKIP_LIMIT];
stack[0] = Frame { left: 1, map: false, prev_key: None };
let mut sp = 1usize;
let mut bignum_tag: Option<u64> = None;
loop {
let start = d.position();
let Some(&initial) = d.input.get(d.pos) else {
return Err(E::TRUNCATED);
};
if head::is_break(initial) {
return Err(E::UNEXPECTED_BREAK);
}
let ai = initial & 0x1f;
let (major, arg, indef) = d.next_head_ext()?;
let was_bignum = bignum_tag.take();
if indef {
return Err(E::NOT_CANONICAL);
}
if !matches!(major, Major::Simple) && ai != head::ai_of(arg) {
return Err(E::NOT_CANONICAL);
}
match major {
Major::Tag => {
bignum_tag = matches!(arg, 2 | 3).then_some(arg);
continue;
}
Major::Unsigned | Major::Negative => {}
Major::Bytes | Major::Text => {
if was_bignum.is_some() && !bignum_preferred_content(d, arg) {
return Err(E::NOT_CANONICAL);
}
let len = d.content_len(arg)?;
d.pos += len;
}
Major::Simple => check_simple(ai, arg, d)?,
Major::Array | Major::Map => {
let items = match major {
Major::Map => usize::try_from(arg.saturating_mul(2))
.map_err(|_| E::INTEGER_OUT_OF_RANGE)?,
_ => usize::try_from(arg).map_err(|_| E::INTEGER_OUT_OF_RANGE)?,
};
if items > 0 {
sp = push(
&mut stack,
sp,
Frame { left: items, map: major == Major::Map, prev_key: None },
)?;
continue;
}
}
}
if unwind(&mut stack, &mut sp, d.input, start, d.position())? {
return Ok(());
}
}
}
fn bignum_preferred_content(d: &Decoder<'_>, len: u64) -> bool {
let start = d.position();
match d.input.get(start..start + len as usize) {
Some(content) => !content.is_empty() && content[0] != 0,
None => false, }
}
fn check_simple(ai: u8, arg: u64, d: &Decoder<'_>) -> Result<(), E> {
#[cfg(not(feature = "float"))]
let _ = d;
match ai {
0..=23 => Ok(()),
24 if arg >= 32 => Ok(()),
#[cfg(feature = "float")]
25..=27 => check_float_width(ai, d),
#[cfg(not(feature = "float"))]
25..=27 => Ok(()),
_ => Err(E::NOT_CANONICAL),
}
}
#[cfg(feature = "float")]
fn check_float_width(ai: u8, d: &Decoder<'_>) -> Result<(), E> {
use crate::float::{f16_bits_of, f32_of_f16_bits};
let ext = head::ext_len(ai);
let bits = &d.input[d.pos - ext..d.pos];
match ai {
25 => Ok(()),
26 => {
let v = f32::from_bits(u32::from_be_bytes([bits[0], bits[1], bits[2], bits[3]]));
match f16_bits_of(v).is_some() {
true => Err(E::NOT_CANONICAL), false => Ok(()),
}
}
_ => {
let v = f64::from_bits(u64::from_be_bytes([
bits[0], bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7],
]));
let fits_half =
f16_bits_of(v as f32).is_some_and(|h| f64::from(f32_of_f16_bits(h)) == v);
let fits_single = f64::from(v as f32) == v;
match fits_half || fits_single || v.is_nan() {
true => Err(E::NOT_CANONICAL),
false => Ok(()),
}
}
}
}
fn push(stack: &mut [Frame; SKIP_LIMIT], sp: usize, frame: Frame) -> Result<usize, E> {
match sp < SKIP_LIMIT {
true => {
stack[sp] = frame;
Ok(sp + 1)
}
false => Err(E::DEPTH_EXCEEDED),
}
}
fn unwind(
stack: &mut [Frame; SKIP_LIMIT],
sp: &mut usize,
input: &[u8],
start: usize,
end: usize,
) -> Result<bool, E> {
loop {
let top = &mut stack[*sp - 1];
if top.map && top.left.is_multiple_of(2) {
if let Some((ps, pe)) = top.prev_key
&& input[ps..pe] >= input[start..end]
{
return Err(E::NOT_CANONICAL); }
top.prev_key = Some((start, end));
}
top.left -= 1;
if top.left != 0 {
return Ok(false);
}
if *sp == 1 {
return Ok(true);
}
*sp -= 1;
}
}