use super::message::{Init, MessageType, ReceiveAccept, SendAccept, TransferControl, VERSION};
use super::{Rejected, StatusCode};
const FIRST_COUNTER: u32 = 0;
pub const DEFAULT_MAX_BLOCK_SIZE: u16 = 1024;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Direction {
Upload,
Download,
}
impl Direction {
#[must_use]
pub const fn init(self) -> MessageType {
match self {
Self::Upload => MessageType::SendInit,
Self::Download => MessageType::ReceiveInit,
}
}
#[must_use]
pub const fn accept(self) -> MessageType {
match self {
Self::Upload => MessageType::SendAccept,
Self::Download => MessageType::ReceiveAccept,
}
}
}
#[derive(Debug, Clone, Copy)]
pub struct Limits {
pub max_block_size: u16,
pub max_length: Option<u64>,
pub min_length: Option<u64>,
pub require_definite_length: bool,
pub allow_start_offset: bool,
pub available: Option<u64>,
pub busy: bool,
}
impl Default for Limits {
fn default() -> Self {
Self {
max_block_size: DEFAULT_MAX_BLOCK_SIZE,
max_length: None,
min_length: None,
require_definite_length: false,
allow_start_offset: true,
available: None,
busy: false,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Parameters {
pub control: TransferControl,
pub max_block_size: u16,
pub start_offset: u64,
pub length: Option<u64>,
}
impl Parameters {
#[must_use]
pub const fn sender_drives(&self) -> bool {
self.control.sender_drive
}
#[must_use]
pub const fn receiver_drives(&self) -> bool {
self.control.receiver_drive
}
#[must_use]
pub const fn send_accept<'a>(&self, metadata: &'a [u8]) -> SendAccept<'a> {
SendAccept {
control: self.control,
max_block_size: self.max_block_size,
metadata,
}
}
#[must_use]
pub const fn receive_accept<'a>(&self, metadata: &'a [u8]) -> ReceiveAccept<'a> {
ReceiveAccept {
control: self.control,
max_block_size: self.max_block_size,
length: self.length,
metadata,
}
}
pub fn from_send_accept(proposed: &Init<'_>, accept: &SendAccept<'_>) -> Rejected<Self> {
let control = check_accepted(proposed.control, accept.control)?;
Ok(Self {
control,
max_block_size: check_block_size(proposed.max_block_size, accept.max_block_size)?,
start_offset: proposed.start_offset.unwrap_or(0),
length: proposed.definite_length,
})
}
pub fn from_receive_accept(proposed: &Init<'_>, accept: &ReceiveAccept<'_>) -> Rejected<Self> {
let control = check_accepted(proposed.control, accept.control)?;
if let (Some(asked), Some(offered)) = (proposed.definite_length, accept.length) {
if offered > asked {
return Err(StatusCode::LengthTooLarge);
}
}
Ok(Self {
control,
max_block_size: check_block_size(proposed.max_block_size, accept.max_block_size)?,
start_offset: proposed.start_offset.unwrap_or(0),
length: accept.length,
})
}
}
pub fn negotiate(direction: Direction, init: &Init<'_>, limits: &Limits) -> Rejected<Parameters> {
if limits.busy {
return Err(StatusCode::ResponderBusy);
}
if init.max_block_size == 0 {
return Err(StatusCode::BadMessageContents);
}
if !init.control.sender_drive && !init.control.receiver_drive {
return Err(StatusCode::TransferMethodNotSupported);
}
let start_offset = match init.start_offset {
Some(_) if !limits.allow_start_offset => return Err(StatusCode::StartOffsetNotSupported),
Some(offset) => offset,
None => 0,
};
if let Some(length) = init.definite_length {
if limits.max_length.is_some_and(|max| length > max) {
return Err(StatusCode::LengthTooLarge);
}
if limits.min_length.is_some_and(|min| length < min) {
return Err(StatusCode::LengthTooShort);
}
} else if limits.require_definite_length {
return Err(StatusCode::LengthRequired);
}
let length = match direction {
Direction::Upload => init.definite_length,
Direction::Download => match (init.definite_length, limits.available) {
(Some(asked), Some(have)) => Some(asked.min(have)),
(Some(asked), None) => Some(asked),
(None, have) => have,
},
};
Ok(Parameters {
control: TransferControl {
version: VERSION,
sender_drive: init.control.sender_drive,
receiver_drive: init.control.receiver_drive && !init.control.sender_drive,
asynchronous: false,
},
max_block_size: init.max_block_size.min(limits.max_block_size),
start_offset,
length,
})
}
fn check_accepted(
proposed: TransferControl,
accepted: TransferControl,
) -> Rejected<TransferControl> {
if accepted.version > proposed.version {
return Err(StatusCode::VersionNotSupported);
}
if accepted.asynchronous || !accepted.is_decided() {
return Err(StatusCode::TransferMethodNotSupported);
}
let offered = (accepted.sender_drive && proposed.sender_drive)
|| (accepted.receiver_drive && proposed.receiver_drive);
if !offered {
return Err(StatusCode::TransferMethodNotSupported);
}
Ok(accepted)
}
fn check_block_size(proposed: u16, accepted: u16) -> Rejected<u16> {
if accepted == 0 || accepted > proposed {
return Err(StatusCode::BadMessageContents);
}
Ok(accepted)
}
#[derive(Debug)]
pub struct Sender {
params: Parameters,
cursor: u64,
sent: u64,
counter: Option<u32>,
queried: bool,
finished: bool,
complete: bool,
}
impl Sender {
#[must_use]
pub const fn new(params: Parameters) -> Self {
Self {
cursor: params.start_offset,
params,
sent: 0,
counter: None,
queried: false,
finished: false,
complete: false,
}
}
#[must_use]
pub const fn parameters(&self) -> &Parameters {
&self.params
}
#[must_use]
pub const fn cursor(&self) -> u64 {
self.cursor
}
#[must_use]
pub const fn sent(&self) -> u64 {
self.sent
}
#[must_use]
pub const fn is_complete(&self) -> bool {
self.complete
}
#[must_use]
pub const fn may_send(&self) -> bool {
if self.finished || self.complete {
return false;
}
self.params.control.sender_drive || self.queried
}
#[must_use]
pub fn room(&self) -> usize {
let block = usize::from(self.params.max_block_size);
match self.params.length {
Some(length) => usize::try_from(length.saturating_sub(self.sent))
.unwrap_or(usize::MAX)
.min(block),
None => block,
}
}
pub fn on_query(&mut self, counter: u32) -> Rejected<()> {
self.on_query_with_skip(counter, 0).map(|_| ())
}
pub fn on_query_with_skip(&mut self, counter: u32, bytes_to_skip: u64) -> Rejected<u64> {
if self.finished || self.complete {
return Err(StatusCode::UnexpectedMessage);
}
if !self.params.control.receiver_drive {
return Err(StatusCode::UnexpectedMessage);
}
if self.queried {
return Err(StatusCode::UnexpectedMessage);
}
if counter != self.next_counter() {
return Err(StatusCode::BadBlockCounter);
}
self.queried = true;
self.cursor = self.cursor.saturating_add(bytes_to_skip);
Ok(self.cursor)
}
pub fn block(&mut self, len: usize, eof: bool) -> Rejected<u32> {
if !self.may_send() {
return Err(StatusCode::UnexpectedMessage);
}
if len > usize::from(self.params.max_block_size) || (len == 0 && !eof) {
return Err(StatusCode::BadMessageContents);
}
let len64 = u64::try_from(len).unwrap_or(u64::MAX);
let total = self
.sent
.checked_add(len64)
.ok_or(StatusCode::LengthTooLarge)?;
if let Some(length) = self.params.length {
if total > length || (eof && total != length) {
return Err(StatusCode::LengthMismatch);
}
}
let counter = self.next_counter();
self.counter = Some(counter);
self.sent = total;
self.cursor = self.cursor.saturating_add(len64);
self.queried = false;
self.finished = eof;
Ok(counter)
}
pub fn on_ack(&mut self, counter: u32, eof: bool) -> Rejected<()> {
let Some(last) = self.counter else {
return Err(StatusCode::UnexpectedMessage);
};
if self.complete {
return Err(StatusCode::UnexpectedMessage);
}
if eof != self.finished {
return Err(StatusCode::UnexpectedMessage);
}
if counter != last {
return Err(StatusCode::BadBlockCounter);
}
self.complete = eof;
Ok(())
}
const fn next_counter(&self) -> u32 {
match self.counter {
Some(last) => last.wrapping_add(1),
None => FIRST_COUNTER,
}
}
}
#[derive(Debug)]
pub struct Receiver {
params: Parameters,
received: u64,
counter: Option<u32>,
query: u32,
pending: bool,
finished: bool,
complete: bool,
}
impl Receiver {
#[must_use]
pub const fn new(params: Parameters) -> Self {
Self {
params,
received: 0,
counter: None,
query: FIRST_COUNTER,
pending: false,
finished: false,
complete: false,
}
}
#[must_use]
pub const fn parameters(&self) -> &Parameters {
&self.params
}
#[must_use]
pub const fn received(&self) -> u64 {
self.received
}
#[must_use]
pub const fn is_complete(&self) -> bool {
self.complete
}
pub fn query(&mut self) -> Rejected<u32> {
if !self.params.control.receiver_drive || self.finished || self.complete {
return Err(StatusCode::UnexpectedMessage);
}
if self.awaiting() {
return Err(StatusCode::UnexpectedMessage);
}
self.pending = false;
let counter = self.query;
self.query = self.query.wrapping_add(1);
Ok(counter)
}
pub fn on_block(&mut self, counter: u32, len: usize, eof: bool) -> Rejected<()> {
if self.finished || self.complete {
return Err(StatusCode::UnexpectedMessage);
}
if self.params.control.receiver_drive && !self.awaiting() {
return Err(StatusCode::UnexpectedMessage);
}
if counter != self.next_counter() {
return Err(StatusCode::BadBlockCounter);
}
if len > usize::from(self.params.max_block_size) || (len == 0 && !eof) {
return Err(StatusCode::BadMessageContents);
}
let len64 = u64::try_from(len).unwrap_or(u64::MAX);
let total = self
.received
.checked_add(len64)
.ok_or(StatusCode::LengthTooLarge)?;
if let Some(length) = self.params.length {
if total > length || (eof && total != length) {
return Err(StatusCode::LengthMismatch);
}
}
self.received = total;
self.counter = Some(counter);
self.pending = true;
self.finished = eof;
Ok(())
}
pub fn ack(&mut self) -> Rejected<(MessageType, u32)> {
let (Some(counter), true) = (self.counter, self.pending) else {
return Err(StatusCode::UnexpectedMessage);
};
self.pending = false;
self.complete = self.finished;
Ok((
if self.finished {
MessageType::BlockAckEof
} else {
MessageType::BlockAck
},
counter,
))
}
const fn awaiting(&self) -> bool {
match self.counter {
Some(last) => self.query != last.wrapping_add(1),
None => self.query != FIRST_COUNTER,
}
}
const fn next_counter(&self) -> u32 {
match self.counter {
Some(last) => last.wrapping_add(1),
None => FIRST_COUNTER,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn agreed(sender_drive: bool) -> Parameters {
Parameters {
control: TransferControl {
version: VERSION,
sender_drive,
receiver_drive: !sender_drive,
asynchronous: false,
},
max_block_size: 16,
start_offset: 0,
length: None,
}
}
#[test]
fn block_counters_wrap_at_2_to_the_32() {
let mut sender = Sender::new(agreed(true));
sender.counter = Some(u32::MAX);
assert_eq!(sender.block(4, false), Ok(0));
let mut receiver = Receiver::new(agreed(true));
receiver.counter = Some(u32::MAX);
assert_eq!(receiver.on_block(0, 4, false), Ok(()));
let mut receiver = Receiver::new(agreed(true));
receiver.counter = Some(u32::MAX);
assert_eq!(
receiver.on_block(1, 4, false),
Err(StatusCode::BadBlockCounter)
);
}
#[test]
fn a_query_wraps_the_same_way() {
let mut sender = Sender::new(agreed(false));
sender.counter = Some(u32::MAX);
assert_eq!(sender.on_query(0), Ok(()));
}
}