use alloc::sync::Arc;
use core::convert::Infallible;
use core::sync::atomic::{AtomicBool, Ordering};
use embedded_io::ErrorType;
use embedded_io_async::Write;
use event_listener::EventListener;
use alloc::vec::Vec;
use super::shared::Shared;
use crate::base::channel::ChannelId;
use crate::base::incoming::PendingOpen;
use crate::base::protocol::command::Command;
use crate::base::protocol::Packet;
use crate::base::slot::ChannelSlot;
use crate::base::wire::{connection_gone, send_pkt};
use crate::error::Error;
#[cfg(doc)]
use super::{Reader, Writer};
pub struct SplitIncoming<WH>
where
WH: Write,
{
pub(super) shared: Arc<Shared<WH>>,
pub(super) pending: Option<PendingOpen>,
pub(super) reserved: Option<ChannelId>,
pub(super) cancelled: Arc<AtomicBool>,
}
impl<WH> SplitIncoming<WH>
where
WH: Write,
{
pub fn destination(&self) -> &[u8] {
&self.pending.as_ref().expect("undecided").destination
}
pub async fn accept(mut self) -> Result<ChannelId, Error<<WH as ErrorType>::Error>> {
let pending = self.pending.as_ref().expect("undecided");
let (remote, credit) = (pending.remote, pending.credit);
let shared = Arc::clone(&self.shared);
let reserved = {
let mut chs = shared.lock_channels();
if self.cancelled.load(Ordering::Relaxed) {
self.pending.take();
return Err(Error::ChannelClosed);
}
chs.allocate().ok().inspect(|&ch| {
chs.insert_accepted(ch, remote, credit);
})
};
let Some(ch) = reserved else {
self.answer(&Packet::refuse(remote)).await?;
return Err(Error::NoFreeChannels);
};
self.reserved = Some(ch);
let payload = match shared.negotiated.advertised_credit() {
Some(credit) => credit.to_le_bytes().to_vec(),
None => Vec::new(),
};
let ready = Packet::new(Command::Ready, ch.local.raw(), remote.raw(), payload);
let mut wh = shared.lock_write_half().await;
if shared
.lock_channels()
.get(ch)
.is_none_or(ChannelSlot::is_closed)
{
self.pending.take();
return Err(Error::ChannelClosed);
}
self.send(&mut wh, &ready).await?;
self.reserved = None;
Ok(ch)
}
pub async fn reject(mut self) -> Result<(), Error<<WH as ErrorType>::Error>> {
if self.cancelled.load(Ordering::Relaxed) {
self.pending.take();
return Ok(());
}
let remote = self.pending.as_ref().expect("undecided").remote;
self.answer(&Packet::refuse(remote)).await
}
async fn answer(&mut self, verdict: &Packet) -> Result<(), Error<<WH as ErrorType>::Error>> {
let shared = Arc::clone(&self.shared);
let mut wh = shared.lock_write_half().await;
self.send(&mut wh, verdict).await
}
async fn send(
&mut self,
wh: &mut WH,
verdict: &Packet,
) -> Result<(), Error<<WH as ErrorType>::Error>> {
let sent = send_pkt(
wh,
&self.shared.desync,
verdict,
self.shared.negotiated.checksum(),
)
.await;
if sent.as_ref().err().is_none_or(connection_gone) {
self.pending.take();
}
sent
}
}
impl<WH> Drop for SplitIncoming<WH>
where
WH: Write,
{
fn drop(&mut self) {
if let Some(ch) = self.reserved.take() {
self.shared.lock_channels().free(ch);
}
let mut staged = self.shared.lock_staged();
let mut incoming = self.shared.lock_incoming();
staged.retain(|(_, flag)| !Arc::ptr_eq(flag, &self.cancelled));
if let Some(pending) = self.pending.take() {
if !self.cancelled.load(Ordering::Relaxed) {
incoming.push_front(pending);
self.shared.incoming_signal.notify(usize::MAX);
}
}
}
}
pub struct IncomingListener<WH>
where
WH: Write,
{
pub(super) shared: Arc<Shared<WH>>,
}
impl<WH> IncomingListener<WH>
where
WH: Write,
{
pub async fn accept(&self) -> Result<SplitIncoming<WH>, Error<<WH as ErrorType>::Error>> {
let mut listener: Option<EventListener> = None;
loop {
if self.shared.desync.check::<Infallible>().is_err() {
self.shared.check_live()?;
}
if let Some(incoming) = self.shared.take_incoming() {
return Ok(incoming);
}
self.shared.check_live()?;
match listener.take() {
Some(waiting) => waiting.await,
None => listener = Some(self.shared.incoming_signal.listen()),
}
}
}
}
impl<WH> Drop for IncomingListener<WH>
where
WH: Write,
{
fn drop(&mut self) {
self.shared.listeners.fetch_sub(1, Ordering::AcqRel);
}
}