From da2ac74281c4adf4dc10b55ec267d84a8a1502dc Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Wed, 16 Jan 2019 23:19:53 +0000
Subject: Implement Display for Version

---
 src/lib.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 02a622b..807a9ca 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -93,6 +93,8 @@ mod otp;
 mod pws;
 mod util;
 
+use std::fmt;
+
 use nitrokey_sys;
 
 pub use crate::auth::{Admin, Authenticate, User};
@@ -125,6 +127,16 @@ pub struct Version {
     pub minor: u32,
 }
 
+impl fmt::Display for Version {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.git.is_empty() {
+            write!(f, "v{}.{}", self.major, self.minor)
+        } else {
+            f.write_str(&self.git)
+        }
+    }
+}
+
 /// Enables or disables debug output.  Calling this method with `true` is equivalent to setting the
 /// log level to `Debug`; calling it with `false` is equivalent to the log level `Error` (see
 /// [`set_log_level`][]).
-- 
cgit v1.2.1


From d974ea42b567ad752c53ec0b2b97246d17380632 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Sat, 19 Jan 2019 15:18:09 +0000
Subject: Introduce DEFAULT_ADMIN_PIN and DEFAULT_USER_PIN constants

The constants can be used for tests or after a factory reset.
---
 src/lib.rs | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 807a9ca..93a9894 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -107,6 +107,11 @@ pub use crate::otp::{ConfigureOtp, GenerateOtp, OtpMode, OtpSlotData};
 pub use crate::pws::{GetPasswordSafe, PasswordSafe, SLOT_COUNT};
 pub use crate::util::{CommandError, LogLevel};
 
+/// The default admin PIN for all Nitrokey devices.
+pub const DEFAULT_ADMIN_PIN: &'static str = "12345678";
+/// The default user PIN for all Nitrokey devices.
+pub const DEFAULT_USER_PIN: &'static str = "123456";
+
 /// A version of the libnitrokey library.
 ///
 /// Use the [`get_library_version`](fn.get_library_version.html) function to query the library
-- 
cgit v1.2.1


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/lib.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 93a9894..cec5db7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -89,6 +89,7 @@
 mod auth;
 mod config;
 mod device;
+mod error;
 mod otp;
 mod pws;
 mod util;
@@ -103,9 +104,10 @@ pub use crate::device::{
     connect, connect_model, Device, DeviceWrapper, Model, Pro, SdCardData, Storage,
     StorageProductionInfo, StorageStatus, VolumeMode, VolumeStatus,
 };
+pub use crate::error::CommandError;
 pub use crate::otp::{ConfigureOtp, GenerateOtp, OtpMode, OtpSlotData};
 pub use crate::pws::{GetPasswordSafe, PasswordSafe, SLOT_COUNT};
-pub use crate::util::{CommandError, LogLevel};
+pub use crate::util::LogLevel;
 
 /// The default admin PIN for all Nitrokey devices.
 pub const DEFAULT_ADMIN_PIN: &'static str = "12345678";
-- 
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/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index cec5db7..df11cc3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -104,7 +104,7 @@ pub use crate::device::{
     connect, connect_model, Device, DeviceWrapper, Model, Pro, SdCardData, Storage,
     StorageProductionInfo, StorageStatus, VolumeMode, VolumeStatus,
 };
-pub use crate::error::CommandError;
+pub use crate::error::{CommandError, Error, Result};
 pub use crate::otp::{ConfigureOtp, GenerateOtp, OtpMode, OtpSlotData};
 pub use crate::pws::{GetPasswordSafe, PasswordSafe, SLOT_COUNT};
 pub use crate::util::LogLevel;
-- 
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/lib.rs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index df11cc3..8522e83 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -25,9 +25,9 @@
 //!
 //! ```no_run
 //! use nitrokey::Device;
-//! # use nitrokey::CommandError;
+//! # use nitrokey::Error;
 //!
-//! # fn try_main() -> Result<(), CommandError> {
+//! # fn try_main() -> Result<(), Error> {
 //! let device = nitrokey::connect()?;
 //! println!("{}", device.get_serial_number()?);
 //! #     Ok(())
@@ -38,9 +38,9 @@
 //!
 //! ```no_run
 //! use nitrokey::{Authenticate, ConfigureOtp, OtpMode, OtpSlotData};
-//! # use nitrokey::CommandError;
+//! # use nitrokey::Error;
 //!
-//! # fn try_main() -> Result<(), (CommandError)> {
+//! # fn try_main() -> Result<(), Error> {
 //! let device = nitrokey::connect()?;
 //! let slot_data = OtpSlotData::new(1, "test", "01234567890123456689", OtpMode::SixDigits);
 //! match device.authenticate_admin("12345678") {
@@ -60,9 +60,9 @@
 //!
 //! ```no_run
 //! use nitrokey::{Device, GenerateOtp};
-//! # use nitrokey::CommandError;
+//! # use nitrokey::Error;
 //!
-//! # fn try_main() -> Result<(), (CommandError)> {
+//! # fn try_main() -> Result<(), Error> {
 //! let device = nitrokey::connect()?;
 //! match device.get_hotp_code(1) {
 //!     Ok(code) => println!("Generated HOTP code: {}", code),
@@ -104,7 +104,7 @@ pub use crate::device::{
     connect, connect_model, Device, DeviceWrapper, Model, Pro, SdCardData, Storage,
     StorageProductionInfo, StorageStatus, VolumeMode, VolumeStatus,
 };
-pub use crate::error::{CommandError, Error, Result};
+pub use crate::error::{CommandError, CommunicationError, Error, Result};
 pub use crate::otp::{ConfigureOtp, GenerateOtp, OtpMode, OtpSlotData};
 pub use crate::pws::{GetPasswordSafe, PasswordSafe, SLOT_COUNT};
 pub use crate::util::LogLevel;
