use alloc::boxed::Box;
use alloc::sync::Arc;
use core::ffi::{c_char, CStr};
use std::sync::Mutex;
use libadb::base::auth::Authenticator;
use libadb::base::connection::{Connection, ConnectionConfig, HostBanner};
use libadb::split::{Reader, SplitIncoming, Writer};
use libadb::Splittable;
use crate::auth::{self, adb_authenticator_t};
use crate::block_on;
use crate::error::{self, AdbStatus};
use crate::slice::copy_out;
use crate::transport::{self, FfiTransport};
pub(crate) type FfiReadHalf = <FfiTransport as Splittable>::ReadHalf;
pub(crate) type FfiWriteHalf = <FfiTransport as Splittable>::WriteHalf;
pub(crate) type FfiReader = Reader<FfiReadHalf, FfiWriteHalf>;
pub(crate) type FfiWriter = Writer<FfiWriteHalf>;
pub(crate) type FfiIncoming = SplitIncoming<FfiWriteHalf>;
#[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, priv_key_pem, pub_key, banner) = unsafe {
(
CStr::from_ptr(uri),
CStr::from_ptr(priv_key_pem),
CStr::from_ptr(pub_key),
CStr::from_ptr(banner),
)
};
let uri = match uri.to_str() {
Ok(s) => s,
Err(e) => return error::fail_invalid_arg(e),
};
let priv_pem = match priv_key_pem.to_str() {
Ok(s) => s,
Err(e) => return error::fail_invalid_arg(e),
};
let pub_key_bytes = pub_key.to_bytes();
let banner_bytes = 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),
};
unsafe { handshake(uri, out, |t| connect_with_key(t, auth, banner_bytes)) }
}
#[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, banner) = unsafe { (CStr::from_ptr(uri), CStr::from_ptr(banner)) };
let uri = match uri.to_str() {
Ok(s) => s,
Err(e) => return error::fail_invalid_arg(e),
};
let banner_bytes = banner.to_bytes();
let auth = match unsafe { auth::CallbackAuthenticator::from_ffi(&*authenticator) } {
Ok(a) => a,
Err(e) => return error::fail_invalid_arg(e),
};
unsafe { handshake(uri, out, |t| connect_plain(t, auth, banner_bytes)) }
}
unsafe fn handshake(
uri: &str,
out: *mut *mut adb_connection_t,
connect: impl FnOnce(FfiTransport) -> Result<Connection<FfiTransport>, AdbStatus>,
) -> AdbStatus {
let (t, tcp_socket) = match transport::connect(uri) {
Ok(opened) => opened,
Err(e) => return error::fail_ffi_connect(e),
};
let conn = match connect(t) {
Ok(c) => c,
Err(status) => return status,
};
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),
});
unsafe { *out = Box::into_raw(boxed) };
AdbStatus::Ok
}
fn connect_plain<A: Authenticator>(
t: FfiTransport,
auth: A,
banner: &[u8],
) -> Result<Connection<FfiTransport>, AdbStatus> {
block_on::block_on(Connection::connect(
t,
auth,
HostBanner::Raw(banner),
ConnectionConfig::new(),
))
.map_err(error::fail_error)
}
#[cfg(feature = "tls")]
fn connect_with_key(
t: FfiTransport,
auth: auth::FfiAuthenticator,
banner: &[u8],
) -> Result<Connection<FfiTransport>, AdbStatus> {
match t {
FfiTransport::Tcp(_) => {
let tls = auth.tls_config().map_err(error::fail_internal)?;
block_on::block_on(Connection::connect_tls(
t,
auth,
HostBanner::Raw(banner),
ConnectionConfig::new(),
&tls,
))
.map_err(error::fail_error)
}
FfiTransport::Usb(_) => connect_plain(t, auth, banner),
}
}
#[cfg(not(feature = "tls"))]
fn connect_with_key(
t: FfiTransport,
auth: auth::FfiAuthenticator,
banner: &[u8],
) -> Result<Connection<FfiTransport>, AdbStatus> {
connect_plain(t, auth, banner)
}
#[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 conn = unsafe { &*conn };
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(unsafe { 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;
}
unsafe { &*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;
}
unsafe { &*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 = unsafe { &*conn }.writer.device_banner();
unsafe { copy_out(banner, buf, buf_len, out_len) };
AdbStatus::Ok
}