libadb 0.9.0

Low-level ADB protocol library for direct TCP and USB communication
Documentation
#[cfg(test)]
mod tests;

use core::convert::Infallible;
use core::future::{pending, poll_fn, Future};
use core::pin::{pin, Pin};
use core::sync::atomic::{AtomicBool, Ordering};
use core::task::Poll;

use bytes::BytesMut;
use embedded_io_async::{Read, Write};

use super::ids::{ChannelIds, LocalId};
use super::negotiated::AckMode;
use super::protocol::command::Command;
use super::protocol::constant::MAX_PAYLOAD;
use super::protocol::Packet;
use super::protocol::{Checksum, MESSAGE_SIZE};
use super::slot::PendingAck;
use crate::error::{Error, ProtocolError};

pub(crate) const MIN_READ: usize = 4096;

#[cfg(test)]
pub(crate) use tests::ZEROED;

fn read_limit(buf: &[u8]) -> usize {
    if buf.len() < MESSAGE_SIZE {
        MIN_READ
    } else {
        Packet::missing(buf)
    }
}

pub(crate) struct Staged<'a> {
    buf: &'a mut BytesMut,
    keep: usize,
}

impl<'a> Staged<'a> {
    pub(crate) fn new(buf: &'a mut BytesMut) -> Self {
        let keep = buf.len();
        let want = read_limit(buf);
        buf.resize(keep + want, 0);
        #[cfg(test)]
        tests::ZEROED.with(|zeroed| zeroed.set(zeroed.get() + want));
        Self { buf, keep }
    }

    fn spare(&mut self) -> &mut [u8] {
        &mut self.buf[self.keep..]
    }

    pub(crate) fn room(&mut self) -> &mut [u8] {
        let limit = read_limit(self.committed());
        let spare = self.spare();
        let room = limit.min(spare.len());
        &mut spare[..room]
    }

    pub(crate) fn commit(&mut self, n: usize) {
        self.keep += n;
    }

    pub(crate) fn committed(&self) -> &[u8] {
        &self.buf[..self.keep]
    }

    pub(crate) fn wants_more(&mut self) -> bool {
        let missing = Packet::missing(self.committed());
        missing != 0 && missing <= self.spare().len()
    }
}

impl Drop for Staged<'_> {
    fn drop(&mut self) {
        self.buf.truncate(self.keep);
    }
}

pub(crate) fn connection_gone<E: embedded_io::Error>(e: &Error<E>) -> bool {
    use embedded_io::ErrorKind::{BrokenPipe, ConnectionAborted, ConnectionReset, NotConnected};
    matches!(e, Error::Io(e) if matches!(
        e.kind(),
        ConnectionReset | ConnectionAborted | BrokenPipe | NotConnected
    ))
}

#[cfg(feature = "split")]
pub(crate) fn ends_connection<E: embedded_io::Error>(e: &Error<E>) -> bool {
    match e {
        Error::UnexpectedEof => true,
        Error::Protocol(e) => *e != ProtocolError::InvalidChecksum,
        e => connection_gone(e),
    }
}

pub(crate) struct DesyncFlag(AtomicBool);

impl DesyncFlag {
    pub(crate) const fn new() -> Self {
        Self(AtomicBool::new(false))
    }

    pub(crate) fn check<E>(&self) -> Result<(), Error<E>> {
        if self.0.load(Ordering::Acquire) {
            return Err(Error::Desynchronized);
        }
        Ok(())
    }

    fn arm(&self) -> ArmedWrite<'_> {
        ArmedWrite(Some(self))
    }
}

struct ArmedWrite<'a>(Option<&'a DesyncFlag>);

impl ArmedWrite<'_> {
    fn disarm(mut self) {
        self.0 = None;
    }
}

impl Drop for ArmedWrite<'_> {
    fn drop(&mut self) {
        if let Some(flag) = self.0 {
            flag.0.store(true, Ordering::Release);
        }
    }
}

pub(crate) async fn write_all<T: Write>(t: &mut T, buf: &[u8]) -> Result<(), Error<T::Error>> {
    let mut pos = 0;
    while pos < buf.len() {
        match t.write(&buf[pos..]).await {
            Ok(0) => return Err(Error::UnexpectedEof),
            Ok(n) => pos += n,
            Err(e) => return Err(Error::Io(e)),
        }
    }
    Ok(())
}

pub(crate) async fn send_pkt<T: Write>(
    t: &mut T,
    desync: &DesyncFlag,
    pkt: &Packet,
    checksum: Checksum,
) -> Result<(), Error<T::Error>> {
    desync.check()?;
    let header = encode_header(pkt.command, pkt.arg0, pkt.arg1, &pkt.data, checksum)?;
    send_frame(t, desync, &header, &pkt.data).await
}

