1use crate::sys::{
27 address_type, bind_le_source, bluetooth_u16_option, close, connect, errno, parse_address,
28 read, shutdown, socket, write, SockAddrL2, AF_BLUETOOTH, BTPROTO_L2CAP, BT_RCVMTU, BT_SNDMTU,
29 EINTR, EMSGSIZE, SHUT_RDWR, SOCK_SEQPACKET,
30};
31use futures_channel::mpsc;
32use futures_core::Stream;
33use futures_util::StreamExt;
34use std::collections::VecDeque;
35use std::ffi::c_int;
36use std::pin::Pin;
37use std::sync::atomic::{AtomicBool, Ordering};
38use std::sync::{Arc, Mutex};
39use std::task::{Context, Poll};
40
41pub use webbluetooth_core::l2cap::{ChannelSink, Closed, Psm};
42
43struct Socket(c_int);
44
45impl Drop for Socket {
46 fn drop(&mut self) {
47 unsafe { close(self.0) };
48 }
49}
50
51pub struct Channel {
53 psm: Psm,
54 peer: String,
55 fd: Arc<Socket>,
56 writing: Mutex<VecDeque<u8>>,
58 send_mtu: std::sync::atomic::AtomicUsize,
61 closed: Arc<Mutex<Option<Closed>>>,
64 stopped: Arc<AtomicBool>,
65}
66
67impl Channel {
68 pub fn connect(
72 address: &str,
73 peer_address_type: &str,
74 psm: Psm,
75 sink: Arc<dyn ChannelSink>,
76 ) -> Result<Self, String> {
77 let bdaddr = parse_address(address)
78 .ok_or_else(|| format!("{address:?} is not a Bluetooth address"))?;
79
80 let fd = unsafe { socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP) };
81 if fd < 0 {
82 return Err(format!(
83 "could not create an L2CAP socket (errno {})",
84 errno()
85 ));
86 }
87 let socket = Arc::new(Socket(fd));
88
89 if let Err(e) = bind_le_source(fd, 0, 0) {
90 return Err(format!("could not bind an LE L2CAP socket (errno {e})"));
91 }
92
93 let addr = SockAddrL2 {
94 family: AF_BLUETOOTH as u16,
95 psm: psm.to_le(),
96 bdaddr,
97 cid: 0,
98 bdaddr_type: address_type(peer_address_type == "random"),
99 };
100 let rc = unsafe { connect(fd, &addr, std::mem::size_of::<SockAddrL2>() as u32) };
101 if rc < 0 {
102 return Err(format!(
103 "could not open L2CAP PSM {psm} on {address} (errno {})",
104 errno()
105 ));
106 }
107
108 let stopped = Arc::new(AtomicBool::new(false));
109 let closed = Arc::new(Mutex::new(None));
110 spawn_reader(socket.clone(), sink, stopped.clone(), closed.clone(), psm);
111
112 Ok(Self {
113 psm,
114 peer: address.to_owned(),
115 send_mtu: send_mtu(fd),
116 fd: socket,
117 writing: Mutex::new(VecDeque::new()),
118 closed,
119 stopped,
120 })
121 }
122
123 pub fn adopt_fd(fd: c_int, psm: Psm, peer: String, sink: Arc<dyn ChannelSink>) -> Self {
125 let socket = Arc::new(Socket(fd));
126 let stopped = Arc::new(AtomicBool::new(false));
127 let closed = Arc::new(Mutex::new(None));
128 spawn_reader(socket.clone(), sink, stopped.clone(), closed.clone(), psm);
129 Self {
130 psm,
131 peer,
132 send_mtu: send_mtu(fd),
133 fd: socket,
134 writing: Mutex::new(VecDeque::new()),
135 closed,
136 stopped,
137 }
138 }
139
140 pub fn psm(&self) -> Psm {
141 self.psm
142 }
143 pub fn peer_id(&self) -> &str {
144 &self.peer
145 }
146
147 pub fn send(&self, bytes: &[u8]) -> Result<(), Closed> {
149 if let Some(reason) = self.closed() {
150 return Err(reason);
151 }
152 let _order = self.writing.lock().unwrap();
154 let mut sent = 0;
155 while sent < bytes.len() {
156 let mtu = self.send_mtu.load(Ordering::Relaxed);
157 let len = (bytes.len() - sent).min(mtu);
158 let n = unsafe { write(self.fd.0, bytes[sent..].as_ptr(), len) };
159 if n > 0 {
160 sent += n as usize;
161 continue;
162 }
163 if n < 0 && errno() == EINTR {
165 continue;
166 }
167 if n < 0 && errno() == EMSGSIZE && mtu > LE_MIN_MTU {
170 self.send_mtu.store((mtu / 2).max(LE_MIN_MTU), Ordering::Relaxed);
171 continue;
172 }
173 let reason = Closed::Error(format!("L2CAP write failed (errno {})", errno()));
174 *self.closed.lock().unwrap() = Some(reason.clone());
175 return Err(reason);
176 }
177 Ok(())
178 }
179
180 pub fn pending_bytes(&self) -> usize {
183 0
184 }
185
186 pub fn closed(&self) -> Option<Closed> {
187 self.closed.lock().unwrap().clone()
188 }
189
190 pub fn close(&self) {
191 {
192 let mut closed = self.closed.lock().unwrap();
193 if closed.is_none() {
194 *closed = Some(Closed::Locally);
195 }
196 }
197 self.stopped.store(true, Ordering::Release);
198 unsafe { shutdown(self.fd.0, SHUT_RDWR) };
200 }
201}
202
203impl Drop for Channel {
204 fn drop(&mut self) {
205 self.close();
206 }
207}
208
209impl std::fmt::Debug for Channel {
210 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
211 f.debug_struct("L2capChannel")
212 .field("psm", &self.psm)
213 .field("peer", &self.peer)
214 .field("closed", &self.closed())
215 .finish()
216 }
217}
218
219const LE_MIN_MTU: usize = 23;
221
222fn send_mtu(fd: c_int) -> std::sync::atomic::AtomicUsize {
225 let mtu = bluetooth_u16_option(fd, BT_SNDMTU).map_or(LE_MIN_MTU, usize::from);
226 std::sync::atomic::AtomicUsize::new(mtu.max(LE_MIN_MTU))
227}
228
229fn spawn_reader(
230 socket: Arc<Socket>,
231 sink: Arc<dyn ChannelSink>,
232 stopped: Arc<AtomicBool>,
233 closed: Arc<Mutex<Option<Closed>>>,
234 psm: Psm,
235) {
236 std::thread::Builder::new()
237 .name(format!("webbluetooth-l2cap-{psm}"))
238 .spawn(move || {
239 let rcv = bluetooth_u16_option(socket.0, BT_RCVMTU).map_or(0, usize::from);
241 let mut buf = vec![0u8; rcv.max(4096)];
242 let reason = loop {
243 if stopped.load(Ordering::Acquire) {
244 break Closed::Locally;
245 }
246 let n = unsafe { read(socket.0, buf.as_mut_ptr(), buf.len()) };
247 match n {
248 0 => break Closed::ByPeer,
249 n if n > 0 => sink.on_bytes(buf[..n as usize].to_vec()),
250 _ if errno() == EINTR => continue,
252 _ => {
253 if stopped.load(Ordering::Acquire) {
254 break Closed::Locally;
255 }
256 break Closed::Error(format!("L2CAP read failed (errno {})", errno()));
257 }
258 }
259 };
260 let reason = closed.lock().unwrap().get_or_insert(reason).clone();
262 sink.on_closed(reason);
263 })
264 .expect("could not start the L2CAP reader thread");
265}
266
267pub type L2capChannel = webbluetooth_core::l2cap::L2capChannel<Channel>;
275
276pub struct L2capListener {
278 socket: Arc<Socket>,
279 incoming: mpsc::UnboundedReceiver<webbluetooth_core::Result<L2capChannel>>,
280}
281
282pub struct L2capListenerHandle {
284 socket: Arc<Socket>,
285}
286
287impl Drop for L2capListenerHandle {
288 fn drop(&mut self) {
289 unsafe { shutdown(self.socket.0, SHUT_RDWR) };
290 }
291}
292
293impl L2capListener {
294 pub fn spawn<F>(self, callback: F) -> webbluetooth_core::Result<L2capListenerHandle>
296 where
297 F: Fn(webbluetooth_core::Result<L2capChannel>) + Send + 'static,
298 {
299 let handle = L2capListenerHandle {
300 socket: self.socket.clone(),
301 };
302 let name = "webbluetooth-l2cap-le-router";
303 std::thread::Builder::new()
304 .name(name.into())
305 .spawn(move || {
306 futures_executor::block_on(async move {
307 let mut listener = self;
308 while let Some(channel) = listener.next().await {
309 callback(channel);
310 }
311 });
312 })
313 .map_err(|error| webbluetooth_core::Error::Network(error.to_string()))?;
314 Ok(handle)
315 }
316}
317
318impl Stream for L2capListener {
319 type Item = webbluetooth_core::Result<L2capChannel>;
320
321 fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
322 Pin::new(&mut self.incoming).poll_next(cx)
323 }
324}
325
326impl Drop for L2capListener {
327 fn drop(&mut self) {
328 unsafe { shutdown(self.socket.0, SHUT_RDWR) };
329 }
330}
331
332pub fn listen(
337 psm: Psm,
338 encryption_required: bool,
339) -> webbluetooth_core::Result<(Psm, L2capListener)> {
340 let fd = unsafe { socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP) };
341 if fd < 0 {
342 return Err(webbluetooth_core::Error::Network(format!(
343 "could not create LE L2CAP listener (errno {})",
344 errno()
345 )));
346 }
347 let socket = Arc::new(Socket(fd));
348 if let Err(code) = crate::sys::set_le_security(fd, encryption_required) {
349 return Err(webbluetooth_core::Error::Network(format!(
350 "could not set the LE L2CAP listener's security (errno {code})"
351 )));
352 }
353 let address = SockAddrL2 {
354 family: AF_BLUETOOTH as u16,
355 psm: psm.to_le(),
356 bdaddr: crate::sys::BDADDR_ANY,
357 cid: 0,
358 bdaddr_type: crate::sys::BDADDR_LE_PUBLIC,
359 };
360 if unsafe {
361 crate::sys::bind(
362 fd,
363 (&raw const address).cast(),
364 std::mem::size_of::<SockAddrL2>() as u32,
365 )
366 } < 0
367 || unsafe { crate::sys::listen(fd, 8) } < 0
368 {
369 return Err(webbluetooth_core::Error::Network(format!(
370 "could not bind LE L2CAP PSM {psm} (errno {})",
371 errno()
372 )));
373 }
374 let mut bound = SockAddrL2 {
375 family: 0,
376 psm: 0,
377 bdaddr: [0; 6],
378 cid: 0,
379 bdaddr_type: 0,
380 };
381 let mut length = std::mem::size_of::<SockAddrL2>() as u32;
382 if unsafe { crate::sys::getsockname(fd, (&raw mut bound).cast(), &mut length) } < 0 {
383 return Err(webbluetooth_core::Error::Network(format!(
384 "could not query LE L2CAP PSM (errno {})",
385 errno()
386 )));
387 }
388 let bound_psm = u16::from_le(bound.psm);
389 let (tx, rx) = mpsc::unbounded();
390 let listener_fd = socket.clone();
391 let accept_fd = listener_fd.clone();
392 std::thread::Builder::new()
393 .name(format!("webbluetooth-l2cap-le-listener-{bound_psm:04x}"))
394 .spawn(move || loop {
395 let mut peer = SockAddrL2 {
396 family: 0,
397 psm: 0,
398 bdaddr: [0; 6],
399 cid: 0,
400 bdaddr_type: 0,
401 };
402 let mut length = std::mem::size_of::<SockAddrL2>() as u32;
403 let accepted =
404 unsafe { crate::sys::accept(accept_fd.0, (&raw mut peer).cast(), &mut length) };
405 if accepted < 0 {
406 break;
407 }
408 let (channel_sink, sink, incoming) = webbluetooth_core::l2cap::sink();
409 let peer_id = peer
410 .bdaddr
411 .iter()
412 .rev()
413 .map(|byte| format!("{byte:02X}"))
414 .collect::<Vec<_>>()
415 .join(":");
416 let channel = Channel::adopt_fd(accepted, bound_psm, peer_id, channel_sink);
417 if tx
418 .unbounded_send(Ok(L2capChannel::new(channel, sink, incoming)))
419 .is_err()
420 {
421 break;
422 }
423 })
424 .map_err(|error| webbluetooth_core::Error::Network(error.to_string()))?;
425 Ok((
426 bound_psm,
427 L2capListener {
428 socket,
429 incoming: rx,
430 },
431 ))
432}
433
434impl webbluetooth_core::l2cap::PlatformChannel for Channel {
435 fn psm(&self) -> Psm {
436 Channel::psm(self)
437 }
438
439 fn peer_id(&self) -> &str {
440 Channel::peer_id(self)
441 }
442
443 fn send(&self, bytes: &[u8]) -> Result<(), Closed> {
444 Channel::send(self, bytes)
445 }
446
447 fn pending_bytes(&self) -> usize {
448 Channel::pending_bytes(self)
449 }
450
451 fn closed(&self) -> Option<Closed> {
452 Channel::closed(self)
453 }
454
455 fn close(&self) {
456 Channel::close(self)
457 }
458}
459
460pub fn open(
465 address: &str,
466 address_type: &str,
467 psm: Psm,
468) -> webbluetooth_core::Result<L2capChannel> {
469 let (channel_sink, sink, incoming) = webbluetooth_core::l2cap::sink();
470 let channel = Channel::connect(address, address_type, psm, channel_sink)
471 .map_err(webbluetooth_core::Error::Network)?;
472 Ok(L2capChannel::new(channel, sink, incoming))
473}
474
475#[cfg(test)]
476mod tests {
477 use super::*;
478
479 #[test]
480 fn addresses_are_reversed_onto_the_wire() {
481 assert_eq!(
484 parse_address("AA:BB:CC:DD:EE:FF"),
485 Some([0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA])
486 );
487 assert_eq!(
488 parse_address("00:00:00:00:00:01"),
489 Some([0x01, 0, 0, 0, 0, 0])
490 );
491 }
492
493 #[test]
494 fn malformed_addresses_are_rejected() {
495 assert_eq!(parse_address(""), None);
496 assert_eq!(parse_address("AA:BB:CC:DD:EE"), None);
497 assert_eq!(parse_address("AA:BB:CC:DD:EE:FF:00"), None);
498 assert_eq!(parse_address("ZZ:BB:CC:DD:EE:FF"), None);
499 }
500
501 #[test]
502 fn the_socket_address_matches_the_kernel_layout() {
503 assert_eq!(std::mem::size_of::<SockAddrL2>(), 13);
505 }
506
507 #[test]
508 fn connecting_to_a_bad_address_errors_rather_than_panicking() {
509 struct Discard;
510 impl ChannelSink for Discard {
511 fn on_bytes(&self, _: Vec<u8>) {}
512 fn on_closed(&self, _: Closed) {}
513 }
514 let err = Channel::connect("not-an-address", "public", 0x0080, Arc::new(Discard));
515 assert!(err.is_err());
516 }
517}