From d0f63513bb935d3d931c86a1ab7b68d6ed44bf27 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Thu, 17 Jan 2019 01:53:08 +0000
Subject: Move util::CommandError to the new error module

This prepares the refactoring of util::CommandError into multiple enums.
---
 src/error.rs | 114 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 src/error.rs

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
new file mode 100644
index 0000000..6aeeef8
--- /dev/null
+++ b/src/error.rs
@@ -0,0 +1,114 @@
+use std::borrow;
+use std::fmt;
+use std::os::raw;
+
+/// Error types returned by Nitrokey device or by the library.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CommandError {
+    /// A packet with a wrong checksum has been sent or received.
+    WrongCrc,
+    /// A command tried to access an OTP slot that does not exist.
+    WrongSlot,
+    /// A command tried to generate an OTP on a slot that is not configured.
+    SlotNotProgrammed,
+    /// The provided password is wrong.
+    WrongPassword,
+    /// You are not authorized for this command or provided a wrong temporary
+    /// password.
+    NotAuthorized,
+    /// An error occurred when getting or setting the time.
+    Timestamp,
+    /// You did not provide a name for the OTP slot.
+    NoName,
+    /// This command is not supported by this device.
+    NotSupported,
+    /// This command is unknown.
+    UnknownCommand,
+    /// AES decryption failed.
+    AesDecryptionFailed,
+    /// An unknown error occurred.
+    Unknown(i64),
+    /// An unspecified error occurred.
+    Undefined,
+    /// You passed a string containing a null byte.
+    InvalidString,
+    /// A supplied string exceeded a length limit.
+    StringTooLong,
+    /// You passed an invalid slot.
+    InvalidSlot,
+    /// The supplied string was not in hexadecimal format.
+    InvalidHexString,
+    /// The target buffer was smaller than the source.
+    TargetBufferTooSmall,
+    /// An error occurred during random number generation.
+    RngError,
+}
+
+impl CommandError {
+    fn as_str(&self) -> borrow::Cow<'static, str> {
+        match *self {
+            CommandError::WrongCrc => {
+                "A packet with a wrong checksum has been sent or received".into()
+            }
+            CommandError::WrongSlot => "The given OTP slot does not exist".into(),
+            CommandError::SlotNotProgrammed => "The given OTP slot is not programmed".into(),
+            CommandError::WrongPassword => "The given password is wrong".into(),
+            CommandError::NotAuthorized => {
+                "You are not authorized for this command or provided a wrong temporary \
+                 password"
+                    .into()
+            }
+            CommandError::Timestamp => "An error occurred when getting or setting the time".into(),
+            CommandError::NoName => "You did not provide a name for the OTP slot".into(),
+            CommandError::NotSupported => "This command is not supported by this device".into(),
+            CommandError::UnknownCommand => "This command is unknown".into(),
+            CommandError::AesDecryptionFailed => "AES decryption failed".into(),
+            CommandError::Unknown(x) => {
+                borrow::Cow::from(format!("An unknown error occurred ({})", x))
+            }
+            CommandError::Undefined => "An unspecified error occurred".into(),
+            CommandError::InvalidString => "You passed a string containing a null byte".into(),
+            CommandError::StringTooLong => "The supplied string is too long".into(),
+            CommandError::InvalidSlot => "The given slot is invalid".into(),
+            CommandError::InvalidHexString => {
+                "The supplied string is not in hexadecimal format".into()
+            }
+            CommandError::TargetBufferTooSmall => "The target buffer is too small".into(),
+            CommandError::RngError => "An error occurred during random number generation".into(),
+        }
+    }
+}
+
+impl fmt::Display for CommandError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl From<raw::c_int> for CommandError {
+    fn from(value: raw::c_int) -> Self {
+        match value {
+            1 => CommandError::WrongCrc,
+            2 => CommandError::WrongSlot,
+            3 => CommandError::SlotNotProgrammed,
+            4 => CommandError::WrongPassword,
+            5 => CommandError::NotAuthorized,
+            6 => CommandError::Timestamp,
+            7 => CommandError::NoName,
+            8 => CommandError::NotSupported,
+            9 => CommandError::UnknownCommand,
+            10 => CommandError::AesDecryptionFailed,
+            200 => CommandError::StringTooLong,
+            201 => CommandError::InvalidSlot,
+            202 => CommandError::InvalidHexString,
+            203 => CommandError::TargetBufferTooSmall,
+            x => CommandError::Unknown(x.into()),
+        }
+    }
+}
+
+impl From<rand_core::Error> for CommandError {
+    fn from(_error: rand_core::Error) -> Self {
+        CommandError::RngError
+    }
+}
-- 
cgit v1.2.1


From 591c55ff294ee12812e4be1b90f03a093f83a4f5 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Thu, 17 Jan 2019 01:58:42 +0000
Subject: Implement std::error::Error for error::CommandError

---
 src/error.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index 6aeeef8..dcaa4d2 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,4 +1,5 @@
 use std::borrow;
+use std::error;
 use std::fmt;
 use std::os::raw;
 
@@ -79,6 +80,8 @@ impl CommandError {
     }
 }
 
+impl error::Error for CommandError {}
+
 impl fmt::Display for CommandError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.as_str())
-- 
cgit v1.2.1


From db198936be1a80f1735731d9e95eb6f4c48a5329 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Thu, 17 Jan 2019 02:05:52 +0000
Subject: Add the Error enum and the Result<T> typedef

