server: Load and dispatch login/default collection/keyring

client/src/portal/secret.rs

@@ -1,3 +1,4 @@
+use rand::Rng;
 use zeroize::{Zeroize, ZeroizeOnDrop};
 
 /// Secret used to unlock the keyring.
@@ -17,3 +18,9 @@ impl std::ops::Deref for Secret {
         &self.0
     }
 }
+
+impl Secret {
+    pub fn random() -> Self {
+        Self(rand::thread_rng().gen::<[u8; 8]>().to_vec())
+    }
+}

server/Cargo.toml

@@ -9,7 +9,9 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
+clap.workspace = true
 oo7 = { workspace = true, features = ["unstable"] }
+rpassword = "7.3"
 serde.workspace = true
 tokio = { workspace = true, features = ["full"] }
 tracing = "0.1"

server/src/collection.rs

@@ -6,12 +6,17 @@ use std::{
     time::{Duration, SystemTime},
 };
 
-use oo7::dbus::api::{Properties, SecretInner};
+use oo7::{
+    dbus::{
+        api::{Properties, SecretInner},
+        ServiceError,
+    },
+    portal::Keyring,
+};
 use tokio::sync::{Mutex, RwLock};
 use zbus::{interface, zvariant};
 use zvariant::{ObjectPath, OwnedObjectPath};
 
-use super::Result;
 use crate::{item, service_manager::ServiceManager};
 
 #[derive(Debug)]
