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