SQUASHME: fix e2e tests

* Allow error helper macros to be called from e2e crate
* Use `manticore::Result` within e2e crate

Author: kesyog

e2e/src/support/rot.rs

@@ -29,6 +29,7 @@ use manticore::protocol::spdm;
 use manticore::server;
 use manticore::server::pa_rot::PaRot;
 use manticore::session::ring::Session;
+use manticore::Result;
 
 use crate::support::fakes;
 use crate::support::tcp;

e2e/src/support/tcp.rs

@@ -47,6 +47,8 @@ use manticore::protocol::wire::WireEnum;
 use manticore::protocol::Command;
 use manticore::protocol::Message;
 use manticore::server;
+use manticore::Result;
+use manticore::{check, fail};
 
 /// Sends `req` to a virtual RoT listening on `localhost:{port}`, using
 /// Cerberus-over-TCP.
@@ -84,7 +86,7 @@ pub fn send_cerberus<
         Ok(Ok(FromWire::from_wire(&mut r, arena)?))
     } else if header.command == cerberus::CommandType::Error {
         log::info!("deserializing {}", type_name::<protocol::Error<'a, Cmd>>());
-        Ok(Err(FromWire::from_wire(&mut r, arena)?))
+        Ok(Err(fail!(FromWire::from_wire(&mut r, arena)?)))
     } else {
         Err(net::Error::BadHeader.into())
     }
@@ -125,7 +127,7 @@ pub fn send_spdm<'a, Cmd: Command<'a, CommandType = spdm::CommandType>>(
         Ok(Ok(FromWire::from_wire(&mut r, arena)?))
     } else if header.command == spdm::CommandType::Error {
         log::info!("deserializing {}", type_name::<protocol::Error<'a, Cmd>>());
-        Ok(Err(FromWire::from_wire(&mut r, arena)?))
+        Ok(Err(fail!(FromWire::from_wire(&mut r, arena)?)))
     } else {
         Err(net::Error::BadHeader.into())
     }
@@ -140,7 +142,7 @@ impl io::Read for TcpReader {
     fn read_bytes(&mut self, out: &mut [u8]) -> Result<(), io::Error> {
         let Self { tcp, len } = self;
         if *len < out.len() {
-            return Err(io::Error::BufferExhausted);
+            return Err(fail!(io::Error::BufferExhausted));
         }
         tcp.read_exact(out).map_err(|e| {
             log::error!("{}", e);
@@ -365,22 +367,22 @@ impl<'req, H: Header + 'req> HostRequest<'req, H> for Inner<H> {
     fn header(&self) -> Result<H, net::Error> {
         if self.output_buffer.is_some() {
             log::error!("header() called out-of-order");
-            return Err(net::Error::OutOfOrder);
+            return Err(fail!(net::Error::OutOfOrder));
         }
         self.stream
             .as_ref()
             .map(|(h, _, _)| *h)
-            .ok_or(net::Error::Disconnected)
+            .ok_or_else(|| fail!(net::Error::Disconnected))
     }
 
     fn payload(&mut self) -> Result<&mut dyn io::ReadZero<'req>, net::Error> {
         if self.stream.is_none() {
             log::error!("payload() called out-of-order");
-            return Err(net::Error::Disconnected);
+            return Err(fail!(net::Error::Disconnected));
         }
         if self.output_buffer.is_some() {
             log::error!("payload() called out-of-order");
-            return Err(net::Error::OutOfOrder);
+            return Err(fail!(net::Error::OutOfOrder));
         }
 
         Ok(self)
@@ -392,11 +394,11 @@ impl<'req, H: Header + 'req> HostRequest<'req, H> for Inner<H> {
     ) -> Result<&mut dyn HostResponse<'req>, net::Error> {
         if self.stream.is_none() {
             log::error!("payload() called out-of-order");
-            return Err(net::Error::Disconnected);
+            return Err(fail!(net::Error::Disconnected));
         }
         if self.output_buffer.is_some() {
             log::error!("payload() called out-of-order");
-            return Err(net::Error::OutOfOrder);
+            return Err(fail!(net::Error::OutOfOrder));
         }
 
         self.output_buffer = Some(Writer::new(header));
@@ -408,13 +410,13 @@ impl<'req, H: Header + 'req> HostResponse<'req> for Inner<H> {
     fn sink(&mut self) -> Result<&mut dyn io::Write, net::Error> {
         if self.stream.is_none() {
             log::error!("sink() called out-of-order");
-            return Err(net::Error::Disconnected);
+            return Err(fail!(net::Error::Disconnected));
         }
 
         self.output_buffer
             .as_mut()
             .map(|w| w as &mut dyn io::Write)
-            .ok_or(net::Error::OutOfOrder)
+            .ok_or_else(|| fail!(net::Error::OutOfOrder))
     }
 
     fn finish(&mut self) -> Result<(), net::Error> {
@@ -434,7 +436,7 @@ impl<'req, H: Header + 'req> HostResponse<'req> for Inner<H> {
                 self.output_buffer = None;
                 Ok(())
             }
-            _ => Err(net::Error::Disconnected),
+            _ => Err(fail!(net::Error::Disconnected)),
         }
     }
 }
@@ -443,9 +445,7 @@ impl<H> io::Read for Inner<H> {
     fn read_bytes(&mut self, out: &mut [u8]) -> Result<(), io::Error> {
         let (_, len, stream) =
             self.stream.as_mut().ok_or(io::Error::Internal)?;
-        if *len < out.len() {
-            return Err(io::Error::BufferExhausted);
-        }
+        check!(*len >= out.len(), io::Error::BufferExhausted);
         stream.read_exact(out).map_err(|e| {
             log::error!("{}", e);
             io::Error::Internal

src/debug.rs

@@ -198,11 +198,12 @@ macro_rules! debug_from {
 ///
 /// If the condition does not hold, constructs the given error, logs it, and
 /// returns out of the current function with it.
+#[macro_export]
 macro_rules! check {
     ($cond:expr, $error:expr) => {
         if !$cond {
             let error = $error;
-            return Err(fail!(
+            return Err($crate::fail!(
                 error,
                 "check failure: `{}`; returned {:?}",
                 stringify!($cond),
@@ -218,19 +219,21 @@ macro_rules! check {
 ///
 /// For example, instead of writing `foo.ok_or(MyError)`, instead write
 /// `foo.ok_or_else(|| fail!(MyError))`.
+#[macro_export]
 macro_rules! fail {
     ($error:expr, $($format:tt)+) => {{
-        error!($($format)+);
-        $crate::debug::Error::__new($error)
+        $crate::error!($($format)+);
+        $crate::Error::__new($error)
     }};
     ($error:expr) => {{
         let error = $error;
-        error!("generated error: `{:?}`", error);
-        $crate::debug::Error::__new(error)
+        $crate::error!("generated error: `{:?}`", error);
+        $crate::Error::__new(error)
     }};
 }
 
 /// Redactable version of [`log::trace!()`].
+#[macro_export]
 macro_rules! trace {
     ($($args:tt)*) => {
         #[cfg(feature = "log")]
@@ -239,6 +242,7 @@ macro_rules! trace {
 }
 
 /// Redactable version of [`log::info!()`].
+#[macro_export]
 macro_rules! info {
     ($($args:tt)*) => {
         #[cfg(feature = "log")]
@@ -247,6 +251,7 @@ macro_rules! info {
 }
 
 /// Redactable version of [`log::warn!()`].
+#[macro_export]
 macro_rules! warn {
     ($($args:tt)*) => {
         #[cfg(feature = "log")]
@@ -255,6 +260,7 @@ macro_rules! warn {
 }
 
 /// Redactable version of [`log::error!()`].
+#[macro_export]
 macro_rules! error {
     ($($args:tt)*) => {
         #[cfg(feature = "log")]