pub(crate) async fn recv_pkt<T: Read>(
    t: &mut T,
    buf: &mut BytesMut,
    max_payload: u32,
) -> Result<Packet, Error<T::Error>> {
    match recv_pkt_or(t, buf, max_payload, pin!(pending::<Infallible>()), true).await? {
        Received::Packet(pkt) => Ok(pkt),
        Received::Interrupted(never) => match never {},
    }
}

pub(crate) enum Received<I> {
    Packet(Packet),
    Interrupted(I),
}

pub(crate) async fn recv_pkt_or<T: Read, F: Future>(
    t: &mut T,
    buf: &mut BytesMut,
    max_payload: u32,
    mut interrupt: Pin<&mut F>,
    race: bool,
) -> Result<Received<F::Output>, Error<T::Error>> {
    loop {
        if let Some(pkt) = Packet::decode(buf, max_payload)? {
            return Ok(Received::Packet(pkt));
        }
        let mut staged = Staged::new(buf);
        loop {
            let got = if race {
                let mut read = pin!(t.read(staged.room()));
                let raced = poll_fn(|cx| {
                    if let Poll::Ready(val) = interrupt.as_mut().poll(cx) {
                        return Poll::Ready(Err(val));
                    }
                    read.as_mut().poll(cx).map(Ok)
                })
                .await;
                match raced {
                    Ok(got) => got,
                    Err(val) => return Ok(Received::Interrupted(val)),
                }
            } else {
                if let Poll::Ready(val) =
                    poll_fn(|cx| Poll::Ready(interrupt.as_mut().poll(cx))).await
                {
                    return Ok(Received::Interrupted(val));
                }
                t.read(staged.room()).await
            };
            match got {
                Ok(0) => return Err(Error::UnexpectedEof),
                Ok(n) => staged.commit(n),
                Err(e) => return Err(Error::Io(e)),
            }
            if !staged.wants_more() {
                break;
            }
        }
    }
}

fn encode_header(
    command: Command,
    arg0: u32,
    arg1: u32,
    payload: &[u8],
    checksum: Checksum,
) -> Result<[u8; MESSAGE_SIZE], ProtocolError> {
    if payload.len() > MAX_PAYLOAD as usize {
        return Err(ProtocolError::PayloadTooLarge);
    }
    let cmd_u32: u32 = command.into();
    let data_length = payload.len() as u32;
    let data_check = checksum.of(payload);
    let magic = command.magic();
    let mut h = [0u8; MESSAGE_SIZE];
    h[0..4].copy_from_slice(&cmd_u32.to_le_bytes());
    h[4..8].copy_from_slice(&arg0.to_le_bytes());
    h[8..12].copy_from_slice(&arg1.to_le_bytes());
    h[12..16].copy_from_slice(&data_length.to_le_bytes());
    h[16..20].copy_from_slice(&data_check.to_le_bytes());
    h[20..24].copy_from_slice(&magic.to_le_bytes());
    Ok(h)
}

pub(crate) async fn send_raw<T: Write>(
    t: &mut T,
    desync: &DesyncFlag,
    command: Command,
    ids: ChannelIds,
    payload: &[u8],
    checksum: Checksum,
) -> Result<(), Error<T::Error>> {
    desync.check()?;
    let header = encode_header(
        command,
        ids.local.raw(),
        ids.remote.raw(),
        payload,
        checksum,
    )?;
    send_frame(t, desync, &header, payload).await
}

pub(crate) async fn send_open<T: Write>(
    t: &mut T,
    desync: &DesyncFlag,
    local: LocalId,
    credit: u32,
    destination: &[u8],
    checksum: Checksum,
) -> Result<(), Error<T::Error>> {
    desync.check()?;
    let header = encode_header(Command::Open, local.raw(), credit, destination, checksum)?;
    send_frame(t, desync, &header, destination).await
}

async fn send_frame<T: Write>(
    t: &mut T,
    desync: &DesyncFlag,
    header: &[u8; MESSAGE_SIZE],
    payload: &[u8],
) -> Result<(), Error<T::Error>> {
    let armed = desync.arm();
    let sent = write_frame(t, header, payload).await;
    if sent.as_ref().err().is_none_or(connection_gone) {
        armed.disarm();
    }
    sent
}

async fn write_frame<T: Write>(
    t: &mut T,
    header: &[u8; MESSAGE_SIZE],
    payload: &[u8],
) -> Result<(), Error<T::Error>> {
    write_all(t, header).await?;
    if !payload.is_empty() {
        write_all(t, payload).await?;
    }
    t.flush().await.map_err(Error::Io)
}

pub(crate) async fn send_okay_to<T: Write>(
    transport: &mut T,
    desync: &DesyncFlag,
    ack: PendingAck,
    mode: AckMode,
    checksum: Checksum,
) -> Result<(), Error<T::Error>> {
    let credit = (ack.len as u32).to_le_bytes();
    let payload: &[u8] = match mode {
        AckMode::Delayed => &credit,
        AckMode::Classic => &[],
    };
    send_raw(
        transport,
        desync,
        Command::Ready,
        ack.ids,
        payload,
        checksum,
    )
    .await
}