use crate::sys::{
address_type, bind_le_source, bluetooth_u16_option, close, connect, errno, parse_address,
read, shutdown, socket, write, SockAddrL2, AF_BLUETOOTH, BTPROTO_L2CAP, BT_RCVMTU, BT_SNDMTU,
EINTR, EMSGSIZE, SHUT_RDWR, SOCK_SEQPACKET,
};
use futures_channel::mpsc;
use futures_core::Stream;
use futures_util::StreamExt;
use std::collections::VecDeque;
use std::ffi::c_int;
use std::pin::Pin;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::task::{Context, Poll};
pub use webbluetooth_core::l2cap::{ChannelSink, Closed, Psm};
struct Socket(c_int);
impl Drop for Socket {
fn drop(&mut self) {
unsafe { close(self.0) };
}
}
pub struct Channel {
psm: Psm,
peer: String,
fd: Arc<Socket>,
writing: Mutex<VecDeque<u8>>,
send_mtu: std::sync::atomic::AtomicUsize,
closed: Arc<Mutex<Option<Closed>>>,
stopped: Arc<AtomicBool>,
}
impl Channel {
pub fn connect(
address: &str,
peer_address_type: &str,
psm: Psm,
sink: Arc<dyn ChannelSink>,
) -> Result<Self, String> {
let bdaddr = parse_address(address)
.ok_or_else(|| format!("{address:?} is not a Bluetooth address"))?;
let fd = unsafe { socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP) };
if fd < 0 {
return Err(format!(
"could not create an L2CAP socket (errno {})",
errno()
));
}
let socket = Arc::new(Socket(fd));
if let Err(e) = bind_le_source(fd, 0, 0) {
return Err(format!("could not bind an LE L2CAP socket (errno {e})"));
}
let addr = SockAddrL2 {
family: AF_BLUETOOTH as u16,
psm: psm.to_le(),
bdaddr,
cid: 0,
bdaddr_type: address_type(peer_address_type == "random"),
};
let rc = unsafe { connect(fd, &addr, std::mem::size_of::<SockAddrL2>() as u32) };
if rc < 0 {
return Err(format!(
"could not open L2CAP PSM {psm} on {address} (errno {})",
errno()
));
}
let stopped = Arc::new(AtomicBool::new(false));
let closed = Arc::new(Mutex::new(None));
spawn_reader(socket.clone(), sink, stopped.clone(), closed.clone(), psm);
Ok(Self {
psm,
peer: address.to_owned(),
send_mtu: send_mtu(fd),
fd: socket,
writing: Mutex::new(VecDeque::new()),
closed,
stopped,
})
}
pub fn adopt_fd(fd: c_int, psm: Psm, peer: String, sink: Arc<dyn ChannelSink>) -> Self {
let socket = Arc::new(Socket(fd));
let stopped = Arc::new(AtomicBool::new(false));
let closed = Arc::new(Mutex::new(None));
spawn_reader(socket.clone(), sink, stopped.clone(), closed.clone(), psm);
Self {
psm,
peer,
send_mtu: send_mtu(fd),
fd: socket,
writing: Mutex::new(VecDeque::new()),
closed,
stopped,
}
}
pub fn psm(&self) -> Psm {
self.psm
}
pub fn peer_id(&self) -> &str {
&self.peer
}
pub fn send(&self, bytes: &[u8]) -> Result<(), Closed> {
if let Some(reason) = self.closed() {
return Err(reason);
}
let _order = self.writing.lock().unwrap();
let mut sent = 0;
while sent < bytes.len() {
let mtu = self.send_mtu.load(Ordering::Relaxed);
let len = (bytes.len() - sent).min(mtu);
let n = unsafe { write(self.fd.0, bytes[sent..].as_ptr(), len) };
if n > 0 {
sent += n as usize;
continue;
}
if n < 0 && errno() == EINTR {
continue;
}
if n < 0 && errno() == EMSGSIZE && mtu > LE_MIN_MTU {
self.send_mtu.store((mtu / 2).max(LE_MIN_MTU), Ordering::Relaxed);
continue;
}
let reason = Closed::Error(format!("L2CAP write failed (errno {})", errno()));
*self.closed.lock().unwrap() = Some(reason.clone());
return Err(reason);
}
Ok(())
}
pub fn pending_bytes(&self) -> usize {
0
}
pub fn closed(&self) -> Option<Closed> {
self.closed.lock().unwrap().clone()
}
pub fn close(&self) {
{
let mut closed = self.closed.lock().unwrap();
if closed.is_none() {
*closed = Some(Closed::Locally);
}
}
self.stopped.store(true, Ordering::Release);
unsafe { shutdown(self.fd.0, SHUT_RDWR) };
}
}
impl Drop for Channel {
fn drop(&mut self) {
self.close();
}
}
impl std::fmt::Debug for Channel {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("L2capChannel")
.field("psm", &self.psm)
.field("peer", &self.peer)
.field("closed", &self.closed())
.finish()
}
}
const LE_MIN_MTU: usize = 23;
fn send_mtu(fd: c_int) -> std::sync::atomic::AtomicUsize {
let mtu = bluetooth_u16_option(fd, BT_SNDMTU).map_or(LE_MIN_MTU, usize::from);
std::sync::atomic::AtomicUsize::new(mtu.max(LE_MIN_MTU))
}
fn spawn_reader(
socket: Arc<Socket>,
sink: Arc<dyn ChannelSink>,
stopped: Arc<AtomicBool>,
closed: Arc<Mutex<Option<Closed>>>,
psm: Psm,
) {
std::thread::Builder::new()
.name(format!("webbluetooth-l2cap-{psm}"))
.spawn(move || {
let rcv = bluetooth_u16_option(socket.0, BT_RCVMTU).map_or(0, usize::from);
let mut buf = vec![0u8; rcv.max(4096)];
let reason = loop {
if stopped.load(Ordering::Acquire) {
break Closed::Locally;
}
let n = unsafe { read(socket.0, buf.as_mut_ptr(), buf.len()) };
match n {
0 => break Closed::ByPeer,
n if n > 0 => sink.on_bytes(buf[..n as usize].to_vec()),
_ if errno() == EINTR => continue,
_ => {
if stopped.load(Ordering::Acquire) {
break Closed::Locally;
}
break Closed::Error(format!("L2CAP read failed (errno {})", errno()));
}
}
};
let reason = closed.lock().unwrap().get_or_insert(reason).clone();
sink.on_closed(reason);
})
.expect("could not start the L2CAP reader thread");
}
pub type L2capChannel = webbluetooth_core::l2cap::L2capChannel<Channel>;
pub struct L2capListener {
socket: Arc<Socket>,
incoming: mpsc::UnboundedReceiver<webbluetooth_core::Result<L2capChannel>>,
}
pub struct L2capListenerHandle {
socket: Arc<Socket>,
}
impl Drop for L2capListenerHandle {
fn drop(&mut self) {
unsafe { shutdown(self.socket.0, SHUT_RDWR) };
}
}
impl L2capListener {
pub fn spawn<F>(self, callback: F) -> webbluetooth_core::Result<L2capListenerHandle>
where
F: Fn(webbluetooth_core::Result<L2capChannel>) + Send + 'static,
{
let handle = L2capListenerHandle {
socket: self.socket.clone(),
};
let name = "webbluetooth-l2cap-le-router";
std::thread::Builder::new()
.name(name.into())
.spawn(move || {
futures_executor::block_on(async move {
let mut listener = self;
while let Some(channel) = listener.next().await {
callback(channel);
}
});
})
.map_err(|error| webbluetooth_core::Error::Network(error.to_string()))?;
Ok(handle)
}
}
impl Stream for L2capListener {
type Item = webbluetooth_core::Result<L2capChannel>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
Pin::new(&mut self.incoming).poll_next(cx)
}
}
impl Drop for L2capListener {
fn drop(&mut self) {
unsafe { shutdown(self.socket.0, SHUT_RDWR) };
}
}
pub fn listen(
psm: Psm,
encryption_required: bool,
) -> webbluetooth_core::Result<(Psm, L2capListener)> {
let fd = unsafe { socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP) };
if fd < 0 {
return Err(webbluetooth_core::Error::Network(format!(
"could not create LE L2CAP listener (errno {})",
errno()
)));
}
let socket = Arc::new(Socket(fd));
if let Err(code) = crate::sys::set_le_security(fd, encryption_required) {
return Err(webbluetooth_core::Error::Network(format!(
"could not set the LE L2CAP listener's security (errno {code})"
)));
}
let address = SockAddrL2 {
family: AF_BLUETOOTH as u16,
psm: psm.to_le(),
bdaddr: crate::sys::BDADDR_ANY,
cid: 0,
bdaddr_type: crate::sys::BDADDR_LE_PUBLIC,
};
if unsafe {
crate::sys::bind(
fd,
(&raw const address).cast(),
std::mem::size_of::<SockAddrL2>() as u32,
)
} < 0
|| unsafe { crate::sys::listen(fd, 8) } < 0
{
return Err(webbluetooth_core::Error::Network(format!(
"could not bind LE L2CAP PSM {psm} (errno {})",
errno()
)));
}
let mut bound = SockAddrL2 {
family: 0,
psm: 0,
bdaddr: [0; 6],
cid: 0,
bdaddr_type: 0,
};
let mut length = std::mem::size_of::<SockAddrL2>() as u32;
if unsafe { crate::sys::getsockname(fd, (&raw mut bound).cast(), &mut length) } < 0 {
return Err(webbluetooth_core::Error::Network(format!(
"could not query LE L2CAP PSM (errno {})",
errno()
)));
}
let bound_psm = u16::from_le(bound.psm);
let (tx, rx) = mpsc::unbounded();
let listener_fd = socket.clone();
let accept_fd = listener_fd.clone();
std::thread::Builder::new()
.name(format!("webbluetooth-l2cap-le-listener-{bound_psm:04x}"))
.spawn(move || loop {
let mut peer = SockAddrL2 {
family: 0,
psm: 0,
bdaddr: [0; 6],
cid: 0,
bdaddr_type: 0,
};
let mut length = std::mem::size_of::<SockAddrL2>() as u32;
let accepted =
unsafe { crate::sys::accept(accept_fd.0, (&raw mut peer).cast(), &mut length) };
if accepted < 0 {
break;
}
let (channel_sink, sink, incoming) = webbluetooth_core::l2cap::sink();
let peer_id = peer
.bdaddr
.iter()
.rev()
.map(|byte| format!("{byte:02X}"))
.collect::<Vec<_>>()
.join(":");
let channel = Channel::adopt_fd(accepted, bound_psm, peer_id, channel_sink);
if tx
.unbounded_send(Ok(L2capChannel::new(channel, sink, incoming)))
.is_err()
{
break;
}
})
.map_err(|error| webbluetooth_core::Error::Network(error.to_string()))?;
Ok((
bound_psm,
L2capListener {
socket,
incoming: rx,
},
))
}
impl webbluetooth_core::l2cap::PlatformChannel for Channel {
fn psm(&self) -> Psm {
Channel::psm(self)
}
fn peer_id(&self) -> &str {
Channel::peer_id(self)
}
fn send(&self, bytes: &[u8]) -> Result<(), Closed> {
Channel::send(self, bytes)
}
fn pending_bytes(&self) -> usize {
Channel::pending_bytes(self)
}
fn closed(&self) -> Option<Closed> {
Channel::closed(self)
}
fn close(&self) {
Channel::close(self)
}
}
pub fn open(
address: &str,
address_type: &str,
psm: Psm,
) -> webbluetooth_core::Result<L2capChannel> {
let (channel_sink, sink, incoming) = webbluetooth_core::l2cap::sink();
let channel = Channel::connect(address, address_type, psm, channel_sink)
.map_err(webbluetooth_core::Error::Network)?;
Ok(L2capChannel::new(channel, sink, incoming))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn addresses_are_reversed_onto_the_wire() {
assert_eq!(
parse_address("AA:BB:CC:DD:EE:FF"),
Some([0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA])
);
assert_eq!(
parse_address("00:00:00:00:00:01"),
Some([0x01, 0, 0, 0, 0, 0])
);
}
#[test]
fn malformed_addresses_are_rejected() {
assert_eq!(parse_address(""), None);
assert_eq!(parse_address("AA:BB:CC:DD:EE"), None);
assert_eq!(parse_address("AA:BB:CC:DD:EE:FF:00"), None);
assert_eq!(parse_address("ZZ:BB:CC:DD:EE:FF"), None);
}
#[test]
fn the_socket_address_matches_the_kernel_layout() {
assert_eq!(std::mem::size_of::<SockAddrL2>(), 13);
}
#[test]
fn connecting_to_a_bad_address_errors_rather_than_panicking() {
struct Discard;
impl ChannelSink for Discard {
fn on_bytes(&self, _: Vec<u8>) {}
fn on_closed(&self, _: Closed) {}
}
let err = Channel::connect("not-an-address", "public", 0x0080, Arc::new(Discard));
assert!(err.is_err());
}
}