use bytes::BytesMut;
use core::future::Future;
use core::task::Poll;
use embedded_io::ErrorType;
use embedded_io_async::{Read, Write};
use super::channel::{
channel_ids_of, dispatch_packet, Channel, ChannelId, ChannelSlot, DispatchOutcome, SelectResult,
};
use super::device_banner::DeviceBanner;
use super::error::Error;
use super::protocol::command::Command;
use super::protocol::features::{self, Feature};
use super::protocol::packet::Packet;
use super::wire::{recv_pkt, send_okay_to, send_pkt, send_raw, RECV_SCRATCH};
pub const DEFAULT_MAX_CHANNELS: usize = 32;
pub const DEFAULT_MAX_PROPERTIES: usize = 64;
pub const DEFAULT_MAX_FEATURES: usize = 24;
pub struct Connection<
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,
{
transport: T,
channels: [Option<ChannelSlot>; MAX_CHANNELS],
max_payload: u32,
device_banner: Option<DeviceBanner<MAX_PROPERTIES, MAX_FEATURES>>,
local_id_counter: u32,
delayed_ack: bool,
recv_buf: BytesMut,
}
async fn dispatch_to<T: Write>(
transport: &mut T,
channels: &mut [Option<ChannelSlot>],
delayed_ack: bool,
pkt: Packet,
) -> Result<(), Error<T::Error>> {
if let DispatchOutcome::AckWrite {
local_id,
remote_id,
len,
} = dispatch_packet(channels, &pkt, delayed_ack)?
{
send_okay_to(transport, delayed_ack, local_id, remote_id, len).await?;
}
Ok(())
}
impl<T, const MAX_CHANNELS: usize, const MAX_PROPERTIES: usize, const MAX_FEATURES: usize>
Connection<T, MAX_CHANNELS, MAX_PROPERTIES, MAX_FEATURES>
where
T: Read + Write,
{
pub fn max_payload(&self) -> u32 {
self.max_payload
}
pub fn device_banner(&self) -> Option<&[u8]> {
self.device_banner.as_ref().map(|v| v.raw())
}
pub fn device_banner_parsed(&self) -> Option<&DeviceBanner<MAX_PROPERTIES, MAX_FEATURES>> {
self.device_banner.as_ref()
}
pub fn require_feature(&self, feature: Feature) -> Result<(), Error<<T as ErrorType>::Error>> {
match &self.device_banner {
Some(b) if b.has_feature(&feature) => Ok(()),
Some(_) => Err(Error::MissingFeature(feature)),
None => Ok(()),
}
}
pub fn delayed_ack(&self) -> bool {
self.delayed_ack
}
pub fn transport(&self) -> &T {
&self.transport
}
pub fn transport_mut(&mut self) -> &mut T {
&mut self.transport
}
pub fn into_transport(self) -> T {
self.transport
}
pub fn into_parts(self) -> (T, BytesMut) {
(self.transport, self.recv_buf)
}
#[cfg(feature = "split")]
#[allow(clippy::type_complexity)]
pub fn split(
self,
) -> Result<
(
crate::split::Reader<
<T as crate::Splittable>::ReadHalf,
<T as crate::Splittable>::WriteHalf,
MAX_CHANNELS,
MAX_PROPERTIES,
MAX_FEATURES,
>,
crate::split::Writer<
<T as crate::Splittable>::WriteHalf,
MAX_CHANNELS,
MAX_PROPERTIES,
MAX_FEATURES,
>,
),
Error<<T as ErrorType>::Error>,
>
where
T: crate::Splittable,
{
use crate::split::{Reader, Shared, Writer};
use alloc::sync::Arc;
use core::sync::atomic::AtomicU32;
let (read_half, write_half) = self.transport.split().map_err(Error::Io)?;
let shared = Arc::new(Shared {
write_half: async_lock::Mutex::new(write_half),
channels: std::sync::Mutex::new(self.channels),
signals: core::array::from_fn(|_| crate::split::FlowSignal::new()),
max_payload: self.max_payload,
delayed_ack: self.delayed_ack,
device_banner: self.device_banner,
local_id_counter: AtomicU32::new(self.local_id_counter),
});
let reader = Reader::new(read_half, self.recv_buf, Arc::clone(&shared));
let writer = Writer::new(shared);
Ok((reader, writer))
}
pub async fn open(
&mut self,
destination: &[u8],
) -> Result<
Channel<'_, T, MAX_CHANNELS, MAX_PROPERTIES, MAX_FEATURES>,
Error<<T as ErrorType>::Error>,
> {
let id = self.open_channel(destination).await?;
Ok(Channel { conn: self, id })
}
pub async fn open_channel(
&mut self,
destination: &[u8],
) -> Result<ChannelId, Error<<T as ErrorType>::Error>> {
let slot_idx = self
.channels
.iter()
.position(|s| s.is_none())
.ok_or(Error::NoFreeChannels)?;
let local_id = self.next_local_id();
let open_arg1 = if self.delayed_ack {
features::INITIAL_DELAYED_ACK_BYTES
} else {
0
};
let pkt = Packet::new(Command::Open, local_id, open_arg1, destination.to_vec());
send_pkt(&mut self.transport, &pkt).await?;
let result = self.await_open_ack(local_id, slot_idx).await;
if let Err(ref e) = result {
if !matches!(e, Error::ChannelClosed) {
let _ = send_raw(&mut self.transport, Command::Close, local_id, 0, &[]).await;
}
}
result
}
async fn await_open_ack(
&mut self,
local_id: u32,
slot_idx: usize,
) -> Result<ChannelId, Error<<T as ErrorType>::Error>> {
loop {
let pkt = recv_pkt(&mut self.transport, &mut self.recv_buf).await?;
match pkt.command {
Command::Ready if pkt.arg1 == local_id => {
let mut slot = ChannelSlot::new(local_id);
slot.accept_open_ready(pkt.arg0, &pkt.data, self.delayed_ack)?;
self.channels[slot_idx] = Some(slot);
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<<T as ErrorType>::Error>> {
{
let slot = self.slot_mut(ch)?;
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.transport, &mut self.recv_buf).await?;
match pkt.command {
Command::Write if pkt.arg1 == local_id => {
let payload_len = pkt.data.len();
self.send_okay(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() {
if let Some(slot) = self.channels[ch.slot].as_mut() {
slot.rx_buf.extend_from_slice(&pkt.data[n..]);
}
}
return Ok(n);
}
Command::Close if pkt.arg1 == local_id => {
if let Some(slot) = self.channels[ch.slot].as_mut() {
slot.apply_close();
}
return Err(Error::ChannelClosed);
}
_ => {
self.dispatch(pkt).await?;
}
}
}
}
pub async fn write_channel(
&mut self,
ch: ChannelId,
data: &[u8],
) -> Result<(), Error<<T as ErrorType>::Error>> {
if data.is_empty() {
return Ok(());
}
let max = (self.max_payload as usize).max(1);
let delayed_ack = self.delayed_ack;
let mut offset = 0;
while offset < data.len() {
self.wait_ack(ch).await?;
let mut n = (data.len() - offset).min(max);
if delayed_ack {
let slot = self.slot_mut(ch)?;
let budget = slot.send_budget.max(0) as usize;
n = n.min(budget);
debug_assert!(n > 0, "wait_ack returned with zero budget");
}
let (local_id, remote_id) = self.channel_ids(ch)?;
send_raw(
&mut self.transport,
Command::Write,
local_id,
remote_id,
&data[offset..offset + n],
)
.await?;
let slot = self.slot_mut(ch)?;
if delayed_ack {
slot.send_budget -= n as i64;
} else {
slot.wrte_acked = false;
}
offset += n;
}
Ok(())
}
pub async fn close_channel(
&mut self,
ch: ChannelId,
) -> Result<(), Error<<T as ErrorType>::Error>> {
let (local_id, remote_id) = self.channel_ids(ch)?;
send_pkt(&mut self.transport, &Packet::close(local_id, remote_id)).await?;
self.channels[ch.slot] = None;
Ok(())
}
pub async fn select_channel<F>(
&mut self,
ch: ChannelId,
buf: &mut [u8],
interrupt: F,
) -> Result<SelectResult<F::Output>, Error<<T as ErrorType>::Error>>
where
F: Future,
{
{
let slot = self.slot_mut(ch)?;
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(SelectResult::Data(n));
}
if slot.is_closed() {
return Err(Error::ChannelClosed);
}
}
let (local_id, remote_id) = self.channel_ids(ch)?;
let delayed_ack = self.delayed_ack;
let mut interrupt = core::pin::pin!(interrupt);
loop {
if let Some(pkt) = Packet::decode(&mut self.recv_buf)? {
match pkt.command {
Command::Write if pkt.arg1 == local_id => {
let payload_len = pkt.data.len();
send_okay_to(
&mut self.transport,
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() {
if let Some(slot) = self.channels[ch.slot].as_mut() {
slot.rx_buf.extend_from_slice(&pkt.data[n..]);
}
}
return Ok(SelectResult::Data(n));
}
Command::Close if pkt.arg1 == local_id => {
if let Some(slot) = self.channels[ch.slot].as_mut() {
slot.apply_close();
}
return Err(Error::ChannelClosed);
}
_ => {
dispatch_to(&mut self.transport, &mut self.channels, delayed_ack, pkt)
.await?;
continue;
}
}
}
{
enum Wakeup<O> {
Read(usize),
Interrupt(O),
}
let mut tmp = [0u8; RECV_SCRATCH];
let wakeup = {
let mut read_fut = core::pin::pin!(self.transport.read(&mut tmp));
core::future::poll_fn(|cx| {
if let Poll::Ready(val) = interrupt.as_mut().poll(cx) {
return Poll::Ready(Ok(Wakeup::Interrupt(val)));
}
match read_fut.as_mut().poll(cx) {
Poll::Ready(Ok(0)) => Poll::Ready(Err(Error::UnexpectedEof)),
Poll::Ready(Ok(n)) => Poll::Ready(Ok(Wakeup::Read(n))),
Poll::Ready(Err(e)) => Poll::Ready(Err(Error::Io(e))),
Poll::Pending => Poll::Pending,
}
})
.await?
};
match wakeup {
Wakeup::Read(n) => self.recv_buf.extend_from_slice(&tmp[..n]),
Wakeup::Interrupt(val) => return Ok(SelectResult::Interrupted(val)),
}
}
}
}
fn next_local_id(&mut self) -> u32 {
const RESERVED_ADB_ID: u32 = 0;
let id = self.local_id_counter;
self.local_id_counter = self.local_id_counter.wrapping_add(1);
if self.local_id_counter == RESERVED_ADB_ID {
self.local_id_counter = 1;
}
id
}
fn slot_mut(
&mut self,
ch: ChannelId,
) -> Result<&mut ChannelSlot, Error<<T as ErrorType>::Error>> {
self.channels
.get_mut(ch.slot)
.and_then(|s| s.as_mut())
.filter(|s| s.local_id == ch.local_id)
.ok_or(Error::ChannelClosed)
}
pub(crate) fn channel_ids(
&self,
ch: ChannelId,
) -> Result<(u32, u32), Error<<T as ErrorType>::Error>> {
channel_ids_of(&self.channels, ch)
}
async fn send_okay(
&mut self,
local_id: u32,
remote_id: u32,
wrte_len: usize,
) -> Result<(), Error<<T as ErrorType>::Error>> {
send_okay_to(
&mut self.transport,
self.delayed_ack,
local_id,
remote_id,
wrte_len,
)
.await
}
async fn dispatch(&mut self, pkt: Packet) -> Result<(), Error<<T as ErrorType>::Error>> {
dispatch_to(
&mut self.transport,
&mut self.channels,
self.delayed_ack,
pkt,
)
.await
}
async fn wait_ack(&mut self, ch: ChannelId) -> Result<(), Error<<T as ErrorType>::Error>> {
let delayed_ack = self.delayed_ack;
loop {
{
let slot = self.slot_mut(ch)?;
if delayed_ack {
if slot.send_budget > 0 {
return Ok(());
}
} else if slot.wrte_acked {
return Ok(());
}
if slot.is_closed() {
return Err(Error::ChannelClosed);
}
}
let local_id = self.channel_ids(ch)?.0;
let pkt = recv_pkt(&mut self.transport, &mut self.recv_buf).await?;
match pkt.command {
Command::Ready if pkt.arg1 == local_id => {
if let Some(slot) = self.channels[ch.slot].as_mut() {
slot.apply_ready(&pkt.data, delayed_ack)?;
if !delayed_ack {
return Ok(());
}
}
}
Command::Close if pkt.arg1 == local_id => {
if let Some(slot) = self.channels[ch.slot].as_mut() {
slot.apply_close();
}
return Err(Error::ChannelClosed);
}
_ => {
self.dispatch(pkt).await?;
}
}
}
}
}
mod handshake;