-- 
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/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 8522e83..993ec92 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -104,7 +104,7 @@ pub use crate::device::{
     connect, connect_model, Device, DeviceWrapper, Model, Pro, SdCardData, Storage,
     StorageProductionInfo, StorageStatus, VolumeMode, VolumeStatus,
 };
-pub use crate::error::{CommandError, CommunicationError, Error, Result};
+pub use crate::error::{CommandError, CommunicationError, Error, LibraryError, Result};
 pub use crate::otp::{ConfigureOtp, GenerateOtp, OtpMode, OtpSlotData};
 pub use crate::pws::{GetPasswordSafe, PasswordSafe, SLOT_COUNT};
 pub use crate::util::LogLevel;
-- 
cgit v1.2.1


From d4663961c41a0fb6f81f4a54aefd0fedce49d350 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Wed, 23 Jan 2019 04:27:14 +0000
Subject: Return UTF-8 error if libnitrokey returns an invalid string
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Previously, we used lossy UTF-8 conversion.  Yet the user should be
notified if we have a problem instead of silently changing the data.
Therefore, we now return an error if we enocunter an invalid UTF-8
string.  This leads to a change in `get_library_version`’s signature.
---
 src/lib.rs | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 993ec92..a1edb6b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -168,21 +168,30 @@ pub fn set_log_level(level: LogLevel) {
 
 /// Returns the libnitrokey library version.
 ///
+/// # Errors
+///
+/// - [`Utf8Error`][] if libnitrokey returned an invalid UTF-8 string
+///
 /// # Example
 ///
 /// ```
-/// let version = nitrokey::get_library_version();
+/// # fn main() -> Result<(), nitrokey::Error> {
+/// let version = nitrokey::get_library_version()?;
 /// println!("Using libnitrokey {}", version.git);
+/// #    Ok(())
+/// # }
 /// ```
-pub fn get_library_version() -> Version {
+///
+/// [`Utf8Error`]: enum.Error.html#variant.Utf8Error
+pub fn get_library_version() -> Result<Version> {
     // NK_get_library_version returns a static string, so we don’t have to free the pointer.
     let git = unsafe { nitrokey_sys::NK_get_library_version() };
     let git = if git.is_null() {
         String::new()
     } else {
-        util::owned_str_from_ptr(git)
+        util::owned_str_from_ptr(git)?
     };
     let major = unsafe { nitrokey_sys::NK_get_major_library_version() };
     let minor = unsafe { nitrokey_sys::NK_get_minor_library_version() };
-    Version { git, major, minor }
+    Ok(Version { git, major, minor })
 }
-- 
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/lib.rs | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index a1edb6b..9d15d03 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,3 +1,6 @@
+// Copyright (C) 2018-2019 Robin Krahl <robin.krahl@ireas.org>
+// SPDX-License-Identifier: MIT
+
 //! Provides access to a Nitrokey device using the native libnitrokey API.
 //!
 //! # Usage
-- 
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/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 9d15d03..18c86e2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -107,7 +107,7 @@ pub use crate::device::{
     connect, connect_model, Device, DeviceWrapper, Model, Pro, SdCardData, Storage,
     StorageProductionInfo, StorageStatus, VolumeMode, VolumeStatus,
 };
-pub use crate::error::{CommandError, CommunicationError, Error, LibraryError, Result};
+pub use crate::error::{CommandError, CommunicationError, Error, LibraryError};
 pub use crate::otp::{ConfigureOtp, GenerateOtp, OtpMode, OtpSlotData};
 pub use crate::pws::{GetPasswordSafe, PasswordSafe, SLOT_COUNT};
 pub use crate::util::LogLevel;
@@ -186,7 +186,7 @@ pub fn set_log_level(level: LogLevel) {
 /// ```
 ///
 /// [`Utf8Error`]: enum.Error.html#variant.Utf8Error
-pub fn get_library_version() -> Result<Version> {
+pub fn get_library_version() -> Result<Version, Error> {
     // NK_get_library_version returns a static string, so we don’t have to free the pointer.
     let git = unsafe { nitrokey_sys::NK_get_library_version() };
     let git = if git.is_null() {
-- 
cgit v1.2.1


From e311ee31b819092a119fa24930ab5777d3c4fd71 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Sun, 27 Jan 2019 13:38:16 +0000
Subject: Remove the static lifetime modifier from constants

The DEFAULT_{ADMIN,USER}_PIN constants implicitly have static lifetime.
Therefore we can remove the static lifetime modifiers.
---
 src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 18c86e2..f2d524e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -113,9 +113,9 @@ pub use crate::pws::{GetPasswordSafe, PasswordSafe, SLOT_COUNT};
 pub use crate::util::LogLevel;
 
 /// The default admin PIN for all Nitrokey devices.
-pub const DEFAULT_ADMIN_PIN: &'static str = "12345678";
+pub const DEFAULT_ADMIN_PIN: &str = "12345678";
 /// The default user PIN for all Nitrokey devices.
-pub const DEFAULT_USER_PIN: &'static str = "123456";
+pub const DEFAULT_USER_PIN: &str = "123456";
 
 /// A version of the libnitrokey library.
 ///
-- 
cgit v1.2.1


From 12b6a4d6c56cba4c2a87027d7c5f26ebe42d3315 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Mon, 28 Jan 2019 20:02:18 +0000
Subject: Prefer eprintln over println for error messages

---
 src/lib.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index f2d524e..f7da8e1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -50,10 +50,10 @@
 //!     Ok(admin) => {
 //!         match admin.write_hotp_slot(slot_data, 0) {
 //!             Ok(()) => println!("Successfully wrote slot."),
-//!             Err(err) => println!("Could not write slot: {}", err),
+//!             Err(err) => eprintln!("Could not write slot: {}", err),
 //!         }
 //!     },
-//!     Err((_, err)) => println!("Could not authenticate as admin: {}", err),
+//!     Err((_, err)) => eprintln!("Could not authenticate as admin: {}", err),
 //! }
 //! #     Ok(())
 //! # }
@@ -69,7 +69,7 @@
 //! let device = nitrokey::connect()?;
 //! match device.get_hotp_code(1) {
 //!     Ok(code) => println!("Generated HOTP code: {}", code),
-//!     Err(err) => println!("Could not generate HOTP code: {}", err),
+//!     Err(err) => eprintln!("Could not generate HOTP code: {}", err),
 //! }
 //! #     Ok(())
 //! # }
-- 
cgit v1.2.1


From f49e61589e32217f97c94aa86d826f6b65170fba Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Mon, 28 Jan 2019 12:27:15 +0000
Subject: Require mutable reference if method changes device state

Previously, all methods that access a Nitrokey device took a reference
to the device as input.  This method changes methods that change the
device state to require a mutable reference instead.  In most case,
this is straightforward as the method writes data to the device (for
example write_config or change_user_pin).  But there are two edge cases:
- Authenticating with a PIN changes the device state as it may decrease
  the PIN retry counter if the authentication fails.
- Generating an HOTP code changes the device state as it increases the
  HOTP counter.
---
 src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index f7da8e1..c35829c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -47,7 +47,7 @@
 //! let device = nitrokey::connect()?;
 //! let slot_data = OtpSlotData::new(1, "test", "01234567890123456689", OtpMode::SixDigits);
 //! match device.authenticate_admin("12345678") {
-//!     Ok(admin) => {
+//!     Ok(mut admin) => {
 //!         match admin.write_hotp_slot(slot_data, 0) {
 //!             Ok(()) => println!("Successfully wrote slot."),
 //!             Err(err) => eprintln!("Could not write slot: {}", err),
@@ -66,7 +66,7 @@
 //! # use nitrokey::Error;
 //!
 //! # fn try_main() -> Result<(), Error> {
-//! let device = nitrokey::connect()?;
+//! let mut device = nitrokey::connect()?;
 //! match device.get_hotp_code(1) {
 //!     Ok(code) => println!("Generated HOTP code: {}", code),
 //!     Err(err) => eprintln!("Could not generate HOTP code: {}", err),
-- 
cgit v1.2.1


From 0972bbe82623c3d9649b6023d8f50d304aa0cde6 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Mon, 28 Jan 2019 14:24:12 +0000
Subject: Refactor User and Admin to use a mutable reference
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In the initial nitrokey-rs implementation, the Admin and the User struct
take the Device by value to make sure that the user cannot initiate a
second authentication while this first is still active (which would
invalidate the temporary password).  Now we realized that this is not
necessary – taking a mutable reference has the same effect, but leads to
a much cleaner API.

This patch refactors the Admin and User structs – and all dependent code
– to use a mutable reference instead of a Device value.
---
 src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index c35829c..d7a8c5e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -44,7 +44,7 @@
 //! # use nitrokey::Error;
 //!
 //! # fn try_main() -> Result<(), Error> {
-//! let device = nitrokey::connect()?;
+//! let mut device = nitrokey::connect()?;
 //! let slot_data = OtpSlotData::new(1, "test", "01234567890123456689", OtpMode::SixDigits);
 //! match device.authenticate_admin("12345678") {
 //!     Ok(mut admin) => {
@@ -53,7 +53,7 @@
 //!             Err(err) => eprintln!("Could not write slot: {}", err),
 //!         }
 //!     },
-//!     Err((_, err)) => eprintln!("Could not authenticate as admin: {}", err),
+//!     Err(err) => eprintln!("Could not authenticate as admin: {}", err),
 //! }
 //! #     Ok(())
 //! # }
-- 
cgit v1.2.1


From 83641ca0518e4c766c63e40d0787e4f0b436652a Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Tue, 5 Feb 2019 12:47:24 +0000
Subject: Revert "Refactor User and Admin to use a mutable reference"

This reverts commit 0972bbe82623c3d9649b6023d8f50d304aa0cde6.
---
 src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index d7a8c5e..c35829c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -44,7 +44,7 @@
 //! # use nitrokey::Error;
 //!
 //! # fn try_main() -> Result<(), Error> {
-//! let mut device = nitrokey::connect()?;
+//! let device = nitrokey::connect()?;
 //! let slot_data = OtpSlotData::new(1, "test", "01234567890123456689", OtpMode::SixDigits);
 //! match device.authenticate_admin("12345678") {
 //!     Ok(mut admin) => {
@@ -53,7 +53,7 @@
 //!             Err(err) => eprintln!("Could not write slot: {}", err),
 //!         }
 //!     },
-//!     Err(err) => eprintln!("Could not authenticate as admin: {}", err),
+//!     Err((_, err)) => eprintln!("Could not authenticate as admin: {}", err),
 //! }
 //! #     Ok(())
 //! # }
-- 
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/lib.rs | 66 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index c35829c..573f45f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -89,6 +89,9 @@
 
 #![warn(missing_docs, rust_2018_compatibility, rust_2018_idioms, unused)]
 
+#[macro_use(lazy_static)]
+extern crate lazy_static;
+
 mod auth;
 mod config;
 mod device;
@@ -98,6 +101,8 @@ mod pws;
 mod util;
 
 use std::fmt;
+use std::marker;
+use std::sync;
 
 use nitrokey_sys;
 
@@ -117,6 +122,10 @@ pub const DEFAULT_ADMIN_PIN: &str = "12345678";
 /// The default user PIN for all Nitrokey devices.
 pub const DEFAULT_USER_PIN: &str = "123456";
 
+lazy_static! {
+    static ref MANAGER: sync::Mutex<Manager> = sync::Mutex::new(Manager::new());
+}
+
 /// A version of the libnitrokey library.
 ///
 /// Use the [`get_library_version`](fn.get_library_version.html) function to query the library
@@ -147,6 +156,63 @@ impl fmt::Display for Version {
     }
 }
 
+/// A manager for connections to Nitrokey devices.
+///
+/// Currently, libnitrokey only provides access to one Nitrokey device at the same time.  This
+/// manager struct makes sure that `nitrokey-rs` does not try to connect to two devices at the same
+/// time.
+///
+/// To obtain an instance of this manager, use the [`take`][] function.
+///
+/// [`take`]: fn.take.html
+#[derive(Debug)]
+pub struct Manager {
+    marker: marker::PhantomData<()>,
+}
+
+impl Manager {
+    fn new() -> Self {
+        Manager {
+            marker: marker::PhantomData,
+        }
+    }
+}
+
+/// Take an instance of the connection manager, blocking until an instance is available.
+///
+/// There may only be one [`Manager`][] instance at the same time.  If there already is an
+/// instance, this method blocks.  If you want a non-blocking version, use [`take`][].
+///
+/// # Errors
+///
+/// - [`PoisonError`][] if the lock is poisoned
+///
+/// [`take`]: fn.take.html
+/// [`PoisonError`]: struct.Error.html#variant.PoisonError
+/// [`Manager`]: struct.Manager.html
+pub fn take_blocking() -> Result<sync::MutexGuard<'static, Manager>, Error> {
+    MANAGER.lock().map_err(Into::into)
+}
+
+/// Try to take an instance of the connection manager.
+///
+/// There may only be one [`Manager`][] instance at the same time.  If there already is an
+/// instance, a [`ConcurrentAccessError`][] is returned.  If you want a blocking version, use
+/// [`take_blocking`][].
+///
+/// # Errors
+///
+/// - [`ConcurrentAccessError`][] if the token for the `Manager` instance cannot be locked
+/// - [`PoisonError`][] if the lock is poisoned
+///
+/// [`take_blocking`]: fn.take_blocking.html
+/// [`ConcurrentAccessError`]: struct.Error.html#variant.ConcurrentAccessError
+/// [`PoisonError`]: struct.Error.html#variant.PoisonError
+/// [`Manager`]: struct.Manager.html
+pub fn take() -> Result<sync::MutexGuard<'static, Manager>, Error> {
+    MANAGER.try_lock().map_err(Into::into)
+}
+
 /// Enables or disables debug output.  Calling this method with `true` is equivalent to setting the
 /// log level to `Debug`; calling it with `false` is equivalent to the log level `Error` (see
 /// [`set_log_level`][]).
-- 
cgit v1.2.1


From 54d23475aa3b712a539bad129fe37223173268f2 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Sun, 27 Jan 2019 17:44:59 +0000
Subject: Move the connect function into Manager

As part of the connection refactoring, we replace the connect function
with the Manager::connect method.  To maintain compatibility with
nitrokey-test, the connect function is not removed but marked as
deprecated.
---
 src/lib.rs | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 573f45f..9f88be3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -108,6 +108,7 @@ use nitrokey_sys;
 
 pub use crate::auth::{Admin, Authenticate, User};
 pub use crate::config::Config;
+#[allow(deprecated)]
 pub use crate::device::{
     connect, connect_model, Device, DeviceWrapper, Model, Pro, SdCardData, Storage,
     StorageProductionInfo, StorageStatus, VolumeMode, VolumeStatus,
@@ -176,6 +177,43 @@ impl Manager {
             marker: marker::PhantomData,
         }
     }
+
+    /// Connects to a Nitrokey device.
+    ///
+    /// This method can be used to connect to any connected device, both a Nitrokey Pro and a
+    /// Nitrokey Storage.
+    ///
+    /// # Errors
+    ///
+    /// - [`NotConnected`][] if no Nitrokey device is connected
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use nitrokey::DeviceWrapper;
+    ///
+    /// fn do_something(device: DeviceWrapper) {}
+    ///
+    /// # fn main() -> Result<(), nitrokey::Error> {
+    /// match nitrokey::take()?.connect() {
+    ///     Ok(device) => do_something(device),
+    ///     Err(err) => println!("Could not connect to a Nitrokey: {}", err),
+    /// }
+    /// #     Ok(())
+    /// # }
+    /// ```
+    ///
+    /// [`NotConnected`]: enum.CommunicationError.html#variant.NotConnected
+    pub fn connect(&mut self) -> Result<DeviceWrapper, Error> {
+        if unsafe { nitrokey_sys::NK_login_auto() } == 1 {
+            match device::get_connected_device() {
+                Some(wrapper) => Ok(wrapper),
+                None => Err(CommunicationError::NotConnected.into()),
+            }
+        } else {
+            Err(CommunicationError::NotConnected.into())
+        }
+    }
 }
 
 /// Take an instance of the connection manager, blocking until an instance is available.
-- 
cgit v1.2.1


From bd7c7a5fdf0ae66a1ff2f00beb5ed4c2e6994ca1 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Sun, 27 Jan 2019 18:07:59 +0000
Subject: Move the connect_model function into Manager

As part of the connection refactoring, this patch moves the
connect_model function to the Manager struct.  As the connect_model
function is not used by nitrokey-test, it is removed.
---
 src/lib.rs | 36 ++++++++++++++++++++++++++++++++++--
 1 file changed, 34 insertions(+), 2 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 9f88be3..784dc6f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -110,8 +110,8 @@ pub use crate::auth::{Admin, Authenticate, User};
 pub use crate::config::Config;
 #[allow(deprecated)]
 pub use crate::device::{
-    connect, connect_model, Device, DeviceWrapper, Model, Pro, SdCardData, Storage,
-    StorageProductionInfo, StorageStatus, VolumeMode, VolumeStatus,
+    connect, Device, DeviceWrapper, Model, Pro, SdCardData, Storage, StorageProductionInfo,
+    StorageStatus, VolumeMode, VolumeStatus,
 };
 pub use crate::error::{CommandError, CommunicationError, Error, LibraryError};
 pub use crate::otp::{ConfigureOtp, GenerateOtp, OtpMode, OtpSlotData};
@@ -214,6 +214,38 @@ impl Manager {
             Err(CommunicationError::NotConnected.into())
         }
     }
+
+    /// Connects to a Nitrokey device of the given model.
+    ///
+    /// # Errors
+    ///
+    /// - [`NotConnected`][] if no Nitrokey device of the given model is connected
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use nitrokey::DeviceWrapper;
+    /// use nitrokey::Model;
+    ///
+    /// fn do_something(device: DeviceWrapper) {}
+    ///
+    /// # fn main() -> Result<(), nitrokey::Error> {
+    /// match nitrokey::take()?.connect_model(Model::Pro) {
+    ///     Ok(device) => do_something(device),
+    ///     Err(err) => println!("Could not connect to a Nitrokey Pro: {}", err),
+    /// }
+    /// #     Ok(())
+    /// # }
+    /// ```
+    ///
+    /// [`NotConnected`]: enum.CommunicationError.html#variant.NotConnected
+    pub fn connect_model(&mut self, model: Model) -> Result<DeviceWrapper, Error> {
+        if device::connect_enum(model) {
+            Ok(device::create_device_wrapper(model))
+        } else {
+            Err(CommunicationError::NotConnected.into())
+        }
+    }
 }
 
 /// Take an instance of the connection manager, blocking until an instance is available.
