use thiserror::Error;
pub const MAXIMUM_TRANSFER_BYTES: usize = 65_536 * 251;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TransferBlock {
pub sequence: u16,
pub last: bool,
pub data: Vec<u8>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TransferProgress {
pub next_sequence: u16,
pub transferred_bytes: usize,
pub complete: bool,
}
#[derive(Debug, Clone)]
pub struct BlockSender<'a> {
source: &'a [u8],
block_size: usize,
offset: usize,
sequence: u16,
complete: bool,
}
impl<'a> BlockSender<'a> {
pub fn new(source: &'a [u8], block_size: usize) -> Result<Self, TransferError> {
if !(1..=251).contains(&block_size) {
return Err(TransferError::BlockSize(block_size));
}
if source.len() > MAXIMUM_TRANSFER_BYTES {
return Err(TransferError::Limit);
}
let required_blocks = source.len().max(1).div_ceil(block_size);
if required_blocks > usize::from(u16::MAX) + 1 {
return Err(TransferError::SequenceSpace);
}
Ok(Self {
source,
block_size,
offset: 0,
sequence: 0,
complete: false,
})
}
pub fn next_block(&mut self) -> Result<Option<TransferBlock>, TransferError> {
if self.complete {
return Ok(None);
}
let end = self
.offset
.saturating_add(self.block_size)
.min(self.source.len());
let last = end == self.source.len();
let block = TransferBlock {
sequence: self.sequence,
last,
data: self.source[self.offset..end].to_vec(),
};
self.offset = end;
self.complete = last;
if !last {
self.sequence = self
.sequence
.checked_add(1)
.ok_or(TransferError::SequenceSpace)?;
}
Ok(Some(block))
}
pub fn progress(&self) -> TransferProgress {
TransferProgress {
next_sequence: self.sequence,
transferred_bytes: self.offset.min(self.source.len()),
complete: self.complete,
}
}
}
#[derive(Debug, Clone)]
pub struct BlockReceiver {
bytes: Vec<u8>,
maximum_bytes: usize,
next_sequence: u16,
complete: bool,
}
impl BlockReceiver {
pub fn new(maximum_bytes: usize) -> Self {
Self {
bytes: Vec::new(),
maximum_bytes: maximum_bytes.min(MAXIMUM_TRANSFER_BYTES),
next_sequence: 0,
complete: false,
}
}
pub fn try_new(maximum_bytes: usize) -> Result<Self, TransferError> {
if maximum_bytes > MAXIMUM_TRANSFER_BYTES {
return Err(TransferError::Limit);
}
Ok(Self::new(maximum_bytes))
}
pub const fn maximum_bytes(&self) -> usize {
self.maximum_bytes
}
pub fn accept(&mut self, block: &TransferBlock) -> Result<TransferProgress, TransferError> {
if self.complete {
return Err(TransferError::AlreadyComplete);
}
if block.data.len() > 251 {
return Err(TransferError::BlockDataSize(block.data.len()));
}
if block.data.is_empty() && !block.last {
return Err(TransferError::EmptyIntermediateBlock);
}
if block.sequence != self.next_sequence {
return Err(TransferError::OutOfOrder {
expected: self.next_sequence,
actual: block.sequence,
});
}
let new_len = self
.bytes
.len()
.checked_add(block.data.len())
.ok_or(TransferError::Limit)?;
if new_len > self.maximum_bytes {
return Err(TransferError::Limit);
}
self.bytes.extend_from_slice(&block.data);
self.complete = block.last;
if !block.last {
self.next_sequence = self
.next_sequence
.checked_add(1)
.ok_or(TransferError::SequenceSpace)?;
}
Ok(self.progress())
}
pub fn progress(&self) -> TransferProgress {
TransferProgress {
next_sequence: self.next_sequence,
transferred_bytes: self.bytes.len(),
complete: self.complete,
}
}
pub fn finish(self) -> Result<Vec<u8>, TransferError> {
if self.complete {
Ok(self.bytes)
} else {
Err(TransferError::Incomplete)
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Error)]
pub enum TransferError {
#[error("block size {0} is outside 1..=251")]
BlockSize(usize),
#[error("block contains {0} data bytes and exceeds the 251-byte limit")]
BlockDataSize(usize),
#[error("a non-final transfer block cannot be empty")]
EmptyIntermediateBlock,
#[error("expected block {expected}, received {actual}")]
OutOfOrder {
expected: u16,
actual: u16,
},
#[error("block-transfer data limit exceeded")]
Limit,
#[error("transfer is already complete")]
AlreadyComplete,
#[error("transfer is not complete")]
Incomplete,
#[error("block-number space exhausted")]
SequenceSpace,
}