#![cfg(target_os = "linux")]
use crate::sys::{bind, close, errno, read, socket, write, AF_BLUETOOTH, BTPROTO_HCI, SOCK_RAW};
use std::ffi::c_int;
const HCI_CHANNEL_RAW: u16 = 0;
#[cfg_attr(not(feature = "raw-acl"), allow(dead_code))]
const HCI_ACLDATA_PKT: u8 = 0x02;
#[cfg_attr(not(feature = "raw-sco"), allow(dead_code))]
const HCI_SCODATA_PKT: u8 = 0x03;
#[cfg_attr(not(feature = "le-audio"), allow(dead_code))]
const HCI_ISODATA_PKT: u8 = 0x05;
#[repr(C, packed)]
struct SockAddrHci {
family: u16,
dev: u16,
channel: u16,
}
struct Socket(c_int);
impl Drop for Socket {
fn drop(&mut self) {
unsafe { close(self.0) };
}
}
pub struct RawHciSocket {
socket: Socket,
packet_type: u8,
}
impl RawHciSocket {
fn open(device: u16, packet_type: u8) -> Result<Self, String> {
let fd = unsafe { socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI) };
if fd < 0 {
return Err(format!(
"could not create raw HCI socket (errno {})",
errno()
));
}
let address = SockAddrHci {
family: AF_BLUETOOTH as u16,
dev: device,
channel: HCI_CHANNEL_RAW,
};
if unsafe {
bind(
fd,
(&raw const address).cast(),
std::mem::size_of::<SockAddrHci>() as u32,
)
} < 0
{
return Err(format!("could not bind raw HCI socket (errno {})", errno()));
}
Ok(Self {
socket: Socket(fd),
packet_type,
})
}
pub fn read(&self) -> Result<Vec<u8>, String> {
let mut buffer = vec![0; 4096];
loop {
let length = unsafe { read(self.socket.0, buffer.as_mut_ptr(), buffer.len()) };
if length < 0 {
return Err(format!("raw HCI read failed (errno {})", errno()));
}
if length == 0 {
return Err("raw HCI socket closed".into());
}
let length = length as usize;
if buffer[0] == self.packet_type {
return Ok(buffer[1..length].to_vec());
}
}
}
pub fn write(&self, payload: &[u8]) -> Result<(), String> {
let mut packet = Vec::with_capacity(payload.len() + 1);
packet.push(self.packet_type);
packet.extend_from_slice(payload);
let written = unsafe { write(self.socket.0, packet.as_ptr(), packet.len()) };
if written < 0 || written as usize != packet.len() {
return Err(format!("raw HCI write failed (errno {})", errno()));
}
Ok(())
}
}
#[cfg(feature = "raw-acl")]
pub fn open_acl(device: u16) -> Result<RawHciSocket, String> {
RawHciSocket::open(device, HCI_ACLDATA_PKT)
}
#[cfg(feature = "raw-sco")]
pub fn open_sco(device: u16) -> Result<RawHciSocket, String> {
RawHciSocket::open(device, HCI_SCODATA_PKT)
}
#[cfg(feature = "le-audio")]
pub fn open_iso(device: u16) -> Result<RawHciSocket, String> {
RawHciSocket::open(device, HCI_ISODATA_PKT)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn packet_types_match_hci_assignments() {
assert_eq!(HCI_ACLDATA_PKT, 0x02);
assert_eq!(HCI_SCODATA_PKT, 0x03);
assert_eq!(HCI_ISODATA_PKT, 0x05);
}
}