#![cfg(feature = "split")]
use alloc::sync::Arc;
use async_lock::Mutex as AsyncMutex;
use bytes::BytesMut;
use core::convert::Infallible;
use core::future::{poll_fn, Future};
use core::pin::{pin, Pin};
use core::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering};
use core::task::Poll;
use embedded_io::ErrorType;
use embedded_io_async::{Read, Write};
use event_listener::{Event, EventListener};
use std::sync::Mutex;
use alloc::collections::VecDeque;
use alloc::vec::Vec;
use crate::base::channel::{
channel_ids_of, clse_closes, dispatch_packet, slot_for_mut, ChannelFault, ChannelId,
ChannelSlot, ChannelState, DispatchOutcome, PendingOpen, SelectResult,
};
use crate::base::connection::{
ConnectionConfig, DEFAULT_MAX_CHANNELS, DEFAULT_MAX_FEATURES, DEFAULT_MAX_PROPERTIES,
};
use crate::base::error::Error;
use crate::base::protocol::command::Command;
use crate::base::protocol::Checksum;
use crate::base::protocol::Packet;
use crate::base::wire::{recv_pkt, send_okay_to, send_pkt, send_raw, DesyncFlag};
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) protocol_version: u32,
pub(crate) config: ConnectionConfig,
pub(crate) delayed_ack: bool,
pub(crate) device_banner: Option<DeviceBanner<MP, MF>>,
pub(crate) local_id_counter: AtomicU32,
pub(crate) desync: DesyncFlag,
pub(crate) incoming: Mutex<VecDeque<PendingOpen>>,
pub(crate) staged: Mutex<Vec<(u32, Arc<AtomicBool>)>>,
pub(crate) stopped: AtomicBool,
pub(crate) listeners: AtomicUsize,
pub(crate) incoming_signal: Event,
pub(crate) owed_closes: Mutex<Vec<(u32, u32)>>,
}
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())
}
fn lock_incoming(&self) -> std::sync::MutexGuard<'_, VecDeque<PendingOpen>> {
self.incoming.lock().unwrap_or_else(|p| p.into_inner())
}
fn lock_staged(&self) -> std::sync::MutexGuard<'_, Vec<(u32, Arc<AtomicBool>)>> {
self.staged.lock().unwrap_or_else(|p| p.into_inner())
}
fn lock_owed(&self) -> std::sync::MutexGuard<'_, Vec<(u32, u32)>> {
self.owed_closes.lock().unwrap_or_else(|p| p.into_inner())
}
async fn send_open(
self: &Arc<Self>,
destination: &[u8],
) -> Result<(ChannelId, SlotGuard<WH, MC, MP, MF>), Error<<WH as ErrorType>::Error>>
where
WH: Write,
{
let (slot, local_id) = {
let mut chs = self.lock_channels();
let idx = chs
.iter()
.position(|s| s.is_none())
.ok_or(Error::NoFreeChannels)?;
let id = self.next_local_id();
chs[idx] = Some(ChannelSlot::new(id));
(idx, id)
};
let guard = SlotGuard::new(Arc::clone(self), slot);
let open_arg1 = if self.delayed_ack {
self.config.advertised_ack_bytes()
} else {
0
};
{
let mut wh = self.lock_write().await?;
send_raw(
&mut *wh,
&self.desync,
Command::Open,
local_id,
open_arg1,
destination,
self.checksum(),
)
.await?;
}
Ok((ChannelId { slot, local_id }, guard))
}
async fn fail_channel(
&self,
idx: usize,
local_id: u32,
remote_id: u32,
fault: ChannelFault,
) -> Result<(), Error<<WH as ErrorType>::Error>>
where
WH: Write,
{
let found = {
let mut chs = self.lock_channels();
let slot = chs[idx].as_mut().filter(|s| s.local_id == local_id);
slot.map(|s| s.fail(fault)).is_some()
};
if found {
self.signals[idx].wake();
}
let mut wh = self.lock_write().await?;
send_pkt(
&mut *wh,
&self.desync,
&Packet::close(local_id, remote_id),
self.checksum(),
)
.await
}
async fn take_buffered(
&self,
ch: ChannelId,
buf: &mut [u8],
) -> Result<Option<usize>, Error<<WH as ErrorType>::Error>>
where
WH: Write,
{
let watermark = self.config.rx_watermark();
{
let mut chs = self.lock_channels();
let slot = slot_for_mut(&mut *chs, ch).ok_or(Error::ChannelClosed)?;
if slot.rx_buf.is_empty() || !slot.take_acks(buf.len(), self.delayed_ack, watermark) {
let taken = slot.take_buffered(buf, self.delayed_ack, watermark)?;
return Ok(taken.map(|(n, _)| n));
}
}
let mut wh = self.lock_write().await?;
let taken = {
let mut chs = self.lock_channels();
let slot = slot_for_mut(&mut *chs, ch).ok_or(Error::ChannelClosed)?;
slot.take_buffered(buf, self.delayed_ack, watermark)?
};
let Some((n, ack)) = taken else {
return Ok(None);
};
if let Some((local_id, remote_id, len)) = ack {
send_okay_to(
&mut *wh,
&self.desync,
self.delayed_ack,
local_id,
remote_id,
len,
self.checksum(),
)
.await?;
}
Ok(Some(n))
}
async fn send_okay(
&self,
local_id: u32,
remote_id: u32,
wrte_len: usize,
) -> Result<(), Error<<WH as ErrorType>::Error>>
where
WH: Write,
{
let mut wh = self.lock_write().await?;
send_okay_to(
&mut *wh,
&self.desync,
self.delayed_ack,
local_id,
remote_id,
wrte_len,
self.checksum(),
)
.await
}
fn stage_incoming(self: &Arc<Self>, pending: PendingOpen) -> SplitIncoming<WH, MC, MP, MF>
where
WH: Write,
{
self.hold_incoming(pending, &mut self.lock_staged())
}
fn take_incoming(self: &Arc<Self>) -> Option<SplitIncoming<WH, MC, MP, MF>>
where
WH: Write,
{
self.take_incoming_past(0)
}
fn take_incoming_past(self: &Arc<Self>, cap: usize) -> Option<SplitIncoming<WH, MC, MP, MF>>
where
WH: Write,
{
let mut staged = self.lock_staged();
let mut incoming = self.lock_incoming();
if staged.len() + incoming.len() <= cap {
return None;
}
let pending = incoming.pop_front()?;
Some(self.hold_incoming(pending, &mut staged))
}
fn hold_incoming(
self: &Arc<Self>,
pending: PendingOpen,
staged: &mut Vec<(u32, Arc<AtomicBool>)>,
) -> SplitIncoming<WH, MC, MP, MF>
where
WH: Write,
{
let cancelled = Arc::new(AtomicBool::new(false));
staged.push((pending.remote_id, Arc::clone(&cancelled)));
SplitIncoming {
shared: Arc::clone(self),
pending: Some(pending),
reserved: None,
cancelled,
}
}
fn checksum(&self) -> Checksum {
Checksum::for_version(self.protocol_version)
}
fn stop(&self) {
self.stopped.store(true, Ordering::Release);
self.wake_all();
}
fn wake_all(&self) {
for signal in &self.signals {
signal.wake();
}
self.incoming_signal.notify(usize::MAX);
}
fn check_live<E>(&self) -> Result<(), Error<E>> {
self.desync.check()?;
if self.stopped.load(Ordering::Acquire) {
return Err(Error::Disconnected);
}
Ok(())
}
async fn lock_write(
&self,
) -> Result<WriteLock<'_, WH, MC, MP, MF>, Error<<WH as ErrorType>::Error>>
where
WH: Write,
{
let mut lock = WriteLock {
guard: self.write_half.lock().await,
shared: self,
};
loop {
let owed = self.lock_owed().pop();
let Some((local_id, remote_id)) = owed else {
return Ok(lock);
};
send_pkt(
&mut *lock,
&self.desync,
&Packet::close(local_id, remote_id),
self.checksum(),
)
.await?;
}
}
}
struct WriteLock<'a, WH, const MC: usize, const MP: usize, const MF: usize> {
guard: async_lock::MutexGuard<'a, WH>,
shared: &'a Shared<WH, MC, MP, MF>,
}
impl<WH, const MC: usize, const MP: usize, const MF: usize> core::ops::Deref
for WriteLock<'_, WH, MC, MP, MF>
{
type Target = WH;
fn deref(&self) -> &WH {
&self.guard
}
}
impl<WH, const MC: usize, const MP: usize, const MF: usize> core::ops::DerefMut
for WriteLock<'_, WH, MC, MP, MF>
{
fn deref_mut(&mut self) -> &mut WH {
&mut self.guard
}
}
impl<WH, const MC: usize, const MP: usize, const MF: usize> Drop for WriteLock<'_, WH, MC, MP, MF> {
fn drop(&mut self) {
if self.shared.desync.check::<Infallible>().is_err() {
self.shared.wake_all();
}
}
}
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();
let Some(slot) = chs.get_mut(self.idx).and_then(Option::take) else {
return;
};
if slot.remote_id != 0 && slot.failed.is_none() {
self.shared
.lock_owed()
.push((slot.local_id, slot.remote_id));
}
}
}
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();
}
}
}
struct QueueGuard<'a, WH, const MC: usize, const MP: usize, const MF: usize> {
shared: &'a Shared<WH, MC, MP, MF>,
ch: ChannelId,
place: u64,
served: bool,
}
impl<WH, const MC: usize, const MP: usize, const MF: usize> Drop
for QueueGuard<'_, WH, MC, MP, MF>
{
fn drop(&mut self) {
if self.served {
return;
}
let head_moved = {
let mut chs = self.shared.lock_channels();
match slot_for_mut(&mut *chs, self.ch) {
Some(slot) => slot.send_leave(self.place),
None => false,
}
};
if head_moved {
if let Some(signal) = self.shared.signals.get(self.ch.slot) {
signal.wake();
}
}
}
}
#[derive(Clone, Copy)]
enum OnFault {
FailCall,
CloseChannel,
}
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 config(&self) -> &ConnectionConfig {
&self.shared.config
}
pub fn protocol_version(&self) -> u32 {
self.shared.protocol_version
}
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>> {
self.shared.desync.check()?;
let (ch, mut guard) = self.shared.send_open(destination).await?;
self.await_open_ack(ch, &mut guard).await
}
async fn drain_overflow(&mut self) -> Result<(), Error<<RH as ErrorType>::Error>> {
while let Some(excess) = self.shared.take_incoming_past(MC) {
excess.reject().await?;
}
Ok(())
}
async fn await_open_ack(
&mut self,
ch: ChannelId,
guard: &mut SlotGuard<WH, MC, MP, MF>,
) -> Result<ChannelId, Error<<RH as ErrorType>::Error>> {
self.drain_overflow().await?;
loop {
let pkt = recv_pkt(
&mut self.read_half,
&mut self.recv_buf,
self.shared.config.max_payload(),
)
.await?;
match pkt.command {
Command::Ready if pkt.arg1 == ch.local_id => {
let accepted = {
let mut chs = self.shared.lock_channels();
match chs[ch.slot].as_mut() {
Some(slot) => {
slot.accept_open_ready(pkt.arg0, &pkt.data, self.shared.delayed_ack)
}
None => Ok(()),
}
};
if let Err(e) = accepted {
let fault = ChannelFault::Protocol(e);
self.shared
.fail_channel(ch.slot, ch.local_id, pkt.arg0, fault)
.await?;
return Err(fault.error());
}
guard.disarm();
return Ok(ch);
}
Command::Close if pkt.arg1 == ch.local_id => {
return Err(Error::ChannelClosed);
}
_ => self.dispatch(pkt, OnFault::FailCall).await?,
}
}
}
pub async fn run(mut self) -> Result<Infallible, Error<<RH as ErrorType>::Error>> {
self.shared.desync.check()?;
loop {
let owes = !self.shared.lock_owed().is_empty();
if owes {
drop(self.shared.lock_write().await?);
}
if self.shared.listeners.load(Ordering::Acquire) == 0 {
while let Some(refused) = self.shared.take_incoming() {
refused.reject().await?;
}
}
let pkt = recv_pkt(
&mut self.read_half,
&mut self.recv_buf,
self.shared.config.max_payload(),
)
.await?;
self.dispatch(pkt, OnFault::CloseChannel).await?;
}
}
pub async fn read_channel(
&mut self,
ch: ChannelId,
buf: &mut [u8],
) -> Result<usize, Error<<RH as ErrorType>::Error>> {
self.shared.desync.check()?;
let delayed_ack = self.shared.delayed_ack;
let watermark = self.shared.config.rx_watermark();
if let Some(n) = self.shared.take_buffered(ch, buf).await? {
return Ok(n);
}
let (local_id, remote_id) = self.channel_ids(ch)?;
self.drain_overflow().await?;
loop {
let pkt = recv_pkt(
&mut self.read_half,
&mut self.recv_buf,
self.shared.config.max_payload(),
)
.await?;
match pkt.command {
Command::Write if pkt.arg1 == local_id => {
let n = buf.len().min(pkt.data.len());
buf[..n].copy_from_slice(&pkt.data[..n]);
let ack = {
let mut chs = self.shared.lock_channels();
match slot_for_mut(&mut *chs, ch) {
Some(slot) => slot.deliver(
&pkt.data,
n,
self.shared.config.rx_cap(),
delayed_ack,
watermark,
)?,
None => None,
}
};
if let Some((local_id, remote_id, len)) = ack {
self.shared.send_okay(local_id, remote_id, len).await?;
}
return Ok(n);
}
Command::Close if clse_closes(pkt.arg0, pkt.arg1, local_id, remote_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, OnFault::FailCall).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)
}
pub async fn accept_incoming(
&mut self,
) -> Result<SplitIncoming<WH, MC, MP, MF>, Error<<RH as ErrorType>::Error>> {
self.shared.desync.check()?;
loop {
if let Some(incoming) = self.shared.take_incoming() {
return Ok(incoming);
}
let pkt = recv_pkt(
&mut self.read_half,
&mut self.recv_buf,
self.shared.config.max_payload(),
)
.await?;
self.dispatch(pkt, OnFault::FailCall).await?;
}
}
pub fn try_accept_incoming(&mut self) -> Option<SplitIncoming<WH, MC, MP, MF>> {
self.shared.take_incoming()
}
async fn dispatch(
&mut self,
pkt: Packet,
on_fault: OnFault,
) -> Result<(), Error<<RH as ErrorType>::Error>> {
let outcome = {
let mut chs = self.shared.lock_channels();
dispatch_packet(
&mut *chs,
&pkt,
self.shared.delayed_ack,
self.shared.config.rx_cap(),
self.shared.config.rx_watermark(),
)
};
match outcome {
DispatchOutcome::AckWrite {
idx,
local_id,
remote_id,
len,
} => {
self.shared.signals[idx].wake();
self.shared.send_okay(local_id, remote_id, len).await?;
}
DispatchOutcome::CreditGranted { idx }
| DispatchOutcome::SlotClosed { idx }
| DispatchOutcome::DataBuffered { idx } => {
self.shared.signals[idx].wake();
}
DispatchOutcome::IncomingOpen {
remote_id,
credit,
destination,
} => {
let pending = PendingOpen {
remote_id,
credit,
destination,
};
let refused = {
let staged = self.shared.lock_staged();
let mut q = self.shared.lock_incoming();
if staged.len() + q.len() >= MC {
Some(pending)
} else {
q.push_back(pending);
None
}
};
if refused.is_none() {
self.shared.incoming_signal.notify(usize::MAX);
}
if let Some(pending) = refused {
self.shared.stage_incoming(pending).reject().await?;
}
}
DispatchOutcome::CancelPendingOpen { remote_id } => {
let mut chs = self.shared.lock_channels();
let staged = self.shared.lock_staged();
let mut incoming = self.shared.lock_incoming();
let mut closed = None;
if remote_id != 0 {
for (idx, slot_opt) in chs.iter_mut().enumerate() {
let Some(slot) = slot_opt else { continue };
if slot.remote_id == remote_id {
slot.apply_close();
closed = Some(idx);
break;
}
}
}
if closed.is_none() {
incoming.retain(|p| p.remote_id != remote_id);
for (id, flag) in staged.iter() {
if *id == remote_id {
flag.store(true, Ordering::Relaxed);
}
}
}
drop(incoming);
drop(staged);
drop(chs);
if let Some(idx) = closed {
if let Some(signal) = self.shared.signals.get(idx) {
signal.wake();
}
}
}
DispatchOutcome::StrayReady {
local_id,
remote_id,
} => {
let mut wh = self.shared.lock_write().await?;
send_pkt(
&mut *wh,
&self.shared.desync,
&Packet::close(local_id, remote_id),
self.shared.checksum(),
)
.await?;
}
DispatchOutcome::ChannelFault {
idx,
local_id,
remote_id,
opening,
fault,
} => {
if opening || matches!(on_fault, OnFault::CloseChannel) {
self.shared
.fail_channel(idx, local_id, remote_id, fault)
.await?;
}
if matches!(on_fault, OnFault::FailCall) {
return Err(fault.error());
}
}
DispatchOutcome::Unmatched => {}
}
Ok(())
}
pub async fn close_channel(
&self,
ch: ChannelId,
) -> Result<(), Error<<RH as ErrorType>::Error>> {
close_channel_via(&self.shared, ch).await
}
}
impl<RH, WH, const MC: usize, const MP: usize, const MF: usize> Drop for Reader<RH, WH, MC, MP, MF>
where
RH: Read,
WH: Write<Error = <RH as ErrorType>::Error>,
{
fn drop(&mut self) {
self.shared.stop();
}
}
pub struct SplitIncoming<
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>>,
pending: Option<PendingOpen>,
reserved: Option<usize>,
cancelled: Arc<AtomicBool>,
}
impl<WH, const MC: usize, const MP: usize, const MF: usize> SplitIncoming<WH, MC, MP, MF>
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_id, credit) = (pending.remote_id, pending.credit);
let shared = Arc::clone(&self.shared);
let checksum = shared.checksum();
let reserved = {
let mut chs = shared.lock_channels();
if self.cancelled.load(Ordering::Relaxed) {
self.pending.take();
return Err(Error::ChannelClosed);
}
chs.iter().position(|s| s.is_none()).map(|idx| {
let local_id = shared.next_local_id();
let mut slot = ChannelSlot::new(local_id);
slot.remote_id = remote_id;
slot.state = ChannelState::Open;
if shared.delayed_ack {
slot.send_budget = i64::from(credit);
}
chs[idx] = Some(slot);
(idx, local_id)
})
};
let Some((slot_idx, local_id)) = reserved else {
let mut wh = shared.lock_write().await?;
send_pkt(
&mut *wh,
&shared.desync,
&Packet::close(0, remote_id),
checksum,
)
.await?;
self.pending.take();
return Err(Error::NoFreeChannels);
};
self.reserved = Some(slot_idx);
let credit_bytes;
let payload: &[u8] = if shared.delayed_ack {
credit_bytes = shared.config.advertised_ack_bytes().to_le_bytes();
&credit_bytes
} else {
&[]
};
{
let mut wh = shared.lock_write().await?;
send_pkt(
&mut *wh,
&shared.desync,
&Packet::new(Command::Ready, local_id, remote_id, payload.to_vec()),
checksum,
)
.await?;
}
self.reserved = None;
self.pending.take();
Ok(ChannelId {
slot: slot_idx,
local_id,
})
}
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_id = self.pending.as_ref().expect("undecided").remote_id;
let shared = Arc::clone(&self.shared);
let checksum = shared.checksum();
{
let mut wh = shared.lock_write().await?;
send_pkt(
&mut *wh,
&shared.desync,
&Packet::close(0, remote_id),
checksum,
)
.await?;
}
self.pending.take();
Ok(())
}
}
impl<WH, const MC: usize, const MP: usize, const MF: usize> Drop for SplitIncoming<WH, MC, MP, MF>
where
WH: Write,
{
fn drop(&mut self) {
if let Some(idx) = self.reserved.take() {
if let Some(slot) = self.shared.lock_channels().get_mut(idx) {
*slot = None;
}
}
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 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 config(&self) -> &ConnectionConfig {
&self.shared.config
}
pub fn delayed_ack(&self) -> bool {
self.shared.delayed_ack
}
pub fn protocol_version(&self) -> u32 {
self.shared.protocol_version
}
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 listen_incoming(&self) -> IncomingListener<WH, MC, MP, MF> {
self.shared.listeners.fetch_add(1, Ordering::AcqRel);
IncomingListener {
shared: Arc::clone(&self.shared),
}
}
pub async fn open_channel(
&self,
destination: &[u8],
) -> Result<ChannelId, Error<<WH as ErrorType>::Error>> {
self.shared.check_live()?;
let (ch, mut guard) = self.shared.send_open(destination).await?;
self.await_open_ack(ch, &mut guard).await
}
async fn await_open_ack(
&self,
ch: ChannelId,
guard: &mut SlotGuard<WH, MC, MP, MF>,
) -> Result<ChannelId, Error<<WH as ErrorType>::Error>> {
let signal = &self.shared.signals[ch.slot];
loop {
self.shared.desync.check()?;
let listener = signal.listen();
{
let chs = self.shared.lock_channels();
match chs[ch.slot].as_ref() {
Some(slot) if slot.local_id == ch.local_id => match slot.state {
ChannelState::Opening => {}
ChannelState::Closed if slot.remote_id == 0 => {
return Err(slot.closed_error())
}
ChannelState::Open | ChannelState::Closed => {
guard.disarm();
return Ok(ch);
}
},
_ => return Err(Error::ChannelClosed),
}
}
self.shared.check_live()?;
listener.await;
}
}
pub async fn read_channel(
&self,
ch: ChannelId,
buf: &mut [u8],
) -> Result<usize, Error<<WH as ErrorType>::Error>> {
match self
.select_channel(ch, buf, core::future::pending::<Infallible>())
.await?
{
SelectResult::Data(n) => Ok(n),
SelectResult::Interrupted(never) => match never {},
}
}
pub async fn select_channel<F: Future>(
&self,
ch: ChannelId,
buf: &mut [u8],
interrupt: F,
) -> Result<SelectResult<F::Output>, Error<<WH as ErrorType>::Error>> {
let Some(signal) = self.shared.signals.get(ch.slot) else {
return Err(Error::ChannelClosed);
};
let mut interrupt = pin!(interrupt);
let mut listener: Option<EventListener> = None;
loop {
self.shared.desync.check()?;
if let Some(n) = self.shared.take_buffered(ch, buf).await? {
return Ok(SelectResult::Data(n));
}
self.shared.check_live()?;
let Some(waiting) = listener.as_mut() else {
listener = Some(signal.listen());
continue;
};
let interrupted = poll_fn(|cx| {
if let Poll::Ready(value) = interrupt.as_mut().poll(cx) {
return Poll::Ready(Some(value));
}
Pin::new(&mut *waiting).poll(cx).map(|()| None)
})
.await;
listener = None;
if let Some(value) = interrupted {
return Ok(SelectResult::Interrupted(value));
}
}
}
pub async fn write_channel(
&self,
ch: ChannelId,
data: &[u8],
) -> Result<(), Error<<WH as ErrorType>::Error>> {
self.shared.desync.check()?;
if data.is_empty() {
return Ok(());
}
let max = (self.shared.max_payload as usize).max(1);
let checksum = self.shared.checksum();
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.lock_write().await?;
send_raw(
&mut *wh,
&self.shared.desync,
Command::Write,
local_id,
remote_id,
chunk,
checksum,
)
.await?;
}
guard.commit();
offset += n;
}
Ok(())
}
pub async fn close_channel(
&self,
ch: ChannelId,
) -> Result<(), Error<<WH as ErrorType>::Error>> {
close_channel_via(&self.shared, ch).await
}
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);
};
let place = {
let mut chs = self.shared.lock_channels();
let Some(slot) = slot_for_mut(&mut *chs, ch) else {
return Err(Error::ChannelClosed);
};
if slot.is_closed() {
return Err(slot.closed_error());
}
slot.send_enqueue()
};
let mut queue = QueueGuard {
shared: &self.shared,
ch,
place,
served: false,
};
loop {
let listener = signal.listen();
match self.try_reserve(ch, want, place) {
Some(Ok((n, more))) => {
queue.served = true;
if more {
signal.wake();
}
return Ok(n);
}
Some(Err(e)) => return Err(e),
None => {
self.shared.check_live()?;
listener.await;
}
}
}
}
#[allow(clippy::type_complexity)]
fn try_reserve(
&self,
ch: ChannelId,
want: usize,
place: u64,
) -> Option<Result<(usize, bool), 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(slot.closed_error()));
}
if slot.send_turn() != place {
return None;
}
slot.try_reserve_send(want, self.shared.delayed_ack)
.map(|n| {
slot.send_advance();
Ok((n, slot.send_budget > 0))
})
}
}
pub struct IncomingListener<
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> IncomingListener<WH, MC, MP, MF>
where
WH: Write,
{
pub async fn accept(
&self,
) -> Result<SplitIncoming<WH, MC, MP, MF>, Error<<WH as ErrorType>::Error>> {
let mut listener: Option<EventListener> = None;
loop {
self.shared.desync.check()?;
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, const MC: usize, const MP: usize, const MF: usize> Drop
for IncomingListener<WH, MC, MP, MF>
where
WH: Write,
{
fn drop(&mut self) {
self.shared.listeners.fetch_sub(1, Ordering::AcqRel);
}
}
async fn close_channel_via<WH, const MC: usize, const MP: usize, const MF: usize>(
shared: &Shared<WH, MC, MP, MF>,
ch: ChannelId,
) -> Result<(), Error<<WH as ErrorType>::Error>>
where
WH: Write,
{
shared.desync.check()?;
let (local_id, remote_id) = {
let chs = shared.lock_channels();
channel_ids_of(&*chs, ch)?
};
{
let mut wh = shared.lock_write().await?;
send_pkt(
&mut *wh,
&shared.desync,
&Packet::close(local_id, remote_id),
shared.checksum(),
)
.await?;
}
{
let mut chs = 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) = shared.signals.get(ch.slot) {
signal.wake();
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::base::connection::Connection;
use crate::base::mock::{abandon, now, okay, split_with_channel, Mock, NoAuth, SharedMock};
fn staged_with_followup(
followup: &[Packet],
) -> (
Reader<SharedMock, SharedMock>,
SplitIncoming<SharedMock>,
SharedMock,
) {
use core::future::Future as _;
use core::task::{Context, Poll, Waker};
let mut mock = Mock::new();
mock.feed(&crate::base::mock::cnxn()).feed(&okay(1));
let seen = SharedMock::new(mock);
let conn = now(Connection::<_>::connect(seen.clone(), NoAuth, &[])).unwrap();
let (mut reader, _writer) = conn.split().unwrap();
let ch = now(reader.open_channel(b"shell:\0")).unwrap();
seen.feed(&Packet::new(Command::Open, 80, 0, b"tcp:80\0".to_vec()));
let pump = |reader: &mut Reader<SharedMock, SharedMock>| {
let mut buf = [0u8; 16];
let mut fut = core::pin::pin!(reader.read_channel(ch, &mut buf));
let mut cx = Context::from_waker(Waker::noop());
match fut.as_mut().poll(&mut cx) {
Poll::Ready(Err(Error::UnexpectedEof)) => {}
other => panic!("expected the drained-transport EOF, got {other:?}"),
}
};
pump(&mut reader);
let inc = reader.try_accept_incoming().expect("the OPEN was queued");
for pkt in followup {
seen.feed(pkt);
}
pump(&mut reader);
(reader, inc, seen)
}
#[test]
fn a_device_cancel_reaches_the_staged_request() {
let (mut reader, inc, seen) = staged_with_followup(&[Packet::close(80, 0)]);
let err = now(inc.accept()).unwrap_err();
assert!(
matches!(err, Error::ChannelClosed),
"expected ChannelClosed, got {err:?}"
);
assert!(
!seen
.sent()
.iter()
.any(|(cmd, _, arg1, _)| *cmd == Command::Ready && *arg1 == 80),
"READY must not answer a withdrawn OPEN"
);
assert!(reader.try_accept_incoming().is_none());
}
#[test]
fn a_staged_reject_after_the_cancel_stays_silent() {
let (_reader, inc, seen) = staged_with_followup(&[Packet::close(80, 0)]);
now(inc.reject()).unwrap();
assert!(
!seen
.sent()
.iter()
.any(|(cmd, _, arg1, _)| *cmd == Command::Close && *arg1 == 80),
"a withdrawn OPEN expects no answer"
);
}
#[test]
fn a_withdrawal_racing_the_accept_closes_the_split_slot() {
let mut mock = Mock::new();
mock.feed(&crate::base::mock::cnxn());
let seen = SharedMock::new(mock);
let conn = now(Connection::<_>::connect(seen.clone(), NoAuth, &[])).unwrap();
let (mut reader, _writer) = conn.split().unwrap();
seen.feed(&Packet::new(Command::Open, 90, 0, b"tcp:90\0".to_vec()));
let inc = now(reader.accept_incoming()).unwrap();
let ch = now(inc.accept()).unwrap();
seen.feed(&Packet::close(90, 0));
let mut buf = [0u8; 8];
let err = now(reader.read_channel(ch, &mut buf)).unwrap_err();
assert!(
matches!(err, Error::ChannelClosed),
"expected ChannelClosed, got {err:?}"
);
}
#[test]
fn held_holders_spend_the_open_storm_budget() {
use core::future::Future as _;
use core::task::{Context, Poll, Waker};
let open_pkt =
|remote_id: u32, dest: &[u8]| Packet::new(Command::Open, remote_id, 0, dest.to_vec());
let mut mock = Mock::new();
mock.feed(&crate::base::mock::cnxn()).feed(&okay(1));
let seen = SharedMock::new(mock);
let conn = now(Connection::<_, 2, 64, 24>::connect(
seen.clone(),
NoAuth,
&[],
))
.unwrap();
let (mut reader, _writer) = conn.split().unwrap();
let ch = now(reader.open_channel(b"shell:\0")).unwrap();
let pump = |reader: &mut Reader<SharedMock, SharedMock, 2, 64, 24>| {
let mut buf = [0u8; 16];
let mut fut = core::pin::pin!(reader.read_channel(ch, &mut buf));
let mut cx = Context::from_waker(Waker::noop());
match fut.as_mut().poll(&mut cx) {
Poll::Ready(Err(Error::UnexpectedEof)) => {}
other => panic!("expected the drained-transport EOF, got {other:?}"),
}
};
seen.feed(&open_pkt(60, b"tcp:60\0"));
pump(&mut reader);
let held_a = reader.try_accept_incoming().unwrap();
seen.feed(&open_pkt(61, b"tcp:61\0"));
pump(&mut reader);
let held_b = reader.try_accept_incoming().unwrap();
assert_eq!(reader.shared.lock_incoming().len(), 0);
seen.feed(&open_pkt(62, b"tcp:62\0"));
pump(&mut reader);
assert!(
seen.sent()
.iter()
.any(|(cmd, _, arg1, _)| *cmd == Command::Close && *arg1 == 62),
"the OPEN past the budget must be refused with CLSE"
);
assert!(
reader.try_accept_incoming().is_none(),
"nothing may be queued past the budget"
);
drop(held_a);
drop(held_b);
assert_eq!(reader.shared.lock_incoming().len(), 2);
}
#[test]
fn repeated_refusal_cancellation_cannot_grow_the_queue() {
use core::future::Future as _;
use core::task::{Context, Poll, Waker};
let open_pkt =
|remote_id: u32, dest: &[u8]| Packet::new(Command::Open, remote_id, 0, dest.to_vec());
let mut mock = Mock::new();
mock.feed(&crate::base::mock::cnxn()).feed(&okay(1));
let seen = SharedMock::new(mock);
let conn = now(Connection::<_, 2, 64, 24>::connect(
seen.clone(),
NoAuth,
&[],
))
.unwrap();
let (mut reader, _writer) = conn.split().unwrap();
let ch = now(reader.open_channel(b"shell:\0")).unwrap();
for id in [70, 71, 72] {
let dest = alloc::format!("tcp:{id}\0");
seen.feed(&open_pkt(id, dest.as_bytes()));
}
let shared = Arc::clone(&reader.shared);
let wh = now(shared.write_half.lock());
let cancel_once = |reader: &mut Reader<SharedMock, SharedMock, 2, 64, 24>| {
let mut buf = [0u8; 16];
let mut fut = core::pin::pin!(reader.read_channel(ch, &mut buf));
let mut cx = Context::from_waker(Waker::noop());
assert!(matches!(fut.as_mut().poll(&mut cx), Poll::Pending));
};
cancel_once(&mut reader);
assert_eq!(reader.shared.lock_incoming().len(), 3);
seen.feed(&open_pkt(73, b"tcp:73\0"));
for _ in 0..3 {
cancel_once(&mut reader);
assert_eq!(
reader.shared.lock_incoming().len(),
3,
"a repeated cancellation grew the supposedly bounded queue"
);
}
drop(wh);
{
let mut buf = [0u8; 16];
let mut fut = core::pin::pin!(reader.read_channel(ch, &mut buf));
let mut cx = Context::from_waker(Waker::noop());
match fut.as_mut().poll(&mut cx) {
Poll::Ready(Err(Error::UnexpectedEof)) => {}
other => panic!("expected the drained-transport EOF, got {other:?}"),
}
}
let refused: alloc::vec::Vec<u32> = seen
.sent()
.iter()
.filter(|(cmd, ..)| *cmd == Command::Close)
.map(|&(_, _, arg1, _)| arg1)
.collect();
assert_eq!(refused, [72, 73], "leftover first, then the new arrival");
let q = reader.shared.lock_incoming();
assert_eq!(q.len(), 2, "back at the cap");
assert_eq!(q.front().unwrap().remote_id, 70);
}
#[test]
fn a_cancelled_overflow_refusal_keeps_the_open_recoverable() {
use core::future::Future as _;
use core::task::{Context, Poll, Waker};
let open_pkt =
|remote_id: u32, dest: &[u8]| Packet::new(Command::Open, remote_id, 0, dest.to_vec());
let mut mock = Mock::new();
mock.feed(&crate::base::mock::cnxn()).feed(&okay(1));
let seen = SharedMock::new(mock);
let conn = now(Connection::<_, 2, 64, 24>::connect(
seen.clone(),
NoAuth,
&[],
))
.unwrap();
let (mut reader, _writer) = conn.split().unwrap();
let ch = now(reader.open_channel(b"shell:\0")).unwrap();
for id in [70, 71, 72] {
let dest = alloc::format!("tcp:{id}\0");
seen.feed(&open_pkt(id, dest.as_bytes()));
}
let shared = Arc::clone(&reader.shared);
let wh = now(shared.write_half.lock());
{
let mut buf = [0u8; 16];
let mut fut = core::pin::pin!(reader.read_channel(ch, &mut buf));
let mut cx = Context::from_waker(Waker::noop());
assert!(matches!(fut.as_mut().poll(&mut cx), Poll::Pending));
}
drop(wh);
{
let q = reader.shared.lock_incoming();
assert_eq!(q.len(), 3, "the refused OPEN must be requeued");
assert_eq!(q.front().unwrap().remote_id, 72);
}
reader
.shared
.desync
.check::<core::convert::Infallible>()
.expect("a cancelled refusal must not poison the connection");
let inc = reader.try_accept_incoming().unwrap();
assert_eq!(inc.destination(), b"tcp:72\0");
now(inc.reject()).unwrap();
let (cmd, _, arg1, _) = seen.sent().last().unwrap().clone();
assert_eq!(
(cmd, arg1),
(Command::Close, 72),
"the CLSE names the refused OPEN"
);
}
#[test]
fn a_cancelled_write_stops_both_halves() {
let (mut reader, writer, ch) = split_with_channel(Some(1));
abandon(writer.write_channel(ch, b"payload-that-never-made-it"));
let err = now(writer.write_channel(ch, b"more")).unwrap_err();
assert!(
matches!(err, Error::Desynchronized),
"writer: expected Desynchronized, got {err:?}"
);
let mut buf = [0u8; 16];
let err = now(reader.read_channel(ch, &mut buf)).unwrap_err();
assert!(
matches!(err, Error::Desynchronized),
"reader: expected Desynchronized, got {err:?}"
);
}
#[test]
fn a_cancelled_write_wakes_reads_waiting_on_other_channels() {
use alloc::task::Wake;
use core::task::{Context, Waker};
struct Woken(AtomicBool);
impl Wake for Woken {
fn wake(self: Arc<Self>) {
self.0.store(true, Ordering::Relaxed);
}
}
let mut mock = Mock::new();
mock.feed(&crate::base::mock::cnxn())
.feed(&okay(1))
.feed(&okay(2))
.stall_write(6 + 1);
let conn = now(Connection::<_>::connect(SharedMock::new(mock), NoAuth, &[])).unwrap();
let (mut reader, writer) = conn.split().unwrap();
let a = now(reader.open_channel(b"shell:\0")).unwrap();
let b = now(reader.open_channel(b"shell:\0")).unwrap();
let woken = Arc::new(Woken(AtomicBool::new(false)));
let waker = Waker::from(Arc::clone(&woken));
let mut buf = [0u8; 16];
let mut read = pin!(writer.read_channel(b, &mut buf));
assert!(read
.as_mut()
.poll(&mut Context::from_waker(&waker))
.is_pending());
abandon(writer.write_channel(a, b"payload-that-never-made-it"));
assert!(
woken.0.load(Ordering::Relaxed),
"the read on b slept through the desync"
);
let err = now(read).unwrap_err();
assert!(matches!(err, Error::Desynchronized), "got {err:?}");
}
#[test]
fn a_ready_without_credit_fails_a_writer_open_on_a_reader_driven_connection() {
use crate::base::error::ProtocolError;
use core::task::{Context, Waker};
let (mut reader, writer, ch, seen) = crate::base::mock::split_one_channel_delayed_ack(
64,
&[Packet::new(Command::Ready, 43, 2, Vec::new())],
);
let mut open = pin!(writer.open_channel(b"svc:\0"));
assert!(open
.as_mut()
.poll(&mut Context::from_waker(Waker::noop()))
.is_pending());
let mut buf = [0u8; 8];
let err = now(reader.read_channel(ch, &mut buf)).unwrap_err();
assert!(
matches!(err, Error::Protocol(ProtocolError::ShortReadyPayload)),
"reader: got {err:?}"
);
let err = now(open).unwrap_err();
assert!(
matches!(err, Error::Protocol(ProtocolError::ShortReadyPayload)),
"opener: got {err:?}"
);
let (cmd, arg0, arg1, _) = seen.sent().last().unwrap().clone();
assert_eq!((cmd, arg0, arg1), (Command::Close, 2, 43));
}
#[test]
fn a_read_dropped_waiting_for_the_ack_lock_takes_nothing() {
use core::task::{Context, Waker};
let (_reader, writer, ch, _seen) =
crate::base::mock::split_one_channel_delayed_ack(64, &[]);
{
let mut chs = writer.shared.lock_channels();
let slot = slot_for_mut(&mut *chs, ch).unwrap();
slot.push_rx(b"hello", usize::MAX).unwrap();
slot.unacked = 5;
}
let wh = now(writer.shared.write_half.lock());
let mut buf = [0u8; 8];
{
let mut read = pin!(writer.read_channel(ch, &mut buf));
assert!(read
.as_mut()
.poll(&mut Context::from_waker(Waker::noop()))
.is_pending());
}
{
let chs = writer.shared.lock_channels();
let slot = chs[ch.slot].as_ref().unwrap();
assert_eq!(
(slot.rx_buf.len(), slot.unacked),
(5, 5),
"a read dropped while waiting took the bytes"
);
}
drop(wh);
let n = now(writer.read_channel(ch, &mut buf)).unwrap();
assert_eq!(&buf[..n], b"hello");
}
#[test]
fn an_opener_dropped_after_its_ready_was_taken_still_closes_the_channel() {
use core::task::{Context, Waker};
let mut mock = Mock::new();
mock.feed(&crate::base::mock::cnxn())
.feed(&okay(1))
.feed(&Packet::new(Command::Ready, 43, 2, Vec::new()))
.feed(&Packet::new(Command::Write, 42, 1, b"x".to_vec()));
let seen = SharedMock::new(mock);
let conn = now(Connection::<_>::connect(seen.clone(), NoAuth, &[])).unwrap();
let (mut reader, writer) = conn.split().unwrap();
let ch = now(reader.open_channel(b"shell:\0")).unwrap();
{
let mut open = pin!(writer.open_channel(b"svc:\0"));
assert!(open
.as_mut()
.poll(&mut Context::from_waker(Waker::noop()))
.is_pending());
let mut buf = [0u8; 4];
assert_eq!(now(reader.read_channel(ch, &mut buf)).unwrap(), 1);
}
now(writer.write_channel(ch, b"y")).unwrap();
let sent = seen.sent();
let tail: Vec<_> = sent[sent.len() - 2..]
.iter()
.map(|(cmd, arg0, arg1, _)| (*cmd, *arg0, *arg1))
.collect();
assert_eq!(tail, [(Command::Close, 2, 43), (Command::Write, 1, 42)]);
}
#[test]
fn a_fault_closes_the_device_end_even_once_the_slot_is_gone() {
let (reader, _writer, _ch) = split_with_channel(None);
let seen = reader.shared.write_half.try_lock().unwrap().clone();
now(reader
.shared
.fail_channel(5, 99, 77, ChannelFault::RxOverflow))
.unwrap();
let (cmd, arg0, arg1, _) = seen.sent().last().unwrap().clone();
assert_eq!((cmd, arg0, arg1), (Command::Close, 99, 77));
}
#[test]
fn a_read_that_owes_no_ack_does_not_wait_for_the_write_lock() {
let config = ConnectionConfig::new()
.with_max_payload(1024)
.with_initial_ack_bytes(1024);
let mut mock = Mock::new();
mock.feed(&crate::base::mock::cnxn()).feed(&okay(1));
let conn = now(Connection::<_>::connect_with_config(
SharedMock::new(mock),
NoAuth,
&[],
config,
))
.unwrap();
let (mut reader, writer) = conn.split().unwrap();
let ch = now(reader.open_channel(b"shell:\0")).unwrap();
{
let mut chs = writer.shared.lock_channels();
let slot = slot_for_mut(&mut *chs, ch).unwrap();
slot.push_rx(&[0xEE; 2000], usize::MAX).unwrap();
slot.unacked = 1000;
}
let _wh = now(writer.shared.write_half.lock());
let mut buf = [0u8; 8];
assert_eq!(now(writer.read_channel(ch, &mut buf)).unwrap(), 8);
let chs = writer.shared.lock_channels();
assert_eq!(chs[ch.slot].as_ref().unwrap().unacked, 1000);
}
#[test]
fn a_read_woken_on_a_desynchronized_connection_hands_out_nothing() {
use core::task::{Context, Waker};
let (_reader, writer, ch) = split_with_channel(Some(1));
let mut buf = [0u8; 8];
let mut read = pin!(writer.read_channel(ch, &mut buf));
assert!(read
.as_mut()
.poll(&mut Context::from_waker(Waker::noop()))
.is_pending());
{
let mut chs = writer.shared.lock_channels();
let slot = slot_for_mut(&mut *chs, ch).unwrap();
slot.push_rx(b"hi", usize::MAX).unwrap();
}
abandon(writer.write_channel(ch, b"payload-that-never-made-it"));
let err = now(read).unwrap_err();
assert!(matches!(err, Error::Desynchronized), "got {err:?}");
}
#[test]
fn writes_that_complete_leave_both_halves_working() {
let (mut reader, writer, ch) = split_with_channel(None);
now(writer.write_channel(ch, b"payload")).unwrap();
let mut buf = [0u8; 16];
assert!(!matches!(
now(reader.read_channel(ch, &mut buf)),
Err(Error::Desynchronized)
));
}
}
#[cfg(test)]
mod send_queue_tests {
use alloc::boxed::Box;
use alloc::vec::Vec;
use core::future::Future;
use core::pin::Pin;
use core::task::{Context, Poll, Waker};
use crate::base::channel::{slot_for_mut, ChannelId};
use crate::base::mock::{okay_with_budget, split_one_channel_delayed_ack, SharedMock};
use crate::base::protocol::command::Command;
fn poll_once<F: Future + ?Sized>(fut: Pin<&mut F>) -> Poll<F::Output> {
let mut cx = Context::from_waker(Waker::noop());
fut.poll(&mut cx)
}
fn wrte_payloads(seen: &SharedMock) -> Vec<Vec<u8>> {
seen.sent()
.into_iter()
.filter(|(cmd, ..)| *cmd == Command::Write)
.map(|(_, _, _, payload)| payload)
.collect()
}
fn grant(writer: &super::Writer<SharedMock>, ch: ChannelId, credit: u32) {
{
let mut chs = writer.shared.lock_channels();
slot_for_mut(&mut *chs, ch)
.unwrap()
.apply_ready(&credit.to_le_bytes(), true)
.unwrap();
}
writer.shared.signals[ch.slot].wake();
}
#[test]
fn a_returning_writer_queues_behind_the_one_already_waiting() {
let (_reader, writer, ch, seen) = split_one_channel_delayed_ack(0, &[]);
let mut first = Box::pin(writer.write_channel(ch, b"aaaaaaaaaa"));
let mut second = Box::pin(writer.write_channel(ch, b"bbbbb"));
assert!(poll_once(first.as_mut()).is_pending());
assert!(poll_once(second.as_mut()).is_pending());
grant(&writer, ch, 5);
assert!(poll_once(first.as_mut()).is_pending());
grant(&writer, ch, 100);
assert!(poll_once(first.as_mut()).is_pending());
assert!(poll_once(second.as_mut()).is_ready());
assert!(poll_once(first.as_mut()).is_ready());
let wrtes = wrte_payloads(&seen);
assert_eq!(wrtes.len(), 3, "expected three WRTEs, got {wrtes:?}");
assert_eq!(&wrtes[0], b"aaaaa");
assert_eq!(
&wrtes[1], b"bbbbb",
"the queued writer goes before the returning one"
);
assert_eq!(&wrtes[2], b"aaaaa");
}
#[test]
fn a_grant_is_served_in_arrival_order_not_by_the_scheduler() {
let (mut reader, writer, ch, seen) =
split_one_channel_delayed_ack(5, &[okay_with_budget(1, 100)]);
let mut first = Box::pin(writer.write_channel(ch, b"aaaaaaaaaa"));
let mut second = Box::pin(writer.write_channel(ch, b"bbbbb"));
assert!(poll_once(first.as_mut()).is_pending());
assert!(poll_once(second.as_mut()).is_pending());
let mut buf = [0u8; 8];
{
let mut read = Box::pin(reader.read_channel(ch, &mut buf));
let _ = poll_once(read.as_mut());
}
assert!(poll_once(second.as_mut()).is_pending());
assert!(poll_once(first.as_mut()).is_ready());
assert!(poll_once(second.as_mut()).is_ready());
let wrtes = wrte_payloads(&seen);
assert_eq!(wrtes.len(), 3, "expected three WRTEs, got {wrtes:?}");
assert_eq!(&wrtes[0], b"aaaaa");
assert_eq!(&wrtes[1], b"aaaaa");
assert_eq!(&wrtes[2], b"bbbbb");
}
#[test]
fn a_cancelled_head_hands_its_turn_to_the_next_writer() {
let (mut reader, writer, ch, seen) =
split_one_channel_delayed_ack(0, &[okay_with_budget(1, 50)]);
let mut first = Box::pin(writer.write_channel(ch, b"aaaaa"));
let mut second = Box::pin(writer.write_channel(ch, b"bbbbb"));
assert!(poll_once(first.as_mut()).is_pending());
assert!(poll_once(second.as_mut()).is_pending());
drop(first);
let mut buf = [0u8; 8];
{
let mut read = Box::pin(reader.read_channel(ch, &mut buf));
let _ = poll_once(read.as_mut());
}
assert!(poll_once(second.as_mut()).is_ready());
let wrtes = wrte_payloads(&seen);
assert_eq!(wrtes.len(), 1, "expected one WRTE, got {wrtes:?}");
assert_eq!(&wrtes[0], b"bbbbb");
}
#[test]
fn a_cancelled_place_mid_queue_is_skipped_when_reached() {
let (mut reader, writer, ch, seen) =
split_one_channel_delayed_ack(0, &[okay_with_budget(1, 50)]);
let mut first = Box::pin(writer.write_channel(ch, b"aaaaa"));
let mut second = Box::pin(writer.write_channel(ch, b"bbbbb"));
let mut third = Box::pin(writer.write_channel(ch, b"ccccc"));
assert!(poll_once(first.as_mut()).is_pending());
assert!(poll_once(second.as_mut()).is_pending());
assert!(poll_once(third.as_mut()).is_pending());
drop(second);
let mut buf = [0u8; 8];
{
let mut read = Box::pin(reader.read_channel(ch, &mut buf));
let _ = poll_once(read.as_mut());
}
assert!(poll_once(first.as_mut()).is_ready());
assert!(poll_once(third.as_mut()).is_ready());
let wrtes = wrte_payloads(&seen);
assert_eq!(wrtes.len(), 2, "expected two WRTEs, got {wrtes:?}");
assert_eq!(&wrtes[0], b"aaaaa");
assert_eq!(&wrtes[1], b"ccccc");
}
}
#[cfg(test)]
mod incoming_tests {
use crate::base::channel::ChannelId;
use crate::base::mock::{now, split_one_channel_delayed_ack, wrte};
use crate::base::protocol::command::Command;
use crate::base::protocol::Packet;
fn open_pkt(remote_id: u32, credit: u32, dest: &[u8]) -> Packet {
Packet::new(Command::Open, remote_id, credit, dest.to_vec())
}
#[test]
fn a_device_open_on_a_split_reader_is_accepted_and_serves_data() {
let (mut reader, writer, _ch, seen) = split_one_channel_delayed_ack(0, &[]);
seen.feed(&open_pkt(77, 4096, b"tcp:9090\0"));
let incoming = now(reader.accept_incoming()).unwrap();
assert_eq!(incoming.destination(), b"tcp:9090\0");
let ch: ChannelId = now(incoming.accept()).unwrap();
let (cmd, local, remote, payload) = seen.sent().last().unwrap().clone();
assert_eq!(cmd, Command::Ready);
assert_eq!(remote, 77);
assert_eq!(payload.len(), 4);
seen.feed(&wrte(local, b"ping"));
let mut buf = [0u8; 16];
let n = now(reader.read_channel(ch, &mut buf)).unwrap();
assert_eq!(&buf[..n], b"ping");
now(writer.write_channel(ch, b"pong")).unwrap();
let (cmd, l, r, payload) = seen.sent().last().unwrap().clone();
assert_eq!(cmd, Command::Write);
assert_eq!((l, r), (local, 77));
assert_eq!(payload, b"pong");
}
#[test]
fn a_rejected_open_on_a_split_reader_answers_clse() {
let (mut reader, _writer, _ch, seen) = split_one_channel_delayed_ack(0, &[]);
seen.feed(&open_pkt(88, 0, b"tcp:1\0"));
let incoming = now(reader.accept_incoming()).unwrap();
now(incoming.reject()).unwrap();
let (cmd, local, remote, _) = seen.sent().last().unwrap().clone();
assert_eq!(cmd, Command::Close);
assert_eq!((local, remote), (0, 88));
}
}
#[cfg(test)]
mod backpressure_tests {
use crate::base::mock::{now, split_two_channels_delayed_ack, wrte};
#[test]
fn a_split_reader_returns_credit_only_for_what_was_read() {
let (mut reader, a, b, seen) =
split_two_channels_delayed_ack(&[wrte(2, b"for-b"), wrte(1, b"for-a")]);
let mut buf = [0u8; 32];
now(reader.read_channel(a, &mut buf)).unwrap();
assert!(
seen.acks_for(2).is_empty(),
"channel B was buffered, not read: its credit stays with us"
);
let n = now(reader.read_channel(b, &mut buf)).unwrap();
assert_eq!(&buf[..n], b"for-b");
assert_eq!(seen.acks_for(2), alloc::vec![5]);
}
}