libadb 0.3.0

Low-level ADB protocol library for direct TCP and USB communication
Documentation
//! Example: ADB sync protocol — stat, list, pull and push files.
//!
//! ```text
//! # Stat a path:
//! cargo run --example sync --features tokio -- 127.0.0.1:5555 stat /sdcard
//! cargo run --example sync --no-default-features --features smol -- 127.0.0.1:5555 stat /sdcard
//!
//! # List a directory:
//! cargo run --example sync --features tokio -- 127.0.0.1:5555 ls /sdcard/DCIM
//!
//! # Pull a file:
//! cargo run --example sync --features tokio -- 127.0.0.1:5555 pull /sdcard/file.txt local.txt
//!
//! # Push a file:
//! cargo run --example sync --features tokio -- 127.0.0.1:5555 push local.txt /sdcard/upload.txt
//! ```
//!
//! Requires `~/.android/adbkey` (private) and `~/.android/adbkey.pub` (public)
//! generated by the standard `adb` tool.

#[cfg(not(any(feature = "tokio", feature = "smol")))]
compile_error!("this example requires --features tokio or --features smol");

use std::{env, fs, process};

use libadb::sync;
use libadb::{Connection, Feature};

#[cfg(feature = "tokio")]
type Tcp = libadb::TokioTcp;
#[cfg(all(feature = "smol", not(feature = "tokio")))]
type Tcp = libadb::SmolTcp;

#[path = "common/adb_key_auth.rs"]
mod adb_key_auth;
use adb_key_auth::AdbKeyAuth;
async fn connect(addr: &str) -> Result<Connection<Tcp>, Box<dyn std::error::Error>> {
    let auth = AdbKeyAuth::load()?;

    #[cfg(feature = "tokio")]
    let transport = {
        let stream = tokio::net::TcpStream::connect(addr).await?;
        stream.set_nodelay(true)?;
        libadb::TokioTcp::new(stream)
    };
    #[cfg(all(feature = "smol", not(feature = "tokio")))]
    let transport = {
        let stream = smol::net::TcpStream::connect(addr).await?;
        stream.set_nodelay(true)?;
        libadb::SmolTcp::new(stream)
    };

    eprintln!("[*] connecting to {addr} ...");
    let conn = Connection::<_>::connect(
        transport,
        auth,
        &[
            Feature::ShellV2,
            Feature::StatV2,
            Feature::LsV2,
            Feature::SendrecvV2,
        ],
    )
    .await
    .map_err(|e| format!("connect: {e}"))?;

    let banner = conn
        .device_banner()
        .map(|b| String::from_utf8_lossy(b).into_owned())
        .unwrap_or_default();
    eprintln!("[*] connected, banner: {banner}");
    Ok(conn)
}

fn format_mode(mode: u32) -> String {
    const S_IFMT: u32 = 0o170000;
    const S_IFSOCK: u32 = 0o140000;
    const S_IFLNK: u32 = 0o120000;
    const S_IFREG: u32 = 0o100000;
    const S_IFBLK: u32 = 0o060000;
    const S_IFDIR: u32 = 0o040000;
    const S_IFCHR: u32 = 0o020000;
    const S_IFIFO: u32 = 0o010000;

    let file_type = match mode & S_IFMT {
        S_IFSOCK => 's',
        S_IFLNK => 'l',
        S_IFREG => '-',
        S_IFBLK => 'b',
        S_IFDIR => 'd',
        S_IFCHR => 'c',
        S_IFIFO => 'p',
        _ => '?',
    };
    let bit = |mask: u32, ch: char| if mode & mask != 0 { ch } else { '-' };
    let mut s = String::with_capacity(10);
    s.push(file_type);
    s.push(bit(0o400, 'r'));
    s.push(bit(0o200, 'w'));
    s.push(bit(0o100, 'x'));
    s.push(bit(0o040, 'r'));
    s.push(bit(0o020, 'w'));
    s.push(bit(0o010, 'x'));
    s.push(bit(0o004, 'r'));
    s.push(bit(0o002, 'w'));
    s.push(bit(0o001, 'x'));
    s
}

async fn cmd_stat(addr: &str, path: &str) -> Result<(), Box<dyn std::error::Error>> {
    let mut conn = connect(addr).await?;
    let mut buf = [0u8; 256];
    let mut session = sync::open(&mut conn, &mut buf)
        .await
        .map_err(|e| format!("sync open: {e}"))?;

    match session.stat_v2(path).await {
        Ok(st) => {
            println!("  path:  {path}");
            println!("  mode:  {} ({:#o})", format_mode(st.mode), st.mode);
            println!("  size:  {}", st.size);
            println!("  uid:   {}", st.uid);
            println!("  gid:   {}", st.gid);
            println!("  nlink: {}", st.nlink);
            println!("  mtime: {}", st.mtime);
            println!("  atime: {}", st.atime);
            println!("  ctime: {}", st.ctime);
            println!("  dev:   {}", st.dev);
            println!("  ino:   {}", st.ino);
        }
        Err(e) => {
            eprintln!("[*] stat_v2 failed ({e}), trying v1 ...");
            let st = session.stat(path).await.map_err(|e| format!("stat: {e}"))?;
            println!("  path:  {path}");
            println!("  mode:  {} ({:#o})", format_mode(st.mode), st.mode);
            println!("  size:  {}", st.size);
            println!("  mtime: {}", st.mtime);
        }
    }

    session.quit().await.map_err(|e| format!("quit: {e}"))?;
    Ok(())
}

