Remove no longer necessary msg parameter from try_with_* functions

With the move to using anyhow's Error type and adding contextual
information at the point where we bubble up errors, we no longer require
the 'msg' argument that is passed to the try_with_pin_* and authenticate
functions.
To that end, this change removes this parameter, concluding the switch
to using anyhow.

1 files changed, 46 insertions, 83 deletions

diff --git a/src/commands.rs b/src/commands.rs
index c9dd629..1d59af5 100644
--- a/src/commands.rs
+++ b/src/commands.rs
@@ -103,31 +103,24 @@ where
 {
   with_device(ctx, |ctx, mut device| {
     let pin_entry = pinentry::PinEntry::from(args::PinType::User, &device)?;
-    try_with_pin_and_data(
-      ctx,
-      &pin_entry,
-      "Could not access the password safe",
-      (),
-      move |ctx, _, pin| {
-        let pws = device
-          .get_password_safe(pin)
-          .map_err(|err| ((), err.into()))?;
-
-        op(ctx, pws).map_err(|err| ((), err))
-      },
-    )
+    try_with_pin_and_data(ctx, &pin_entry, (), move |ctx, _, pin| {
+      let pws = device.get_password_safe(pin).or_else(|err| {
+        Err(err)
+          .context("Could not access the password safe")
+          .map_err(|err| ((), err))
+      })?;
+
+      op(ctx, pws).map_err(|err| ((), err))
+    })
   })?;
   Ok(())
 }
 
 /// Authenticate the given device using the given PIN type and operation.
-///
-/// If an error occurs, the error message `msg` is used.
 fn authenticate<'mgr, D, A, F>(
   ctx: &mut ExecCtx<'_>,
   device: D,
   pin_type: args::PinType,
-  msg: &'static str,
   op: F,
 ) -> anyhow::Result<A>
 where
@@ -136,7 +129,7 @@ where
 {
   let pin_entry = pinentry::PinEntry::from(pin_type, &device)?;
 
-  try_with_pin_and_data(ctx, &pin_entry, msg, device, op)
+  try_with_pin_and_data(ctx, &pin_entry, device, op)
 }
 
 /// Authenticate the given device with the user PIN.
@@ -147,19 +140,13 @@ fn authenticate_user<'mgr, T>(
 where
   T: Device<'mgr>,
 {
-  authenticate(
-    ctx,
-    device,
-    args::PinType::User,
-    "Could not authenticate as user",
-    |_ctx, device, pin| {
-      device.authenticate_user(pin).or_else(|(x, err)| {
-        Err(err)
-          .context("Failed to authenticate as user")
-          .map_err(|err| (x, err))
-      })
-    },
-  )
+  authenticate(ctx, device, args::PinType::User, |_ctx, device, pin| {
+    device.authenticate_user(pin).or_else(|(x, err)| {
+      Err(err)
+        .context("Failed to authenticate as user")
+        .map_err(|err| (x, err))
+    })
+  })
 }
 
 /// Authenticate the given device with the admin PIN.
@@ -170,19 +157,13 @@ fn authenticate_admin<'mgr, T>(
 where
   T: Device<'mgr>,
 {
-  authenticate(
-    ctx,
-    device,
-    args::PinType::Admin,
-    "Could not authenticate as admin",
-    |_ctx, device, pin| {
-      device.authenticate_admin(pin).or_else(|(x, err)| {
-        Err(err)
-          .context("Failed to authenticate as admin")
-          .map_err(|err| (x, err))
-      })
-    },
-  )
+  authenticate(ctx, device, args::PinType::Admin, |_ctx, device, pin| {
+    device.authenticate_admin(pin).or_else(|(x, err)| {
+      Err(err)
+        .context("Failed to authenticate as admin")
+        .map_err(|err| (x, err))
+    })
+  })
 }
 
 /// Return a string representation of the given volume status.
@@ -215,7 +196,6 @@ fn get_volume_status(status: &nitrokey::VolumeStatus) -> &'static str {
 fn try_with_pin_and_data_with_pinentry<D, F, R>(
   ctx: &mut ExecCtx<'_>,
   pin_entry: &pinentry::PinEntry,
-  _msg: &'static str,
   data: D,
   mut op: F,
 ) -> anyhow::Result<R>
@@ -254,7 +234,6 @@ where
 fn try_with_pin_and_data<D, F, R>(
   ctx: &mut ExecCtx<'_>,
   pin_entry: &pinentry::PinEntry,
-  msg: &'static str,
   data: D,
   mut op: F,
 ) -> anyhow::Result<R>
