daemon: Share D-Bus connection between server and client

Author: iinuwa

credentialsd/src/dbus/flow_control.rs

@@ -11,12 +11,11 @@ use credentialsd_common::model::{
 };
 use credentialsd_common::server::{BackgroundEvent, WindowHandle};
 use futures_lite::{Stream, StreamExt};
+use tokio::sync::mpsc::Receiver;
 use tokio::sync::oneshot;
-use tokio::sync::{
-    mpsc::{self, Sender},
-    Mutex as AsyncMutex,
-};
-use zbus::connection::{Builder, Connection};
+use tokio::sync::{mpsc::Sender, Mutex as AsyncMutex};
+use tokio::task::AbortHandle;
+use zbus::connection::Connection;
 
 use crate::credential_service::ManageDevice;
 use crate::dbus::ui_control::Ceremony;
@@ -27,33 +26,23 @@ use crate::{
     model::{CredentialRequest, CredentialResponse},
 };
 
-pub const SERVICE_NAME: &str = "xyz.iinuwa.credentialsd.FlowControl";
-
 pub async fn start_flow_control_service<M: ManageDevice + Debug + Send + Sync + 'static>(
-    device_manager: M,
-) -> zbus::Result<(
-    Connection,
-    Sender<(
+    conn: Connection,
+    mut listener: Receiver<(
         CredentialRequest,
         RequestingApplication,
         Option<WindowHandle>, // Client window handle
         oneshot::Sender<Result<CredentialResponse, CredentialServiceError>>,
     )>,
-)> {
+    device_manager: M,
+) -> zbus::Result<AbortHandle> {
     let svc = Arc::new(AsyncMutex::new(device_manager));
     let svc2 = svc.clone();
-    let conn = Builder::session()?.name(SERVICE_NAME)?.build().await?;
-    let (initiator_tx, mut initiator_rx) = mpsc::channel::<(
-        CredentialRequest,
-        RequestingApplication,
-        Option<WindowHandle>,
-        oneshot::Sender<Result<CredentialResponse, CredentialServiceError>>,
-    )>(2);
-    let conn2 = conn.clone();
-    tokio::spawn(async move {
-        while let Some((msg, requesting_app, window_handle, tx)) = initiator_rx.recv().await {
+
+    let task = tokio::spawn(async move {
+        while let Some((msg, requesting_app, window_handle, tx)) = listener.recv().await {
             let svc = svc2.clone();
-            let ui_control_client = UiControlServiceClient::new(conn2.clone());
+            let ui_control_client = UiControlServiceClient::new(conn.clone());
             if let Err(_) =
                 tx.send(handle(svc, ui_control_client, msg, requesting_app, window_handle).await)
             {
@@ -63,7 +52,7 @@ pub async fn start_flow_control_service<M: ManageDevice + Debug + Send + Sync +
             }
         }
     });
-    Ok((conn, initiator_tx))
+    Ok(task.abort_handle())
 }
 
 async fn handle<M: ManageDevice + Debug + Send + Sync + 'static, UC: UiController + Debug>(

credentialsd/src/gateway/dbus.rs

@@ -18,11 +18,10 @@ use credentialsd_common::{
     },
 };
 
-use crate::webauthn::AppId;
+use crate::{webauthn::AppId, DBUS_SERVICE_NAME};
 
 use super::{check_origin_from_app, GatewayService, RequestContext};
 
-pub const SERVICE_NAME: &str = "xyz.iinuwa.credentialsd.Credentials";
 pub const PORTAL_SERVICE_PATH: &str = "/org/freedesktop/portal/desktop";
 
 pub(super) async fn start_dbus_gateway(
@@ -32,7 +31,7 @@ pub(super) async fn start_dbus_gateway(
         .inspect_err(|err| {
             tracing::error!("Failed to connect to D-Bus session: {err}");
         })?
-        .name(SERVICE_NAME)?
+        .name(DBUS_SERVICE_NAME)?
         .serve_at(
             PORTAL_SERVICE_PATH,
             CredentialPortalGateway {

credentialsd/src/main.rs

@@ -7,14 +7,17 @@ mod webauthn;
 use std::error::Error;
 
 use credential_service::nfc::InProcessNfcHandler;
+use tokio::sync::mpsc;
 
 use crate::{
     credential_service::{
         hybrid::InternalHybridHandler, usb::InProcessUsbHandler, CredentialService,
     },
-    dbus::{CredentialRequestControllerClient, UiControlServiceClient},
+    dbus::CredentialRequestControllerClient,
 };
 
+pub const DBUS_SERVICE_NAME: &str = "xyz.iinuwa.credentialsd.Credentials";
+
 #[tokio::main]
 async fn main() {
     // Initialize logger
@@ -25,29 +28,32 @@ async fn main() {
 }
 
 async fn run() -> Result<(), Box<dyn Error>> {
-    print!("Connecting to D-Bus as client...\t");
-    let dbus_client_conn = zbus::connection::Builder::session()?.build().await?;
+    print!("Starting D-Bus public client service...");
+    let (incoming_request_tx, incoming_request_rx) = mpsc::channel(2);
+    let request_controller = CredentialRequestControllerClient {
+        initiator: incoming_request_tx,
+    };
+    let dbus_conn = gateway::start_gateway(request_controller).await?;
     println!(" ✅");
 
-    print!("Starting D-Bus UI -> Credential control service...");
+    // initialize client to interact with UI
     let credential_service = CredentialService::new(
         InternalHybridHandler::new(),
         InProcessNfcHandler {},
         InProcessUsbHandler {},
     );
-    let (_flow_control_conn, initiator) =
-        dbus::start_flow_control_service(credential_service).await?;
-    println!(" ✅");
-
-    print!("Starting D-Bus public client service...");
-    let initiator = CredentialRequestControllerClient { initiator };
-    let _gateway_conn = gateway::start_gateway(initiator).await?;
-    println!(" ✅");
+    let flow_control_svc = dbus::start_flow_control_service(
+        dbus_conn.clone(),
+        incoming_request_rx,
+        credential_service,
+    )
+    .await?;
 
     println!("Waiting for messages...");
     tokio::signal::ctrl_c()
         .await
         .map_err(|err| format!("Failed to wait for shutdown signals: {err}. Shutting down"))?;
 
+    flow_control_svc.abort();
     Ok(())
 }