The Error enum is a wrapper for the possible error types (currently only
CommandError).  Result<T> is defined as Result<T, Error>.
---
 src/error.rs | 35 ++++++++++++++++++++++++++++++++++-
 1 file changed, 34 insertions(+), 1 deletion(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index dcaa4d2..89c4c82 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -2,8 +2,41 @@ use std::borrow;
 use std::error;
 use std::fmt;
 use std::os::raw;
+use std::result;
 
-/// Error types returned by Nitrokey device or by the library.
+/// An error returned by the nitrokey crate.
+#[derive(Debug)]
+pub enum Error {
+    /// An error reported by the Nitrokey device in the response packet.
+    CommandError(CommandError),
+}
+
+impl From<CommandError> for Error {
+    fn from(err: CommandError) -> Self {
+        Error::CommandError(err)
+    }
+}
+
+impl error::Error for Error {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match *self {
+            Error::CommandError(ref err) => Some(err),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Error::CommandError(ref err) => write!(f, "Command error: {}", err),
+        }
+    }
+}
+
+/// A result returned by the nitrokey crate.
+pub type Result<T> = result::Result<T, Error>;
+
+/// An error reported by the Nitrokey device in the response packet.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum CommandError {
     /// A packet with a wrong checksum has been sent or received.
-- 
cgit v1.2.1


From 94390aadc8a3997d379bf5e4c0bc00c2a9669a34 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Sun, 20 Jan 2019 20:58:18 +0000
Subject: Return Error instead of CommandError

This patch changes all public functions to return the Error enum instead
of the CommandError enum.  This breaks the tests which will be fixed
with the next patch.

This patch also adds a placeholder variant Error::CommandError and a
placeholder enum CommandError to make the transition to a new
nitrokey-test version easier.
---
 src/error.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index 89c4c82..3f60af2 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -9,6 +9,8 @@ use std::result;
 pub enum Error {
     /// An error reported by the Nitrokey device in the response packet.
     CommandError(CommandError),
+    /// Placeholder for testing.
+    CommunicationError(CommunicationError),
 }
 
 impl From<CommandError> for Error {
@@ -21,6 +23,7 @@ impl error::Error for Error {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         match *self {
             Error::CommandError(ref err) => Some(err),
+            Error::CommunicationError(_) => None,
         }
     }
 }
@@ -29,6 +32,7 @@ impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             Error::CommandError(ref err) => write!(f, "Command error: {}", err),
+            Error::CommunicationError(_) => write!(f, "Placeholder"),
         }
     }
 }
@@ -78,6 +82,13 @@ pub enum CommandError {
     RngError,
 }
 
+/// Placeholder for testing.
+#[derive(Debug)]
+pub enum CommunicationError {
+    /// Placeholder for testing.
+    NotConnected,
+}
+
 impl CommandError {
     fn as_str(&self) -> borrow::Cow<'static, str> {
         match *self {
-- 
cgit v1.2.1


From cafc3a6f8cfb9f82343c1d3fe843c7f8d7ef1136 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Sun, 20 Jan 2019 21:05:58 +0000
Subject: Refactor CommandError::RngError into Error::RandError

We reserve CommandError for errors returned by the Nitrokey device.
Errors during random number generation should have their own type.
---
 src/error.rs | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index 3f60af2..dfe1680 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -11,6 +11,8 @@ pub enum Error {
     CommandError(CommandError),
     /// Placeholder for testing.
     CommunicationError(CommunicationError),
+    /// An error that occured during random number generation.
+    RandError(rand_core::Error),
 }
 
 impl From<CommandError> for Error {
@@ -19,11 +21,18 @@ impl From<CommandError> for Error {
     }
 }
 
+impl From<rand_core::Error> for Error {
+    fn from(error: rand_core::Error) -> Self {
+        Error::RandError(error)
+    }
+}
+
 impl error::Error for Error {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         match *self {
             Error::CommandError(ref err) => Some(err),
             Error::CommunicationError(_) => None,
+            Error::RandError(ref err) => Some(err),
         }
     }
 }
@@ -33,6 +42,7 @@ impl fmt::Display for Error {
         match *self {
             Error::CommandError(ref err) => write!(f, "Command error: {}", err),
             Error::CommunicationError(_) => write!(f, "Placeholder"),
+            Error::RandError(ref err) => write!(f, "RNG error: {}", err),
         }
     }
 }
@@ -78,8 +88,6 @@ pub enum CommandError {
     InvalidHexString,
     /// The target buffer was smaller than the source.
     TargetBufferTooSmall,
-    /// An error occurred during random number generation.
-    RngError,
 }
 
 /// Placeholder for testing.
@@ -119,7 +127,6 @@ impl CommandError {
                 "The supplied string is not in hexadecimal format".into()
             }
             CommandError::TargetBufferTooSmall => "The target buffer is too small".into(),
-            CommandError::RngError => "An error occurred during random number generation".into(),
         }
     }
 }
@@ -153,9 +160,3 @@ impl From<raw::c_int> for CommandError {
         }
     }
 }
-
-impl From<rand_core::Error> for CommandError {
-    fn from(_error: rand_core::Error) -> Self {
-        CommandError::RngError
-    }
-}
-- 
cgit v1.2.1


From 944e1fa0d51e547dde2a9368d2b8431b109f63c4 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Thu, 17 Jan 2019 04:15:31 +0000
Subject: Move the CommandError::Unknown to Error

An error code can not only indiciate a command error, but also a library
or device communication error.  Therefore, the variant for an unknown
error code should be placed in the top-level Error enum instead of the
CommandError enum.
---
 src/error.rs | 61 +++++++++++++++++++++++++++++++++---------------------------
 1 file changed, 34 insertions(+), 27 deletions(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index dfe1680..c5a975e 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -13,6 +13,18 @@ pub enum Error {
     CommunicationError(CommunicationError),
     /// An error that occured during random number generation.
     RandError(rand_core::Error),
+    /// An unknown error returned by libnitrokey.
+    Unknown(i64),
+}
+
+impl From<raw::c_int> for Error {
+    fn from(code: raw::c_int) -> Self {
+        if let Some(err) = CommandError::try_from(code) {
+            Error::CommandError(err)
+        } else {
+            Error::Unknown(code.into())
+        }
+    }
 }
 
 impl From<CommandError> for Error {
@@ -33,6 +45,7 @@ impl error::Error for Error {
             Error::CommandError(ref err) => Some(err),
             Error::CommunicationError(_) => None,
             Error::RandError(ref err) => Some(err),
+            Error::Unknown(_) => None,
         }
     }
 }