@@ -275,7 +254,7 @@ where
       .ok_or_else(|| anyhow::anyhow!("Failed to read PIN: Invalid Unicode data found"))?;
     op(ctx, data, &pin).map_err(|(_, err)| err)
   } else {
-    try_with_pin_and_data_with_pinentry(ctx, pin_entry, msg, data, op)
+    try_with_pin_and_data_with_pinentry(ctx, pin_entry, data, op)
   }
 }
 
@@ -286,13 +265,12 @@ where
 fn try_with_pin<F>(
   ctx: &mut ExecCtx<'_>,
   pin_entry: &pinentry::PinEntry,
-  msg: &'static str,
   mut op: F,
 ) -> anyhow::Result<()>
 where
   F: FnMut(&str) -> anyhow::Result<()>,
 {
-  try_with_pin_and_data(ctx, pin_entry, msg, (), |_ctx, data, pin| {
+  try_with_pin_and_data(ctx, pin_entry, (), |_ctx, data, pin| {
     op(pin).map_err(|err| (data, err))
   })
 }
@@ -437,7 +415,7 @@ pub fn reset(ctx: &mut ExecCtx<'_>) -> anyhow::Result<()> {
     // factory reset, we clear the pinentry cache for the admin PIN.
     pinentry::clear(&pin_entry).context("Failed to clear cached secret")?;
 
-    try_with_pin(ctx, &pin_entry, "Factory reset failed", |pin| {
+    try_with_pin(ctx, &pin_entry, |pin| {
       device
         .factory_reset(&pin)
         .context("Failed to reset to factory settings")?;
@@ -472,16 +450,11 @@ pub fn unencrypted_set(
     // disk.
     unsafe { sync() };
 
-    try_with_pin(
-      ctx,
-      &pin_entry,
-      "Changing unencrypted volume mode failed",
-      |pin| {
-        device
-          .set_unencrypted_volume_mode(&pin, mode)
-          .context("Failed to change unencrypted volume mode")
-      },
-    )
+    try_with_pin(ctx, &pin_entry, |pin| {
+      device
+        .set_unencrypted_volume_mode(&pin, mode)
+        .context("Failed to change unencrypted volume mode")
+    })
   })
 }
 
@@ -494,7 +467,7 @@ pub fn encrypted_open(ctx: &mut ExecCtx<'_>) -> anyhow::Result<()> {
     // flush caches to disk.
     unsafe { sync() };
 
-    try_with_pin(ctx, &pin_entry, "Opening encrypted volume failed", |pin| {
+    try_with_pin(ctx, &pin_entry, |pin| {
       device
         .enable_encrypted_volume(&pin)
         .context("Failed to open encrypted volume")
@@ -869,19 +842,14 @@ pub fn pin_set(ctx: &mut ExecCtx<'_>, pin_type: args::PinType) -> anyhow::Result
     let pin_entry = pinentry::PinEntry::from(pin_type, &device)?;
     let new_pin = choose_pin(ctx, &pin_entry, true)?;
 
-    try_with_pin(
-      ctx,
-      &pin_entry,
-      "Could not change the PIN",
-      |current_pin| match pin_type {
-        args::PinType::Admin => device
-          .change_admin_pin(&current_pin, &new_pin)
-          .context("Failed to change admin PIN"),
-        args::PinType::User => device
-          .change_user_pin(&current_pin, &new_pin)
-          .context("Failed to change user PIN"),
-      },
-    )?;
+    try_with_pin(ctx, &pin_entry, |current_pin| match pin_type {
+      args::PinType::Admin => device
+        .change_admin_pin(&current_pin, &new_pin)
+        .context("Failed to change admin PIN"),
+      args::PinType::User => device
+        .change_user_pin(&current_pin, &new_pin)
+        .context("Failed to change user PIN"),
+    })?;
 
     // We just changed the PIN but confirmed the action with the old PIN,
     // which may have caused it to be cached. Since it no longer applies,
@@ -897,16 +865,11 @@ pub fn pin_unblock(ctx: &mut ExecCtx<'_>) -> anyhow::Result<()> {
     let user_pin = choose_pin(ctx, &pin_entry, false)?;
     let pin_entry = pinentry::PinEntry::from(args::PinType::Admin, &device)?;
 
-    try_with_pin(
-      ctx,
-      &pin_entry,
-      "Could not unblock the user PIN",
-      |admin_pin| {
-        device
-          .unlock_user_pin(&admin_pin, &user_pin)
-          .context("Failed to unblock user PIN")
-      },
-    )
+    try_with_pin(ctx, &pin_entry, |admin_pin| {
+      device
+        .unlock_user_pin(&admin_pin, &user_pin)
+        .context("Failed to unblock user PIN")
+    })
   })
 }