#![no_std]
#![allow(unsafe_code)]
#![cfg_attr(docsrs, feature(doc_cfg))]
extern crate alloc;
extern crate std;
mod auth;
mod block_on;
mod error;
mod feature;
#[macro_use]
mod macros;
mod shell;
mod slice;
mod transport;
use alloc::boxed::Box;
use alloc::sync::Arc;
use core::ffi::{c_char, CStr};
use core::ptr;
use std::sync::Mutex;
use libadb::base::auth::Authenticator;
use libadb::base::channel::ChannelId;
use libadb::base::connection::Connection;
use libadb::reverse;
use libadb::split::{Reader, SplitIncoming, Writer};
use transport::FfiTransport;
pub use auth::{adb_authenticator_t, AdbSignFn};
pub use error::{adb_last_error, AdbStatus};
pub use shell::{
adb_shell_close, adb_shell_close_stdin, adb_shell_free, adb_shell_open, adb_shell_read_frame,
adb_shell_set_window_size, adb_shell_t, adb_shell_write_stdin,
};
pub(crate) type FfiReader = Reader<FfiTransport, FfiTransport>;
pub(crate) type FfiWriter = Writer<FfiTransport>;
pub(crate) type FfiIncoming = SplitIncoming<FfiTransport>;
fn encode_channel_id(ch: ChannelId) -> u64 {
((ch.local_id() as u64) << 32) | (ch.slot() as u32 as u64)
}
fn decode_channel_id(id: u64) -> ChannelId {
ChannelId::from_raw((id & 0xFFFF_FFFF) as u32 as usize, (id >> 32) as u32)
}
#[allow(non_camel_case_types)]
pub struct adb_connection_t {
pub(crate) reader: Arc<Mutex<FfiReader>>,
pub(crate) writer: FfiWriter,
pub(crate) tcp_socket: Option<std::net::TcpStream>,
pub(crate) staged_incoming: Mutex<Option<FfiIncoming>>,
}
pub(crate) fn lock_poisoned<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
m.lock().unwrap_or_else(|p| p.into_inner())
}
impl adb_connection_t {
pub(crate) fn lock_reader(&self) -> std::sync::MutexGuard<'_, FfiReader> {
lock_poisoned(&self.reader)
}
}
const _: fn() = || {
fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<adb_connection_t>();
};
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_connect(
uri: *const c_char,
priv_key_pem: *const c_char,
pub_key: *const c_char,
banner: *const c_char,
out: *mut *mut adb_connection_t,
) -> AdbStatus {
error::clear_last_error();
if uri.is_null()
|| priv_key_pem.is_null()
|| pub_key.is_null()
|| banner.is_null()
|| out.is_null()
{
return error::fail_invalid_arg("null pointer");
}
let uri = match CStr::from_ptr(uri).to_str() {
Ok(s) => s,
Err(e) => return error::fail_invalid_arg(e),
};
let priv_pem = match CStr::from_ptr(priv_key_pem).to_str() {
Ok(s) => s,
Err(e) => return error::fail_invalid_arg(e),
};
let pub_key_bytes = CStr::from_ptr(pub_key).to_bytes();
let banner_bytes = CStr::from_ptr(banner).to_bytes();
let auth = match auth::FfiAuthenticator::from_pkcs8_pem(priv_pem, pub_key_bytes) {
Ok(a) => a,
Err(e) => return error::fail_auth(e),
};
handshake(uri, auth, banner_bytes, out)
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_connect_with_authenticator(
uri: *const c_char,
authenticator: *const adb_authenticator_t,
banner: *const c_char,
out: *mut *mut adb_connection_t,
) -> AdbStatus {
error::clear_last_error();
if uri.is_null() || authenticator.is_null() || banner.is_null() || out.is_null() {
return error::fail_invalid_arg("null pointer");
}
let uri = match CStr::from_ptr(uri).to_str() {
Ok(s) => s,
Err(e) => return error::fail_invalid_arg(e),
};
let banner_bytes = CStr::from_ptr(banner).to_bytes();
let auth = match auth::CallbackAuthenticator::from_ffi(&*authenticator) {
Ok(a) => a,
Err(e) => return error::fail_invalid_arg(e),
};
handshake(uri, auth, banner_bytes, out)
}
unsafe fn handshake<A: Authenticator>(
uri: &str,
auth: A,
banner_bytes: &[u8],
out: *mut *mut adb_connection_t,
) -> AdbStatus {
let t = match transport::connect(uri) {
Ok(t) => t,
Err(e) => return error::fail_ffi_connect(e),
};
let tcp_socket = match transport::tcp_socket_of(&t) {
Ok(s) => s,
Err(e) => return error::fail_ffi_connect(transport::FfiConnectError::Tcp(e)),
};
let conn = ffi_try!(Connection::connect_with_raw_banner(t, auth, banner_bytes));
let (reader, writer) = match conn.split() {
Ok(pair) => pair,
Err(e) => return error::fail_error(e),
};
let boxed = Box::new(adb_connection_t {
reader: Arc::new(Mutex::new(reader)),
writer,
tcp_socket,
staged_incoming: Mutex::new(None),
});
*out = Box::into_raw(boxed);
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_connection_set_io_timeout_ms(
conn: *mut adb_connection_t,
read_ms: u32,
write_ms: u32,
) -> AdbStatus {
error::clear_last_error();
if conn.is_null() {
return error::fail_invalid_arg("null pointer");
}
let Some(socket) = &(*conn).tcp_socket else {
return error::fail_invalid_arg("timeouts apply to tcp:// transports only");
};
let as_duration = |ms: u32| (ms > 0).then(|| std::time::Duration::from_millis(u64::from(ms)));
if let Err(e) = socket.set_read_timeout(as_duration(read_ms)) {
return error::fail_io(e);
}
if let Err(e) = socket.set_write_timeout(as_duration(write_ms)) {
return error::fail_io(e);
}
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_connection_free(conn: *mut adb_connection_t) {
if conn.is_null() {
return;
}
drop(Box::from_raw(conn));
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_connection_max_payload(conn: *const adb_connection_t) -> u32 {
if conn.is_null() {
return 0;
}
(*conn).writer.max_payload()
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_connection_delayed_ack(conn: *const adb_connection_t) -> bool {
if conn.is_null() {
return false;
}
(*conn).writer.delayed_ack()
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_connection_device_banner(
conn: *const adb_connection_t,
buf: *mut u8,
buf_len: usize,
out_len: *mut usize,
) -> AdbStatus {
error::clear_last_error();
if conn.is_null() {
return error::fail_invalid_arg("null handle");
}
let banner = (*conn).writer.device_banner().unwrap_or(&[]);
if !out_len.is_null() {
*out_len = banner.len();
}
if !buf.is_null() && buf_len > 0 {
let n = banner.len().min(buf_len);
ptr::copy_nonoverlapping(banner.as_ptr(), buf, n);
}
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_connection_has_feature(
conn: *const adb_connection_t,
feature: u32,
) -> bool {
if conn.is_null() {
return false;
}
let Some(ff) = feature::FfiFeature::from_raw(feature) else {
return false;
};
(*conn)
.writer
.device_banner_parsed()
.is_some_and(|b| b.has_feature(&ff.to_feature()))
}
#[unsafe(no_mangle)]
pub extern "C" fn adb_feature_name(feature: u32) -> *const c_char {
match feature::FfiFeature::from_raw(feature) {
Some(f) => f.wire_name(),
None => ptr::null(),
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_connection_features(
conn: *const adb_connection_t,
buf: *mut u32,
buf_cap: usize,
out_len: *mut usize,
) -> AdbStatus {
error::clear_last_error();
if conn.is_null() {
return error::fail_invalid_arg("null handle");
}
let features = (*conn)
.writer
.device_banner_parsed()
.map_or(&[][..], |b| b.features());
if !out_len.is_null() {
*out_len = features.len();
}
if !buf.is_null() && buf_cap > 0 {
let n = features.len().min(buf_cap);
for (slot, f) in features.iter().take(n).enumerate() {
*buf.add(slot) = feature::FfiFeature::from_feature(f) as u32;
}
}
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_open_channel(
conn: *mut adb_connection_t,
destination: *const u8,
destination_len: usize,
out_id: *mut u64,
) -> AdbStatus {
error::clear_last_error();
if conn.is_null() || out_id.is_null() || (destination.is_null() && destination_len > 0) {
return error::fail_invalid_arg("null pointer");
}
let dest = slice::from_ptr(destination, destination_len);
let mut g = (*conn).lock_reader();
let id = ffi_try!(g.open_channel(dest));
*out_id = encode_channel_id(id);
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_read_channel(
conn: *mut adb_connection_t,
id: u64,
buf: *mut u8,
buf_len: usize,
out_read: *mut usize,
) -> AdbStatus {
error::clear_last_error();
if conn.is_null() || out_read.is_null() || (buf.is_null() && buf_len > 0) {
return error::fail_invalid_arg("null pointer");
}
if buf_len == 0 {
return error::fail_invalid_arg("buf_len is zero");
}
let slice = slice::from_mut_ptr(buf, buf_len);
let mut g = (*conn).lock_reader();
let ch = decode_channel_id(id);
let n = loop {
let n = ffi_try!(g.read_channel(ch, slice));
if n > 0 {
break n;
}
};
*out_read = n;
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_write_channel(
conn: *mut adb_connection_t,
id: u64,
buf: *const u8,
buf_len: usize,
) -> AdbStatus {
error::clear_last_error();
if conn.is_null() || (buf.is_null() && buf_len > 0) {
return error::fail_invalid_arg("null pointer");
}
let slice = slice::from_ptr(buf, buf_len);
let ch = decode_channel_id(id);
ffi_try!((*conn).writer.write_channel(ch, slice));
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_close_channel(conn: *mut adb_connection_t, id: u64) -> AdbStatus {
error::clear_last_error();
if conn.is_null() {
return error::fail_invalid_arg("null handle");
}
let ch = decode_channel_id(id);
ffi_try!((*conn).writer.close_channel(ch));
AdbStatus::Ok
}
unsafe fn copy_out(src: &[u8], buf: *mut u8, buf_len: usize, out_len: *mut usize) {
if !out_len.is_null() {
*out_len = src.len();
}
if !buf.is_null() && buf_len > 0 {
let n = src.len().min(buf_len);
ptr::copy_nonoverlapping(src.as_ptr(), buf, n);
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_reverse_forward(
conn: *mut adb_connection_t,
device_spec: *const c_char,
host_spec: *const c_char,
data: *mut u8,
data_cap: usize,
out_data_len: *mut usize,
) -> AdbStatus {
error::clear_last_error();
if conn.is_null() || device_spec.is_null() || host_spec.is_null() {
return error::fail_invalid_arg("null pointer");
}
let (Ok(device), Ok(host)) = (
CStr::from_ptr(device_spec).to_str(),
CStr::from_ptr(host_spec).to_str(),
) else {
return error::fail_invalid_arg("spec is not valid UTF-8");
};
let mut g = (*conn).lock_reader();
let bound = ffi_try!(reverse::establish(&mut *g, device, host));
copy_out(&bound, data, data_cap, out_data_len);
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_reverse_remove(
conn: *mut adb_connection_t,
device_spec: *const c_char,
) -> AdbStatus {
error::clear_last_error();
if conn.is_null() || device_spec.is_null() {
return error::fail_invalid_arg("null pointer");
}
let Ok(device) = CStr::from_ptr(device_spec).to_str() else {
return error::fail_invalid_arg("spec is not valid UTF-8");
};
let mut g = (*conn).lock_reader();
ffi_try!(reverse::remove(&mut *g, device));
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_reverse_remove_all(conn: *mut adb_connection_t) -> AdbStatus {
error::clear_last_error();
if conn.is_null() {
return error::fail_invalid_arg("null handle");
}
let mut g = (*conn).lock_reader();
ffi_try!(reverse::remove_all(&mut *g));
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_reverse_list(
conn: *mut adb_connection_t,
buf: *mut u8,
buf_len: usize,
out_len: *mut usize,
) -> AdbStatus {
error::clear_last_error();
if conn.is_null() {
return error::fail_invalid_arg("null handle");
}
let mut g = (*conn).lock_reader();
let listing = ffi_try!(reverse::list(&mut *g));
copy_out(&listing, buf, buf_len, out_len);
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_accept_channel(
conn: *mut adb_connection_t,
dest: *mut u8,
dest_cap: usize,
out_dest_len: *mut usize,
) -> AdbStatus {
error::clear_last_error();
if conn.is_null() {
return error::fail_invalid_arg("null handle");
}
let mut staged = lock_poisoned(&(*conn).staged_incoming);
if let Some(incoming) = staged.as_ref() {
copy_out(incoming.destination(), dest, dest_cap, out_dest_len);
return AdbStatus::Ok;
}
let mut g = (*conn).lock_reader();
let incoming = ffi_try!(g.accept_incoming());
drop(g);
copy_out(incoming.destination(), dest, dest_cap, out_dest_len);
*staged = Some(incoming);
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_incoming_accept(
conn: *mut adb_connection_t,
out_id: *mut u64,
) -> AdbStatus {
error::clear_last_error();
if conn.is_null() || out_id.is_null() {
return error::fail_invalid_arg("null pointer");
}
let staged = lock_poisoned(&(*conn).staged_incoming).take();
let Some(incoming) = staged else {
return error::fail_invalid_arg("no incoming channel is staged");
};
let ch = ffi_try!(incoming.accept());
*out_id = encode_channel_id(ch);
AdbStatus::Ok
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn adb_incoming_reject(conn: *mut adb_connection_t) -> AdbStatus {
error::clear_last_error();
if conn.is_null() {
return error::fail_invalid_arg("null handle");
}
let staged = lock_poisoned(&(*conn).staged_incoming).take();
let Some(incoming) = staged else {
return error::fail_invalid_arg("no incoming channel is staged");
};
ffi_try!(incoming.reject());
AdbStatus::Ok
}