async fn cmd_ls(addr: &str, path: &str) -> Result<(), Box<dyn std::error::Error>> {
    let mut conn = connect(addr).await?;
    let mut buf = [0u8; 4096];
    let mut session = sync::open(&mut conn, &mut buf)
        .await
        .map_err(|e| format!("sync open: {e}"))?;

    match session.list_v2(path).await {
        Ok(entries) => {
            for entry in &entries {
                let name = std::str::from_utf8(&entry.name).unwrap_or("<invalid utf-8>");
                println!(
                    "{} {:>8} {:>12} {}",
                    format_mode(entry.stat.mode),
                    entry.stat.uid,
                    entry.stat.size,
                    name,
                );
            }
            eprintln!("[*] {} entries (v2)", entries.len());
            session.quit().await.map_err(|e| format!("quit: {e}"))?;
        }
        Err(e) => {
            eprintln!("[*] list_v2 failed ({e}), trying v1 ...");
            // Release the borrow on `conn` before re-opening below.
            let _ = session;
            let mut buf2 = [0u8; 4096];
            let mut session = sync::open(&mut conn, &mut buf2)
                .await
                .map_err(|e| format!("sync open: {e}"))?;
            let entries = session.list(path).await.map_err(|e| format!("list: {e}"))?;
            for entry in &entries {
                let name = std::str::from_utf8(&entry.name).unwrap_or("<invalid utf-8>");
                println!("{} {:>12} {}", format_mode(entry.mode), entry.size, name,);
            }
            eprintln!("[*] {} entries (v1)", entries.len());
            session.quit().await.map_err(|e| format!("quit: {e}"))?;
        }
    }
    Ok(())
}

async fn cmd_pull(addr: &str, remote: &str, local: &str) -> Result<(), Box<dyn std::error::Error>> {
    let mut conn = connect(addr).await?;
    let mut buf = [0u8; 66_000];
    let mut session = sync::open(&mut conn, &mut buf)
        .await
        .map_err(|e| format!("sync open: {e}"))?;

    eprintln!("[*] pulling {remote} -> {local}");
    session
        .recv_start(remote)
        .await
        .map_err(|e| format!("recv_start: {e}"))?;

    let mut total: u64 = 0;
    let mut file = fs::File::create(local)?;
    while let Some(chunk) = session
        .recv_next()
        .await
        .map_err(|e| format!("recv: {e}"))?
    {
        std::io::Write::write_all(&mut file, chunk)?;
        total += chunk.len() as u64;
    }

    session.quit().await.map_err(|e| format!("quit: {e}"))?;
    eprintln!("[*] done, {total} bytes written");
    Ok(())
}

async fn cmd_push(addr: &str, local: &str, remote: &str) -> Result<(), Box<dyn std::error::Error>> {
    let mut conn = connect(addr).await?;
    let mut buf = [0u8; 66_000];
    let mut session = sync::open(&mut conn, &mut buf)
        .await
        .map_err(|e| format!("sync open: {e}"))?;

    let data = fs::read(local)?;
    let mode: u32 = 0o100644;
    let mtime: u32 = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_secs() as u32)
        .unwrap_or(0);

    eprintln!("[*] pushing {local} ({} bytes) -> {remote}", data.len());

    session
        .send(remote, mode, mtime, &data)
        .await
        .map_err(|e| format!("send: {e}"))?;

    session.quit().await.map_err(|e| format!("quit: {e}"))?;
    eprintln!("[*] done");
    Ok(())
}

fn usage(prog: &str) -> ! {
    eprintln!("Usage: {prog} <host:port> <command> [args...]");
    eprintln!();
    eprintln!("Commands:");
    eprintln!("  stat <path>                  stat a remote file");
    eprintln!("  ls   <path>                  list a remote directory");
    eprintln!("  pull <remote> <local>         pull a file from the device");
    eprintln!("  push <local>  <remote>        push a file to the device");
    process::exit(2);
}

async fn async_main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 4 {
        usage(&args[0]);
    }

    let addr = &args[1];
    let cmd = args[2].as_str();

    let result = match cmd {
        "stat" if args.len() == 4 => cmd_stat(addr, &args[3]).await,
        "ls" if args.len() == 4 => cmd_ls(addr, &args[3]).await,
        "pull" if args.len() == 5 => cmd_pull(addr, &args[3], &args[4]).await,
        "push" if args.len() == 5 => cmd_push(addr, &args[3], &args[4]).await,
        _ => usage(&args[0]),
    };

    if let Err(e) = result {
        eprintln!("error: {e}");
        process::exit(1);
    }
}

#[cfg(feature = "tokio")]
#[tokio::main]
async fn main() {
    async_main().await;
}

#[cfg(all(feature = "smol", not(feature = "tokio")))]
fn main() {
    smol::block_on(async_main());
}