keep standard I/O errors

src/comm/mod.rs

-use crate::locking::MutexGuard;
+use crate::{locking::MutexGuard, Error};
 use rtsc::data_policy::DataDeliveryPolicy;
 use std::{
     io::{Read, Write},
@@ -60,6 +60,29 @@ impl Client {
     }
 }
 
+impl Read for Client {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        match self.0.read_exact(buf) {
+            Ok(()) => Ok(buf.len()),
+            Err(Error::IO(e)) => Err(e),
+            Err(e) => Err(std::io::Error::new(std::io::ErrorKind::Other, e)),
+        }
+    }
+}
+
+impl Write for Client {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        match self.0.write(buf) {
+            Ok(()) => Ok(buf.len()),
+            Err(Error::IO(e)) => Err(e),
+            Err(e) => Err(std::io::Error::new(std::io::ErrorKind::Other, e)),
+        }
+    }
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+}
+
 pub struct SessionGuard {
     client: Client,
     session_id: usize,

src/lib.rs

@@ -44,7 +44,7 @@ pub mod thread_rt;
 pub type Result<T> = std::result::Result<T, Error>;
 
 /// The crate error type
-#[derive(thiserror::Error, Debug, PartialEq, Eq)]
+#[derive(thiserror::Error, Debug)]
 pub enum Error {
     /// the channel is full and the value can not be sent
     #[error("channel full")]
@@ -68,9 +68,12 @@ pub enum Error {
     /// Timeouts
     #[error("timed out")]
     Timeout,
-    /// I/O and threading errors
+    /// Standard I/O errors
     #[error("I/O error: {0}")]
-    IO(String),
+    IO(#[from] std::io::Error),
+    // Non-standard I/O errors
+    #[error("Communication error: {0}")]
+    Comm(String),
     /// 3rd party API errors
     #[error("API error {0}: {1}")]
     API(String, i64),
@@ -149,10 +152,9 @@ macro_rules! impl_error {
     };
 }
 
-impl_error!(std::io::Error, IO);
 #[cfg(feature = "modbus")]
-impl_error!(rmodbus::ErrorKind, IO);
-impl_error!(oneshot::RecvError, IO);
+impl_error!(rmodbus::ErrorKind, Comm);
+impl_error!(oneshot::RecvError, Comm);
 impl_error!(num::ParseIntError, InvalidData);
 impl_error!(num::ParseFloatError, InvalidData);
 impl_error!(binrw::Error, BinRw);
@@ -165,7 +167,7 @@ impl Error {
         Error::InvalidData(msg.to_string())
     }
     pub fn io<S: fmt::Display>(msg: S) -> Self {
-        Error::IO(msg.to_string())
+        Error::Comm(msg.to_string())
     }
     pub fn failed<S: fmt::Display>(msg: S) -> Self {
         Error::Failed(msg.to_string())

src/thread_rt.rs

@@ -496,14 +496,14 @@ fn thread_init_external(
 ) -> Result<libc::c_int> {
     let (tid, tx_ok) = rx_tid.recv()?;
     if tid < 0 {
-        tx_ok.send(false).map_err(|e| Error::IO(e.to_string()))?;
+        tx_ok.send(false).map_err(|e| Error::Comm(e.to_string()))?;
         return Err(Error::RTGetTId(tid));
     }
     if let Err(e) = apply_thread_params(tid, params, quiet) {
-        tx_ok.send(false).map_err(|e| Error::IO(e.to_string()))?;
+        tx_ok.send(false).map_err(|e| Error::Comm(e.to_string()))?;
         return Err(e);
     }
-    tx_ok.send(true).map_err(|e| Error::IO(e.to_string()))?;
+    tx_ok.send(true).map_err(|e| Error::Comm(e.to_string()))?;
     Ok(tid)
 }