libadb 0.9.0

Low-level ADB protocol library for direct TCP and USB communication
Documentation
//! Example: shell on an ADB device via the legacy `shell:` protocol.
//!
//! ```text
//! # Interactive shell (persistent connection, raw terminal):
//! cargo run --example shell_v1 --features tokio,host-keys -- 127.0.0.1:5555
//! cargo run --example shell_v1 --no-default-features --features smol,host-keys -- 127.0.0.1:5555
//!
//! # Run a single command:
//! cargo run --example shell_v1 --features tokio,host-keys -- 127.0.0.1:5555 "ls -la /sdcard"
//! ```
//!
//! Reuses `~/.android/adbkey`; if there is none, a key is generated
//! and saved on first run — confirm it on the device when asked.
//!
//! Unlike `shell_v2`, the legacy protocol has no framing: stdout and
//! stderr are interleaved in a single byte stream, there is no exit
//! code, and terminal resize events cannot be forwarded to the device.

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

use std::io::Write as _;
use std::mem::MaybeUninit;
use std::{env, process};

use libadb::channel::SelectResult;
use libadb::shell::v1 as shell_v1;
use libadb::{Connection, ConnectionConfig, HostBanner};

#[cfg(feature = "tokio")]
use tokio::sync::mpsc;

#[path = "common/adb_key_auth.rs"]
mod adb_key_auth;
struct RawMode {
    original: libc::termios,
}

impl RawMode {
    fn enable() -> Self {
        unsafe {
            let mut original = MaybeUninit::<libc::termios>::uninit();
            libc::tcgetattr(libc::STDIN_FILENO, original.as_mut_ptr());
            let original = original.assume_init();
            let mut raw = original;
            libc::cfmakeraw(&mut raw);
            libc::tcsetattr(libc::STDIN_FILENO, libc::TCSANOW, &raw);
            Self { original }
        }
    }
}

impl Drop for RawMode {
    fn drop(&mut self) {
        unsafe {
            libc::tcsetattr(libc::STDIN_FILENO, libc::TCSANOW, &self.original);
        }
    }
}

async fn run_interactive(addr: &str) -> Result<(), Box<dyn std::error::Error>> {
    let auth = adb_key_auth::load_or_generate()?;

    #[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 mut conn = Connection::connect(
        transport,
        auth,
        HostBanner::Features(&[]),
        ConnectionConfig::new(),
    )
    .await
    .map_err(|e| format!("connect: {e}"))?;

    eprintln!("[*] connected, device: {:?}", conn.device_banner());

    let _raw = RawMode::enable();

    let mut rx = [0u8; 64 * 1024];
    let mut shell = shell_v1::open(&mut conn, "", &mut rx)
        .await
        .map_err(|e| format!("open: {e}"))?;

    #[cfg(feature = "tokio")]
    let (stdin_tx, mut stdin_rx) = mpsc::channel::<Vec<u8>>(16);
    #[cfg(all(feature = "smol", not(feature = "tokio")))]
    let (stdin_tx, stdin_rx) = smol::channel::bounded::<Vec<u8>>(16);

    std::thread::spawn(move || {
        use std::io::Read;
        let mut buf = [0u8; 4096];
        let stdin = std::io::stdin();
        let mut handle = stdin.lock();
        loop {
            match handle.read(&mut buf) {
                Ok(0) | Err(_) => break,
                Ok(n) => {
                    #[cfg(feature = "tokio")]
                    let result = stdin_tx.blocking_send(buf[..n].to_vec());
                    #[cfg(all(feature = "smol", not(feature = "tokio")))]
                    let result = stdin_tx.send_blocking(buf[..n].to_vec());
                    if result.is_err() {
                        break;
                    }
                }
            }
        }
    });

    loop {
        #[cfg(feature = "tokio")]
        let interrupt = stdin_rx.recv();
        #[cfg(all(feature = "smol", not(feature = "tokio")))]
        let interrupt = async { stdin_rx.recv().await.ok() };

        match shell.select(&mut rx, interrupt).await {
            Ok(SelectResult::Data(n)) => {
                std::io::stdout().write_all(&rx[..n])?;
                std::io::stdout().flush()?;
            }
            Ok(SelectResult::Interrupted(Some(data))) => {
                shell.write_stdin(&data).await.map_err(|e| format!("{e}"))?;
            }
            Ok(SelectResult::Interrupted(None)) => break,
            Err(libadb::Error::ChannelClosed) => break,
            Err(e) => return Err(format!("{e}").into()),
        }
    }

    shell.close().await.map_err(|e| format!("close: {e}"))?;

    drop(_raw);
    eprintln!("[*] session ended");
    Ok(())
}

async fn run_command(addr: &str, command: &str) -> Result<(), Box<dyn std::error::Error>> {
    let auth = adb_key_auth::load_or_generate()?;

    #[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 mut conn = Connection::connect(
        transport,
        auth,
        HostBanner::Features(&[]),
        ConnectionConfig::new(),
    )
    .await
    .map_err(|e| format!("connect: {e}"))?;

    eprintln!("[*] connected, device: {:?}", conn.device_banner());

    let mut buf = [0u8; 64 * 1024];
    let n = shell_v1::exec(&mut conn, command, &mut buf)
        .await
        .map_err(|e| format!("exec: {e}"))?;

    std::io::stdout().write_all(&buf[..n])?;
    std::io::stdout().flush()?;

    Ok(())
}

async fn async_main() {
    let args: Vec<String> = env::args().collect();

    match args.len() {
        2 => {
            if let Err(e) = run_interactive(&args[1]).await {
                eprintln!("error: {e}");
                process::exit(1);
            }
        }
        3 => {
            if let Err(e) = run_command(&args[1], &args[2]).await {
                eprintln!("error: {e}");
                process::exit(1);
            }
        }
        _ => {
            eprintln!("Usage: {} <host:port> [command]", args[0]);
            eprintln!();
            eprintln!("  Interactive shell:");
            eprintln!("    {} 127.0.0.1:5555", args[0]);
            eprintln!();
            eprintln!("  Run a command:");
            eprintln!("    {} 127.0.0.1:5555 \"ls /sdcard\"", args[0]);
            process::exit(2);
        }
    }
}

#[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());
}