age-core: Add plugin::Error enum

age-core/CHANGELOG.md

@@ -7,11 +7,16 @@ and this project adheres to Rust's notion of
 to 1.0.0 are beta releases.
 
 ## [Unreleased]
+### Added
+- `age_core::plugin::Error`
+
 ### Changed
 - MSRV is now 1.51.0.
 - The `body` property of `age_core::format::AgeStanza` has been replaced by the
   `AgeStanza::body` method, to enable enclosing parsers to defer Base64 decoding
   until the very end.
+- `age_core::plugin::Result` now only takes a single generic argument, and uses
+  `age_core::plugin::Error` for its inner error type.
 
 ## [0.6.0] - 2021-05-02
 ### Security

age-core/src/plugin.rs

@@ -1,5 +1,6 @@
 use rand::{thread_rng, Rng};
 use secrecy::Zeroize;
+use std::fmt;
 use std::io::{self, BufRead, BufReader, Read, Write};
 use std::iter;
 use std::path::Path;
@@ -15,13 +16,29 @@ const RESPONSE_OK: &str = "ok";
 const RESPONSE_FAIL: &str = "fail";
 const RESPONSE_UNSUPPORTED: &str = "unsupported";
 
+/// An error within the plugin protocol.
+#[derive(Debug)]
+pub enum Error {
+    Fail,
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Fail => write!(f, "General plugin protocol error"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
 /// Result type for the plugin protocol.
 ///
 /// - The outer error indicates a problem with the IPC transport or state machine; these
 ///   should result in the state machine being terminated and the connection closed.
 /// - The inner error indicates an error within the plugin protocol, that the recipient
 ///   should explicitly handle.
-pub type Result<T, E> = io::Result<std::result::Result<T, E>>;
+pub type Result<T> = io::Result<std::result::Result<T, Error>>;
 
 type UnidirResult<A, B, C, E> = io::Result<(
     std::result::Result<Vec<A>, Vec<E>>,
@@ -287,7 +304,7 @@ pub struct BidirSend<'a, R: Read, W: Write>(&'a mut Connection<R, W>);
 
 impl<'a, R: Read, W: Write> BidirSend<'a, R, W> {
     /// Send a command and receive a response.
-    pub fn send(&mut self, command: &str, metadata: &[&str], data: &[u8]) -> Result<Stanza, ()> {
+    pub fn send(&mut self, command: &str, metadata: &[&str], data: &[u8]) -> Result<Stanza> {
         for grease in self.0.grease_gun() {
             self.0.send(&grease.tag, &grease.args, &grease.body)?;
             self.0.receive()?;
@@ -296,7 +313,7 @@ impl<'a, R: Read, W: Write> BidirSend<'a, R, W> {
         let s = self.0.receive()?;
         match s.tag.as_ref() {
             RESPONSE_OK => Ok(Ok(s)),
-            RESPONSE_FAIL => Ok(Err(())),
+            RESPONSE_FAIL => Ok(Err(Error::Fail)),
             tag => Err(io::Error::new(
                 io::ErrorKind::InvalidData,
                 format!("unexpected response: {}", tag),
@@ -310,7 +327,7 @@ impl<'a, R: Read, W: Write> BidirSend<'a, R, W> {
         command: &str,
         metadata: &[&str],
         stanza: &Stanza,
-    ) -> Result<Stanza, ()> {
+    ) -> Result<Stanza> {
         for grease in self.0.grease_gun() {
             self.0.send(&grease.tag, &grease.args, &grease.body)?;
             self.0.receive()?;
@@ -319,7 +336,7 @@ impl<'a, R: Read, W: Write> BidirSend<'a, R, W> {
         let s = self.0.receive()?;
         match s.tag.as_ref() {
             RESPONSE_OK => Ok(Ok(s)),
-            RESPONSE_FAIL => Ok(Err(())),
+            RESPONSE_FAIL => Ok(Err(Error::Fail)),
             tag => Err(io::Error::new(
                 io::ErrorKind::InvalidData,
                 format!("unexpected response: {}", tag),

age-plugin/CHANGELOG.md

@@ -11,6 +11,8 @@ to 1.0.0 are beta releases.
 ## [Unreleased]
 ### Changed
 - MSRV is now 1.51.0.
+- `age_plugin::Callbacks` methods now return `age_core::plugin::Error` instead
+  of `()` for internal errors, following changes to `age_core::plugin::Result`.
 
 ## [0.1.0] - 2021-05-02
 Initial beta release!

age-plugin/src/identity.rs

@@ -56,13 +56,13 @@ impl<'a, 'b, R: io::Read, W: io::Write> Callbacks<Error> for BidirCallbacks<'a,
     ///
     /// This can be used to prompt the user to take some physical action, such as
     /// inserting a hardware key.
-    fn message(&mut self, message: &str) -> plugin::Result<(), ()> {
+    fn message(&mut self, message: &str) -> plugin::Result<()> {
         self.0
             .send("msg", &[], message.as_bytes())
             .map(|res| res.map(|_| ()))
     }
 
-    fn request_public(&mut self, message: &str) -> plugin::Result<String, ()> {
+    fn request_public(&mut self, message: &str) -> plugin::Result<String> {
         self.0
             .send("request-public", &[], message.as_bytes())
             .and_then(|res| match res {
@@ -71,25 +71,25 @@ impl<'a, 'b, R: io::Read, W: io::Write> Callbacks<Error> for BidirCallbacks<'a,
                         io::Error::new(io::ErrorKind::InvalidData, "response is not UTF-8")
                     })
                     .map(Ok),
-                Err(()) => Ok(Err(())),
+                Err(e) => Ok(Err(e)),
             })
     }
 
     /// Requests a secret value from the user, such as a passphrase.
     ///
     /// `message` will be displayed to the user, providing context for the request.
-    fn request_secret(&mut self, message: &str) -> plugin::Result<SecretString, ()> {
+    fn request_secret(&mut self, message: &str) -> plugin::Result<SecretString> {
         self.0
             .send("request-secret", &[], message.as_bytes())
             .and_then(|res| match res {
                 Ok(s) => String::from_utf8(s.body)
                     .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "secret is not UTF-8"))
                     .map(|s| Ok(SecretString::new(s))),
-                Err(()) => Ok(Err(())),
+                Err(e) => Ok(Err(e)),
             })
     }
 
-    fn error(&mut self, error: Error) -> plugin::Result<(), ()> {
+    fn error(&mut self, error: Error) -> plugin::Result<()> {
         error.send(self.0).map(|()| Ok(()))
     }
 }

age-plugin/src/lib.rs

@@ -234,24 +234,24 @@ pub trait Callbacks<E> {
     ///
     /// This can be used to prompt the user to take some physical action, such as
     /// inserting a hardware key.
-    fn message(&mut self, message: &str) -> age_core::plugin::Result<(), ()>;
+    fn message(&mut self, message: &str) -> age_core::plugin::Result<()>;
 
     /// Requests a non-secret value from the user.
     ///
     /// `message` will be displayed to the user, providing context for the request.
     ///
     /// To request secrets, use [`Callbacks::request_secret`].
-    fn request_public(&mut self, message: &str) -> age_core::plugin::Result<String, ()>;
+    fn request_public(&mut self, message: &str) -> age_core::plugin::Result<String>;
 
     /// Requests a secret value from the user, such as a passphrase.
     ///
     /// `message` will be displayed to the user, providing context for the request.
-    fn request_secret(&mut self, message: &str) -> age_core::plugin::Result<SecretString, ()>;
+    fn request_secret(&mut self, message: &str) -> age_core::plugin::Result<SecretString>;
 
     /// Sends an error.
     ///
     /// Note: This API may be removed in a subsequent API refactor, after we've figured
     /// out how errors should be handled overall, and how to distinguish between hard and
     /// soft errors.
-    fn error(&mut self, error: E) -> age_core::plugin::Result<(), ()>;
+    fn error(&mut self, error: E) -> age_core::plugin::Result<()>;
 }

age-plugin/src/recipient.rs

@@ -56,13 +56,13 @@ impl<'a, 'b, R: io::Read, W: io::Write> Callbacks<Error> for BidirCallbacks<'a,
     ///
     /// This can be used to prompt the user to take some physical action, such as
     /// inserting a hardware key.
-    fn message(&mut self, message: &str) -> plugin::Result<(), ()> {
+    fn message(&mut self, message: &str) -> plugin::Result<()> {
         self.0
             .send("msg", &[], message.as_bytes())
             .map(|res| res.map(|_| ()))
     }
 
-    fn request_public(&mut self, message: &str) -> plugin::Result<String, ()> {
+    fn request_public(&mut self, message: &str) -> plugin::Result<String> {
         self.0
             .send("request-public", &[], message.as_bytes())
             .and_then(|res| match res {
@@ -71,25 +71,25 @@ impl<'a, 'b, R: io::Read, W: io::Write> Callbacks<Error> for BidirCallbacks<'a,
                         io::Error::new(io::ErrorKind::InvalidData, "response is not UTF-8")
                     })
                     .map(Ok),
-                Err(()) => Ok(Err(())),
+                Err(e) => Ok(Err(e)),
             })
     }
 
     /// Requests a secret value from the user, such as a passphrase.
     ///
     /// `message` will be displayed to the user, providing context for the request.
-    fn request_secret(&mut self, message: &str) -> plugin::Result<SecretString, ()> {
+    fn request_secret(&mut self, message: &str) -> plugin::Result<SecretString> {
         self.0
             .send("request-secret", &[], message.as_bytes())
             .and_then(|res| match res {
                 Ok(s) => String::from_utf8(s.body)
                     .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "secret is not UTF-8"))
                     .map(|s| Ok(SecretString::new(s))),
-                Err(()) => Ok(Err(())),
+                Err(e) => Ok(Err(e)),
             })
     }
 
-    fn error(&mut self, error: Error) -> plugin::Result<(), ()> {
+    fn error(&mut self, error: Error) -> plugin::Result<()> {
         error.send(self.0).map(|()| Ok(()))
     }
 }