Create status channel for MacOS

jcjones · jcjones · commit 518e0ddfb396 · 2020-08-10T14:53:10.000-07:00
diff --git a/examples/main.rs b/examples/main.rs
@@ -5,10 +5,12 @@
 extern crate authenticator;
 extern crate base64;
 extern crate sha2;
-use authenticator::{AuthenticatorTransports, KeyHandle, RegisterFlags, SignFlags, U2FManager};
+use authenticator::{
+    AuthenticatorTransports, KeyHandle, RegisterFlags, SignFlags, StatusUpdate, U2FManager,
+};
 use sha2::{Digest, Sha256};
-use std::io;
-use std::sync::mpsc::channel;
+use std::sync::mpsc::{channel, RecvError};
+use std::{io, thread};
 
 extern crate env_logger;
 extern crate log;
@@ -60,21 +62,41 @@ fn main() {
     let manager = U2FManager::new().unwrap();
     let flags = RegisterFlags::empty();
 
-    let (tx, rx) = channel();
+    let (status_tx, status_rx) = channel::<StatusUpdate>();
+    thread::spawn(move || loop {
+        match status_rx.recv() {
+            Ok(StatusUpdate::DeviceAvailable { dev_info }) => {
+                println!("STATUS: device available: {}", dev_info)
+            }
+            Ok(StatusUpdate::DeviceUnavailable { dev_info }) => {
+                println!("STATUS: device unavailable: {}", dev_info)
+            }
+            Ok(StatusUpdate::Success { dev_info }) => {
+                println!("STATUS: success using device: {}", dev_info);
+            }
+            Err(RecvError) => {
+                println!("STATUS: end");
+                return;
+            }
+        }
+    });
+
+    let (register_tx, register_rx) = channel();
     manager
         .register(
             flags,
             15_000,
             chall_bytes.clone(),
             app_bytes.clone(),
             vec![],
+            status_tx.clone(),
             move |rv| {
-                tx.send(rv).unwrap();
+                register_tx.send(rv).unwrap();
             },
         )
         .unwrap();
 
-    let register_result = try_or!(rx.recv(), |_| {
+    let register_result = try_or!(register_rx.recv(), |_| {
         panic!("Problem receiving, unable to continue");
     });
     let (register_data, device_info) =
@@ -90,21 +112,22 @@ fn main() {
     };
 
     let flags = SignFlags::empty();
-    let (tx, rx) = channel();
+    let (sign_tx, sign_rx) = channel();
     manager
         .sign(
             flags,
             15_000,
             chall_bytes,
             vec![app_bytes],
             vec![key_handle],
+            status_tx,
             move |rv| {
-                tx.send(rv).unwrap();
+                sign_tx.send(rv).unwrap();
             },
         )
         .unwrap();
 
-    let sign_result = try_or!(rx.recv(), |_| {
+    let sign_result = try_or!(sign_rx.recv(), |_| {
         panic!("Problem receiving, unable to continue");
     });
     let (_, handle_used, sign_data, device_info) =
diff --git a/src/capi.rs b/src/capi.rs
@@ -5,6 +5,7 @@
 use libc::size_t;
 use rand::{thread_rng, Rng};
 use std::collections::HashMap;
+use std::sync::mpsc::channel;
 use std::{ptr, slice};
 
 use crate::U2FManager;
@@ -229,13 +230,16 @@ pub unsafe extern "C" fn rust_u2f_mgr_register(
     let application = from_raw(application_ptr, application_len);
     let key_handles = (*khs).clone();
 
+    let (tx, _rx) = channel::<crate::StatusUpdate>();
+
     let tid = new_tid();
     let res = (*mgr).register(
         flags,
         timeout,
         challenge,
         application,
         key_handles,
+        tx,
         move |rv| {
             let result = match rv {
                 Ok((registration, dev_info)) => {
@@ -295,26 +299,36 @@ pub unsafe extern "C" fn rust_u2f_mgr_sign(
     let app_ids = (*app_ids).clone();
     let key_handles = (*khs).clone();
 
+    let (tx, _rx) = channel::<crate::StatusUpdate>();
+
     let tid = new_tid();
-    let res = (*mgr).sign(flags, timeout, challenge, app_ids, key_handles, move |rv| {
-        let result = match rv {
-            Ok((app_id, key_handle, signature, dev_info)) => {
-                let mut bufs = HashMap::new();
-                bufs.insert(RESBUF_ID_KEYHANDLE, key_handle);
-                bufs.insert(RESBUF_ID_SIGNATURE, signature);
-                bufs.insert(RESBUF_ID_APPID, app_id);
-                bufs.insert(RESBUF_ID_VENDOR_NAME, dev_info.vendor_name);
-                bufs.insert(RESBUF_ID_DEVICE_NAME, dev_info.device_name);
-                bufs.insert(RESBUF_ID_FIRMWARE_MAJOR, vec![dev_info.version_major]);
-                bufs.insert(RESBUF_ID_FIRMWARE_MINOR, vec![dev_info.version_minor]);
-                bufs.insert(RESBUF_ID_FIRMWARE_BUILD, vec![dev_info.version_build]);
-                U2FResult::Success(bufs)
-            }
-            Err(e) => U2FResult::Error(e),
-        };
-
-        callback(tid, Box::into_raw(Box::new(result)));
-    });
+    let res = (*mgr).sign(
+        flags,
+        timeout,
+        challenge,
+        app_ids,
+        key_handles,
+        tx,
+        move |rv| {
+            let result = match rv {
+                Ok((app_id, key_handle, signature, dev_info)) => {
+                    let mut bufs = HashMap::new();
+                    bufs.insert(RESBUF_ID_KEYHANDLE, key_handle);
+                    bufs.insert(RESBUF_ID_SIGNATURE, signature);
+                    bufs.insert(RESBUF_ID_APPID, app_id);
+                    bufs.insert(RESBUF_ID_VENDOR_NAME, dev_info.vendor_name);
+                    bufs.insert(RESBUF_ID_DEVICE_NAME, dev_info.device_name);
+                    bufs.insert(RESBUF_ID_FIRMWARE_MAJOR, vec![dev_info.version_major]);
+                    bufs.insert(RESBUF_ID_FIRMWARE_MINOR, vec![dev_info.version_minor]);
+                    bufs.insert(RESBUF_ID_FIRMWARE_BUILD, vec![dev_info.version_build]);
+                    U2FResult::Success(bufs)
+                }
+                Err(e) => U2FResult::Error(e),
+            };
+
+            callback(tid, Box::into_raw(Box::new(result)));
+        },
+    );
 
     if res.is_ok() {
         tid
diff --git a/src/lib.rs b/src/lib.rs
@@ -112,6 +112,13 @@ pub enum Error {
     NotAllowed = 5,
 }
 
+#[derive(Debug, Clone)]
+pub enum StatusUpdate {
+    DeviceAvailable { dev_info: u2ftypes::U2FDeviceInfo },
+    DeviceUnavailable { dev_info: u2ftypes::U2FDeviceInfo },
+    Success { dev_info: u2ftypes::U2FDeviceInfo },
+}
+
 #[cfg(fuzzing)]
 pub use consts::*;
 #[cfg(fuzzing)]
diff --git a/src/manager.rs b/src/manager.rs
@@ -18,6 +18,7 @@ enum QueueAction {
         challenge: Vec<u8>,
         application: crate::AppId,
         key_handles: Vec<crate::KeyHandle>,
+        status: Sender<crate::StatusUpdate>,
         callback: StateCallback<Result<crate::RegisterResult, crate::Error>>,
     },
     Sign {
@@ -26,6 +27,7 @@ enum QueueAction {
         challenge: Vec<u8>,
         app_ids: Vec<crate::AppId>,
         key_handles: Vec<crate::KeyHandle>,
+        status: Sender<crate::StatusUpdate>,
         callback: StateCallback<Result<crate::SignResult, crate::Error>>,
     },
     Cancel,
@@ -52,6 +54,7 @@ impl U2FManager {
                         challenge,
                         application,
                         key_handles,
+                        status,
                         callback,
                     }) => {
                         // This must not block, otherwise we can't cancel.
@@ -61,6 +64,7 @@ impl U2FManager {
                             challenge,
                             application,
                             key_handles,
+                            status,
                             callback,
                         );
                     }
@@ -70,10 +74,19 @@ impl U2FManager {
                         challenge,
                         app_ids,
                         key_handles,
+                        status,
                         callback,
                     }) => {
                         // This must not block, otherwise we can't cancel.
-                        sm.sign(flags, timeout, challenge, app_ids, key_handles, callback);
+                        sm.sign(
+                            flags,
+                            timeout,
+                            challenge,
+                            app_ids,
+                            key_handles,
+                            status,
+                            callback,
+                        );
                     }
                     Ok(QueueAction::Cancel) => {
                         // Cancelling must block so that we don't start a new
@@ -101,6 +114,7 @@ impl U2FManager {
         challenge: Vec<u8>,
         application: crate::AppId,
         key_handles: Vec<crate::KeyHandle>,
+        status: Sender<crate::StatusUpdate>,
         callback: F,
     ) -> Result<(), crate::Error>
     where
@@ -124,6 +138,7 @@ impl U2FManager {
             challenge,
             application,
             key_handles,
+            status,
             callback,
         };
         self.tx.send(action).map_err(|_| crate::Error::Unknown)
@@ -136,6 +151,7 @@ impl U2FManager {
         challenge: Vec<u8>,
         app_ids: Vec<crate::AppId>,
         key_handles: Vec<crate::KeyHandle>,
+        status: Sender<crate::StatusUpdate>,
         callback: F,
     ) -> Result<(), crate::Error>
     where
@@ -169,6 +185,7 @@ impl U2FManager {
             challenge,
             app_ids,
             key_handles,
+            status,
             callback,
         };
         self.tx.send(action).map_err(|_| crate::Error::Unknown)
diff --git a/src/statemachine.rs b/src/statemachine.rs
