added old work source files. Trying to get started again

Author: AndrewGi

cli/src/commands/ble/hci/dump.rs

@@ -48,7 +48,7 @@ pub async fn dump_adapter_pcap(
     which_adapter: &'_ str,
     pcap_file: Option<&'_ str>,
 ) -> Result<(), CLIError> {
-    let adapter = helper::hci_adapter(which_adapter)?;
+    let adapter = helper::hci_adapter(which_adapter).await?;
     println!("using adapter `{:?}`", adapter);
     match pcap_file {
         Some(pcap_file) => {

cli/src/commands/provisioner.rs

@@ -73,16 +73,13 @@ pub async fn provision(
     const BEARER_CHANNEL_SIZE: usize = 16;
     let dsm = crate::helper::load_device_state(device_state_path)?;
     println!("opening HCI adapter...");
-    let adapter = crate::helper::hci_adapter(which_adapter)?;
+    let adapter = crate::helper::hci_adapter(which_adapter).await?;
     println!("HCI adapter (`{:?}`) open!", adapter);
-    // If using USB HCI adapter, `read_event()` blocks instead of `Poll::Pending` so this will
-    // block the current thread
+    // TODO: I wrote a async usb driver (`usbw`) so a BufferedHCIAdvertiser might not be needed anymore!
     let (mut adapter, mut bearer_rx, bearer_tx) =
         BufferedHCIAdvertiser::new_with_channel_size(adapter, BEARER_CHANNEL_SIZE);
-    // Workaround is to spawn a thread for the adapter. In the future, hopefully there will be a
-    // async rust USB library.
-    let _adapter_thread = std::thread::spawn(move || {
-        tokio_runtime().block_on(adapter.run_loop_send_error());
+    let _adapter_task = task::spawn(async move {
+        adapter.run_loop_send_error().await;
     });
     async move {
         let early_end_error =

cli/src/helper.rs

@@ -129,7 +129,7 @@ pub fn write_device_state(
         .map_err(CLIError::SerdeJSON)
 }
 pub fn tokio_runtime() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_current_thread()
+    tokio::runtime::Builder::new_multi_thread()
         .enable_all()
         .build()
         .expect("can't make async runtime")
@@ -169,16 +169,17 @@ impl Adapter for HCIAdapter {
 pub fn libusb_context() -> &'static AsyncContext {
     static CONTEXT: once_cell::sync::OnceCell<AsyncContext> = once_cell::sync::OnceCell::new();
     CONTEXT.get_or_init(|| {
-        usbw::libusb::context::default_context()
-            .expect("unable to start libusb context")
-            .start_async()
+        let context =
+            usbw::libusb::context::default_context().expect("unable to start libusb context");
+        context.set_debug_level(usbw::libusb::context::LogLevel::Info);
+        context.start_async()
     })
 }
-pub fn usb_adapter(adapter_id: u16) -> Result<btle::hci::usb::adapter::Adapter, CLIError> {
+pub async fn usb_adapter(adapter_id: u16) -> Result<btle::hci::usb::adapter::Adapter, CLIError> {
     let context = libusb_context();
     let device_list = context.context_ref().device_list();
     let mut adapters = btle::hci::usb::device::bluetooth_adapters(device_list.iter());
-    let mut adapter = adapters
+    let adapter = adapters
         .nth(adapter_id.into())
         .ok_or_else(|| CLIError::OtherMessage("no usb bluetooth adapters found".to_owned()))??
         .open()
@@ -191,20 +192,23 @@ pub fn usb_adapter(adapter_id: u16) -> Result<btle::hci::usb::adapter::Adapter,
                 btle::hci::usb::Error::from(e).into(),
             )),
         })?;
-    adapter.reset().map_err(btle::hci::usb::Error::from)?;
-    Ok(btle::hci::usb::adapter::Adapter::open(
-        context.make_async_device(adapter),
-    )?)
-}
-pub fn hci_adapter(which_adapter: &str) -> Result<HCIAdapter, CLIError> {
+    let mut adapter = btle::hci::usb::adapter::Adapter::open(context.make_async_device(adapter))?;
+    adapter
+        .flush_event_buffer()
+        .await
+        .map_err(btle::hci::usb::Error::from)?;
+    Ok(adapter)
+}
+pub async fn hci_adapter(which_adapter: &str) -> Result<HCIAdapter, CLIError> {
     pub const USB_PREFIX: &'static str = "usb:";
     pub const BLUEZ_PREFIX: &'static str = "bluez:";
     if which_adapter.starts_with(USB_PREFIX) {
-        Ok(HCIAdapter::Usb(usb_adapter(
-            (&which_adapter[USB_PREFIX.len()..]).parse().map_err(|_| {
+        Ok(HCIAdapter::Usb(
+            usb_adapter((&which_adapter[USB_PREFIX.len()..]).parse().map_err(|_| {
                 CLIError::OtherMessage(format!("bad usb adapter {}", which_adapter))
-            })?,
-        )?))
+            })?)
+            .await?,
+        ))
     } else if which_adapter.starts_with(BLUEZ_PREFIX) {
         Ok(HCIAdapter::BlueZ(bluez_adapter(
             (&which_adapter[BLUEZ_PREFIX.len()..])

src/provisioning/link.rs

@@ -127,7 +127,7 @@ impl<B: Storage<u8>> Link<B> {
         link_id: LinkID,
         uuid: &UUID,
     ) -> Link<B> {
-        let mut link = Link {
+        let link = Link {
             link_id,
             my_transaction_number: TransactionNumber::new_provisioner().next(),
             other_transaction_number: TransactionNumber::new_provisionee(),

src/stack/bearers/advertiser.rs

@@ -235,17 +235,13 @@ impl<A: btle::hci::adapter::Adapter> BufferedHCIAdvertiser<A> {
         self.bearer
             .set_advertising_data(advertisement.as_ref())
             .await?;
-        println!("start send");
         // Enable advertising
         self.bearer.set_advertising_enable(true).await?;
-        println!("wait");
         // Scan for advertisements while advertising for `advertisement_duration`
         self.handle_incoming_for(advertisement_duration * u32::from(transmit_count))
             .await?;
         // Disable advertising
-        println!("stop send");
         self.bearer.set_advertising_enable(false).await?;
-        println!("done");
         Ok(())
     }
 }

src/stack/incoming.rs

@@ -63,7 +63,7 @@ impl Incoming {
     async fn handle_encrypted_access_loop(
         internals: Arc<RwLock<StackInternals>>,
         mut incoming_encrypted_access: mpsc::Receiver<EncryptedIncomingMessage<Box<[u8]>>>,
-        mut outgoing_encrypted_access: mpsc::Sender<IncomingMessage<Box<[u8]>>>,
+        outgoing_encrypted_access: mpsc::Sender<IncomingMessage<Box<[u8]>>>,
     ) -> Result<(), RecvError> {
         loop {
             let next = incoming_encrypted_access
@@ -175,7 +175,7 @@ impl Incoming {
         replay_cache: Arc<Mutex<replay::Cache>>,
         mut outgoing_relay: Option<mpsc::Sender<RelayPDU>>,
         mut incoming: mpsc::Receiver<IncomingEncryptedNetworkPDU>,
-        mut outgoing: mpsc::Sender<IncomingNetworkPDU>,
+        outgoing: mpsc::Sender<IncomingNetworkPDU>,
     ) -> Result<(), RecvError> {
         loop {
             let next = incoming.recv().await.ok_or(RecvError::ChannelClosed)?;