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/asynch.rs

@@ -10,6 +10,7 @@
 use crate::ipc::{
     self, IpcMessage, IpcReceiver, IpcReceiverSet, IpcSelectionResult, IpcSender, OpaqueIpcReceiver,
 };
+use crate::IpcError;
 use futures_channel::mpsc::UnboundedReceiver;
 use futures_channel::mpsc::UnboundedSender;
 use futures_core::stream::FusedStream;
@@ -96,7 +97,7 @@ impl<T> Stream for IpcStream<T>
 where
     T: for<'de> Deserialize<'de> + Serialize,
 {
-    type Item = Result<T, bincode::Error>;
+    type Item = Result<T, IpcError>;
 
     fn poll_next(mut self: Pin<&mut Self>, ctx: &mut Context) -> Poll<Option<Self::Item>> {
         let recv = Pin::new(&mut self.0);

src/error.rs

@@ -0,0 +1,25 @@
+use std::io;
+
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+#[non_exhaustive]
+pub enum SerializationError {}
+
+#[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.
@@ -364,7 +313,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(
@@ -744,7 +693,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 +835,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

@@ -7,20 +7,19 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use crate::ipc::{self, IpcMessage};
-use bincode;
+use crate::ipc::IpcMessage;
 use crossbeam_channel::{self, Receiver, RecvTimeoutError, Select, Sender, TryRecvError};
 use std::cell::{Ref, RefCell};
 use std::cmp::PartialEq;
 use std::collections::hash_map::HashMap;
-use std::error::Error as StdError;
 use std::fmt::{self, Debug, Formatter};
 use std::io;
 use std::ops::{Deref, RangeFrom};
 use std::slice;
 use std::sync::{Arc, LazyLock, Mutex};
 use std::time::Duration;
 use std::usize;
+use thiserror::Error;
 use uuid::Uuid;
 
 #[derive(Clone)]
@@ -387,11 +386,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,42 +405,23 @@ 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 {
+impl From<ChannelError> for crate::IpcError {
     fn from(error: ChannelError) -> Self {
         match error {
-            ChannelError::ChannelClosedError => ipc::IpcError::Disconnected,
-            e => ipc::IpcError::Bincode(io::Error::from(e).into()),
+            ChannelError::ChannelClosedError => crate::IpcError::Disconnected,
+            e => crate::IpcError::Io(io::Error::from(e).into()),
         }
     }
 }
 
-impl From<ChannelError> for ipc::TryRecvError {
+impl From<ChannelError> for crate::TryRecvError {
     fn from(error: ChannelError) -> Self {
         match error {
             ChannelError::ChannelClosedError => {
-                ipc::TryRecvError::IpcError(ipc::IpcError::Disconnected)
+                crate::TryRecvError::IpcError(crate::IpcError::Disconnected)
             },
-            ChannelError::ChannelEmpty => ipc::TryRecvError::Empty,
-            e => ipc::TryRecvError::IpcError(ipc::IpcError::Bincode(io::Error::from(e).into())),
+            ChannelError::ChannelEmpty => crate::TryRecvError::Empty,
+            e => crate::TryRecvError::IpcError(crate::IpcError::Io(io::Error::from(e).into())),
         }
     }
 }

src/platform/macos/mod.rs

@@ -12,14 +12,12 @@ use self::mach_sys::{kern_return_t, mach_msg_body_t, mach_msg_header_t, mach_msg
 use self::mach_sys::{mach_msg_ool_descriptor_t, mach_msg_port_descriptor_t, mach_msg_type_name_t};
 use self::mach_sys::{mach_msg_timeout_t, mach_port_limits_t, mach_port_msgcount_t};
 use self::mach_sys::{mach_port_right_t, mach_port_t, mach_task_self_, vm_inherit_t};
-use crate::ipc::{self, IpcMessage};
+use crate::ipc::IpcMessage;
 
-use bincode;
 use libc::{self, c_char, c_uint, c_void, size_t};
 use rand::{self, Rng};
 use std::cell::Cell;
 use std::convert::TryInto;
-use std::error::Error as StdError;
 use std::ffi::CString;
 use std::fmt::{self, Debug, Formatter};
 use std::io;
@@ -30,6 +28,7 @@ use std::ptr;
 use std::slice;
 use std::sync::RwLock;
 use std::time::Duration;
+use thiserror::Error;
 
 mod mach_sys;
 
@@ -997,43 +996,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 +1034,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 +1169,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,27 +1216,23 @@ 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 {
+impl From<MachError> for crate::TryRecvError {
     fn from(error: MachError) -> Self {
         match error {
-            MachError::NotifyNoSenders => ipc::TryRecvError::IpcError(ipc::IpcError::Disconnected),
-            MachError::RcvTimedOut => ipc::TryRecvError::Empty,
-            e => ipc::TryRecvError::IpcError(ipc::IpcError::Io(io::Error::from(e))),
+            MachError::NotifyNoSenders => {
+                crate::TryRecvError::IpcError(crate::IpcError::Disconnected)
+            },
+            MachError::RcvTimedOut => crate::TryRecvError::Empty,
+            e => crate::TryRecvError::IpcError(crate::IpcError::Io(io::Error::from(e))),
         }
     }
 }
 
-impl From<MachError> for ipc::IpcError {
+impl From<MachError> for crate::IpcError {
     fn from(error: MachError) -> Self {
         match error {
-            MachError::NotifyNoSenders => ipc::IpcError::Disconnected,
-            e => ipc::IpcError::Io(io::Error::from(e)),
+            MachError::NotifyNoSenders => crate::IpcError::Disconnected,
+            e => crate::IpcError::Io(io::Error::from(e)),
         }
     }
 }