-- 
cgit v1.2.1


From 379bc798477a1de7ffda923c5d10ca63aebae25f Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Sun, 27 Jan 2019 18:21:08 +0000
Subject: Move {Pro, Storage}::connect into Manager

As part of the connection refactoring, this patch moves the connect
methods of the Pro and Storage structs into the Manager struct.  To
maintain compatibility with nitrokey-test, the old methods are not
removed but marked as deprecated.
---
 src/lib.rs | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 784dc6f..dc3432a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -246,6 +246,68 @@ impl Manager {
             Err(CommunicationError::NotConnected.into())
         }
     }
+
+    /// Connects to a Nitrokey Pro.
+    ///
+    /// # Errors
+    ///
+    /// - [`NotConnected`][] if no Nitrokey device of the given model is connected
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use nitrokey::Pro;
+    ///
+    /// fn use_pro(device: Pro) {}
+    ///
+    /// # fn main() -> Result<(), nitrokey::Error> {
+    /// match nitrokey::take()?.connect_pro() {
+    ///     Ok(device) => use_pro(device),
+    ///     Err(err) => println!("Could not connect to the Nitrokey Pro: {}", err),
+    /// }
+    /// #     Ok(())
+    /// # }
+    /// ```
+    ///
+    /// [`NotConnected`]: enum.CommunicationError.html#variant.NotConnected
+    pub fn connect_pro(&mut self) -> Result<Pro, Error> {
+        if device::connect_enum(device::Model::Pro) {
+            Ok(device::Pro::new())
+        } else {
+            Err(CommunicationError::NotConnected.into())
+        }
+    }
+
+    /// Connects to a Nitrokey Storage.
+    ///
+    /// # Errors
+    ///
+    /// - [`NotConnected`][] if no Nitrokey device of the given model is connected
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use nitrokey::Storage;
+    ///
+    /// fn use_storage(device: Storage) {}
+    ///
+    /// # fn main() -> Result<(), nitrokey::Error> {
+    /// match nitrokey::take()?.connect_storage() {
+    ///     Ok(device) => use_storage(device),
+    ///     Err(err) => println!("Could not connect to the Nitrokey Storage: {}", err),
+    /// }
+    /// #     Ok(())
+    /// # }
+    /// ```
+    ///
+    /// [`NotConnected`]: enum.CommunicationError.html#variant.NotConnected
+    pub fn connect_storage(&mut self) -> Result<Storage, Error> {
+        if device::connect_enum(Model::Storage) {
+            Ok(Storage::new())
+        } else {
+            Err(CommunicationError::NotConnected.into())
+        }
+    }
 }
 
 /// Take an instance of the connection manager, blocking until an instance is available.
