Merge branch 'release-0.7.0'

8 files changed, 33 insertions, 37 deletions

diff --git a/src/auth.rs b/src/auth.rs
index 6748ca1..fe2f7f2 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -8,8 +8,6 @@ use std::ops;
 use std::os::raw::c_char;
 use std::os::raw::c_int;
 
-use nitrokey_sys;
-
 use crate::config::{Config, RawConfig};
 use crate::device::{Device, DeviceWrapper, Pro, Storage};
 use crate::error::Error;
diff --git a/src/device/mod.rs b/src/device/mod.rs
index 067fdf6..c84faa1 100644
--- a/src/device/mod.rs
+++ b/src/device/mod.rs
@@ -10,8 +10,6 @@ use std::ffi;
 use std::fmt;
 use std::str;
 
-use nitrokey_sys;
-
 use crate::auth::Authenticate;
 use crate::config::{Config, RawConfig};
 use crate::error::{CommunicationError, Error, LibraryError};
@@ -225,9 +223,8 @@ fn get_hidapi_serial_number(serial_number: &str) -> Option<SerialNumber> {
         return None;
     }
 
-    let iter = serial_number.char_indices().rev();
-    let first_non_null = iter.skip_while(|(_, c)| *c == '0').next();
-    if let Some((i, _)) = first_non_null {
+    let mut iter = serial_number.char_indices().rev();
+    if let Some((i, _)) = iter.find(|(_, c)| *c != '0') {
         let substr = if len - i < 8 {
             // The last eight characters contain at least one non-zero character --> use them
             serial_number.split_at(len - 8).1
diff --git a/src/device/pro.rs b/src/device/pro.rs
index 591b730..0d5443e 100644
--- a/src/device/pro.rs
+++ b/src/device/pro.rs
@@ -1,8 +1,6 @@
 // Copyright (C) 2018-2019 Robin Krahl <robin.krahl@ireas.org>
 // SPDX-License-Identifier: MIT
 
-use nitrokey_sys;
-
 use crate::device::{Device, Model, Status};
 use crate::error::Error;
 use crate::otp::GenerateOtp;
diff --git a/src/device/storage.rs b/src/device/storage.rs
index 5669a91..a18d94f 100644
--- a/src/device/storage.rs
+++ b/src/device/storage.rs
@@ -5,8 +5,6 @@ use std::convert::TryFrom as _;
 use std::fmt;
 use std::ops;
 
-use nitrokey_sys;
-
 use crate::device::{Device, FirmwareVersion, Model, SerialNumber, Status};
 use crate::error::{CommandError, Error};
 use crate::otp::GenerateOtp;
diff --git a/src/error.rs b/src/error.rs
index 7bea3f2..1aa1793 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -21,9 +21,7 @@ pub enum Error {
     /// A library usage error.
     LibraryError(LibraryError),
     /// An error that occurred due to a poisoned lock.
-    PoisonError(sync::PoisonError<sync::MutexGuard<'static, crate::Manager>>),
-    /// An error that occurred during random number generation.
-    RandError(Box<dyn error::Error>),
+    PoisonError,
     /// An error that is caused by an unexpected value returned by libnitrokey.
     UnexpectedError(String),
     /// An unknown error returned by libnitrokey.
@@ -72,14 +70,14 @@ impl From<str::Utf8Error> for Error {
     }
 }
 
-impl From<sync::PoisonError<sync::MutexGuard<'static, crate::Manager>>> for Error {
-    fn from(error: sync::PoisonError<sync::MutexGuard<'static, crate::Manager>>) -> Self {
-        Error::PoisonError(error)
+impl<T> From<sync::PoisonError<T>> for Error {
+    fn from(_error: sync::PoisonError<T>) -> Self {
+        Error::PoisonError
     }
 }
 
-impl From<sync::TryLockError<sync::MutexGuard<'static, crate::Manager>>> for Error {
-    fn from(error: sync::TryLockError<sync::MutexGuard<'static, crate::Manager>>) -> Self {
+impl<T> From<sync::TryLockError<T>> for Error {
+    fn from(error: sync::TryLockError<T>) -> Self {
         match error {
             sync::TryLockError::Poisoned(err) => err.into(),
             sync::TryLockError::WouldBlock => Error::ConcurrentAccessError,
@@ -100,8 +98,7 @@ impl error::Error for Error {
             Error::CommunicationError(ref err) => Some(err),
             Error::ConcurrentAccessError => None,
             Error::LibraryError(ref err) => Some(err),
-            Error::PoisonError(ref err) => Some(err),
-            Error::RandError(ref err) => Some(err.as_ref()),
+            Error::PoisonError => None,
             Error::UnexpectedError(_) => None,
             Error::UnknownError(_) => None,
             Error::UnsupportedModelError => None,
@@ -117,8 +114,7 @@ impl fmt::Display for Error {
             Error::CommunicationError(ref err) => write!(f, "Communication error: {}", err),
             Error::ConcurrentAccessError => write!(f, "Internal error: concurrent access"),
             Error::LibraryError(ref err) => write!(f, "Library error: {}", err),
-            Error::PoisonError(_) => write!(f, "Internal error: poisoned lock"),
-            Error::RandError(ref err) => write!(f, "RNG error: {}", err),
+            Error::PoisonError => write!(f, "Internal error: poisoned lock"),
             Error::UnexpectedError(ref s) => write!(f, "An unexpected error occurred: {}", s),
             Error::UnknownError(ref err) => write!(f, "Unknown error: {}", err),
             Error::UnsupportedModelError => write!(f, "Unsupported Nitrokey model"),
@@ -271,3 +267,22 @@ impl fmt::Display for LibraryError {
         })
     }
 }
+
+// build our own static assertion that Error implements error::Error, Send, Sync, 'static
+
+struct Helper<T>(T);
+
+trait Assert {
+    fn assert() -> bool;
+}
+
+impl<T: error::Error + Send + Sync + 'static> Assert for Helper<T> {
+    fn assert() -> bool {
+        true
+    }
+}
+
+#[allow(unused)]
+fn assert_error_impl() {
+    let _ = Helper::<Error>::assert();
+}
diff --git a/src/lib.rs b/src/lib.rs
index 92247d7..5b72d63 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -133,8 +133,6 @@ use std::marker;
 use std::ptr::NonNull;
 use std::sync;
 
-use nitrokey_sys;
-
 pub use crate::auth::{Admin, Authenticate, User};
 pub use crate::config::Config;
 pub use crate::device::{
@@ -472,13 +470,10 @@ pub fn take() -> Result<sync::MutexGuard<'static, Manager>, Error> {
 /// [`ConcurrentAccessError`]: struct.Error.html#variant.ConcurrentAccessError
 /// [`Manager`]: struct.Manager.html
 pub fn force_take() -> Result<sync::MutexGuard<'static, Manager>, Error> {
-    match take() {
-        Ok(guard) => Ok(guard),
-        Err(err) => match err {
-            Error::PoisonError(err) => Ok(err.into_inner()),
-            err => Err(err),
-        },
-    }
+    MANAGER.try_lock().or_else(|err| match err {
+        sync::TryLockError::Poisoned(err) => Ok(err.into_inner()),
+        sync::TryLockError::WouldBlock => Err(Error::ConcurrentAccessError),
+    })
 }
 
 /// List all connected Nitrokey devices.
diff --git a/src/otp.rs b/src/otp.rs
index 4667aff..1d5f507 100644
--- a/src/otp.rs
+++ b/src/otp.rs
@@ -3,8 +3,6 @@
 
 use std::ffi::CString;
 
-use nitrokey_sys;
-
 use crate::error::Error;
 use crate::util::{get_command_result, get_cstring, result_from_string};
 
diff --git a/src/pws.rs b/src/pws.rs
index 3398deb..93294c5 100644
--- a/src/pws.rs
+++ b/src/pws.rs
@@ -1,9 +1,6 @@
 // Copyright (C) 2018-2019 Robin Krahl <robin.krahl@ireas.org>
 // SPDX-License-Identifier: MIT
 
-use libc;
-use nitrokey_sys;
-
 use crate::device::{Device, DeviceWrapper, Pro, Storage};
 use crate::error::{CommandError, Error};
 use crate::util::{get_command_result, get_cstring, get_last_error, result_from_string};