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/device.rs | 64 +++++++++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 54 insertions(+), 10 deletions(-)

(limited to 'src/device.rs')

diff --git a/src/device.rs b/src/device.rs
index 50ff071..e1a71fa 100644
--- a/src/device.rs
+++ b/src/device.rs
@@ -156,7 +156,7 @@ pub enum DeviceWrapper<'a> {
 /// [`Pro::connect`]: #method.connect
 #[derive(Debug)]
 pub struct Pro<'a> {
-    manager: &'a mut crate::Manager,
+    manager: Option<&'a mut crate::Manager>,
 }
 
 /// A Nitrokey Storage device without user or admin authentication.
@@ -200,7 +200,7 @@ pub struct Pro<'a> {
 /// [`Storage::connect`]: #method.connect
 #[derive(Debug)]
 pub struct Storage<'a> {
-    manager: &'a mut crate::Manager,
+    manager: Option<&'a mut crate::Manager>,
 }
 
 /// The status of a volume on a Nitrokey Storage device.
@@ -291,7 +291,32 @@ pub struct StorageStatus {
 ///
 /// This trait provides the commands that can be executed without authentication and that are
 /// present on all supported Nitrokey devices.
-pub trait Device: Authenticate + GetPasswordSafe + GenerateOtp + fmt::Debug {
+pub trait Device<'a>: Authenticate<'a> + GetPasswordSafe<'a> + GenerateOtp + fmt::Debug {
+    /// Returns the [`Manager`][] instance that has been used to connect to this device.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use nitrokey::{Device, DeviceWrapper};
+    ///
+    /// fn do_something(device: DeviceWrapper) {
+    ///     // reconnect to any device
+    ///     let manager = device.into_manager();
+    ///     let device = manager.connect();
+    ///     // do something with the device
+    ///     // ...
+    /// }
+    ///
+    /// # 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(())
+    /// # }
+    /// ```
+    fn into_manager(self) -> &'a mut crate::Manager;
+
     /// Returns the model of the connected Nitrokey device.
     ///
     /// # Example
@@ -657,14 +682,14 @@ pub(crate) fn connect_enum(model: Model) -> bool {
 }
 
 impl<'a> DeviceWrapper<'a> {
-    fn device(&self) -> &dyn Device {
+    fn device(&self) -> &dyn Device<'a> {
         match *self {
             DeviceWrapper::Storage(ref storage) => storage,
             DeviceWrapper::Pro(ref pro) => pro,
         }
     }
 
-    fn device_mut(&mut self) -> &mut dyn Device {
+    fn device_mut(&mut self) -> &mut dyn Device<'a> {
         match *self {
             DeviceWrapper::Storage(ref mut storage) => storage,
             DeviceWrapper::Pro(ref mut pro) => pro,
@@ -702,7 +727,14 @@ impl<'a> GenerateOtp for DeviceWrapper<'a> {
     }
 }
 
-impl<'a> Device for DeviceWrapper<'a> {
+impl<'a> Device<'a> for DeviceWrapper<'a> {
+    fn into_manager(self) -> &'a mut crate::Manager {
+        match self {
+            DeviceWrapper::Pro(dev) => dev.into_manager(),
+            DeviceWrapper::Storage(dev) => dev.into_manager(),
+        }
+    }
+
     fn get_model(&self) -> Model {
         match *self {
             DeviceWrapper::Pro(_) => Model::Pro,
@@ -713,7 +745,9 @@ impl<'a> Device for DeviceWrapper<'a> {
 
 impl<'a> Pro<'a> {
     pub(crate) fn new(manager: &'a mut crate::Manager) -> Pro<'a> {
-        Pro { manager }
+        Pro {
+            manager: Some(manager),
+        }
     }
 }
 
@@ -725,7 +759,11 @@ impl<'a> Drop for Pro<'a> {
     }
 }
 
-impl<'a> Device for Pro<'a> {
+impl<'a> Device<'a> for Pro<'a> {
+    fn into_manager(mut self) -> &'a mut crate::Manager {
+        self.manager.take().unwrap()
+    }
+
     fn get_model(&self) -> Model {
         Model::Pro
     }
@@ -735,7 +773,9 @@ impl<'a> GenerateOtp for Pro<'a> {}
 
 impl<'a> Storage<'a> {
     pub(crate) fn new(manager: &'a mut crate::Manager) -> Storage<'a> {
-        Storage { manager }
+        Storage {
+            manager: Some(manager),
+        }
     }
 
     /// Changes the update PIN.
@@ -1248,7 +1288,11 @@ impl<'a> Drop for Storage<'a> {
     }
 }
 
-impl<'a> Device for Storage<'a> {
+impl<'a> Device<'a> for Storage<'a> {
+    fn into_manager(mut self) -> &'a mut crate::Manager {
+        self.manager.take().unwrap()
+    }
+
     fn get_model(&self) -> Model {
         Model::Storage
     }
-- 
cgit v1.2.1