@@ -43,6 +56,7 @@ impl fmt::Display for Error {
             Error::CommandError(ref err) => write!(f, "Command error: {}", err),
             Error::CommunicationError(_) => write!(f, "Placeholder"),
             Error::RandError(ref err) => write!(f, "RNG error: {}", err),
+            Error::Unknown(ref err) => write!(f, "Unknown error: {}", err),
         }
     }
 }
@@ -74,8 +88,6 @@ pub enum CommandError {
     UnknownCommand,
     /// AES decryption failed.
     AesDecryptionFailed,
-    /// An unknown error occurred.
-    Unknown(i64),
     /// An unspecified error occurred.
     Undefined,
     /// You passed a string containing a null byte.
@@ -98,6 +110,26 @@ pub enum CommunicationError {
 }
 
 impl CommandError {
+    fn try_from(value: raw::c_int) -> Option<Self> {
+        match value {
+            1 => Some(CommandError::WrongCrc),
+            2 => Some(CommandError::WrongSlot),
+            3 => Some(CommandError::SlotNotProgrammed),
+            4 => Some(CommandError::WrongPassword),
+            5 => Some(CommandError::NotAuthorized),
+            6 => Some(CommandError::Timestamp),
+            7 => Some(CommandError::NoName),
+            8 => Some(CommandError::NotSupported),
+            9 => Some(CommandError::UnknownCommand),
+            10 => Some(CommandError::AesDecryptionFailed),
+            200 => Some(CommandError::StringTooLong),
+            201 => Some(CommandError::InvalidSlot),
+            202 => Some(CommandError::InvalidHexString),
+            203 => Some(CommandError::TargetBufferTooSmall),
+            _ => None,
+        }
+    }
+
     fn as_str(&self) -> borrow::Cow<'static, str> {
         match *self {
             CommandError::WrongCrc => {
@@ -116,9 +148,6 @@ impl CommandError {
             CommandError::NotSupported => "This command is not supported by this device".into(),
             CommandError::UnknownCommand => "This command is unknown".into(),
             CommandError::AesDecryptionFailed => "AES decryption failed".into(),
-            CommandError::Unknown(x) => {
-                borrow::Cow::from(format!("An unknown error occurred ({})", x))
-            }
             CommandError::Undefined => "An unspecified error occurred".into(),
             CommandError::InvalidString => "You passed a string containing a null byte".into(),
             CommandError::StringTooLong => "The supplied string is too long".into(),
@@ -138,25 +167,3 @@ impl fmt::Display for CommandError {
         write!(f, "{}", self.as_str())
     }
 }
-
-impl From<raw::c_int> for CommandError {
-    fn from(value: raw::c_int) -> Self {
-        match value {
-            1 => CommandError::WrongCrc,
-            2 => CommandError::WrongSlot,
-            3 => CommandError::SlotNotProgrammed,
-            4 => CommandError::WrongPassword,
-            5 => CommandError::NotAuthorized,
-            6 => CommandError::Timestamp,
-            7 => CommandError::NoName,
-            8 => CommandError::NotSupported,
-            9 => CommandError::UnknownCommand,
-            10 => CommandError::AesDecryptionFailed,
-            200 => CommandError::StringTooLong,
-            201 => CommandError::InvalidSlot,
-            202 => CommandError::InvalidHexString,
-            203 => CommandError::TargetBufferTooSmall,
-            x => CommandError::Unknown(x.into()),
-        }
-    }
-}
-- 
cgit v1.2.1


From 5e258d26b55af6bed7c316b1c7ac12e20946702d Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Thu, 17 Jan 2019 12:47:52 +0000
Subject: Refactor library errors into LibraryError enum

Previously, library errors were part of the CommandError enum.  As
command errors and library errors are two different error types, they
should be split into two enums.
---
 src/error.rs | 74 +++++++++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 53 insertions(+), 21 deletions(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index c5a975e..f40d07f 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -11,6 +11,8 @@ pub enum Error {
     CommandError(CommandError),
     /// Placeholder for testing.
     CommunicationError(CommunicationError),
+    /// A library usage error.
+    LibraryError(LibraryError),
     /// An error that occured during random number generation.
     RandError(rand_core::Error),
     /// An unknown error returned by libnitrokey.
@@ -21,6 +23,8 @@ impl From<raw::c_int> for Error {
     fn from(code: raw::c_int) -> Self {
         if let Some(err) = CommandError::try_from(code) {
             Error::CommandError(err)
+        } else if let Some(err) = LibraryError::try_from(code) {
+            Error::LibraryError(err)
         } else {
             Error::Unknown(code.into())
         }
@@ -33,6 +37,12 @@ impl From<CommandError> for Error {
     }
 }
 
+impl From<LibraryError> for Error {
+    fn from(err: LibraryError) -> Self {
+        Error::LibraryError(err)
+    }
+}
+
 impl From<rand_core::Error> for Error {
     fn from(error: rand_core::Error) -> Self {
         Error::RandError(error)
@@ -44,6 +54,7 @@ impl error::Error for Error {
         match *self {
             Error::CommandError(ref err) => Some(err),
             Error::CommunicationError(_) => None,
+            Error::LibraryError(ref err) => Some(err),
             Error::RandError(ref err) => Some(err),
             Error::Unknown(_) => None,
         }
@@ -55,6 +66,7 @@ impl fmt::Display for Error {
         match *self {
             Error::CommandError(ref err) => write!(f, "Command error: {}", err),
             Error::CommunicationError(_) => write!(f, "Placeholder"),
+            Error::LibraryError(ref err) => write!(f, "Library error: {}", err),
             Error::RandError(ref err) => write!(f, "RNG error: {}", err),
             Error::Unknown(ref err) => write!(f, "Unknown error: {}", err),
         }
@@ -90,16 +102,6 @@ pub enum CommandError {
     AesDecryptionFailed,
     /// An unspecified error occurred.
     Undefined,
-    /// You passed a string containing a null byte.
-    InvalidString,
-    /// A supplied string exceeded a length limit.
-    StringTooLong,
-    /// You passed an invalid slot.
-    InvalidSlot,
-    /// The supplied string was not in hexadecimal format.
-    InvalidHexString,
-    /// The target buffer was smaller than the source.
-    TargetBufferTooSmall,
 }
 
 /// Placeholder for testing.
@@ -122,10 +124,6 @@ impl CommandError {
             8 => Some(CommandError::NotSupported),
             9 => Some(CommandError::UnknownCommand),
             10 => Some(CommandError::AesDecryptionFailed),
-            200 => Some(CommandError::StringTooLong),
-            201 => Some(CommandError::InvalidSlot),
-            202 => Some(CommandError::InvalidHexString),
-            203 => Some(CommandError::TargetBufferTooSmall),
             _ => None,
         }
     }
@@ -149,13 +147,6 @@ impl CommandError {
             CommandError::UnknownCommand => "This command is unknown".into(),
             CommandError::AesDecryptionFailed => "AES decryption failed".into(),
             CommandError::Undefined => "An unspecified error occurred".into(),
-            CommandError::InvalidString => "You passed a string containing a null byte".into(),
-            CommandError::StringTooLong => "The supplied string is too long".into(),
-            CommandError::InvalidSlot => "The given slot is invalid".into(),
-            CommandError::InvalidHexString => {
-                "The supplied string is not in hexadecimal format".into()
-            }
-            CommandError::TargetBufferTooSmall => "The target buffer is too small".into(),
         }
     }
 }
@@ -167,3 +158,44 @@ impl fmt::Display for CommandError {
         write!(f, "{}", self.as_str())
     }
 }
+
+/// A library usage error.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum LibraryError {
+    /// A supplied string exceeded a length limit.
+    StringTooLong,
+    /// You passed an invalid slot.
+    InvalidSlot,
+    /// The supplied string was not in hexadecimal format.
+    InvalidHexString,
+    /// The target buffer was smaller than the source.
+    TargetBufferTooSmall,
+    /// You passed a string containing a null byte.
+    InvalidString,
+}
+
+impl LibraryError {
+    fn try_from(value: raw::c_int) -> Option<Self> {
+        match value {
+            200 => Some(LibraryError::StringTooLong),
+            201 => Some(LibraryError::InvalidSlot),
+            202 => Some(LibraryError::InvalidHexString),
+            203 => Some(LibraryError::TargetBufferTooSmall),
+            _ => None,
+        }
+    }
+}
+
+impl error::Error for LibraryError {}
+
+impl fmt::Display for LibraryError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match *self {
+            LibraryError::StringTooLong => "The supplied string is too long",
+            LibraryError::InvalidSlot => "The given slot is invalid",
+            LibraryError::InvalidHexString => "The supplied string is not in hexadecimal format",
+            LibraryError::TargetBufferTooSmall => "The target buffer is too small",
+            LibraryError::InvalidString => "You passed a string containing a null byte",
+        })
+    }
+}
-- 
cgit v1.2.1


From 27138c4b799248d2d39e9681337a620c89636557 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Thu, 17 Jan 2019 13:10:01 +0000
Subject: Add the CommunicationError enum

Communication errors returned by libnitrokey were previously not mapped
to an error type in the nitrokey crate.  We introduce the
CommunicationError enum to represent these errors.
---
 src/error.rs | 59 +++++++++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 49 insertions(+), 10 deletions(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index f40d07f..a2b3848 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -9,7 +9,7 @@ use std::result;
 pub enum Error {
     /// An error reported by the Nitrokey device in the response packet.
     CommandError(CommandError),
-    /// Placeholder for testing.
+    /// A device communication.
     CommunicationError(CommunicationError),
     /// A library usage error.
     LibraryError(LibraryError),
@@ -23,6 +23,8 @@ impl From<raw::c_int> for Error {
     fn from(code: raw::c_int) -> Self {
         if let Some(err) = CommandError::try_from(code) {
             Error::CommandError(err)
+        } else if let Some(err) = CommunicationError::try_from(256 - code) {
+            Error::CommunicationError(err)
         } else if let Some(err) = LibraryError::try_from(code) {
             Error::LibraryError(err)
         } else {
@@ -37,6 +39,12 @@ impl From<CommandError> for Error {
     }
 }
 
+impl From<CommunicationError> for Error {
+    fn from(err: CommunicationError) -> Self {
+        Error::CommunicationError(err)
+    }
+}
+
 impl From<LibraryError> for Error {
     fn from(err: LibraryError) -> Self {
         Error::LibraryError(err)
@@ -53,7 +61,7 @@ impl error::Error for Error {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         match *self {
             Error::CommandError(ref err) => Some(err),
-            Error::CommunicationError(_) => None,
+            Error::CommunicationError(ref err) => Some(err),
             Error::LibraryError(ref err) => Some(err),
             Error::RandError(ref err) => Some(err),
             Error::Unknown(_) => None,
@@ -65,7 +73,7 @@ impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             Error::CommandError(ref err) => write!(f, "Command error: {}", err),
-            Error::CommunicationError(_) => write!(f, "Placeholder"),
+            Error::CommunicationError(ref err) => write!(f, "Communication error: {}", err),
             Error::LibraryError(ref err) => write!(f, "Library error: {}", err),
             Error::RandError(ref err) => write!(f, "RNG error: {}", err),
             Error::Unknown(ref err) => write!(f, "Unknown error: {}", err),
@@ -104,13 +112,6 @@ pub enum CommandError {
     Undefined,
 }
 
-/// Placeholder for testing.
-#[derive(Debug)]
-pub enum CommunicationError {
-    /// Placeholder for testing.
-    NotConnected,
-}
-
 impl CommandError {
     fn try_from(value: raw::c_int) -> Option<Self> {
         match value {
@@ -159,6 +160,44 @@ impl fmt::Display for CommandError {
     }
 }
 
+/// A device communication error.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CommunicationError {
+    /// Could not connect to a Nitrokey device.
+    NotConnected,
+    /// Sending a packet failed.
+    SendingFailure,
+    /// Receiving a packet failed.
+    ReceivingFailure,
+    /// A packet with a wrong checksum was received.
+    InvalidCrc,
+}
+
+impl CommunicationError {
+    fn try_from(value: raw::c_int) -> Option<Self> {
+        match value {
+            2 => Some(CommunicationError::NotConnected),
+            3 => Some(CommunicationError::SendingFailure),
+            4 => Some(CommunicationError::ReceivingFailure),
+            5 => Some(CommunicationError::InvalidCrc),
+            _ => None,
+        }
+    }
+}
+
+impl error::Error for CommunicationError {}
+
+impl fmt::Display for CommunicationError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match *self {
+            CommunicationError::NotConnected => "Could not connect to a Nitrokey device",
+            CommunicationError::SendingFailure => "Sending a packet failed",
+            CommunicationError::ReceivingFailure => "Receiving a packet failed",
+            CommunicationError::InvalidCrc => "A packet with a wrong checksum was received",
+        })
+    }
+}
+
 /// A library usage error.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum LibraryError {
-- 
cgit v1.2.1


From 391cfd03edafd6e857d6cdbee1347f38e7a02b3f Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Thu, 17 Jan 2019 13:28:03 +0000
Subject: Remove CommandError::as_str method

AsStr is automatically implementeded if Display is implemented, so
having a manual as_str() method is not necessary.
---
 src/error.rs | 40 ++++++++++++++++------------------------
 1 file changed, 16 insertions(+), 24 deletions(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index a2b3848..1aaf21f 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,4 +1,3 @@
-use std::borrow;
 use std::error;
 use std::fmt;
 use std::os::raw;
@@ -128,35 +127,28 @@ impl CommandError {
             _ => None,
         }
     }
-
-    fn as_str(&self) -> borrow::Cow<'static, str> {
-        match *self {
-            CommandError::WrongCrc => {
-                "A packet with a wrong checksum has been sent or received".into()
-            }
-            CommandError::WrongSlot => "The given OTP slot does not exist".into(),
-            CommandError::SlotNotProgrammed => "The given OTP slot is not programmed".into(),
-            CommandError::WrongPassword => "The given password is wrong".into(),
-            CommandError::NotAuthorized => {
-                "You are not authorized for this command or provided a wrong temporary \
-                 password"
-                    .into()
-            }
-            CommandError::Timestamp => "An error occurred when getting or setting the time".into(),
-            CommandError::NoName => "You did not provide a name for the OTP slot".into(),
-            CommandError::NotSupported => "This command is not supported by this device".into(),
-            CommandError::UnknownCommand => "This command is unknown".into(),
-            CommandError::AesDecryptionFailed => "AES decryption failed".into(),
-            CommandError::Undefined => "An unspecified error occurred".into(),
-        }
-    }
 }
 
 impl error::Error for CommandError {}
 
 impl fmt::Display for CommandError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.as_str())
+        f.write_str(match *self {
+            CommandError::WrongCrc => "A packet with a wrong checksum has been sent or received",
+            CommandError::WrongSlot => "The given OTP slot does not exist",
+            CommandError::SlotNotProgrammed => "The given OTP slot is not programmed",
+            CommandError::WrongPassword => "The given password is wrong",
+            CommandError::NotAuthorized => {
+                "You are not authorized for this command or provided a wrong temporary \
+                 password"
+            }
+            CommandError::Timestamp => "An error occurred when getting or setting the time",
+            CommandError::NoName => "You did not provide a name for the OTP slot",
+            CommandError::NotSupported => "This command is not supported by this device",
+            CommandError::UnknownCommand => "This command is unknown",
+            CommandError::AesDecryptionFailed => "AES decryption failed",
+            CommandError::Undefined => "An unspecified error occurred",
+        })
     }
 }
 
-- 
cgit v1.2.1


From c3e551dd40142bcd2552972d549f31ad7483621d Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Thu, 17 Jan 2019 13:30:20 +0000
Subject: Make CommandError messages more general

For example, the WrongSlot error may also be returned for a PWS slot.
---
 src/error.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index 1aaf21f..ef9b149 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -135,15 +135,15 @@ impl fmt::Display for CommandError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(match *self {
             CommandError::WrongCrc => "A packet with a wrong checksum has been sent or received",
-            CommandError::WrongSlot => "The given OTP slot does not exist",
-            CommandError::SlotNotProgrammed => "The given OTP slot is not programmed",
+            CommandError::WrongSlot => "The given slot does not exist",
+            CommandError::SlotNotProgrammed => "The given slot is not programmed",
             CommandError::WrongPassword => "The given password is wrong",
             CommandError::NotAuthorized => {
                 "You are not authorized for this command or provided a wrong temporary \
                  password"
             }
             CommandError::Timestamp => "An error occurred when getting or setting the time",
-            CommandError::NoName => "You did not provide a name for the OTP slot",
+            CommandError::NoName => "You did not provide a name for the slot",
             CommandError::NotSupported => "This command is not supported by this device",
             CommandError::UnknownCommand => "This command is unknown",
             CommandError::AesDecryptionFailed => "AES decryption failed",
-- 
cgit v1.2.1


From c191e875492ff8aeab1b4493b87486cd265f0edc Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Thu, 17 Jan 2019 13:38:28 +0000
Subject: Introduce the Error::UnexpectedError variant
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The UnexpectedError variant is used when a libnitrokey function returns
a value that violates the function’s contract, for example if a function
returns a null pointer although it guarantees to never return null.
Previously, we returned a CommandError::Unspecified in these cases.
---
 src/error.rs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index ef9b149..b27124c 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -14,6 +14,8 @@ pub enum Error {
     LibraryError(LibraryError),
     /// An error that occured during random number generation.
     RandError(rand_core::Error),
+    /// An error that is caused by an unexpected value returned by libnitrokey.
+    UnexpectedError,
     /// An unknown error returned by libnitrokey.
     Unknown(i64),
 }
@@ -63,6 +65,7 @@ impl error::Error for Error {
             Error::CommunicationError(ref err) => Some(err),
             Error::LibraryError(ref err) => Some(err),
             Error::RandError(ref err) => Some(err),
+            Error::UnexpectedError => None,
             Error::Unknown(_) => None,
         }
     }
@@ -75,6 +78,7 @@ impl fmt::Display for Error {
             Error::CommunicationError(ref err) => write!(f, "Communication error: {}", err),
             Error::LibraryError(ref err) => write!(f, "Library error: {}", err),
             Error::RandError(ref err) => write!(f, "RNG error: {}", err),
+            Error::UnexpectedError => write!(f, "An unexpected error occurred"),
             Error::Unknown(ref err) => write!(f, "Unknown error: {}", err),
         }
     }
-- 
cgit v1.2.1


From 17f9c30a0ace070cba856e4e89fcccedcab5e8e6 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Thu, 17 Jan 2019 14:00:54 +0000
Subject: Remove the unused CommandError::Undefined variant

The CommandError::Undefined variant has been refactored into
Error::UnexpectedError and CommunicationError::NotConnected and is
therefore no longer needed.
---
 src/error.rs | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index b27124c..cde9a34 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -111,8 +111,6 @@ pub enum CommandError {
     UnknownCommand,
     /// AES decryption failed.
     AesDecryptionFailed,
-    /// An unspecified error occurred.
-    Undefined,
 }
 
 impl CommandError {
@@ -151,7 +149,6 @@ impl fmt::Display for CommandError {
             CommandError::NotSupported => "This command is not supported by this device",
             CommandError::UnknownCommand => "This command is unknown",
             CommandError::AesDecryptionFailed => "AES decryption failed",
-            CommandError::Undefined => "An unspecified error occurred",
         })
     }
 }
-- 
cgit v1.2.1


From c79ddf8116659efd1aa7de42bb85337632f238dd Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Wed, 23 Jan 2019 04:16:59 +0000
Subject: Add Error::Utf8Error variant

Previously, we just ignored UTF-8 errors.  This patch prepares the
Utf8Error variant so that we are able to return UTF-8 errors.
---
 src/error.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index cde9a34..4b82c6e 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -2,6 +2,7 @@ use std::error;
 use std::fmt;
 use std::os::raw;
 use std::result;
+use std::str;
 
 /// An error returned by the nitrokey crate.
 #[derive(Debug)]
@@ -18,6 +19,8 @@ pub enum Error {
     UnexpectedError,
     /// An unknown error returned by libnitrokey.
     Unknown(i64),
+    /// An error occurred when interpreting a UTF-8 string.
+    Utf8Error(str::Utf8Error),
 }
 
 impl From<raw::c_int> for Error {
@@ -58,6 +61,12 @@ impl From<rand_core::Error> for Error {
     }
 }
 
+impl From<str::Utf8Error> for Error {
+    fn from(error: str::Utf8Error) -> Self {
+        Error::Utf8Error(error)
+    }
+}
+
 impl error::Error for Error {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         match *self {
@@ -67,6 +76,7 @@ impl error::Error for Error {
             Error::RandError(ref err) => Some(err),
             Error::UnexpectedError => None,
             Error::Unknown(_) => None,
+            Error::Utf8Error(ref err) => Some(err),
         }
     }
 }
@@ -80,6 +90,7 @@ impl fmt::Display for Error {
             Error::RandError(ref err) => write!(f, "RNG error: {}", err),
             Error::UnexpectedError => write!(f, "An unexpected error occurred"),
             Error::Unknown(ref err) => write!(f, "Unknown error: {}", err),
+            Error::Utf8Error(ref err) => write!(f, "UTF-8 error: {}", err),
         }
     }
 }
