use crate::error::{Error, ErrorCode, Result};
use crate::msg::ProtocolId;
use crate::sc::status::{GeneralCode, StatusReport};
pub const LENGTH_PREFIX: usize = 4;
pub const DATAGRAM_MAX: usize = 1280;
pub const DEFAULT_MAX_MESSAGE: usize = 64 * 1024;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Framed<'a> {
Message(&'a [u8]),
Incomplete {
needed: usize,
},
}
#[derive(Debug)]
pub struct Framer<const N: usize> {
body: heapless::Vec<u8, N>,
prefix: heapless::Vec<u8, LENGTH_PREFIX>,
expecting: Option<usize>,
failed: bool,
taken: bool,
}
impl<const N: usize> Default for Framer<N> {
fn default() -> Self {
Self::new()
}
}
impl<const N: usize> Framer<N> {
#[must_use]
pub const fn new() -> Self {
Self {
body: heapless::Vec::new(),
prefix: heapless::Vec::new(),
expecting: None,
failed: false,
taken: false,
}
}
#[must_use]
pub const fn max_message(&self) -> usize {
N
}
#[must_use]
pub const fn is_failed(&self) -> bool {
self.failed
}
#[must_use]
pub fn buffered(&self) -> usize {
if self.taken {
return 0;
}
self.body.len().saturating_add(self.prefix.len())
}
pub fn push(&mut self, bytes: &[u8]) -> Result<usize> {
self.guard()?;
self.drain();
let mut consumed = 0usize;
let mut rest = bytes;
while !rest.is_empty() {
let took = match self.expecting {
None => self.take_prefix(rest)?,
Some(length) => self.take_body(rest, length)?,
};
if took == 0 {
break;
}
consumed = consumed.saturating_add(took);
rest = rest.get(took..).unwrap_or(&[]);
}
Ok(consumed)
}
pub fn poll(&mut self) -> Result<Framed<'_>> {
self.guard()?;
self.drain();
let Some(length) = self.expecting else {
return Ok(Framed::Incomplete {
needed: LENGTH_PREFIX.saturating_sub(self.prefix.len()),
});
};
if self.body.len() < length {
return Ok(Framed::Incomplete {
needed: length.saturating_sub(self.body.len()),
});
}
self.taken = true;
Ok(Framed::Message(&self.body))
}
const fn guard(&self) -> Result<()> {
if self.failed {
return Err(Error::new(ErrorCode::MessageTooLarge));
}
Ok(())
}
fn drain(&mut self) {
if !self.taken {
return;
}
self.taken = false;
self.body.clear();
self.expecting = None;
}
fn take_body(&mut self, bytes: &[u8], length: usize) -> Result<usize> {
let take = length.saturating_sub(self.body.len()).min(bytes.len());
let Some(chunk) = bytes.get(..take) else {
return Ok(0);
};
self.body
.extend_from_slice(chunk)
.map_err(|_| Error::new(ErrorCode::BufferTooSmall))?;
Ok(take)
}
fn take_prefix(&mut self, bytes: &[u8]) -> Result<usize> {
let wanted = LENGTH_PREFIX.saturating_sub(self.prefix.len());
let take = wanted.min(bytes.len());
let Some(chunk) = bytes.get(..take) else {
return Ok(0);
};
self.prefix
.extend_from_slice(chunk)
.map_err(|_| Error::new(ErrorCode::BufferTooSmall))?;
if self.prefix.len() < LENGTH_PREFIX {
return Ok(take);
}
let bytes = <[u8; LENGTH_PREFIX]>::try_from(self.prefix.as_slice())
.map_err(|_| Error::new(ErrorCode::BufferTooSmall))?;
self.prefix.clear();
let length = usize::try_from(u32::from_le_bytes(bytes))
.map_err(|_| Error::new(ErrorCode::MessageTooLarge))?;
if length == 0 || length > N {
self.failed = true;
return Err(Error::new(ErrorCode::MessageTooLarge));
}
self.expecting = Some(length);
Ok(take)
}
}
pub fn frame<'b>(message: &[u8], buf: &'b mut [u8]) -> Result<&'b [u8]> {
let total = LENGTH_PREFIX
.checked_add(message.len())
.ok_or_else(|| Error::new(ErrorCode::MessageTooLarge))?;
if total > buf.len() {
return Err(Error::new(ErrorCode::BufferTooSmall));
}
let length =
u32::try_from(message.len()).map_err(|_| Error::new(ErrorCode::MessageTooLarge))?;
let (prefix, rest) = buf
.split_at_mut_checked(LENGTH_PREFIX)
.ok_or_else(|| Error::new(ErrorCode::BufferTooSmall))?;
prefix.copy_from_slice(&length.to_le_bytes());
let body = rest
.get_mut(..message.len())
.ok_or_else(|| Error::new(ErrorCode::BufferTooSmall))?;
body.copy_from_slice(message);
buf.get(..total)
.ok_or_else(|| Error::new(ErrorCode::BufferTooSmall))
}
pub fn too_large(buf: &mut [u8]) -> Result<&[u8]> {
let written = StatusReport {
general: GeneralCode::MessageTooLarge,
protocol: ProtocolId::SECURE_CHANNEL,
protocol_code: 0,
data: &[],
}
.encode(buf)?;
buf.get(..written)
.ok_or_else(|| Error::new(ErrorCode::BufferTooSmall))
}