Unify error handling to have IpcError and TryRecvError be the main error

types.
These types will give the Bincode error, Io errors (which are converted
from platform errors) and Disconnect.
Additionally we now use the thiserror crate which removes some of the
code.

Signed-off-by: Narfinger <[email protected]>

Author: Narfinger

Cargo.toml

@@ -38,6 +38,7 @@ futures-channel = { version = "0.3.31", optional = true }
 futures-core = { version = "0.3.31", optional = true }
 libc = "0.2.162"
 serde = { version = "1.0", features = ["rc"] }
+thiserror = "2.0.12"
 uuid = { version = "1", features = ["v4"] }
 
 [target.'cfg(any(target_os = "linux", target_os = "openbsd", target_os = "freebsd", target_os = "illumos"))'.dependencies]

src/error.rs

@@ -0,0 +1,30 @@
+use std::io;
+
+use thiserror::Error;
+
+#[cfg(all(
+    not(feature = "force-inprocess"),
+    any(
+        target_os = "linux",
+        target_os = "openbsd",
+        target_os = "freebsd",
+        target_os = "illumos",
+    )
+))]
+#[derive(Debug, Error)]
+pub enum IpcError {
+    #[error("Error in decoding or encoding: {0}")]
+    Bincode(#[from] bincode::Error),
+    #[error("Error in IO: {0}")]
+    Io(#[from] io::Error),
+    #[error("Ipc Disconnected")]
+    Disconnected,
+}
+
+#[derive(Debug, Error)]
+pub enum TryRecvError {
+    #[error("IPC error")]
+    IpcError(#[from] IpcError),
+    #[error("Channel empty")]
+    Empty,
+}

src/ipc.rs

@@ -11,12 +11,12 @@ use crate::platform::{self, OsIpcChannel, OsIpcReceiver, OsIpcReceiverSet, OsIpc
 use crate::platform::{
     OsIpcOneShotServer, OsIpcSelectionResult, OsIpcSharedMemory, OsOpaqueIpcChannel,
 };
+use crate::{IpcError, TryRecvError};
 
 use bincode;
 use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
 use std::cell::RefCell;
 use std::cmp::min;
-use std::error::Error as StdError;
 use std::fmt::{self, Debug, Formatter};
 use std::io;
 use std::marker::PhantomData;
@@ -37,57 +37,6 @@ thread_local! {
         const { RefCell::new(Vec::new()) }
 }
 
-#[derive(Debug)]
-pub enum IpcError {
-    Bincode(bincode::Error),
-    Io(io::Error),
-    Disconnected,
-}
-
-impl fmt::Display for IpcError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            IpcError::Bincode(ref err) => write!(fmt, "bincode error: {err}"),
-            IpcError::Io(ref err) => write!(fmt, "io error: {err}"),
-            IpcError::Disconnected => write!(fmt, "disconnected"),
-        }
-    }
-}
-
-impl StdError for IpcError {
-    fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        match *self {
-            IpcError::Bincode(ref err) => Some(err),
-            IpcError::Io(ref err) => Some(err),
-            IpcError::Disconnected => None,
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum TryRecvError {
-    IpcError(IpcError),
-    Empty,
-}
-
-impl fmt::Display for TryRecvError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            TryRecvError::IpcError(ref err) => write!(fmt, "ipc error: {err}"),
-            TryRecvError::Empty => write!(fmt, "empty"),
-        }
-    }
-}
-
-impl StdError for TryRecvError {
-    fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        match *self {
-            TryRecvError::IpcError(ref err) => Some(err),
-            TryRecvError::Empty => None,
-        }
-    }
-}
-
 /// Create a connected [IpcSender] and [IpcReceiver] that
 /// transfer messages of a given type provided by type `T`
 /// or inferred by the types of messages sent by the sender.
