wip: query all devices at once

Author: iinuwa

Cargo.lock

@@ -13,9 +13,7 @@ pub trait FlowController {
         &self,
     ) -> impl Future<Output = Result<Vec<Device>, ()>> + Send;
 
-    fn get_hybrid_credential(&mut self) -> impl Future<Output = Result<(), ()>> + Send;
-    fn get_usb_credential(&mut self) -> impl Future<Output = Result<(), ()>> + Send;
-    fn get_nfc_credential(&mut self) -> impl Future<Output = Result<(), ()>> + Send;
+    fn start_discovery(&mut self) -> impl Future<Output = Result<(), ()>> + Send;
     fn subscribe(
         &mut self,
     ) -> impl Future<

credentialsd-common/src/client.rs

@@ -270,6 +270,9 @@ pub enum NfcState {
 }
 
 pub enum UserInteractedEvent {
+    /// Start discovery
+    DiscoveryRequested,
+    /*
     /// Start Hybrid discovery
     HybridDiscoveryRequested,
 
@@ -278,7 +281,7 @@ pub enum UserInteractedEvent {
 
     /// Start USB discovery
     UsbDiscoveryRequested,
-
+    */
     /// Send client PIN. Length of the PIN MUST not be greater than 63 bytes.
     /// File descriptor must be memory-mapped to be read.
     ClientPinEntered(OwnedFd),
@@ -292,17 +295,16 @@ pub enum UserInteractedEvent {
 impl std::fmt::Debug for UserInteractedEvent {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::HybridDiscoveryRequested => write!(f, "StartHybridDiscovery"),
-            Self::NfcDiscoveryRequested => write!(f, "StartNfcDiscovery"),
-            Self::UsbDiscoveryRequested => write!(f, "StartUsbDiscovery"),
+            Self::DiscoveryRequested => write!(f, stringify!(DiscoveryRequested)),
             Self::ClientPinEntered(_) => f
-                .debug_tuple("EnterClientPin")
+                .debug_tuple(stringify!(ClientPinEntered))
                 .field(&"******".to_string())
                 .finish(),
-            Self::CredentialSelected(arg0) => {
-                f.debug_tuple("SelectCredential").field(arg0).finish()
-            }
-            Self::RequestCancelled => write!(f, "CancelRequest"),
+            Self::CredentialSelected(arg0) => f
+                .debug_tuple(stringify!(CredentialSelected))
+                .field(arg0)
+                .finish(),
+            Self::RequestCancelled => write!(f, stringify!(RequestCancelled)),
         }
     }
 }

credentialsd-common/src/model.rs

@@ -49,9 +49,12 @@ const BACKGROUND_EVENT_ERROR_CREDENTIAL_EXCLUDED: u32 = 0x80000006;
 const BACKGROUND_EVENT_ERROR_PIN_ATTEMPTS_EXHAUSTED: u32 = 0x80000007;
 const BACKGROUND_EVENT_ERROR_PIN_NOT_SET: u32 = 0x80000008;
 
+/*
 const USER_INTERACTED_EVENT_HYBRID_DISCOVERY_REQUESTED: u32 = 0x01;
 const USER_INTERACTED_EVENT_NFC_DISCOVERY_REQUESTED: u32 = 0x02;
 const USER_INTERACTED_EVENT_USB_DISCOVERY_REQUESTED: u32 = 0x03;
+*/
+const USER_INTERACTED_EVENT_DISCOVERY_REQUESTED: u32 = 0x01;
 const USER_INTERACTED_EVENT_CLIENT_PIN_ENTERED: u32 = 0x04;
 const USER_INTERACTED_EVENT_CREDENTIAL_SELECTED: u32 = 0x05;
 const USER_INTERACTED_EVENT_REQUEST_CANCELLED: u32 = 0x06;