-- 
cgit v1.2.1


From fe2f39826ade5a156945dabb8c8ab725378a15c1 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Sun, 27 Jan 2019 18:42:14 +0000
Subject: Store mutable reference to Manager in Device

In the last patches, we ensured that devices can only be obtained using
the Manager struct.  But we did not ensure that there is only one device
at a time.  This patch adds a mutable reference to the Manager instance
to the Device implementations.  The borrow checker makes sure that there
is only one mutable reference at a time.

In this patch, we have to remove the old connect, Pro::connect and
Storage::connect functions as they do no longer compile.  (They discard
the MutexGuard which invalidates the reference to the Manager.)
Therefore the tests do no longer compile.
---
 src/lib.rs | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index dc3432a..8b0aae5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -110,8 +110,8 @@ pub use crate::auth::{Admin, Authenticate, User};
 pub use crate::config::Config;
 #[allow(deprecated)]
 pub use crate::device::{
-    connect, Device, DeviceWrapper, Model, Pro, SdCardData, Storage, StorageProductionInfo,
-    StorageStatus, VolumeMode, VolumeStatus,
+    Device, DeviceWrapper, Model, Pro, SdCardData, Storage, StorageProductionInfo, StorageStatus,
+    VolumeMode, VolumeStatus,
 };
 pub use crate::error::{CommandError, CommunicationError, Error, LibraryError};
 pub use crate::otp::{ConfigureOtp, GenerateOtp, OtpMode, OtpSlotData};
