remove warnings around initiator loading. cleaner error handling remains todo.

bffhd/actors/mod.rs

@@ -12,7 +12,7 @@ use std::future::Future;
 
 use std::pin::Pin;
 
-use miette::{Diagnostic, IntoDiagnostic};
+use miette::Diagnostic;
 use std::task::{Context, Poll};
 use std::time::Duration;
 use thiserror::Error;

bffhd/authentication/fabfire/server.rs

@@ -2,7 +2,6 @@ use desfire::desfire::desfire::MAX_BYTES_PER_TRANSACTION;
 use desfire::desfire::Desfire;
 use desfire::error::Error as DesfireError;
 use desfire::iso7816_4::apduresponse::APDUResponse;
-use rsasl::callback::SessionData;
 use rsasl::mechanism::{
     Authentication, Demand, DemandReply, MechanismData, MechanismError, MechanismErrorKind,
     Provider, State, ThisProvider,
@@ -13,7 +12,6 @@ use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
 use std::fmt::{Debug, Display, Formatter};
 use std::io::Write;
-use std::sync::Arc;
 
 use crate::authentication::fabfire::FabFireCardKey;
 
@@ -104,6 +102,7 @@ struct AuthInfo {
     iv: Vec<u8>,
 }
 
+#[allow(non_camel_case_types)]
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(tag = "Cmd")]
 enum CardCommand {

bffhd/authentication/fabfire_bin/server.rs

@@ -2,7 +2,6 @@ use desfire::desfire::desfire::MAX_BYTES_PER_TRANSACTION;
 use desfire::desfire::Desfire;
 use desfire::error::Error as DesfireError;
 use desfire::iso7816_4::apduresponse::APDUResponse;
-use rsasl::callback::SessionData;
 use rsasl::mechanism::{
     Authentication, Demand, DemandReply, MechanismData, MechanismError, MechanismErrorKind,
     Provider, State, ThisProvider,
@@ -13,7 +12,6 @@ use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
 use std::fmt::{Debug, Display, Formatter};
 use std::io::Write;
-use std::sync::Arc;
 
 use crate::authentication::fabfire::FabFireCardKey;
 use crate::CONFIG;

bffhd/authentication/mod.rs

@@ -26,7 +26,7 @@ impl Callback {
 impl SessionCallback for Callback {
     fn callback(
         &self,
-        session_data: &SessionData,
+        _session_data: &SessionData,
         context: &Context,
         request: &mut Request,
     ) -> Result<(), SessionError> {

bffhd/capnp/authenticationsystem.rs

@@ -4,10 +4,8 @@ use capnp_rpc::pry;
 use rsasl::mechname::Mechname;
 use rsasl::prelude::State as SaslState;
 use rsasl::prelude::{MessageSent, Session};
-use rsasl::property::AuthId;
 use std::fmt;
 use std::fmt::{Formatter, Write};
-use std::io::Cursor;
 use tracing::Span;
 
 use crate::authentication::V;
@@ -115,7 +113,7 @@ impl AuthenticationSystem for Authentication {
                 f.write_char(')')
             }
         }
-        let mut response;
+        let response;
 
         let mut builder = results.get();
         if let State::Running(mut session, manager) =

bffhd/capnp/machine.rs

@@ -211,7 +211,6 @@ impl ManageServer for Machine {
         mut result: manage::GetMachineInfoExtendedResults,
     ) -> Promise<(), ::capnp::Error> {
         let mut builder = result.get();
-        let user = User::new_self(self.session.clone());
         User::build_optional(
             &self.session,
             self.resource.get_current_user(),

bffhd/capnp/mod.rs

@@ -5,11 +5,11 @@ use async_net::TcpListener;
 use capnp_rpc::rpc_twoparty_capnp::Side;
 use capnp_rpc::twoparty::VatNetwork;
 use capnp_rpc::RpcSystem;
-use executor::prelude::{Executor, GroupId, SupervisionRegistry};
+use executor::prelude::{Executor, SupervisionRegistry};
 use futures_rustls::server::TlsStream;
 use futures_rustls::TlsAcceptor;
 use futures_util::stream::FuturesUnordered;
-use futures_util::{stream, AsyncRead, AsyncWrite, FutureExt, StreamExt};
+use futures_util::{stream, AsyncRead, AsyncWrite, StreamExt};
 
 use std::future::Future;
 use std::io;

bffhd/capnp/permissionsystem.rs

@@ -1,4 +1,3 @@
-use crate::authorization::roles::Role;
 use crate::Roles;
 use api::permissionsystem_capnp::permission_system::info::{
     GetRoleListParams, GetRoleListResults, Server as PermissionSystem,
@@ -37,7 +36,7 @@ impl PermissionSystem for Permissions {
 
         tracing::trace!("method call");
         let roles = self.roles.list().collect::<Vec<&String>>();
-        let mut builder = results.get();
+        let builder = results.get();
         let mut b = builder.init_role_list(roles.len() as u32);
         for (i, role) in roles.into_iter().enumerate() {
             let mut role_builder = b.reborrow().get(i as u32);

bffhd/capnp/user.rs

@@ -109,7 +109,7 @@ impl manage::Server for User {
         if let Some(mut user) = self.session.users.get_user(uid) {
             if let Ok(true) = user.check_password(old_pw.as_bytes()) {
                 user.set_pw(new_pw.as_bytes());
-                self.session.users.put_user(uid, &user);
+                pry!(self.session.users.put_user(uid, &user));
             }
         }
         Promise::ok(())
@@ -143,9 +143,9 @@ impl admin::Server for User {
             // Only update if needed
             if !target.userdata.roles.iter().any(|r| r.as_str() == rolename) {
                 target.userdata.roles.push(rolename.to_string());
-                self.session
+                pry!(self.session
                     .users
-                    .put_user(self.user.get_username(), &target);
+                    .put_user(self.user.get_username(), &target));
             }
         }
 
@@ -168,9 +168,9 @@ impl admin::Server for User {
             // Only update if needed
             if target.userdata.roles.iter().any(|r| r.as_str() == rolename) {
                 target.userdata.roles.retain(|r| r.as_str() != rolename);
-                self.session
+                pry!(self.session
                     .users
-                    .put_user(self.user.get_username(), &target);
+                    .put_user(self.user.get_username(), &target));
             }
         }
 
@@ -185,7 +185,7 @@ impl admin::Server for User {
         let uid = self.user.get_username();
         if let Some(mut user) = self.session.users.get_user(uid) {
             user.set_pw(new_pw.as_bytes());
-            self.session.users.put_user(uid, &user);
+            pry!(self.session.users.put_user(uid, &user));
         }
         Promise::ok(())
     }
@@ -221,7 +221,7 @@ impl card_d_e_s_fire_e_v2::Server for User {
                 Vec::new()
             });
         if !tk.is_empty() {
-            let mut b = results.get();
+            let b = results.get();
             let mut lb = b.init_token_list(1);
             lb.set(0, &tk[..]);
         }
@@ -299,7 +299,8 @@ impl card_d_e_s_fire_e_v2::Server for User {
             .insert("cardtoken".to_string(), token.to_string());
         user.userdata.kv.insert("cardkey".to_string(), card_key);
 
-        self.session.users.put_user(self.user.get_username(), &user);
+        pry!(self.session.users.put_user(self.user.get_username(), &user));
+
         Promise::ok(())
     }
 
@@ -338,7 +339,7 @@ impl card_d_e_s_fire_e_v2::Server for User {
             }
         }
 
-        self.session.users.put_user(self.user.get_username(), &user);
+        pry!(self.session.users.put_user(self.user.get_username(), &user));
 
         Promise::ok(())
     }

bffhd/capnp/user_system.rs

@@ -84,13 +84,13 @@ impl manage::Server for Users {
             "method call"
         );
 
-        let mut builder = result.get();
+        let builder = result.get();
 
         if !username.is_empty() && !password.is_empty() {
             if self.session.users.get_user(username).is_none() {
                 let user = db::User::new_with_plain_pw(username, password);
-                self.session.users.put_user(username, &user);
+                pry!(self.session.users.put_user(username, &user));
-                let mut builder = builder.init_successful();
+                let builder = builder.init_successful();
                 User::fill(&self.session, user, builder);
             } else {
                 let mut builder = builder.init_failed();

bffhd/config/dhall.rs

@@ -1,8 +1,6 @@
 use std::collections::HashMap;
 use std::default::Default;
-use std::error::Error;
+use std::fmt::Debug;
-use std::fmt::{Debug, Display};
-use std::marker::PhantomData;
 use std::path::PathBuf;
 
 use serde::{Deserialize, Serialize};
@@ -12,7 +10,6 @@ use crate::authorization::roles::Role;
 use crate::capnp::{Listen, TlsListen};
 use crate::logging::LogConfig;
 
-use miette::IntoDiagnostic;
 use std::path::Path;
 
 #[derive(Debug)]

bffhd/config/mod.rs

@@ -38,13 +38,15 @@ pub fn read(file: impl AsRef<Path>) -> Result<Config, ConfigError> {
     if !path.is_file() {
         return Err(ConfigError::NotAFile(path.to_string_lossy().to_string()));
     }
-    let mut config = dhall::read_config_file(file)?;
+    let config = dhall::read_config_file(file)?;
-    for (envvar, value) in std::env::vars() {
+    // TODO: configuration by environment variables?
-        match envvar.as_str() {
+    //       but rather in in a separate function
-            // Do things like this?
+    // for (envvar, value) in std::env::vars() {
-            // "BFFH_LOG" => config.logging.filter = Some(value),
+    //     match envvar.as_str() {
-            _ => {}
+    //         // Do things like this?
-        }
+    //         // "BFFH_LOG" => config.logging.filter = Some(value),
-    }
+    //         _ => {}
+    //     }
+    // }
     Ok(config)
 }

bffhd/db/mod.rs

@@ -1,10 +1,13 @@
 use thiserror::Error;
 
+// for converting a database error into a failed promise
+use capnp;
+
 mod raw;
 
-use miette::{Diagnostic, LabeledSpan, Severity, SourceCode};
+use miette::{Diagnostic, Severity};
 pub use raw::RawDB;
-use std::fmt::{Debug, Display, Formatter};
+use std::fmt::{Debug, Display};
 
 mod typed;
 pub use typed::{Adapter, AlignedAdapter, ArchivedValue, DB};
@@ -79,3 +82,9 @@ impl Diagnostic for Error {
         None
     }
 }
+
+impl From<Error> for capnp::Error {
+    fn from(dberr: Error) -> capnp::Error {
+        capnp::Error::failed(format!("database error: {}", dberr.to_string()))
+    }
+}

bffhd/db/raw.rs

@@ -1,4 +1,3 @@
-use super::Result;
 use lmdb::{DatabaseFlags, Environment, RwTransaction, Transaction, WriteFlags};
 
 #[derive(Debug, Clone)]

bffhd/error.rs

@@ -1,4 +1,4 @@
-use miette::{Diagnostic, LabeledSpan, Severity, SourceCode};
+use miette::{Diagnostic, Severity};
 use std::error;
 use std::fmt::{Display, Formatter};
 use std::io;

bffhd/initiators/dummy.rs

@@ -5,14 +5,11 @@ use super::Initiator;
 use crate::initiators::InitiatorCallbacks;
 use crate::resources::modules::fabaccess::Status;
 use crate::session::SessionHandle;
-use crate::users::UserRef;
 use async_io::Timer;
 use futures_util::future::BoxFuture;
 use futures_util::ready;
-use lmdb::Stat;
 use std::collections::HashMap;
 use std::future::Future;
-use std::mem;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::time::{Duration, Instant};
@@ -64,10 +61,7 @@ impl Future for Dummy {
             match &mut self.state {
                 DummyState::Empty => {
                     tracing::trace!("Dummy initiator is empty, initializing…");
-                    mem::replace(
+                    self.state = DummyState::Sleeping(Self::timer(), Some(Status::Free));
-                        &mut self.state,
-                        DummyState::Sleeping(Self::timer(), Some(Status::Free)),
-                    );
                 }
                 DummyState::Sleeping(timer, next) => {
                     tracing::trace!("Sleep timer exists, polling it.");
@@ -78,7 +72,7 @@ impl Future for Dummy {
 
                     let status = next.take().unwrap();
                     let f = self.flip(status);
-                    mem::replace(&mut self.state, DummyState::Updating(f));
+                    self.state = DummyState::Updating(f);
                 }
                 DummyState::Updating(f) => {
                     tracing::trace!("Update future exists, polling it .");
@@ -87,10 +81,7 @@ impl Future for Dummy {
 
                     tracing::trace!("Update future completed, sleeping!");
 
-                    mem::replace(
+                    self.state = DummyState::Sleeping(Self::timer(), Some(next));
-                        &mut self.state,
-                        DummyState::Sleeping(Self::timer(), Some(next)),
-                    );
                 }
             }
         }

bffhd/initiators/mod.rs

@@ -3,22 +3,15 @@ use crate::initiators::process::Process;
 use crate::resources::modules::fabaccess::Status;
 use crate::session::SessionHandle;
 use crate::{
-    AuthenticationHandle, Config, MachineState, Resource, ResourcesHandle, SessionManager,
+    AuthenticationHandle, Config, Resource, ResourcesHandle, SessionManager,
 };
-use async_compat::CompatExt;
 use executor::prelude::Executor;
 use futures_util::ready;
-use miette::IntoDiagnostic;
-use rumqttc::ConnectReturnCode::Success;
-use rumqttc::{AsyncClient, ConnectionError, Event, Incoming, MqttOptions};
 use std::collections::HashMap;
-use std::fmt::Display;
 use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
-use std::time::Duration;
 use tracing::Span;
-use url::Url;
 
 mod dummy;
 mod process;
@@ -107,7 +100,7 @@ pub fn load(
     config: &Config,
     resources: ResourcesHandle,
     sessions: SessionManager,
-    authentication: AuthenticationHandle,
+    _authentication: AuthenticationHandle,
 ) -> miette::Result<()> {
     let span = tracing::info_span!("loading initiators");
     let _guard = span.enter();

bffhd/initiators/process.rs

@@ -1,10 +1,9 @@
 use super::Initiator;
 use super::InitiatorCallbacks;
 use crate::resources::modules::fabaccess::Status;
-use crate::resources::state::State;
 use crate::utils::linebuffer::LineBuffer;
 use async_process::{Child, ChildStderr, ChildStdout, Command, Stdio};
-use futures_lite::{ready, AsyncRead};
+use futures_lite::AsyncRead;
 use miette::{miette, IntoDiagnostic};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -117,7 +116,7 @@ impl ProcessState {
 impl Future for Process {
     type Output = ();
 
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         if let Process {
             state: Some(state),
             buffer,

bffhd/lib.rs

@@ -9,7 +9,6 @@
 //! The entry point of bffhd can be found in [bin/bffhd/main.rs](../bin/bffhd/main.rs)
 
 use miette::Diagnostic;
-use std::io;
 use thiserror::Error;
 
 pub mod config;
@@ -48,7 +47,6 @@ mod tls;
 use std::sync::Arc;
 
 use futures_util::{FutureExt, StreamExt};
-use miette::{Context, IntoDiagnostic, Report};
 use once_cell::sync::OnceCell;
 
 use crate::audit::AuditLog;
@@ -89,6 +87,7 @@ impl error::Description for SignalHandlerErr {
 }
 
 #[derive(Debug, Error, Diagnostic)]
+// TODO 0.5: #[non_exhaustive]
 pub enum BFFHError {
     #[error("DB operation failed")]
     DBError(
@@ -212,7 +211,9 @@ impl Diflouroborane {
             self.resources.clone(),
             sessionmanager.clone(),
             authentication.clone(),
-        );
+        ).expect("initializing initiators failed");
+        // TODO 0.5: error handling. Add variant to BFFHError
+
         actors::load(self.executor.clone(), &self.config, self.resources.clone())?;
 
         let tlsconfig = TlsConfig::new(self.config.tlskeylog.as_ref(), !self.config.is_quiet())?;
@@ -231,13 +232,13 @@ impl Diflouroborane {
         self.executor.spawn(apiserver.handle_until(rx));
 
         let f = async {
-            let mut sig = None;
+            let mut sig;
             while {
                 sig = signals.next().await;
                 sig.is_none()
             } {}
             tracing::info!(signal = %sig.unwrap(), "Received signal");
-            tx.send(());
+            _ = tx.send(()); // ignore result, as an Err means that the executor we want to stop has already stopped
         };
 
         self.executor.run(f);

bffhd/logging.rs

@@ -2,8 +2,7 @@ use serde::{Deserialize, Serialize};
 use std::path::Path;
 use tracing_subscriber::fmt::format::Format;
 use tracing_subscriber::prelude::*;
-use tracing_subscriber::reload::Handle;
+use tracing_subscriber::EnvFilter;
-use tracing_subscriber::{reload, EnvFilter};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LogConfig {

bffhd/resources/mod.rs

@@ -85,10 +85,13 @@ impl Inner {
         self.db.put(&self.id.as_bytes(), &state).unwrap();
         tracing::trace!("Updated DB, sending update signal");
 
-        AUDIT
+        let res = AUDIT
             .get()
             .unwrap()
             .log(self.id.as_str(), &format!("{}", state));
+        if let Err(e) = res {
+            tracing::error!("Writing to the audit log failed for {} {}: {e}", self.id.as_str(), state);
+        }
 
         self.signal.set(state);
         tracing::trace!("Sent update signal");
@@ -161,7 +164,7 @@ impl Resource {
 
     fn set_state(&self, state: MachineState) {
         let mut serializer = AllocSerializer::<1024>::default();
-        serializer.serialize_value(&state);
+        serializer.serialize_value(&state).expect("serializing a MachineState shoud be infallible");
         let archived = ArchivedValue::new(serializer.into_serializer().into_inner());
         self.inner.set_state(archived)
     }

bffhd/resources/modules/fabaccess.rs

@@ -3,7 +3,6 @@ use crate::utils::oid::ObjectIdentifier;
 use once_cell::sync::Lazy;
 use rkyv::{Archive, Archived, Deserialize, Infallible};
 use std::fmt;
-use std::fmt::Write;
 use std::str::FromStr;
 
 //use crate::oidvalue;

bffhd/resources/state/db.rs

@@ -3,10 +3,8 @@ use thiserror::Error;
 use crate::db;
 use crate::db::{AlignedAdapter, ArchivedValue, RawDB, DB};
 use lmdb::{DatabaseFlags, Environment, EnvironmentFlags, Transaction, WriteFlags};
-use miette::{Diagnostic, LabeledSpan, Severity, SourceCode};
+use miette::Diagnostic;
-use std::any::TypeId;
+use std::fmt::Debug;
-use std::error::Error;
-use std::fmt::{Debug, Display, Formatter};
 use std::{path::Path, sync::Arc};
 
 use crate::resources::state::State;
@@ -54,8 +52,8 @@ impl StateDB {
     }
 
     pub fn open_with_env(env: Arc<Environment>) -> Result<Self, StateDBError> {
-        let db = unsafe { RawDB::open(&env, Some("state")) };
+        let db = RawDB::open(&env, Some("state"))
-        let db = db.map_err(|e| StateDBError::Open(e.into()))?;
+            .map_err(|e| StateDBError::Open(e.into()))?;
         Ok(Self::new(env, db))
     }
 
@@ -66,8 +64,8 @@ impl StateDB {
 
     pub fn create_with_env(env: Arc<Environment>) -> Result<Self, StateDBError> {
         let flags = DatabaseFlags::empty();
-        let db = unsafe { RawDB::create(&env, Some("state"), flags) };
+        let db = RawDB::create(&env, Some("state"), flags)
-        let db = db.map_err(|e| StateDBError::Create(e.into()))?;
+            .map_err(|e| StateDBError::Create(e.into()))?;
 
         Ok(Self::new(env, db))
     }

bffhd/resources/state/mod.rs

@@ -1,5 +1,5 @@
 use std::fmt::{Debug, Display, Formatter};
-use std::{fmt, hash::Hasher};
+use std::fmt;
 
 use std::ops::Deref;
 

bffhd/resources/state/value.rs

@@ -14,8 +14,6 @@ use inventory;
 
 use rkyv::ser::{ScratchSpace, Serializer};
 
-use serde::ser::SerializeMap;
-
 use std::collections::HashMap;
 
 use std::ops::Deref;

bffhd/users/db.rs

@@ -2,7 +2,6 @@ use lmdb::{DatabaseFlags, Environment, RwTransaction, Transaction, WriteFlags};
 use rkyv::Infallible;
 use std::collections::HashMap;
 
-use miette::{Context, IntoDiagnostic};
 use std::sync::Arc;
 
 use crate::db;
@@ -183,8 +182,8 @@ impl UserDB {
     }
 
     pub fn clear_txn(&self, txn: &mut RwTransaction) -> Result<(), db::Error> {
-        self.db.clear(txn);
+        // TODO: why was the result ignored here?
-        Ok(())
+        self.db.clear(txn)
     }
 
     pub fn get_all(&self) -> Result<HashMap<String, UserData>, db::Error> {

bffhd/users/mod.rs

@@ -7,8 +7,7 @@ use std::collections::HashMap;
 use std::fmt::{Display, Formatter};
 use std::io::Write;
 
-use clap::ArgMatches;
+use miette::{Diagnostic, IntoDiagnostic, SourceSpan};
-use miette::{Context, Diagnostic, IntoDiagnostic, SourceOffset, SourceSpan};
 use std::path::Path;
 use std::sync::Arc;
 

build.rs

@@ -1,4 +1,4 @@
 fn main() {
     // Extract build-time information using the `shadow-rs` crate
-    shadow_rs::new();
+    shadow_rs::new().unwrap();
 }