use alloc::collections::BTreeSet;
use bytes::{Buf, Bytes, BytesMut};
use core::future::Future;
use super::error::{Error, ProtocolError, RxOverflow};
use super::protocol::command::Command;
use super::protocol::Packet;
use super::session::Session;
pub(crate) fn parse_ready_credit(payload: &[u8]) -> Result<u32, ProtocolError> {
if payload.len() >= 4 {
Ok(u32::from_le_bytes([
payload[0], payload[1], payload[2], payload[3],
]))
} else {
Err(ProtocolError::ShortReadyPayload)
}
}
pub(crate) enum AckDecision {
Now {
local_id: u32,
remote_id: u32,
len: usize,
},
Hold,
}
pub(crate) enum DispatchOutcome {
AckWrite {
#[allow(dead_code)] idx: usize,
local_id: u32,
remote_id: u32,
len: usize,
},
CreditGranted {
#[allow(dead_code)] idx: usize,
},
SlotClosed {
#[allow(dead_code)] idx: usize,
},
DataBuffered {
#[allow(dead_code)] idx: usize,
},
IncomingOpen {
remote_id: u32,
credit: u32,
destination: Bytes,
},
CancelPendingOpen {
remote_id: u32,
},
StrayReady {
local_id: u32,
remote_id: u32,
},
ChannelFault {
#[allow(dead_code)] idx: usize,
#[allow(dead_code)] local_id: u32,
#[allow(dead_code)] remote_id: u32,
#[allow(dead_code)] opening: bool,
fault: ChannelFault,
},
Unmatched,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ChannelFault {
RxOverflow,
Protocol(ProtocolError),
}
impl ChannelFault {
pub fn error<E>(self) -> Error<E> {
match self {
Self::RxOverflow => Error::ChannelRxOverflow,
Self::Protocol(e) => Error::Protocol(e),
}
}
}
#[derive(Debug)]
pub(crate) struct PendingOpen {
pub remote_id: u32,
pub credit: u32,
pub destination: Bytes,
}
pub(crate) fn clse_closes(arg0: u32, arg1: u32, local_id: u32, remote_id: u32) -> bool {
arg1 == local_id || (arg1 == 0 && arg0 == remote_id)
}
pub(crate) fn dispatch_packet(
channels: &mut [Option<ChannelSlot>],
pkt: &Packet,
delayed_ack: bool,
rx_cap: usize,
watermark: usize,
) -> DispatchOutcome {
if matches!(
pkt.command,
Command::Connect | Command::Auth | Command::StartTls
) {
log::warn!(
"dropping {:?} from the device after the handshake",
pkt.command
);
return DispatchOutcome::Unmatched;
}
if pkt.command == Command::Open {
return DispatchOutcome::IncomingOpen {
remote_id: pkt.arg0,
credit: pkt.arg1,
destination: pkt.data.clone(),
};
}
if pkt.command == Command::Close && pkt.arg1 == 0 {
if pkt.arg0 != 0 {
for (idx, slot_opt) in channels.iter_mut().enumerate() {
let Some(slot) = slot_opt else { continue };
if slot.remote_id == pkt.arg0 {
slot.apply_close();
return DispatchOutcome::SlotClosed { idx };
}
}
}
return DispatchOutcome::CancelPendingOpen {
remote_id: pkt.arg0,
};
}
for (idx, slot_opt) in channels.iter_mut().enumerate() {
let Some(slot) = slot_opt else { continue };
match pkt.command {
Command::Write | Command::Ready
if pkt.arg1 == slot.local_id && slot.failed.is_some() =>
{
return DispatchOutcome::Unmatched;
}
Command::Write if pkt.arg1 == slot.local_id => {
return match slot.apply_write(&pkt.data, rx_cap, delayed_ack, watermark) {
Ok(AckDecision::Now {
local_id,
remote_id,
len,
}) => DispatchOutcome::AckWrite {
idx,
local_id,
remote_id,
len,
},
Ok(AckDecision::Hold) => DispatchOutcome::DataBuffered { idx },
Err(RxOverflow) => slot.fault(idx, pkt.arg0, ChannelFault::RxOverflow),
};
}
Command::Ready if pkt.arg1 == slot.local_id => {
let granted = if slot.state == ChannelState::Opening {
slot.accept_open_ready(pkt.arg0, &pkt.data, delayed_ack)
} else {
slot.apply_ready(&pkt.data, delayed_ack)
};
return match granted {
Ok(()) => DispatchOutcome::CreditGranted { idx },
Err(e) => slot.fault(idx, pkt.arg0, ChannelFault::Protocol(e)),
};
}
Command::Close if pkt.arg1 == slot.local_id => {
slot.apply_close();
return DispatchOutcome::SlotClosed { idx };
}
_ => {}
}
}
if pkt.command == Command::Ready && pkt.arg0 != 0 && pkt.arg1 != 0 {
return DispatchOutcome::StrayReady {
local_id: pkt.arg1,
remote_id: pkt.arg0,
};
}
DispatchOutcome::Unmatched
}
#[derive(Debug)]
pub enum SelectResult<T> {
Data(usize),
Interrupted(T),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ChannelId {
pub(crate) slot: usize,
pub(crate) local_id: u32,
}
impl ChannelId {
pub fn from_raw(slot: usize, local_id: u32) -> Self {
Self { slot, local_id }
}
pub fn slot(self) -> usize {
self.slot
}
pub fn local_id(self) -> u32 {
self.local_id
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ChannelState {
Opening,
Open,
Closed,
}
pub(crate) struct ChannelSlot {
pub local_id: u32,
pub remote_id: u32,
pub state: ChannelState,
pub rx_buf: BytesMut,
pub wrte_acked: bool,
pub send_budget: i64,
pub unacked: usize,
pub send_q_head: u64,
pub send_q_tail: u64,
pub send_q_gone: BTreeSet<u64>,
pub failed: Option<ChannelFault>,
}
impl ChannelSlot {
pub fn new(local_id: u32) -> Self {
Self {
local_id,
remote_id: 0,
state: ChannelState::Opening,
rx_buf: BytesMut::new(),
wrte_acked: true,
send_budget: 0,
unacked: 0,
send_q_head: 0,
send_q_tail: 0,
send_q_gone: BTreeSet::new(),
failed: None,
}
}
pub fn channel_ids(&self) -> (u32, u32) {
(self.local_id, self.remote_id)
}
pub fn is_closed(&self) -> bool {
self.state == ChannelState::Closed
}
pub fn closed_error<E>(&self) -> Error<E> {
self.failed
.map_or(Error::ChannelClosed, ChannelFault::error)
}
#[allow(dead_code)] pub fn fail(&mut self, fault: ChannelFault) {
self.failed = Some(fault);
self.state = ChannelState::Closed;
self.unacked = 0;
}
fn fault(&self, idx: usize, remote_id: u32, fault: ChannelFault) -> DispatchOutcome {
DispatchOutcome::ChannelFault {
idx,
local_id: self.local_id,
remote_id,
opening: self.state == ChannelState::Opening,
fault,
}
}
pub fn accept_open_ready(
&mut self,
remote_id: u32,
payload: &[u8],
delayed_ack: bool,
) -> Result<(), ProtocolError> {
if delayed_ack {
self.send_budget = parse_ready_credit(payload)? as i64;
}
self.remote_id = remote_id;
self.state = ChannelState::Open;
Ok(())
}
pub fn apply_ready(&mut self, payload: &[u8], delayed_ack: bool) -> Result<(), ProtocolError> {
if delayed_ack {
self.send_budget += parse_ready_credit(payload)? as i64;
} else {
self.wrte_acked = true;
}
Ok(())
}
pub fn apply_write(
&mut self,
payload: &[u8],
cap: usize,
delayed_ack: bool,
watermark: usize,
) -> Result<AckDecision, RxOverflow> {
self.push_rx(payload, cap)?;
self.unacked = self.unacked.saturating_add(payload.len());
if !delayed_ack && self.rx_buf.len() < watermark {
self.unacked = 0;
return Ok(AckDecision::Now {
local_id: self.local_id,
remote_id: self.remote_id,
len: payload.len(),
});
}
Ok(AckDecision::Hold)
}
pub fn deliver(
&mut self,
payload: &[u8],
taken: usize,
cap: usize,
delayed_ack: bool,
watermark: usize,
) -> Result<Option<(u32, u32, usize)>, RxOverflow> {
if taken < payload.len() {
self.push_rx(&payload[taken..], cap)?;
self.unacked = self.unacked.saturating_add(payload.len() - taken);
}
if delayed_ack {
return Ok((taken > 0).then_some((self.local_id, self.remote_id, taken)));
}
if self.rx_buf.len() >= watermark {
return Ok(None);
}
let len = core::mem::take(&mut self.unacked);
Ok(Some((self.local_id, self.remote_id, len)))
}
pub fn consume(
&mut self,
n: usize,
delayed_ack: bool,
watermark: usize,
) -> Option<(u32, u32, usize)> {
let len = self.ack_len(n, self.rx_buf.len(), delayed_ack, watermark)?;
self.unacked -= len;
Some((self.local_id, self.remote_id, len))
}
#[allow(dead_code)] pub fn take_acks(&self, want: usize, delayed_ack: bool, watermark: usize) -> bool {
let n = want.min(self.rx_buf.len());
let remaining = self.rx_buf.len() - n;
self.ack_len(n, remaining, delayed_ack, watermark).is_some()
}
fn ack_len(
&self,
n: usize,
remaining: usize,
delayed_ack: bool,
watermark: usize,
) -> Option<usize> {
if self.unacked == 0 {
return None;
}
if delayed_ack {
let len = n.min(self.unacked);
return (len > 0).then_some(len);
}
(remaining < watermark).then_some(self.unacked)
}
#[allow(clippy::type_complexity)]
pub fn take_buffered<E>(
&mut self,
buf: &mut [u8],
delayed_ack: bool,
watermark: usize,
) -> Result<Option<(usize, Option<(u32, u32, usize)>)>, Error<E>> {
if self.rx_buf.is_empty() {
return if self.is_closed() {
Err(self.closed_error())
} else {
Ok(None)
};
}
let n = buf.len().min(self.rx_buf.len());
buf[..n].copy_from_slice(&self.rx_buf[..n]);
self.rx_buf.advance(n);
Ok(Some((n, self.consume(n, delayed_ack, watermark))))
}
pub fn push_rx(&mut self, payload: &[u8], cap: usize) -> Result<(), RxOverflow> {
if self.rx_buf.len().saturating_add(payload.len()) > cap {
return Err(RxOverflow);
}
self.rx_buf.extend_from_slice(payload);
Ok(())
}
pub fn apply_close(&mut self) {
self.state = ChannelState::Closed;
}
#[allow(dead_code)] pub fn try_reserve_send(&mut self, want: usize, delayed_ack: bool) -> Option<usize> {
if delayed_ack {
if self.send_budget > 0 {
let n = (self.send_budget as usize).min(want);
self.send_budget -= n as i64;
return Some(n);
}
} else if self.wrte_acked {
self.wrte_acked = false;
return Some(want);
}
None
}
#[allow(dead_code)] pub fn refund(&mut self, n: usize, delayed_ack: bool) {
if delayed_ack {
self.send_budget += n as i64;
} else {
self.wrte_acked = true;
}
}
#[allow(dead_code)] pub fn send_enqueue(&mut self) -> u64 {
let place = self.send_q_tail;
self.send_q_tail += 1;
place
}
#[allow(dead_code)] pub fn send_turn(&self) -> u64 {
self.send_q_head
}
#[allow(dead_code)] pub fn send_advance(&mut self) {
self.send_q_head += 1;
while self.send_q_gone.remove(&self.send_q_head) {
self.send_q_head += 1;
}
}
#[allow(dead_code)] pub fn send_leave(&mut self, place: u64) -> bool {
if place == self.send_q_head {
self.send_advance();
true
} else if place + 1 == self.send_q_tail {
self.send_q_tail = place;
while self.send_q_tail > self.send_q_head
&& self.send_q_gone.remove(&(self.send_q_tail - 1))
{
self.send_q_tail -= 1;
}
false
} else if place > self.send_q_head {
self.send_q_gone.insert(place);
false
} else {
false
}
}
}
pub(crate) fn channel_ids_of<E>(
channels: &[Option<ChannelSlot>],
ch: ChannelId,
) -> Result<(u32, u32), Error<E>> {
channels
.get(ch.slot)
.and_then(|s| s.as_ref())
.filter(|s| s.local_id == ch.local_id)
.map(ChannelSlot::channel_ids)
.ok_or(Error::ChannelClosed)
}
#[allow(dead_code)] pub(crate) fn slot_for_mut(
channels: &mut [Option<ChannelSlot>],
ch: ChannelId,
) -> Option<&mut ChannelSlot> {
channels
.get_mut(ch.slot)
.and_then(|s| s.as_mut())
.filter(|s| s.local_id == ch.local_id)
}
pub struct Channel<'a, S> {
pub(crate) session: &'a mut S,
pub(crate) id: ChannelId,
}
impl<S: Session> Channel<'_, S> {
pub async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error<S::IoError>> {
self.session.read_channel(self.id, buf).await
}
pub async fn write(&mut self, data: &[u8]) -> Result<(), Error<S::IoError>> {
self.session.write_channel(self.id, data).await
}
pub async fn select<F: Future>(
&mut self,
buf: &mut [u8],
interrupt: F,
) -> Result<SelectResult<F::Output>, Error<S::IoError>> {
self.session.select_channel(self.id, buf, interrupt).await
}
pub async fn close(self) -> Result<(), Error<S::IoError>> {
self.session.close_channel(self.id).await
}
}
#[cfg(test)]
mod tests {
use super::ChannelSlot;
#[test]
fn cancellation_churn_behind_a_blocked_head_does_not_accumulate() {
let mut slot = ChannelSlot::new(1);
let _head = slot.send_enqueue();
for _ in 0..1_000 {
let mid = slot.send_enqueue();
let tail = slot.send_enqueue();
assert!(!slot.send_leave(mid));
assert!(!slot.send_leave(tail));
}
assert!(slot.send_q_gone.is_empty());
assert_eq!(slot.send_q_tail, 1);
assert_eq!(slot.send_q_head, 0);
}
}