@@ -25,6 +30,8 @@ pub struct Collection {
     modified: Mutex<Duration>,
     // Other attributes
     alias: Mutex<String>,
+    #[allow(unused)]
+    keyring: Arc<Keyring>,
     manager: Arc<Mutex<ServiceManager>>,
     n_items: RwLock<i32>,
     path: OwnedObjectPath,
@@ -33,12 +40,15 @@ pub struct Collection {
 #[interface(name = "org.freedesktop.Secret.Collection")]
 impl Collection {
     #[zbus(out_args("prompt"))]
-    pub async fn delete(&self) -> Result<ObjectPath> {
+    pub async fn delete(&self) -> Result<ObjectPath, ServiceError> {
         todo!()
     }
 
     #[zbus(out_args("results"))]
-    pub async fn search_items(&self, _attributes: HashMap<String, String>) -> Vec<OwnedObjectPath> {
+    pub async fn search_items(
+        &self,
+        _attributes: HashMap<String, String>,
+    ) -> Result<Vec<OwnedObjectPath>, ServiceError> {
         todo!()
     }
 
@@ -48,13 +58,18 @@ impl Collection {
         _properties: Properties,
         _secret: SecretInner,
         _replace: bool,
-    ) -> Result<(OwnedObjectPath, ObjectPath)> {
+    ) -> Result<(OwnedObjectPath, ObjectPath), ServiceError> {
         todo!()
     }
 }
 
 impl Collection {
-    pub fn new(label: &str, alias: &str, manager: Arc<Mutex<ServiceManager>>) -> Self {
+    pub fn new(
+        label: &str,
+        alias: &str,
+        manager: Arc<Mutex<ServiceManager>>,
+        keyring: Arc<Keyring>,
+    ) -> Self {
         let created = SystemTime::now()
             .duration_since(SystemTime::UNIX_EPOCH)
             .unwrap();
@@ -73,6 +88,7 @@ impl Collection {
             .unwrap(),
             created,
             manager,
+            keyring,
         }
     }
 

server/src/error.rs

@@ -0,0 +1,42 @@
+use std::fmt;
+
+#[derive(Debug)]
+pub enum Error {
+    // File backend error
+    Portal(oo7::portal::Error),
+    // Zbus error
+    Zbus(zbus::Error),
+    // IO error
+    IO(std::io::Error),
+    // Empty password error
+    EmptyPassword,
+}
+
+impl From<zbus::Error> for Error {
+    fn from(err: zbus::Error) -> Self {
+        Self::Zbus(err)
+    }
+}
+
+impl From<oo7::portal::Error> for Error {
+    fn from(err: oo7::portal::Error) -> Self {
+        Self::Portal(err)
+    }
+}
+
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Self {
+        Self::IO(err)
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Portal(err) => write!(f, "Portal error {err}"),
+            Self::Zbus(err) => write!(f, "Zbus error {err}"),
+            Self::IO(err) => write!(f, "IO error {err}"),
+            Self::EmptyPassword => write!(f, "Login password can't be empty"),
+        }
+    }
+}

server/src/item.rs

@@ -1,26 +1,24 @@
 // org.freedesktop.Secret.Item
 
-use oo7::dbus::api::SecretInner;
+use oo7::dbus::{api::SecretInner, ServiceError};
 use zbus::zvariant::ObjectPath;
 
-use super::Result;
-
 #[derive(Debug)]
 pub struct Item {}
 
 #[zbus::interface(name = "org.freedesktop.Secret.Item")]
 impl Item {
     #[zbus(out_args("prompt"))]
-    pub async fn delete(&self) -> Result<ObjectPath> {
+    pub async fn delete(&self) -> Result<ObjectPath, ServiceError> {
         todo!()
     }
 
     #[zbus(out_args("secret"))]
-    pub async fn get_secret(&self, _session: ObjectPath<'_>) -> Result<SecretInner> {
+    pub async fn get_secret(&self, _session: ObjectPath<'_>) -> Result<SecretInner, ServiceError> {
         todo!()
     }
 
-    pub async fn set_secret(&self, _secret: SecretInner) -> Result<()> {
+    pub async fn set_secret(&self, _secret: SecretInner) -> Result<(), ServiceError> {
         todo!()
     }
 }

server/src/main.rs

@@ -1,20 +1,49 @@
 mod collection;
+mod error;
 mod item;
 mod prompt;
 mod service;
 mod service_manager;
 mod session;
 
-use service::{Result, Service};
+use clap::Parser;
+use oo7::portal::Secret;
+use service::Service;
+
+use crate::error::Error;
 
 const BINARY_NAME: &str = env!("CARGO_BIN_NAME");
 
+#[derive(Parser)]
+#[command(version, about, long_about = None)]
+struct Args {
+    #[arg(
+        short = 'l',
+        long,
+        default_value_t = false,
+        help = "Read a password from stdin, and use it to unlock the login keyring."
+    )]
+    login: bool,
+}
+
 #[tokio::main]
-async fn main() -> Result<()> {
+async fn main() -> Result<(), Error> {
     tracing_subscriber::fmt::init();
+    let args = Args::parse();
+    let mut secret: Option<Secret> = None;
+
+    if args.login {
+        let password = rpassword::prompt_password("Enter the login password: ")?;
+        if password.is_empty() {
+            tracing::error!("Login password can't be empty.");
+            return Err(Error::EmptyPassword);
+        }
+        secret = Some(Secret::from(password.into_bytes()));
+    }
+
     tracing::info!("Starting {}", BINARY_NAME);
 
-    Service::run().await?;
+    Service::run(secret).await?;
 
     std::future::pending::<()>().await;
 

server/src/prompt.rs

@@ -1,19 +1,18 @@
 // org.freedesktop.Secret.Prompt
 
+use oo7::dbus::ServiceError;
 use zbus::interface;
 
-use super::Result;
-
 #[derive(Debug)]
 pub struct Prompt {}
 
 #[interface(name = "org.freedesktop.Secret.Prompt")]
 impl Prompt {
-    pub async fn prompt(&self, _window_id: &str) -> Result<()> {
+    pub async fn prompt(&self, _window_id: &str) -> Result<(), ServiceError> {
         todo!()
     }
 
-    pub async fn dismiss(&self) -> Result<()> {
+    pub async fn dismiss(&self) -> Result<(), ServiceError> {
         todo!()
     }
 }