use libadb::base::channel::ChannelId;
use crate::block_on;
use crate::connection::adb_connection_t;
use crate::error::{self, AdbStatus};
use crate::slice;
pub(crate) fn encode_channel_id(ch: ChannelId) -> u64 {
((ch.local_id() as u64) << 32) | (ch.slot() as u32 as u64)
}
fn decode_channel_id(conn: &adb_connection_t, id: u64) -> Result<ChannelId, AdbStatus> {
let slot = usize::try_from(id & 0xFFFF_FFFF)
.ok()
.filter(|&slot| slot < conn.writer.config().max_channels());
let Some(slot) = slot else {
return Err(error::fail_invalid_arg(
"channel id names no slot of this connection",
));
};
Ok(ChannelId::from_raw(slot, (id >> 32) as u32))
}
#[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 conn = unsafe { &*conn };
let dest = unsafe { slice::from_ptr(destination, destination_len) };
let mut g = conn.lock_reader();
let id = ffi_try!(g.open_channel(dest));
unsafe { *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 conn = unsafe { &*conn };
let slice = unsafe { slice::from_mut_ptr(buf, buf_len) };
let ch = match decode_channel_id(conn, id) {
Ok(ch) => ch,
Err(status) => return status,
};
let n = match block_on::block_on_read(&conn.reader, &conn.writer, ch, slice) {
Ok(n) => n,
Err(e) => return error::fail_error(e),
};
unsafe { *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 conn = unsafe { &*conn };
let slice = unsafe { slice::from_ptr(buf, buf_len) };
let ch = match decode_channel_id(conn, id) {
Ok(ch) => ch,
Err(status) => return status,
};
let write = conn.writer.write_channel(ch, slice);
if let Err(e) = block_on::block_on_write(&conn.reader, &conn.writer, ch, write) {
return error::fail_error(e);
}
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 conn = unsafe { &*conn };
let ch = match decode_channel_id(conn, id) {
Ok(ch) => ch,
Err(status) => return status,
};
ffi_try!(conn.writer.close_channel(ch));
AdbStatus::Ok
}