-- 
cgit v1.2.1


From b00bbaa5603504597729ed2ce0d1e8ff50ea078d Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Wed, 23 Jan 2019 04:36:57 +0000
Subject: Implement From<(T: Device, Error)> for Error

Not all users of the authenticate methods want to use the device after
an error, so implementing From<(T: Device, Error)> for Error makes it
easier for them to discard the device.
---
 src/error.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index 4b82c6e..551dd0f 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -4,6 +4,8 @@ use std::os::raw;
 use std::result;
 use std::str;
 
+use crate::device;
+
 /// An error returned by the nitrokey crate.
 #[derive(Debug)]
 pub enum Error {
@@ -67,6 +69,12 @@ impl From<str::Utf8Error> for Error {
     }
 }
 
+impl<T: device::Device> From<(T, Error)> for Error {
+    fn from((_, err): (T, Error)) -> Self {
+        err
+    }
+}
+
 impl error::Error for Error {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         match *self {
-- 
cgit v1.2.1


From fdb7bac3063e62776bfc13f184cf786da19f42d1 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Wed, 23 Jan 2019 16:33:26 +0100
Subject: Add license and copyright information

This patch adds license and copyright information to all files to make
nitrokey-rs compliant with the REUSE practices [0].

[0] https://reuse.software/practices/2.0/
---
 src/error.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index 551dd0f..9cdb932 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,3 +1,6 @@
+// Copyright (C) 2019 Robin Krahl <robin.krahl@ireas.org>
+// SPDX-License-Identifier: MIT
+
 use std::error;
 use std::fmt;
 use std::os::raw;
-- 
cgit v1.2.1


From 809d31a4273505487febb2dd281376d2bb3766ab Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Fri, 25 Jan 2019 18:46:57 +0000
Subject: Remove rand_core::Error from public API

rand_core does not have a stable release yet, and it is unlikely that
there will be one soon.  To be able to stabilize nitrokey without
waiting for a stable rand_core version, we remove the rand_core::Error
type from the public API and replace it with a Box<dyn error::Error>.
---
 src/error.rs | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index 9cdb932..1b36975 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -19,7 +19,7 @@ pub enum Error {
     /// A library usage error.
     LibraryError(LibraryError),
     /// An error that occured during random number generation.
-    RandError(rand_core::Error),
+    RandError(Box<dyn error::Error>),
     /// An error that is caused by an unexpected value returned by libnitrokey.
     UnexpectedError,
     /// An unknown error returned by libnitrokey.
@@ -60,12 +60,6 @@ impl From<LibraryError> for Error {
     }
 }
 
-impl From<rand_core::Error> for Error {
-    fn from(error: rand_core::Error) -> Self {
-        Error::RandError(error)
-    }
-}
-
 impl From<str::Utf8Error> for Error {
     fn from(error: str::Utf8Error) -> Self {
         Error::Utf8Error(error)
@@ -84,7 +78,7 @@ impl error::Error for Error {
             Error::CommandError(ref err) => Some(err),
             Error::CommunicationError(ref err) => Some(err),
             Error::LibraryError(ref err) => Some(err),
-            Error::RandError(ref err) => Some(err),
+            Error::RandError(ref err) => Some(err.as_ref()),
             Error::UnexpectedError => None,
             Error::Unknown(_) => None,
             Error::Utf8Error(ref err) => Some(err),
-- 
cgit v1.2.1


From a30562638aed90d113739bb36dd6814f6cf7ace2 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Sun, 27 Jan 2019 13:31:36 +0000
Subject: Remove the Result typedef

Many of our functions do not return a Result<_, Error>, but for example
a Result<_, (Device, Error)>.  We only use the typedef in one function,
but it makes the other functions more complicated as we have to use
result::Result (if crate::Result is imported).  Therefore, this patch
removes the typedef.  Applications or libraries can still redefine it if
they want to.
---
 src/error.rs | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index 1b36975..5c8c52e 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -4,7 +4,6 @@
 use std::error;
 use std::fmt;
 use std::os::raw;
-use std::result;
 use std::str;
 
 use crate::device;
@@ -100,9 +99,6 @@ impl fmt::Display for Error {
     }
 }
 
-/// A result returned by the nitrokey crate.
-pub type Result<T> = result::Result<T, Error>;
-
 /// An error reported by the Nitrokey device in the response packet.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum CommandError {
-- 
cgit v1.2.1


From 33a65c1635e54ae51089ef3c37a749d67853be02 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Sun, 27 Jan 2019 13:36:13 +0000
Subject: Rename Error::Unknown to Error::UnknownError

For consistency with the other Error variants, we rename Unknown to
UnknownError.
---
 src/error.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index 5c8c52e..1730171 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -22,7 +22,7 @@ pub enum Error {
     /// An error that is caused by an unexpected value returned by libnitrokey.
     UnexpectedError,
     /// An unknown error returned by libnitrokey.
-    Unknown(i64),
+    UnknownError(i64),
     /// An error occurred when interpreting a UTF-8 string.
     Utf8Error(str::Utf8Error),
 }
@@ -36,7 +36,7 @@ impl From<raw::c_int> for Error {
         } else if let Some(err) = LibraryError::try_from(code) {
             Error::LibraryError(err)
         } else {
-            Error::Unknown(code.into())
+            Error::UnknownError(code.into())
         }
     }
 }
@@ -79,7 +79,7 @@ impl error::Error for Error {
             Error::LibraryError(ref err) => Some(err),
             Error::RandError(ref err) => Some(err.as_ref()),
             Error::UnexpectedError => None,
-            Error::Unknown(_) => None,
+            Error::UnknownError(_) => None,
             Error::Utf8Error(ref err) => Some(err),
         }
     }
@@ -93,7 +93,7 @@ impl fmt::Display for Error {
             Error::LibraryError(ref err) => write!(f, "Library error: {}", err),
             Error::RandError(ref err) => write!(f, "RNG error: {}", err),
             Error::UnexpectedError => write!(f, "An unexpected error occurred"),
-            Error::Unknown(ref err) => write!(f, "Unknown error: {}", err),
+            Error::UnknownError(ref err) => write!(f, "Unknown error: {}", err),
             Error::Utf8Error(ref err) => write!(f, "UTF-8 error: {}", err),
         }
     }