@@ -248,16 +197,12 @@ where
 {
     /// Blocking receive.
     pub fn recv(&self) -> Result<T, IpcError> {
-        self.os_receiver.recv()?.to().map_err(IpcError::Bincode)
+        self.os_receiver.recv()?.to()
     }
 
     /// Non-blocking receive
     pub fn try_recv(&self) -> Result<T, TryRecvError> {
-        self.os_receiver
-            .try_recv()?
-            .to()
-            .map_err(IpcError::Bincode)
-            .map_err(TryRecvError::IpcError)
+        self.os_receiver.try_recv()?.to().map_err(|e| e.into())
     }
 
     /// Blocks for up to the specified duration attempting to receive a message.
@@ -270,8 +215,7 @@ where
         self.os_receiver
             .try_recv_timeout(duration)?
             .to()
-            .map_err(IpcError::Bincode)
-            .map_err(TryRecvError::IpcError)
+            .map_err(|e| e.into())
     }
 
     /// Erase the type of the channel.
@@ -364,7 +308,7 @@ where
     }
 
     /// Send data across the channel to the receiver.
-    pub fn send(&self, data: T) -> Result<(), bincode::Error> {
+    pub fn send(&self, data: T) -> Result<(), IpcError> {
         let mut bytes = Vec::with_capacity(4096);
         OS_IPC_CHANNELS_FOR_SERIALIZATION.with(|os_ipc_channels_for_serialization| {
             OS_IPC_SHARED_MEMORY_REGIONS_FOR_SERIALIZATION.with(
@@ -726,7 +670,7 @@ impl IpcMessage {
     }
 
     /// Deserialize the raw data in the contained message into the inferred type.
-    pub fn to<T>(mut self) -> Result<T, bincode::Error>
+    pub fn to<T>(mut self) -> Result<T, IpcError>
     where
         T: for<'de> Deserialize<'de> + Serialize,
     {
@@ -744,7 +688,7 @@ impl IpcMessage {
                             .map(Some)
                             .collect(),
                     );
-                    let result = bincode::deserialize(&self.data[..]);
+                    let result = bincode::deserialize(&self.data[..]).map_err(|e| e.into());
                     *os_ipc_shared_memory_regions_for_deserialization.borrow_mut() =
                         old_ipc_shared_memory_regions_for_deserialization;
                     mem::swap(
@@ -886,7 +830,7 @@ where
         ))
     }
 
-    pub fn accept(self) -> Result<(IpcReceiver<T>, T), bincode::Error> {
+    pub fn accept(self) -> Result<(IpcReceiver<T>, T), IpcError> {
         let (os_receiver, ipc_message) = self.os_server.accept()?;
         Ok((
             IpcReceiver {

src/lib.rs

@@ -32,11 +32,12 @@ pub mod asynch;
 #[cfg(all(not(feature = "force-inprocess"), target_os = "windows"))]
 extern crate windows;
 
+mod error;
 pub mod ipc;
 pub mod platform;
 pub mod router;
 
 #[cfg(test)]
 mod test;
 
-pub use bincode::{Error, ErrorKind};
+pub use error::{IpcError, TryRecvError};

src/platform/inprocess/mod.rs

@@ -387,11 +387,15 @@ impl OsIpcSharedMemory {
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Error)]
 pub enum ChannelError {
+    #[error("Channel Closed")]
     ChannelClosedError,
+    #[error("Broken Pipe")]
     BrokenPipeError,
+    #[error("Channel Empty")]
     ChannelEmpty,
+    #[error("Unknown Error")]
     UnknownError,
 }
 
@@ -402,30 +406,11 @@ impl ChannelError {
     }
 }
 
-impl fmt::Display for ChannelError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            ChannelError::ChannelClosedError => write!(fmt, "channel closed"),
-            ChannelError::BrokenPipeError => write!(fmt, "broken pipe"),
-            ChannelError::ChannelEmpty => write!(fmt, "channel empty"),
-            ChannelError::UnknownError => write!(fmt, "unknown error"),
-        }
-    }
-}
-
-impl StdError for ChannelError {}
-
-impl From<ChannelError> for bincode::Error {
-    fn from(crossbeam_error: ChannelError) -> Self {
-        io::Error::from(crossbeam_error).into()
-    }
-}
-
 impl From<ChannelError> for ipc::IpcError {
     fn from(error: ChannelError) -> Self {
         match error {
             ChannelError::ChannelClosedError => ipc::IpcError::Disconnected,
-            e => ipc::IpcError::Bincode(io::Error::from(e).into()),
+            e => ipc::IpcError::Io(io::Error::from(e).into()),
         }
     }
 }
@@ -437,7 +422,7 @@ impl From<ChannelError> for ipc::TryRecvError {
                 ipc::TryRecvError::IpcError(ipc::IpcError::Disconnected)
             },
             ChannelError::ChannelEmpty => ipc::TryRecvError::Empty,
-            e => ipc::TryRecvError::IpcError(ipc::IpcError::Bincode(io::Error::from(e).into())),
+            e => ipc::TryRecvError::IpcError(ipc::IpcError::Io(io::Error::from(e).into())),
         }
     }
 }

src/platform/macos/mod.rs

@@ -997,43 +997,28 @@ impl Message {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, Error, PartialEq)]
 pub enum KernelError {
+    #[error("Success")]
     Success,
+    #[error("No room in IPC name space for another right.")]
     NoSpace,
+    #[error("Name doesn't denote a right in the task")]
     InvalidName,
+    #[error("Name denotes a right, but not an appropiate right.")]
     InvalidRight,
+    #[error("Blatant range error")]
     InvalidValue,
+    #[error("The supplied (port) capability is improper")]
     InvalidCapability,
+    #[error("Operation would overflow limit on user-references")]
     UrefsOverflow,
+    #[error("Receive right is not a member of a port set.")]
     NotInSet,
+    #[error("Unkown kernel error. {0}")]
     Unknown(kern_return_t),
 }
 