@@ -426,6 +429,10 @@ impl Type for UserInteractedEvent {
 impl From<&UserInteractedEvent> for Structure<'_> {
     fn from(value: &UserInteractedEvent) -> Self {
         match value {
+            UserInteractedEvent::DiscoveryRequested => {
+                tag_value_to_struct(USER_INTERACTED_EVENT_DISCOVERY_REQUESTED, None)
+            }
+            /*
             UserInteractedEvent::HybridDiscoveryRequested => {
                 tag_value_to_struct(USER_INTERACTED_EVENT_HYBRID_DISCOVERY_REQUESTED, None)
             }
@@ -435,6 +442,7 @@ impl From<&UserInteractedEvent> for Structure<'_> {
             UserInteractedEvent::UsbDiscoveryRequested => {
                 tag_value_to_struct(USER_INTERACTED_EVENT_USB_DISCOVERY_REQUESTED, None)
             }
+            */
             UserInteractedEvent::ClientPinEntered(pin_fd) => tag_value_to_struct(
                 USER_INTERACTED_EVENT_CLIENT_PIN_ENTERED,
                 Some(Value::Fd(pin_fd.into())),
@@ -457,15 +465,17 @@ impl TryFrom<&Structure<'_>> for UserInteractedEvent {
         let (tag, value) = parse_tag_value_struct(value)?;
 
         match tag {
-            USER_INTERACTED_EVENT_HYBRID_DISCOVERY_REQUESTED => {
-                Ok(UserInteractedEvent::HybridDiscoveryRequested)
+            USER_INTERACTED_EVENT_DISCOVERY_REQUESTED => {
+                Ok(UserInteractedEvent::DiscoveryRequested)
             }
+            /*
             USER_INTERACTED_EVENT_NFC_DISCOVERY_REQUESTED => {
                 Ok(UserInteractedEvent::NfcDiscoveryRequested)
             }
             USER_INTERACTED_EVENT_USB_DISCOVERY_REQUESTED => {
                 Ok(UserInteractedEvent::UsbDiscoveryRequested)
             }
+            */
             USER_INTERACTED_EVENT_CLIENT_PIN_ENTERED => {
                 let fd = value.downcast_ref::<Fd>()?;
                 let owned_fd = fd.try_to_owned()?;

credentialsd-common/src/server.rs

@@ -24,6 +24,10 @@ pub struct FlowControlClient {
 }
 
 impl FlowControlClient {
+    pub async fn discover_authenticators(&self) -> Result<(), ()> {
+        self.send(UserInteractedEvent::DiscoveryRequested).await
+    }
+    /*
     pub async fn discover_hybrid_authenticators(&self) -> Result<(), ()> {
         self.send(UserInteractedEvent::HybridDiscoveryRequested)
             .await
@@ -36,6 +40,7 @@ impl FlowControlClient {
     pub async fn discover_usb_authenticators(&mut self) -> Result<(), ()> {
         self.send(UserInteractedEvent::UsbDiscoveryRequested).await
     }
+    */
 
     pub async fn enter_client_pin(&mut self, pin: String) -> Result<(), ()> {
         let fd = match write_secret(pin) {

credentialsd-ui/src/client.rs

@@ -261,9 +261,11 @@ impl ViewModel {
             button.connect_clicked(move |button| {
                 let id = button.widget_name().to_string();
                 let tx = tx.clone();
+                /*
                 glib::spawn_future_local(async move {
                     tx.send(ViewEvent::DeviceSelected(id)).await.unwrap();
                 });
+                */
             });
             button.into()
         });

credentialsd-ui/src/gui/view_model/gtk/mod.rs

@@ -127,6 +127,12 @@ impl ViewModel {
             .unwrap();
     }
 
+    pub(crate) async fn start_discovery(&self) {
+        let cred_service = self.flow_controller.lock().await;
+        (*cred_service).discover_authenticators().await.unwrap();
+    }
+
+    /*
     pub(crate) async fn select_device(&mut self, id: &str) {
         let device = self.devices.iter().find(|d| d.id == id).unwrap();
         tracing::debug!("Device selected: {:?}", device);
@@ -176,6 +182,7 @@ impl ViewModel {
             .await
             .unwrap();
     }
+    */
 
     pub(crate) async fn start_event_loop(&mut self) {
         let view_events = self.rx_event.clone().map(Event::View);
@@ -189,11 +196,14 @@ impl ViewModel {
                 Event::View(ViewEvent::Initiated) => {
                     self.update_title().await;
                     self.update_devices(self.devices.clone()).await;
+                    self.start_discovery().await;
                 }
+                /*
                 Event::View(ViewEvent::DeviceSelected(id)) => {
                     self.select_device(&id).await;
                     println!("Selected device {id}");
                 }
+                */
                 Event::View(ViewEvent::PinEntered(pin)) => {
                     let mut cred_service = self.flow_controller.lock().await;
                     if cred_service.enter_client_pin(pin).await.is_err() {
@@ -366,7 +376,7 @@ impl ViewModel {
 #[derive(Serialize, Deserialize)]
 pub enum ViewEvent {
     Initiated,
-    DeviceSelected(String),
+    // DeviceSelected(String),
     CredentialSelected(String),
     PinEntered(String),
     UserCancelled,

credentialsd-ui/src/gui/view_model/mod.rs

@@ -10,6 +10,7 @@ async-stream = "0.3.6"
 async-trait = "0.1.89"
 base64 = "0.22.1"
 credentialsd-common = { path = "../credentialsd-common" }
+futures = "0.3.32"
 futures-lite.workspace = true
 libc.workspace = true
 libwebauthn = { version = "0.3.0", features = ["libnfc","pcsc"] }

credentialsd/Cargo.toml

@@ -10,15 +10,18 @@ use std::{
 };
 
 use async_trait::async_trait;
-use futures_lite::{FutureExt, Stream, StreamExt};
+use futures_lite::{stream, FutureExt, Stream, StreamExt};
 use libwebauthn::{
     self,
     ops::webauthn::{GetAssertionResponse, MakeCredentialResponse},
 };
 use nfc::{NfcEvent, NfcHandler, NfcState, NfcStateInternal};
 use tokio::sync::oneshot;
 
-use credentialsd_common::model::{Device, Error as CredentialServiceError, RequestId, Transport};
+use credentialsd_common::{
+    model::{Device, Error as CredentialServiceError, RequestId, Transport},
+    server::BackgroundEvent,
+};
 
 use crate::{
     credential_service::{hybrid::HybridEvent, usb::UsbEvent},
@@ -59,11 +62,9 @@ pub trait ManageDevice {
     ) -> Result<RequestId, CredentialServiceError>;
     async fn cancel_request(&self, request_id: RequestId);
     async fn get_available_public_key_devices(&self) -> Result<Vec<Device>, ()>;
-    async fn get_hybrid_credential(
+    async fn start_discovery(
         &self,
-    ) -> Pin<Box<dyn Stream<Item = HybridState> + Send + 'static>>;
-    async fn get_nfc_credential(&self) -> Pin<Box<dyn Stream<Item = NfcState> + Send + 'static>>;
-    async fn get_usb_credential(&self) -> Pin<Box<dyn Stream<Item = UsbState> + Send + 'static>>;
+    ) -> Pin<Box<dyn Stream<Item = DeviceStateUpdate> + Send + 'static>>;
 }
 
 #[derive(Debug)]
@@ -90,6 +91,54 @@ impl<H: HybridHandler + Debug, N: NfcHandler + Debug, U: UsbHandler + Debug>
     }
 }
 
+impl<H: HybridHandler + Send, N: NfcHandler + Send, U: UsbHandler + Send>
+    CredentialService<H, N, U>
+{
+    async fn get_hybrid_credential(
+        &self,
+    ) -> Pin<Box<dyn Stream<Item = HybridState> + Send + 'static>> {
+        let guard = self.ctx.lock().unwrap();
+        if let Some(RequestContext { ref request, .. }) = *guard {
+            let stream = self.hybrid_handler.lock().unwrap().start(request);
+            let ctx = self.ctx.clone();
+            Box::pin(HybridStateStream { inner: stream, ctx })
+        } else {
+            tracing::error!(
+                "Attempted to start hybrid credential flow, but no request context was found."
+            );
+            todo!("Handle error when context is not set up.")
+        }
+    }
+
+    async fn get_usb_credential(&self) -> Pin<Box<dyn Stream<Item = UsbState> + Send + 'static>> {
+        let guard = self.ctx.lock().unwrap();
+        if let Some(RequestContext { ref request, .. }) = *guard {
+            let stream = self.usb_handler.lock().unwrap().start(request);
+            let ctx = self.ctx.clone();
+            Box::pin(UsbStateStream { inner: stream, ctx })
+        } else {
+            tracing::error!(
+                "Attempted to start usb credential flow, but no request context was found."
+            );
+            todo!("Handle error when context is not set up.")
+        }
+    }
+
+    async fn get_nfc_credential(&self) -> Pin<Box<dyn Stream<Item = NfcState> + Send + 'static>> {
+        let guard = self.ctx.lock().unwrap();
+        if let Some(RequestContext { ref request, .. }) = *guard {
+            let stream = self.nfc_handler.lock().unwrap().start(request);
+            let ctx = self.ctx.clone();
+            Box::pin(NfcStateStream { inner: stream, ctx })
+        } else {
+            tracing::error!(
+                "Attempted to start nfc credential flow, but no request context was found."
+            );
+            todo!("Handle error when context is not set up.")
+        }
+    }
+}
+
 #[async_trait]
 impl<H: HybridHandler + Send, N: NfcHandler + Send, U: UsbHandler + Send> ManageDevice
     for CredentialService<H, N, U>
@@ -158,48 +207,27 @@ impl<H: HybridHandler + Send, N: NfcHandler + Send, U: UsbHandler + Send> Manage
         Ok(devices)
     }
 
-    async fn get_hybrid_credential(
+    async fn start_discovery(
         &self,
-    ) -> Pin<Box<dyn Stream<Item = HybridState> + Send + 'static>> {
-        let guard = self.ctx.lock().unwrap();
-        if let Some(RequestContext { ref request, .. }) = *guard {
-            let stream = self.hybrid_handler.lock().unwrap().start(request);
-            let ctx = self.ctx.clone();
-            Box::pin(HybridStateStream { inner: stream, ctx })
-        } else {
-            tracing::error!(
-                "Attempted to start hybrid credential flow, but no request context was found."
-            );
-            todo!("Handle error when context is not set up.")
-        }
-    }
-
-    async fn get_usb_credential(&self) -> Pin<Box<dyn Stream<Item = UsbState> + Send + 'static>> {
-        let guard = self.ctx.lock().unwrap();
-        if let Some(RequestContext { ref request, .. }) = *guard {
-            let stream = self.usb_handler.lock().unwrap().start(request);
-            let ctx = self.ctx.clone();
-            Box::pin(UsbStateStream { inner: stream, ctx })
-        } else {
-            tracing::error!(
-                "Attempted to start usb credential flow, but no request context was found."
-            );
-            todo!("Handle error when context is not set up.")
-        }
-    }
-
-    async fn get_nfc_credential(&self) -> Pin<Box<dyn Stream<Item = NfcState> + Send + 'static>> {
-        let guard = self.ctx.lock().unwrap();
-        if let Some(RequestContext { ref request, .. }) = *guard {
-            let stream = self.nfc_handler.lock().unwrap().start(request);
-            let ctx = self.ctx.clone();
-            Box::pin(NfcStateStream { inner: stream, ctx })
-        } else {
-            tracing::error!(
-                "Attempted to start nfc credential flow, but no request context was found."
-            );
-            todo!("Handle error when context is not set up.")
-        }
+    ) -> Pin<Box<dyn Stream<Item = DeviceStateUpdate> + Send + 'static>> {
+        let usb = self
+            .get_usb_credential()
+            .await
+            .map(DeviceStateUpdate::from)
+            .boxed();
+        /*
+        let nfc = self
+            .get_nfc_credential()
+            .await
+            .map(DeviceStateUpdate::from)
+            .boxed();
+        */
+        let hybrid = self
+            .get_hybrid_credential()
+            .await
+            .map(DeviceStateUpdate::from)
+            .boxed();
+        futures::stream::select_all([usb, /* nfc, */ hybrid]).boxed()
     }
 }
 
@@ -309,6 +337,40 @@ where
     }
 }
 
+pub enum DeviceStateUpdate {
+    Hybrid(HybridState),
+    Nfc(NfcState),
+    Usb(UsbState),
+}
+
+impl From<DeviceStateUpdate> for BackgroundEvent {
+    fn from(value: DeviceStateUpdate) -> Self {
+        match value {
+            DeviceStateUpdate::Hybrid(state) => (&state).into(),
+            DeviceStateUpdate::Nfc(state) => (&state).into(),
+            DeviceStateUpdate::Usb(state) => (&state).into(),
+        }
+    }
+}
+
+impl From<HybridState> for DeviceStateUpdate {
+    fn from(value: HybridState) -> Self {
+        Self::Hybrid(value)
+    }
+}
+
+impl From<NfcState> for DeviceStateUpdate {
+    fn from(value: NfcState) -> Self {
+        Self::Nfc(value)
+    }
+}
+
+impl From<UsbState> for DeviceStateUpdate {
+    fn from(value: UsbState) -> Self {
+        Self::Usb(value)
+    }
+}
+
 fn complete_request(ctx: &Mutex<Option<RequestContext>>, response: CredentialResponse) {
     if let Some(ctx) = ctx.lock().unwrap().take() {
         ctx.send_response(Ok(response));