#[cfg(not(any(feature = "tokio", feature = "smol")))]
compile_error!("this example requires --features tokio,host-keys or --features smol,host-keys");
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;
async fn connect(addr: &str) -> Result<Connection<Tcp>, 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 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.escape_debug());
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 ...");
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());
}