-- 
cgit v1.2.1


From a52676d9577f587e0f4d8e47ddc71ba34f0b31ca Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Sun, 27 Jan 2019 15:04:19 +0000
Subject: Add ConcurrentAccessError and PoisonError variants

This patch prepares the refactoring of the connection methods by
introducing the Error variants ConcurrentAccessError and PoisonError.
ConcurrentAccessError indicates that the user tried to connect to
obtain a token that is currently locked, and PoisonError indicates that
a lock has been poisoned, i. e. a thread panicked while accessing using
a token.
---
 src/error.rs | 28 ++++++++++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index 1730171..c6b19db 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -5,6 +5,7 @@ use std::error;
 use std::fmt;
 use std::os::raw;
 use std::str;
+use std::sync;
 
 use crate::device;
 
@@ -13,11 +14,15 @@ use crate::device;
 pub enum Error {
     /// An error reported by the Nitrokey device in the response packet.
     CommandError(CommandError),
-    /// A device communication.
+    /// A device communication error.
     CommunicationError(CommunicationError),
+    /// An error occurred due to concurrent access to the Nitrokey device.
+    ConcurrentAccessError,
     /// A library usage error.
     LibraryError(LibraryError),
-    /// An error that occured during random number generation.
+    /// An error that occurred due to a poisoned lock.
+    PoisonError,
+    /// An error that occurred during random number generation.
     RandError(Box<dyn error::Error>),
     /// An error that is caused by an unexpected value returned by libnitrokey.
     UnexpectedError,
@@ -65,6 +70,21 @@ impl From<str::Utf8Error> for Error {
     }
 }
 
