use alloc::collections::BTreeSet;
use bytes::BytesMut;
use core::future::Future;
use embedded_io::ErrorType;
use embedded_io_async::{Read, Write};
use super::connection::{
Connection, DEFAULT_MAX_CHANNELS, DEFAULT_MAX_FEATURES, DEFAULT_MAX_PROPERTIES,
};
use super::error::{Error, ProtocolError, RxOverflow};
use super::protocol::command::Command;
use super::protocol::Packet;
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 {
local_id: u32,
remote_id: u32,
len: usize,
},
CreditGranted {
#[allow(dead_code)] idx: usize,
},
SlotClosed {
#[allow(dead_code)] idx: usize,
},
DataBuffered,
Unmatched,
}
pub(crate) fn dispatch_packet<E>(
channels: &mut [Option<ChannelSlot>],
pkt: &Packet,
delayed_ack: bool,
rx_cap: usize,
watermark: usize,
) -> Result<DispatchOutcome, Error<E>> {
for (idx, slot_opt) in channels.iter_mut().enumerate() {
let Some(slot) = slot_opt else { continue };
match pkt.command {
Command::Write if pkt.arg1 == slot.local_id => {
return Ok(
match slot.apply_write(&pkt.data, rx_cap, delayed_ack, watermark)? {
AckDecision::Now {
local_id,
remote_id,
len,
} => DispatchOutcome::AckWrite {
local_id,
remote_id,
len,
},
AckDecision::Hold => DispatchOutcome::DataBuffered,
},
);
}
Command::Ready if pkt.arg1 == slot.local_id => {
slot.apply_ready(&pkt.data, delayed_ack)?;
return Ok(DispatchOutcome::CreditGranted { idx });
}
Command::Close if pkt.arg1 == slot.local_id => {
slot.apply_close();
return Ok(DispatchOutcome::SlotClosed { idx });
}
_ => {}
}
}
Ok(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>,
}
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(),
}
}
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 accept_open_ready(
&mut self,
remote_id: u32,
payload: &[u8],
delayed_ack: bool,
) -> Result<(), ProtocolError> {
self.remote_id = remote_id;
self.state = ChannelState::Open;
if delayed_ack {
self.send_budget = parse_ready_credit(payload)? as i64;
}
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)> {
if self.unacked == 0 {
return None;
}
if delayed_ack {
let len = n.min(self.unacked);
if len == 0 {
return None;
}
self.unacked -= len;
return Some((self.local_id, self.remote_id, len));
}
if self.rx_buf.len() >= watermark {
return None;
}
let len = core::mem::take(&mut self.unacked);
Some((self.local_id, self.remote_id, len))
}
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,
T,
const MAX_CHANNELS: usize = DEFAULT_MAX_CHANNELS,
const MAX_PROPERTIES: usize = DEFAULT_MAX_PROPERTIES,
const MAX_FEATURES: usize = DEFAULT_MAX_FEATURES,
> where
T: Read + Write,
{
pub(crate) conn: &'a mut Connection<T, MAX_CHANNELS, MAX_PROPERTIES, MAX_FEATURES>,
pub(crate) id: ChannelId,
}
impl<'a, T, const MAX_CHANNELS: usize, const MAX_PROPERTIES: usize, const MAX_FEATURES: usize>
Channel<'a, T, MAX_CHANNELS, MAX_PROPERTIES, MAX_FEATURES>
where
T: Read + Write,
{
pub async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error<<T as ErrorType>::Error>> {
self.conn.read_channel(self.id, buf).await
}
pub async fn write(&mut self, data: &[u8]) -> Result<(), Error<<T as ErrorType>::Error>> {
self.conn.write_channel(self.id, data).await
}
pub async fn select<F: Future>(
&mut self,
buf: &mut [u8],
interrupt: F,
) -> Result<SelectResult<F::Output>, Error<<T as ErrorType>::Error>>
where
T: crate::transport::ReadCancelSafety,
{
self.conn.select_channel(self.id, buf, interrupt).await
}
pub async fn close(self) -> Result<(), Error<<T as ErrorType>::Error>> {
self.conn.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);
}
}