-impl fmt::Display for KernelError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            KernelError::Success => write!(fmt, "Success."),
-            KernelError::NoSpace => write!(fmt, "No room in IPC name space for another right."),
-            KernelError::InvalidName => write!(fmt, "Name doesn't denote a right in the task."),
-            KernelError::InvalidRight => {
-                write!(fmt, "Name denotes a right, but not an appropriate right.")
-            },
-            KernelError::InvalidValue => write!(fmt, "Blatant range error."),
-            KernelError::InvalidCapability => {
-                write!(fmt, "The supplied (port) capability is improper.")
-            },
-            KernelError::UrefsOverflow => {
-                write!(fmt, "Operation would overflow limit on user-references.")
-            },
-            KernelError::NotInSet => write!(fmt, "Receive right is not a member of a port set."),
-            KernelError::Unknown(code) => write!(fmt, "Unknown kernel error: {:x}", code),
-        }
-    }
-}
-
-impl StdError for KernelError {}
-
 impl From<kern_return_t> for KernelError {
     fn from(code: kern_return_t) -> KernelError {
         match code {
@@ -1050,10 +1035,10 @@ impl From<kern_return_t> for KernelError {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, Error, PartialEq)]
 pub enum MachError {
     Success,
-    Kernel(KernelError),
+    Kernel(#[from] KernelError),
     IpcSpace,
     VmSpace,
     IpcKernel,
@@ -1185,14 +1170,6 @@ impl fmt::Display for MachError {
     }
 }
 
-impl StdError for MachError {}
-
-impl From<MachError> for bincode::Error {
-    fn from(mach_error: MachError) -> Self {
-        io::Error::from(mach_error).into()
-    }
-}
-
 impl From<mach_msg_return_t> for MachError {
     fn from(code: mach_msg_return_t) -> MachError {
         match code {
@@ -1240,12 +1217,6 @@ impl From<mach_msg_return_t> for MachError {
     }
 }
 
-impl From<KernelError> for MachError {
-    fn from(kernel_error: KernelError) -> MachError {
-        MachError::Kernel(kernel_error)
-    }
-}
-
 impl From<MachError> for ipc::TryRecvError {
     fn from(error: MachError) -> Self {
         match error {