use super::{Rejected, StatusCode};
use crate::error::{Error, ErrorCode, Result};
pub const VERSION: u8 = 0;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum MessageType {
SendInit = 0x01,
SendAccept = 0x02,
ReceiveInit = 0x04,
ReceiveAccept = 0x05,
BlockQuery = 0x10,
Block = 0x11,
BlockEof = 0x12,
BlockAck = 0x13,
BlockAckEof = 0x14,
BlockQueryWithSkip = 0x15,
}
impl MessageType {
pub const fn from_u8(value: u8) -> Rejected<Self> {
Ok(match value {
0x01 => Self::SendInit,
0x02 => Self::SendAccept,
0x04 => Self::ReceiveInit,
0x05 => Self::ReceiveAccept,
0x10 => Self::BlockQuery,
0x11 => Self::Block,
0x12 => Self::BlockEof,
0x13 => Self::BlockAck,
0x14 => Self::BlockAckEof,
0x15 => Self::BlockQueryWithSkip,
_ => return Err(StatusCode::UnexpectedMessage),
})
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct TransferControl {
pub version: u8,
pub sender_drive: bool,
pub receiver_drive: bool,
pub asynchronous: bool,
}
impl TransferControl {
const VERSION_MASK: u8 = 0x0F;
const SENDER_DRIVE: u8 = 1 << 4;
const RECEIVER_DRIVE: u8 = 1 << 5;
const ASYNC: u8 = 1 << 6;
#[must_use]
pub const fn proposal() -> Self {
Self {
version: VERSION,
sender_drive: true,
receiver_drive: true,
asynchronous: false,
}
}
#[must_use]
pub const fn from_u8(value: u8) -> Self {
Self {
version: value & Self::VERSION_MASK,
sender_drive: value & Self::SENDER_DRIVE != 0,
receiver_drive: value & Self::RECEIVER_DRIVE != 0,
asynchronous: value & Self::ASYNC != 0,
}
}
#[must_use]
pub const fn to_u8(self) -> u8 {
let mut out = self.version & Self::VERSION_MASK;
if self.sender_drive {
out |= Self::SENDER_DRIVE;
}
if self.receiver_drive {
out |= Self::RECEIVER_DRIVE;
}
if self.asynchronous {
out |= Self::ASYNC;
}
out
}
#[must_use]
pub const fn is_decided(self) -> bool {
self.sender_drive ^ self.receiver_drive
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
struct RangeControl {
definite_length: bool,
start_offset: bool,
wide_range: bool,
}
impl RangeControl {
const DEFLEN: u8 = 1 << 0;
const STARTOFS: u8 = 1 << 1;
const WIDERANGE: u8 = 1 << 4;
const fn from_u8(value: u8) -> Self {
Self {
definite_length: value & Self::DEFLEN != 0,
start_offset: value & Self::STARTOFS != 0,
wide_range: value & Self::WIDERANGE != 0,
}
}
const fn to_u8(self) -> u8 {
let mut out = 0;
if self.definite_length {
out |= Self::DEFLEN;
}
if self.start_offset {
out |= Self::STARTOFS;
}
if self.wide_range {
out |= Self::WIDERANGE;
}
out
}
const fn width(self) -> usize {
if self.wide_range { 8 } else { 4 }
}
}
const fn needs_wide(value: u64) -> bool {
value > u32::MAX as u64
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Init<'a> {
pub control: TransferControl,
pub max_block_size: u16,
pub start_offset: Option<u64>,
pub definite_length: Option<u64>,
pub file_designator: &'a [u8],
pub metadata: &'a [u8],
}
impl<'a> Init<'a> {
#[must_use]
pub const fn new(file_designator: &'a [u8], max_block_size: u16) -> Self {
Self {
control: TransferControl::proposal(),
max_block_size,
start_offset: None,
definite_length: None,
file_designator,
metadata: &[],
}
}
fn range(&self) -> RangeControl {
let offset = self.start_offset.unwrap_or(0);
let length = self.definite_length.unwrap_or(0);
RangeControl {
definite_length: self.definite_length.is_some_and(|len| len != 0),
start_offset: self.start_offset.is_some(),
wide_range: needs_wide(offset) || needs_wide(length),
}
}
pub fn encode(&self, buf: &mut [u8]) -> Result<usize> {
let range = self.range();
let mut w = Writer::new(buf);
w.u8(self.control.to_u8())?;
w.u8(range.to_u8())?;
w.u16(self.max_block_size)?;
if range.start_offset {
w.uint(self.start_offset.unwrap_or(0), range.width())?;
}
if range.definite_length {
w.uint(self.definite_length.unwrap_or(0), range.width())?;
}
let designator_len = u16::try_from(self.file_designator.len())
.map_err(|_| Error::new(ErrorCode::NoSpace))?;
w.u16(designator_len)?;
w.bytes(self.file_designator)?;
w.bytes(self.metadata)?;
Ok(w.written())
}
pub fn decode(payload: &'a [u8]) -> Rejected<Self> {
let mut r = Reader::new(payload);
let control = TransferControl::from_u8(r.u8()?);
let range = RangeControl::from_u8(r.u8()?);
let max_block_size = r.u16()?;
let start_offset = if range.start_offset {
Some(r.uint(range.width())?)
} else {
None
};
let definite_length = if range.definite_length {
Some(r.uint(range.width())?).filter(|len| *len != 0)
} else {
None
};
let designator_len = usize::from(r.u16()?);
let file_designator = r.bytes(designator_len)?;
Ok(Self {
control,
max_block_size,
start_offset,
definite_length,
file_designator,
metadata: r.rest(),
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SendAccept<'a> {
pub control: TransferControl,
pub max_block_size: u16,
pub metadata: &'a [u8],
}
impl<'a> SendAccept<'a> {
pub fn encode(&self, buf: &mut [u8]) -> Result<usize> {
let mut w = Writer::new(buf);
w.u8(self.control.to_u8())?;
w.u16(self.max_block_size)?;
w.bytes(self.metadata)?;
Ok(w.written())
}
pub fn decode(payload: &'a [u8]) -> Rejected<Self> {
let mut r = Reader::new(payload);
let control = TransferControl::from_u8(r.u8()?);
let max_block_size = r.u16()?;
Ok(Self {
control,
max_block_size,
metadata: r.rest(),
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ReceiveAccept<'a> {
pub control: TransferControl,
pub max_block_size: u16,
pub length: Option<u64>,
pub metadata: &'a [u8],
}
impl<'a> ReceiveAccept<'a> {
fn range(&self) -> RangeControl {
let length = self.length.unwrap_or(0);
RangeControl {
definite_length: self.length.is_some_and(|len| len != 0),
start_offset: false,
wide_range: needs_wide(length),
}
}
pub fn encode(&self, buf: &mut [u8]) -> Result<usize> {
let range = self.range();
let mut w = Writer::new(buf);
w.u8(self.control.to_u8())?;
w.u8(range.to_u8())?;
w.u16(self.max_block_size)?;
if range.definite_length {
w.uint(self.length.unwrap_or(0), range.width())?;
}
w.bytes(self.metadata)?;
Ok(w.written())
}
pub fn decode(payload: &'a [u8]) -> Rejected<Self> {
let mut r = Reader::new(payload);
let control = TransferControl::from_u8(r.u8()?);
let range = RangeControl::from_u8(r.u8()?);
let max_block_size = r.u16()?;
let length = if range.definite_length {
Some(r.uint(range.width())?).filter(|len| *len != 0)
} else {
None
};
Ok(Self {
control,
max_block_size,
length,
metadata: r.rest(),
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Block<'a> {
pub counter: u32,
pub data: &'a [u8],
}
impl<'a> Block<'a> {
pub fn encode(&self, buf: &mut [u8]) -> Result<usize> {
let mut w = Writer::new(buf);
w.u32(self.counter)?;
w.bytes(self.data)?;
Ok(w.written())
}
pub fn decode(payload: &'a [u8]) -> Rejected<Self> {
let mut r = Reader::new(payload);
let counter = r.u32()?;
Ok(Self {
counter,
data: r.rest(),
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Counter {
pub counter: u32,
}
impl Counter {
pub fn encode(&self, buf: &mut [u8]) -> Result<usize> {
let mut w = Writer::new(buf);
w.u32(self.counter)?;
Ok(w.written())
}
pub fn decode(payload: &[u8]) -> Rejected<Self> {
let mut r = Reader::new(payload);
let counter = r.u32()?;
r.end()?;
Ok(Self { counter })
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct BlockQueryWithSkip {
pub counter: u32,
pub bytes_to_skip: u64,
}
impl BlockQueryWithSkip {
pub fn encode(&self, buf: &mut [u8]) -> Result<usize> {
let mut w = Writer::new(buf);
w.u32(self.counter)?;
w.uint(self.bytes_to_skip, 8)?;
Ok(w.written())
}
pub fn decode(payload: &[u8]) -> Rejected<Self> {
let mut r = Reader::new(payload);
let counter = r.u32()?;
let bytes_to_skip = r.uint(8)?;
r.end()?;
Ok(Self {
counter,
bytes_to_skip,
})
}
}
struct Reader<'a> {
rest: &'a [u8],
}
impl<'a> Reader<'a> {
const fn new(payload: &'a [u8]) -> Self {
Self { rest: payload }
}
fn bytes(&mut self, len: usize) -> Rejected<&'a [u8]> {
let (head, tail) = self
.rest
.split_at_checked(len)
.ok_or(StatusCode::BadMessageContents)?;
self.rest = tail;
Ok(head)
}
fn u8(&mut self) -> Rejected<u8> {
let bytes = self.bytes(1)?;
bytes.first().copied().ok_or(StatusCode::BadMessageContents)
}
fn u16(&mut self) -> Rejected<u16> {
let bytes =
<[u8; 2]>::try_from(self.bytes(2)?).map_err(|_| StatusCode::BadMessageContents)?;
Ok(u16::from_le_bytes(bytes))
}
fn u32(&mut self) -> Rejected<u32> {
let bytes =
<[u8; 4]>::try_from(self.bytes(4)?).map_err(|_| StatusCode::BadMessageContents)?;
Ok(u32::from_le_bytes(bytes))
}
fn uint(&mut self, width: usize) -> Rejected<u64> {
let mut out = [0u8; 8];
let bytes = self.bytes(width)?;
let slot = out.get_mut(..width).ok_or(StatusCode::BadMessageContents)?;
slot.copy_from_slice(bytes);
Ok(u64::from_le_bytes(out))
}
const fn rest(&self) -> &'a [u8] {
self.rest
}
fn end(&self) -> Rejected<()> {
if self.rest.is_empty() {
Ok(())
} else {
Err(StatusCode::BadMessageContents)
}
}
}
struct Writer<'a> {
buf: &'a mut [u8],
at: usize,
}
impl<'a> Writer<'a> {
const fn new(buf: &'a mut [u8]) -> Self {
Self { buf, at: 0 }
}
const fn written(&self) -> usize {
self.at
}
fn bytes(&mut self, bytes: &[u8]) -> Result<()> {
let end = self
.at
.checked_add(bytes.len())
.ok_or(Error::new(ErrorCode::BufferTooSmall))?;
let slot = self
.buf
.get_mut(self.at..end)
.ok_or(Error::new(ErrorCode::BufferTooSmall))?;
slot.copy_from_slice(bytes);
self.at = end;
Ok(())
}
fn u8(&mut self, value: u8) -> Result<()> {
self.bytes(&[value])
}
fn u16(&mut self, value: u16) -> Result<()> {
self.bytes(&value.to_le_bytes())
}
fn u32(&mut self, value: u32) -> Result<()> {
self.bytes(&value.to_le_bytes())
}
fn uint(&mut self, value: u64, width: usize) -> Result<()> {
let bytes = value.to_le_bytes();
let slot = bytes
.get(..width)
.ok_or(Error::new(ErrorCode::InvalidArgument))?;
self.bytes(slot)
}
}