+impl<T> From<sync::PoisonError<T>> for Error {
+    fn from(_error: sync::PoisonError<T>) -> Self {
+        Error::PoisonError
+    }
+}
+
+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,
+        }
+    }
+}
+
 impl<T: device::Device> From<(T, Error)> for Error {
     fn from((_, err): (T, Error)) -> Self {
         err
@@ -76,7 +96,9 @@ impl error::Error for Error {
         match *self {
             Error::CommandError(ref err) => Some(err),
             Error::CommunicationError(ref err) => Some(err),
+            Error::ConcurrentAccessError => None,
             Error::LibraryError(ref err) => Some(err),
+            Error::PoisonError => None,
             Error::RandError(ref err) => Some(err.as_ref()),
             Error::UnexpectedError => None,
             Error::UnknownError(_) => None,
@@ -90,7 +112,9 @@ impl fmt::Display for Error {
         match *self {
             Error::CommandError(ref err) => write!(f, "Command error: {}", err),
             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::UnexpectedError => write!(f, "An unexpected error occurred"),
             Error::UnknownError(ref err) => write!(f, "Unknown error: {}", err),
-- 
cgit v1.2.1


From 588066f415e956fdcd2c6f6216c52b25911a3b1d Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Sun, 27 Jan 2019 15:43:32 +0000
Subject: Add Manager struct to manage Nitrokey connections

As part of the connection refactoring, we introduce the Manager struct
that deals with connection management.  To make sure there can be only
once instance of the manager, we add a global static Mutex that holds
the single Manager instance.  We use the struct to ensure that the user
can only connect to one device at a time.

This also changes the Error::PoisonError variant to store the
sync::PoisonError.  This allows the user to call into_inner on the
PoisonError to retrieve the MutexGuard and to ignore the error (for
example useful during testing).
---
 src/error.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index c6b19db..b84f5eb 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -21,7 +21,7 @@ pub enum Error {
     /// A library usage error.
     LibraryError(LibraryError),
     /// An error that occurred due to a poisoned lock.
-    PoisonError,
+    PoisonError(sync::PoisonError<sync::MutexGuard<'static, crate::Manager>>),
     /// An error that occurred during random number generation.
     RandError(Box<dyn error::Error>),
     /// An error that is caused by an unexpected value returned by libnitrokey.
@@ -70,14 +70,14 @@ impl From<str::Utf8Error> for Error {
     }
 }
 
-impl<T> From<sync::PoisonError<T>> for Error {
-    fn from(_error: sync::PoisonError<T>) -> Self {
-        Error::PoisonError
+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::TryLockError<T>> for Error {
-    fn from(error: sync::TryLockError<T>) -> Self {
+impl From<sync::TryLockError<sync::MutexGuard<'static, crate::Manager>>> for Error {
+    fn from(error: sync::TryLockError<sync::MutexGuard<'static, crate::Manager>>) -> Self {
         match error {
             sync::TryLockError::Poisoned(err) => err.into(),
             sync::TryLockError::WouldBlock => Error::ConcurrentAccessError,
@@ -98,7 +98,7 @@ impl error::Error for Error {
             Error::CommunicationError(ref err) => Some(err),
             Error::ConcurrentAccessError => None,
             Error::LibraryError(ref err) => Some(err),
-            Error::PoisonError => None,
+            Error::PoisonError(ref err) => Some(err),
             Error::RandError(ref err) => Some(err.as_ref()),
             Error::UnexpectedError => None,
             Error::UnknownError(_) => None,
@@ -114,7 +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::PoisonError(_) => write!(f, "Internal error: poisoned lock"),
             Error::RandError(ref err) => write!(f, "RNG error: {}", err),
             Error::UnexpectedError => write!(f, "An unexpected error occurred"),
             Error::UnknownError(ref err) => write!(f, "Unknown error: {}", err),
-- 
cgit v1.2.1


From 12fa62483cf45d868099d5d4020333af492eebde Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Tue, 9 Jul 2019 08:09:02 +0000
Subject: Introduce into_manager for Device
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

To enable applications like nitrokey-test to go back to a manager
instance from a Device instance, we add the into_manager function to the
Device trait.  To do that, we have to keep track of the Manager’s
lifetime by adding a lifetime to Device (and then to some other traits
that use Device).
---
 src/error.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/error.rs')

diff --git a/src/error.rs b/src/error.rs
index b84f5eb..9e6adc0 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -85,7 +85,7 @@ impl From<sync::TryLockError<sync::MutexGuard<'static, crate::Manager>>> for Err
     }
 }
 
-impl<T: device::Device> From<(T, Error)> for Error {
+impl<'a, T: device::Device<'a>> From<(T, Error)> for Error {
     fn from((_, err): (T, Error)) -> Self {
         err
     }
-- 
cgit v1.2.1