@@ -204,12 +204,9 @@ impl Manager {
     /// ```
     ///
     /// [`NotConnected`]: enum.CommunicationError.html#variant.NotConnected
-    pub fn connect(&mut self) -> Result<DeviceWrapper, Error> {
+    pub fn connect(&mut self) -> Result<DeviceWrapper<'_>, Error> {
         if unsafe { nitrokey_sys::NK_login_auto() } == 1 {
-            match device::get_connected_device() {
-                Some(wrapper) => Ok(wrapper),
-                None => Err(CommunicationError::NotConnected.into()),
-            }
+            device::get_connected_device(self)
         } else {
             Err(CommunicationError::NotConnected.into())
         }
@@ -239,9 +236,9 @@ impl Manager {
     /// ```
     ///
     /// [`NotConnected`]: enum.CommunicationError.html#variant.NotConnected
-    pub fn connect_model(&mut self, model: Model) -> Result<DeviceWrapper, Error> {
+    pub fn connect_model(&mut self, model: Model) -> Result<DeviceWrapper<'_>, Error> {
         if device::connect_enum(model) {
-            Ok(device::create_device_wrapper(model))
+            Ok(device::create_device_wrapper(self, model))
         } else {
             Err(CommunicationError::NotConnected.into())
         }
@@ -270,9 +267,9 @@ impl Manager {
     /// ```
     ///
     /// [`NotConnected`]: enum.CommunicationError.html#variant.NotConnected
-    pub fn connect_pro(&mut self) -> Result<Pro, Error> {
+    pub fn connect_pro(&mut self) -> Result<Pro<'_>, Error> {
         if device::connect_enum(device::Model::Pro) {
-            Ok(device::Pro::new())
+            Ok(device::Pro::new(self))
         } else {
             Err(CommunicationError::NotConnected.into())
         }
@@ -301,9 +298,9 @@ impl Manager {
     /// ```
     ///
     /// [`NotConnected`]: enum.CommunicationError.html#variant.NotConnected
-    pub fn connect_storage(&mut self) -> Result<Storage, Error> {
+    pub fn connect_storage(&mut self) -> Result<Storage<'_>, Error> {
         if device::connect_enum(Model::Storage) {
-            Ok(Storage::new())
+            Ok(Storage::new(self))
         } else {
             Err(CommunicationError::NotConnected.into())
         }
-- 
cgit v1.2.1


From 62e8ee8f5d02511d6eb5dc179b087b04e88c1b94 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Sun, 27 Jan 2019 19:52:53 +0000
Subject: Update documentation for Manager refactoring

This patch updates the documentation to reflect the latest changes to
connection handling.  It also updates the doc tests to prefer the new
methods over the old ones.
---
 src/lib.rs | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 64 insertions(+), 13 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 8b0aae5..36a1dfd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,13 +9,16 @@
 //! performed without authentication, some require user access, and some require admin access.
 //! This is modelled using the types [`User`][] and [`Admin`][].
 //!
-//! Use [`connect`][] to connect to any Nitrokey device.  The method will return a
+//! You can only connect to one Nitrokey at a time.  Use the global [`take`][] function to obtain
+//! an reference to the [`Manager`][] singleton that keeps track of the connections.  Then use the
+//! [`connect`][] method to connect to any Nitrokey device.  The method will return a
 //! [`DeviceWrapper`][] that abstracts over the supported Nitrokey devices.  You can also use
-//! [`Pro::connect`][] or [`Storage::connect`][] to connect to a specific device.
+//! [`connect_model`][], [`connect_pro`][] or [`connect_storage`][] to connect to a specific
+//! device.
 //!
-//! You can then use [`authenticate_user`][] or [`authenticate_admin`][] to get an authenticated
-//! device that can perform operations that require authentication.  You can use [`device`][] to go
-//! back to the unauthenticated device.
+//! You can call [`authenticate_user`][] or [`authenticate_admin`][] to get an authenticated device
+//! that can perform operations that require authentication.  You can use [`device`][] to go back
+//! to the unauthenticated device.
 //!
 //! This makes sure that you can only execute a command if you have the required access rights.
 //! Otherwise, your code will not compile.  The only exception are the methods to generate one-time
@@ -31,7 +34,8 @@
 //! # use nitrokey::Error;
 //!
 //! # fn try_main() -> Result<(), Error> {
-//! let device = nitrokey::connect()?;
+//! let mut manager = nitrokey::take()?;
+//! let device = manager.connect()?;
 //! println!("{}", device.get_serial_number()?);
 //! #     Ok(())
 //! # }
@@ -44,7 +48,8 @@
 //! # use nitrokey::Error;
 //!
 //! # fn try_main() -> Result<(), Error> {
-//! let device = nitrokey::connect()?;
+//! let mut manager = nitrokey::take()?;
+//! let device = manager.connect()?;
 //! let slot_data = OtpSlotData::new(1, "test", "01234567890123456689", OtpMode::SixDigits);
 //! match device.authenticate_admin("12345678") {
 //!     Ok(mut admin) => {
@@ -66,7 +71,8 @@
 //! # use nitrokey::Error;
 //!
 //! # fn try_main() -> Result<(), Error> {
-//! let mut device = nitrokey::connect()?;
+//! let mut manager = nitrokey::take()?;
+//! let mut device = manager.connect()?;
 //! match device.get_hotp_code(1) {
 //!     Ok(code) => println!("Generated HOTP code: {}", code),
 //!     Err(err) => eprintln!("Could not generate HOTP code: {}", err),
@@ -77,9 +83,12 @@
 //!
 //! [`authenticate_admin`]: trait.Authenticate.html#method.authenticate_admin
 //! [`authenticate_user`]: trait.Authenticate.html#method.authenticate_user
-//! [`connect`]: fn.connect.html
-//! [`Pro::connect`]: struct.Pro.html#fn.connect.html
-//! [`Storage::connect`]: struct.Storage.html#fn.connect.html
+//! [`take`]: fn.take.html
+//! [`connect`]: struct.Manager.html#method.connect
+//! [`connect_model`]: struct.Manager.html#method.connect_model
+//! [`connect_pro`]: struct.Manager.html#method.connect_pro
+//! [`connect_storage`]: struct.Manager.html#method.connect_storage
+//! [`manager`]: trait.Device.html#method.manager
 //! [`device`]: struct.User.html#method.device
 //! [`get_hotp_code`]: trait.GenerateOtp.html#method.get_hotp_code
 //! [`get_totp_code`]: trait.GenerateOtp.html#method.get_totp_code
@@ -163,9 +172,50 @@ impl fmt::Display for Version {
 /// manager struct makes sure that `nitrokey-rs` does not try to connect to two devices at the same
 /// time.
 ///
-/// To obtain an instance of this manager, use the [`take`][] function.
+/// To obtain a reference to an instance of this manager, use the [`take`][] function.  Use one of
+/// the connect methods – [`connect`][], [`connect_model`][], [`connect_pro`][] or
+/// [`connect_storage`][] – to retrieve a [`Device`][] instance.
 ///
+/// # Examples
+///
+/// Connect to a single device:
+///
+/// ```no_run
+/// use nitrokey::Device;
+/// # use nitrokey::Error;
+///
+/// # fn try_main() -> Result<(), Error> {
+/// let mut manager = nitrokey::take()?;
+/// let device = manager.connect()?;
+/// println!("{}", device.get_serial_number()?);
+/// #     Ok(())
+/// # }
+/// ```
+///
+/// Connect to a Pro and a Storage device:
+///
+/// ```no_run
+/// use nitrokey::{Device, Model};
+/// # use nitrokey::Error;
+///
+/// # fn try_main() -> Result<(), Error> {
+/// let mut manager = nitrokey::take()?;
+/// let device = manager.connect_model(Model::Pro)?;
+/// println!("Pro: {}", device.get_serial_number()?);
+/// drop(device);
+/// let device = manager.connect_model(Model::Storage)?;
+/// println!("Storage: {}", device.get_serial_number()?);
+/// #     Ok(())
+/// # }
+/// ```
+///
+/// [`connect`]: #method.connect
+/// [`connect_model`]: #method.connect_model
+/// [`connect_pro`]: #method.connect_pro
+/// [`connect_storage`]: #method.connect_storage
+/// [`manager`]: trait.Device.html#method.manager
 /// [`take`]: fn.take.html
+/// [`Device`]: trait.Device.html
 #[derive(Debug)]
 pub struct Manager {
     marker: marker::PhantomData<()>,
@@ -195,7 +245,8 @@ impl Manager {
     /// fn do_something(device: DeviceWrapper) {}
     ///
     /// # fn main() -> Result<(), nitrokey::Error> {
-    /// match nitrokey::take()?.connect() {
+    /// let mut manager = nitrokey::take()?;
+    /// match manager.connect() {
     ///     Ok(device) => do_something(device),
     ///     Err(err) => println!("Could not connect to a Nitrokey: {}", err),
     /// }
-- 
cgit v1.2.1


From 88b32f5c2187e59fece93cd245aeadb4e5f9e04a Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Tue, 9 Jul 2019 10:22:08 +0000
Subject: Remove allow(deprecated) attribute for in lib.rs

During the connection manager refactoring, we temporarily used
deprecated methods.  This is no longer the case, so we can remove the
allow(deprecated) attribute.
---
 src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 36a1dfd..4e45877 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -117,7 +117,6 @@ use nitrokey_sys;
 
 pub use crate::auth::{Admin, Authenticate, User};
 pub use crate::config::Config;
-#[allow(deprecated)]
 pub use crate::device::{
     Device, DeviceWrapper, Model, Pro, SdCardData, Storage, StorageProductionInfo, StorageStatus,
     VolumeMode, VolumeStatus,
-- 
cgit v1.2.1


From 5e8f0fbaf6df0cb919e4b02401cc21d5280bf09c Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Tue, 9 Jul 2019 10:44:45 +0000
Subject: Add force_take function to ignore poisoned cache

The take and take_blocking functions return a PoisonError if the cache
is poisoned, i. e. if a thread panicked while holding the manager.  This
is a sensible default behaviour, but for example during testing, one
might want to ignore the poisoned cache.  This patch adds the force_take
function that unwraps the PoisonError and returns the cached Manager
even if the cache was poisoned.
---
 src/lib.rs | 32 +++++++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 4e45877..a4402c5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -377,7 +377,8 @@ pub fn take_blocking() -> Result<sync::MutexGuard<'static, Manager>, Error> {
 ///
 /// There may only be one [`Manager`][] instance at the same time.  If there already is an
 /// instance, a [`ConcurrentAccessError`][] is returned.  If you want a blocking version, use
-/// [`take_blocking`][].
+/// [`take_blocking`][].  If you want to access the manager instance even if the cache is poisoned,
+/// use [`force_take`][].
 ///
 /// # Errors
 ///
@@ -385,6 +386,7 @@ pub fn take_blocking() -> Result<sync::MutexGuard<'static, Manager>, Error> {
 /// - [`PoisonError`][] if the lock is poisoned
 ///
 /// [`take_blocking`]: fn.take_blocking.html
+/// [`force_take`]: fn.force_take.html
 /// [`ConcurrentAccessError`]: struct.Error.html#variant.ConcurrentAccessError
 /// [`PoisonError`]: struct.Error.html#variant.PoisonError
 /// [`Manager`]: struct.Manager.html
@@ -392,6 +394,34 @@ pub fn take() -> Result<sync::MutexGuard<'static, Manager>, Error> {
     MANAGER.try_lock().map_err(Into::into)
 }
 
+/// Try to take an instance of the connection manager, ignoring a poisoned cache.
+///
+/// There may only be one [`Manager`][] instance at the same time.  If there already is an
+/// instance, a [`ConcurrentAccessError`][] is returned.  If you want a blocking version, use
+/// [`take_blocking`][].
+///
+/// If a thread has previously panicked while accessing the manager instance, the cache is
+/// poisoned.  The default implementation, [`take`][], returns a [`PoisonError`][] on subsequent
+/// calls.  This implementation ignores the poisoned cache and returns the manager instance.
+///
+/// # Errors
+///
+/// - [`ConcurrentAccessError`][] if the token for the `Manager` instance cannot be locked
+///
+/// [`take`]: fn.take.html
+/// [`take_blocking`]: fn.take_blocking.html
+/// [`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),
+        },
+    }
+}
+
 /// Enables or disables debug output.  Calling this method with `true` is equivalent to setting the
 /// log level to `Debug`; calling it with `false` is equivalent to the log level `Error` (see
 /// [`set_log_level`][]).
-- 
cgit v1.2.1


From 4467ce7a2d1eedb320e92e5a26f1b93bc41d3611 Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Fri, 27 Dec 2019 23:08:29 +0100
Subject: Simplify doc tests with results

Since Rust 1.34.0, we no longer need a `fn main` comment in doc tests
that return results.  It is sufficient to have an `Ok` return value with
type annotations.
---
 src/lib.rs | 20 +++++---------------
 1 file changed, 5 insertions(+), 15 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index a4402c5..059792d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -243,14 +243,12 @@ impl Manager {
     ///
     /// fn do_something(device: DeviceWrapper) {}
     ///
-    /// # fn main() -> Result<(), nitrokey::Error> {
     /// let mut manager = nitrokey::take()?;
     /// match manager.connect() {
     ///     Ok(device) => do_something(device),
     ///     Err(err) => println!("Could not connect to a Nitrokey: {}", err),
     /// }
-    /// #     Ok(())
-    /// # }
+    /// # Ok::<(), nitrokey::Error>(())
     /// ```
     ///
     /// [`NotConnected`]: enum.CommunicationError.html#variant.NotConnected
@@ -276,13 +274,11 @@ impl Manager {
     ///
     /// fn do_something(device: DeviceWrapper) {}
     ///
-    /// # fn main() -> Result<(), nitrokey::Error> {
     /// match nitrokey::take()?.connect_model(Model::Pro) {
     ///     Ok(device) => do_something(device),
     ///     Err(err) => println!("Could not connect to a Nitrokey Pro: {}", err),
     /// }
-    /// #     Ok(())
-    /// # }
+    /// # Ok::<(), nitrokey::Error>(())
     /// ```
     ///
     /// [`NotConnected`]: enum.CommunicationError.html#variant.NotConnected
@@ -307,13 +303,11 @@ impl Manager {
     ///
     /// fn use_pro(device: Pro) {}
     ///
-    /// # fn main() -> Result<(), nitrokey::Error> {
     /// match nitrokey::take()?.connect_pro() {
     ///     Ok(device) => use_pro(device),
     ///     Err(err) => println!("Could not connect to the Nitrokey Pro: {}", err),
     /// }
-    /// #     Ok(())
-    /// # }
+    /// # Ok::<(), nitrokey::Error>(())
     /// ```
     ///
     /// [`NotConnected`]: enum.CommunicationError.html#variant.NotConnected
@@ -338,13 +332,11 @@ impl Manager {
     ///
     /// fn use_storage(device: Storage) {}
     ///
-    /// # fn main() -> Result<(), nitrokey::Error> {
     /// match nitrokey::take()?.connect_storage() {
     ///     Ok(device) => use_storage(device),
     ///     Err(err) => println!("Could not connect to the Nitrokey Storage: {}", err),
     /// }
-    /// #     Ok(())
-    /// # }
+    /// # Ok::<(), nitrokey::Error>(())
     /// ```
     ///
     /// [`NotConnected`]: enum.CommunicationError.html#variant.NotConnected
@@ -453,11 +445,9 @@ pub fn set_log_level(level: LogLevel) {
 /// # Example
 ///
 /// ```
-/// # fn main() -> Result<(), nitrokey::Error> {
 /// let version = nitrokey::get_library_version()?;
 /// println!("Using libnitrokey {}", version.git);
-/// #    Ok(())
-/// # }
+/// # Ok::<(), nitrokey::Error>(())
 /// ```
 ///
 /// [`Utf8Error`]: enum.Error.html#variant.Utf8Error
-- 
cgit v1.2.1