#![cfg(feature = "split")]
use alloc::sync::Arc;
use async_lock::Mutex as AsyncMutex;
use bytes::BytesMut;
use core::sync::atomic::{AtomicU32, Ordering};
use embedded_io::ErrorType;
use embedded_io_async::{Read, Write};
use event_listener::{Event, EventListener};
use std::sync::Mutex;
use crate::base::channel::{
channel_ids_of, dispatch_packet, slot_for_mut, ChannelId, ChannelSlot, DispatchOutcome,
};
use crate::base::connection::{DEFAULT_MAX_CHANNELS, DEFAULT_MAX_FEATURES, DEFAULT_MAX_PROPERTIES};
use crate::base::error::Error;
use crate::base::protocol::command::Command;
use crate::base::protocol::features;
use crate::base::protocol::packet::Packet;
use crate::base::wire::{recv_pkt, send_okay_to, send_pkt, send_raw};
use crate::device_banner::DeviceBanner;
pub(crate) struct FlowSignal {
event: Event,
}
impl FlowSignal {
pub(crate) const fn new() -> Self {
Self {
event: Event::new(),
}
}
fn listen(&self) -> EventListener {
self.event.listen()
}
fn wake(&self) {
self.event.notify(usize::MAX);
}
}
pub(crate) struct Shared<WH, const MC: usize, const MP: usize, const MF: usize> {
pub(crate) write_half: AsyncMutex<WH>,
pub(crate) channels: Mutex<[Option<ChannelSlot>; MC]>,
pub(crate) signals: [FlowSignal; MC],
pub(crate) max_payload: u32,
pub(crate) delayed_ack: bool,
pub(crate) device_banner: Option<DeviceBanner<MP, MF>>,
pub(crate) local_id_counter: AtomicU32,
}
impl<WH, const MC: usize, const MP: usize, const MF: usize> Shared<WH, MC, MP, MF> {
fn next_local_id(&self) -> u32 {
loop {
let id = self.local_id_counter.fetch_add(1, Ordering::Relaxed);
if id != 0 {
return id;
}
}
}
fn lock_channels(&self) -> std::sync::MutexGuard<'_, [Option<ChannelSlot>; MC]> {
self.channels.lock().unwrap_or_else(|p| p.into_inner())
}
}
struct SlotGuard<WH, const MC: usize, const MP: usize, const MF: usize> {
shared: Arc<Shared<WH, MC, MP, MF>>,
idx: usize,
armed: bool,
}
impl<WH, const MC: usize, const MP: usize, const MF: usize> SlotGuard<WH, MC, MP, MF> {
fn new(shared: Arc<Shared<WH, MC, MP, MF>>, idx: usize) -> Self {
Self {
shared,
idx,
armed: true,
}
}
fn disarm(&mut self) {
self.armed = false;
}
}
impl<WH, const MC: usize, const MP: usize, const MF: usize> Drop for SlotGuard<WH, MC, MP, MF> {
fn drop(&mut self) {
if !self.armed {
return;
}
let mut chs = self.shared.lock_channels();
if self.idx < chs.len() {
chs[self.idx] = None;
}
}
}
struct CreditGuard<'a, WH, const MC: usize, const MP: usize, const MF: usize> {
shared: &'a Shared<WH, MC, MP, MF>,
ch: ChannelId,
n: usize,
committed: bool,
}
impl<'a, WH, const MC: usize, const MP: usize, const MF: usize> CreditGuard<'a, WH, MC, MP, MF> {
fn new(shared: &'a Shared<WH, MC, MP, MF>, ch: ChannelId, n: usize) -> Self {
Self {
shared,
ch,
n,
committed: false,
}
}
fn commit(&mut self) {
self.committed = true;
}
}
impl<WH, const MC: usize, const MP: usize, const MF: usize> Drop
for CreditGuard<'_, WH, MC, MP, MF>
{
fn drop(&mut self) {
if self.committed {
return;
}
{
let mut chs = self.shared.lock_channels();
if let Some(slot) = slot_for_mut(&mut *chs, self.ch) {
slot.refund(self.n, self.shared.delayed_ack);
}
}
if let Some(signal) = self.shared.signals.get(self.ch.slot) {
signal.wake();
}
}
}
pub struct Reader<
RH,
WH,
const MAX_CHANNELS: usize = DEFAULT_MAX_CHANNELS,
const MAX_PROPERTIES: usize = DEFAULT_MAX_PROPERTIES,
const MAX_FEATURES: usize = DEFAULT_MAX_FEATURES,
> where
RH: Read,
WH: Write<Error = <RH as ErrorType>::Error>,
{
read_half: RH,
recv_buf: BytesMut,
shared: Arc<Shared<WH, MAX_CHANNELS, MAX_PROPERTIES, MAX_FEATURES>>,
}
impl<RH, WH, const MC: usize, const MP: usize, const MF: usize> Reader<RH, WH, MC, MP, MF>
where
RH: Read,
WH: Write<Error = <RH as ErrorType>::Error>,
{
pub(crate) fn new(
read_half: RH,
recv_buf: BytesMut,
shared: Arc<Shared<WH, MC, MP, MF>>,
) -> Self {
Self {
read_half,
recv_buf,
shared,
}
}
pub fn max_payload(&self) -> u32 {
self.shared.max_payload
}
pub fn delayed_ack(&self) -> bool {
self.shared.delayed_ack
}
pub fn device_banner(&self) -> Option<&[u8]> {
self.shared.device_banner.as_ref().map(|b| b.raw())
}
pub fn device_banner_parsed(&self) -> Option<&DeviceBanner<MP, MF>> {
self.shared.device_banner.as_ref()
}
pub fn require_feature(
&self,
feature: crate::protocol::features::Feature,
) -> Result<(), Error<<RH as ErrorType>::Error>> {
match &self.shared.device_banner {
Some(b) if b.has_feature(&feature) => Ok(()),
Some(_) => Err(Error::MissingFeature(feature)),
None => Ok(()),
}
}
pub async fn open_channel(
&mut self,
destination: &[u8],
) -> Result<ChannelId, Error<<RH as ErrorType>::Error>> {
let (slot_idx, local_id) = {
let mut chs = self.shared.lock_channels();
let idx = chs
.iter()
.position(|s| s.is_none())
.ok_or(Error::NoFreeChannels)?;
let id = self.shared.next_local_id();
chs[idx] = Some(ChannelSlot::new(id));
(idx, id)
};
let mut guard = SlotGuard::new(Arc::clone(&self.shared), slot_idx);
let open_arg1 = if self.shared.delayed_ack {
features::INITIAL_DELAYED_ACK_BYTES
} else {
0
};
let pkt = Packet::new(Command::Open, local_id, open_arg1, destination.to_vec());
{
let mut wh = self.shared.write_half.lock().await;
send_pkt(&mut *wh, &pkt).await?;
}
let result = self.await_open_ack(local_id, slot_idx, &mut guard).await;
if let Err(ref e) = result {
if !matches!(e, Error::ChannelClosed) {
let mut wh = self.shared.write_half.lock().await;
let _ = send_raw(&mut *wh, Command::Close, local_id, 0, &[]).await;
}
}
result
}
async fn await_open_ack(
&mut self,
local_id: u32,
slot_idx: usize,
guard: &mut SlotGuard<WH, MC, MP, MF>,
) -> Result<ChannelId, Error<<RH as ErrorType>::Error>> {
loop {
let pkt = recv_pkt(&mut self.read_half, &mut self.recv_buf).await?;
match pkt.command {
Command::Ready if pkt.arg1 == local_id => {
{
let mut chs = self.shared.lock_channels();
if let Some(slot) = chs[slot_idx].as_mut() {
slot.accept_open_ready(pkt.arg0, &pkt.data, self.shared.delayed_ack)?;
}
}
guard.disarm();
return Ok(ChannelId {
slot: slot_idx,
local_id,
});
}
Command::Close if pkt.arg1 == local_id => {
return Err(Error::ChannelClosed);
}
_ => self.dispatch(pkt).await?,
}
}
}
pub async fn read_channel(
&mut self,
ch: ChannelId,
buf: &mut [u8],
) -> Result<usize, Error<<RH as ErrorType>::Error>> {
{
let mut chs = self.shared.lock_channels();
let slot = slot_for_mut(&mut *chs, ch).ok_or(Error::ChannelClosed)?;
if !slot.rx_buf.is_empty() {
let n = buf.len().min(slot.rx_buf.len());
buf[..n].copy_from_slice(&slot.rx_buf[..n]);
let _ = slot.rx_buf.split_to(n);
return Ok(n);
}
if slot.is_closed() {
return Err(Error::ChannelClosed);
}
}
let (local_id, remote_id) = self.channel_ids(ch)?;
loop {
let pkt = recv_pkt(&mut self.read_half, &mut self.recv_buf).await?;
match pkt.command {
Command::Write if pkt.arg1 == local_id => {
let payload_len = pkt.data.len();
{
let mut wh = self.shared.write_half.lock().await;
send_okay_to(
&mut *wh,
self.shared.delayed_ack,
local_id,
remote_id,
payload_len,
)
.await?;
}
let n = buf.len().min(pkt.data.len());
buf[..n].copy_from_slice(&pkt.data[..n]);
if n < pkt.data.len() {
let mut chs = self.shared.lock_channels();
if let Some(slot) = slot_for_mut(&mut *chs, ch) {
slot.rx_buf.extend_from_slice(&pkt.data[n..]);
}
}
return Ok(n);
}
Command::Close if pkt.arg1 == local_id => {
{
let mut chs = self.shared.lock_channels();
if let Some(slot) = slot_for_mut(&mut *chs, ch) {
slot.apply_close();
}
}
if let Some(signal) = self.shared.signals.get(ch.slot) {
signal.wake();
}
return Err(Error::ChannelClosed);
}
_ => self.dispatch(pkt).await?,
}
}
}
fn channel_ids(&self, ch: ChannelId) -> Result<(u32, u32), Error<<RH as ErrorType>::Error>> {
let chs = self.shared.lock_channels();
channel_ids_of(&*chs, ch)
}
async fn dispatch(&mut self, pkt: Packet) -> Result<(), Error<<RH as ErrorType>::Error>> {
let outcome = {
let mut chs = self.shared.lock_channels();
dispatch_packet(&mut *chs, &pkt, self.shared.delayed_ack)?
};
match outcome {
DispatchOutcome::AckWrite {
local_id,
remote_id,
len,
} => {
let mut wh = self.shared.write_half.lock().await;
send_okay_to(&mut *wh, self.shared.delayed_ack, local_id, remote_id, len).await?;
}
DispatchOutcome::SlotUpdated { idx } => {
self.shared.signals[idx].wake();
}
DispatchOutcome::Unmatched => {}
}
Ok(())
}
}
pub struct Writer<
WH,
const MAX_CHANNELS: usize = DEFAULT_MAX_CHANNELS,
const MAX_PROPERTIES: usize = DEFAULT_MAX_PROPERTIES,
const MAX_FEATURES: usize = DEFAULT_MAX_FEATURES,
> where
WH: Write,
{
shared: Arc<Shared<WH, MAX_CHANNELS, MAX_PROPERTIES, MAX_FEATURES>>,
}
impl<WH, const MC: usize, const MP: usize, const MF: usize> Clone for Writer<WH, MC, MP, MF>
where
WH: Write,
{
fn clone(&self) -> Self {
Self {
shared: Arc::clone(&self.shared),
}
}
}
impl<WH, const MC: usize, const MP: usize, const MF: usize> Writer<WH, MC, MP, MF>
where
WH: Write,
{
pub(crate) fn new(shared: Arc<Shared<WH, MC, MP, MF>>) -> Self {
Self { shared }
}
pub fn max_payload(&self) -> u32 {
self.shared.max_payload
}
pub fn delayed_ack(&self) -> bool {
self.shared.delayed_ack
}
pub fn device_banner(&self) -> Option<&[u8]> {
self.shared.device_banner.as_ref().map(|b| b.raw())
}
pub fn device_banner_parsed(&self) -> Option<&DeviceBanner<MP, MF>> {
self.shared.device_banner.as_ref()
}
pub async fn write_channel(
&self,
ch: ChannelId,
data: &[u8],
) -> Result<(), Error<<WH as ErrorType>::Error>> {
if data.is_empty() {
return Ok(());
}
let max = (self.shared.max_payload as usize).max(1);
let mut offset = 0;
while offset < data.len() {
let want = (data.len() - offset).min(max);
let n = self.acquire_credit(ch, want).await?;
let mut guard = CreditGuard::new(&self.shared, ch, n);
let (local_id, remote_id) = self.channel_ids(ch)?;
let chunk = &data[offset..offset + n];
{
let mut wh = self.shared.write_half.lock().await;
send_raw(&mut *wh, Command::Write, local_id, remote_id, chunk).await?;
}
guard.commit();
offset += n;
}
Ok(())
}
pub async fn close_channel(
&self,
ch: ChannelId,
) -> Result<(), Error<<WH as ErrorType>::Error>> {
let (local_id, remote_id) = self.channel_ids(ch)?;
{
let mut wh = self.shared.write_half.lock().await;
send_pkt(&mut *wh, &Packet::close(local_id, remote_id)).await?;
}
{
let mut chs = self.shared.lock_channels();
if let Some(slot) = chs.get_mut(ch.slot) {
if slot.as_ref().is_some_and(|s| s.local_id == ch.local_id) {
*slot = None;
}
}
}
if let Some(signal) = self.shared.signals.get(ch.slot) {
signal.wake();
}
Ok(())
}
fn channel_ids(&self, ch: ChannelId) -> Result<(u32, u32), Error<<WH as ErrorType>::Error>> {
let chs = self.shared.lock_channels();
channel_ids_of(&*chs, ch)
}
async fn acquire_credit(
&self,
ch: ChannelId,
want: usize,
) -> Result<usize, Error<<WH as ErrorType>::Error>> {
let Some(signal) = self.shared.signals.get(ch.slot) else {
return Err(Error::ChannelClosed);
};
loop {
let listener = signal.listen();
if let Some(result) = self.try_reserve(ch, want) {
return result;
}
listener.await;
}
}
fn try_reserve(
&self,
ch: ChannelId,
want: usize,
) -> Option<Result<usize, Error<<WH as ErrorType>::Error>>> {
let mut chs = self.shared.lock_channels();
let Some(slot) = slot_for_mut(&mut *chs, ch) else {
return Some(Err(Error::ChannelClosed));
};
if slot.is_closed() {
return Some(Err(Error::ChannelClosed));
}
slot.try_reserve_send(want, self.shared.delayed_ack).map(Ok)
}
}