libadb 0.1.0

Low-level ADB protocol library for direct TCP and USB communication
Documentation
use bytes::BytesMut;
use embedded_io_async::{Read, Write};

use super::error::{Error, ProtocolError};
use super::protocol::command::Command;
use super::protocol::constant::MAX_PAYLOAD;
use super::protocol::packet::Packet;
use super::protocol::MESSAGE_SIZE;

pub(crate) const RECV_SCRATCH: usize = 4096;

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, pkt: &Packet) -> Result<(), Error<T::Error>> {
    let mut buf = BytesMut::with_capacity(MESSAGE_SIZE + pkt.data.len());
    pkt.encode(&mut buf)?;
    write_all(t, &buf).await
}

pub(crate) async fn recv_pkt<T: Read>(
    t: &mut T,
    buf: &mut BytesMut,
) -> Result<Packet, Error<T::Error>> {
    let mut tmp = [0u8; RECV_SCRATCH];
    loop {
        if let Some(pkt) = Packet::decode(buf)? {
            return Ok(pkt);
        }
        match t.read(&mut tmp).await {
            Ok(0) => return Err(Error::UnexpectedEof),
            Ok(n) => buf.extend_from_slice(&tmp[..n]),
            Err(e) => return Err(Error::Io(e)),
        }
    }
}

fn payload_checksum(payload: &[u8]) -> u32 {
    let mut sum = 0u32;
    for &b in payload {
        sum = sum.wrapping_add(b as u32);
    }
    sum
}

fn encode_header(
    command: Command,
    arg0: u32,
    arg1: u32,
    payload: &[u8],
) -> 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 = payload_checksum(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,
    command: Command,
    arg0: u32,
    arg1: u32,
    payload: &[u8],
) -> Result<(), Error<T::Error>> {
    let header = encode_header(command, arg0, arg1, payload)?;
    write_all(t, &header).await?;
    if !payload.is_empty() {
        write_all(t, payload).await?;
    }
    Ok(())
}

pub(crate) async fn send_okay_to<T: Write>(
    transport: &mut T,
    delayed_ack: bool,
    local_id: u32,
    remote_id: u32,
    wrte_len: usize,
) -> Result<(), Error<T::Error>> {
    let ack = (wrte_len as u32).to_le_bytes();
    let payload: &[u8] = if delayed_ack { &ack } else { &[] };
    send_raw(transport, Command::Ready, local_id, remote_id, payload).await
}