Merge "Ports zmodem to no_std and kata_io"

GitOrigin-RevId: 09bc871f7c4fdd64f3b4591a47cf5ba0bffa72c2

apps/system/components/DebugConsole/zmodem/tests/lib.rs

@@ -12,6 +12,12 @@ use std::result;
 use std::thread::{sleep, spawn};
 use std::time::*;
 
+extern crate kata_io;
+
+fn forget_err(_e: std::io::Error) -> kata_io::Error {
+    kata_io::Error {}
+}
+
 struct InOut<R: Read, W: Write> {
     r: R,
     w: W,
@@ -23,24 +29,66 @@ impl<R: Read, W: Write> InOut<R, W> {
     }
 }
 
-impl<R: Read, W: Write> Read for InOut<R, W> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
-        self.r.read(buf)
+impl<R: Read, W: Write> kata_io::Read for InOut<R, W> {
+    fn read(&mut self, buf: &mut [u8]) -> kata_io::Result<usize> {
+        self.r.read(buf).map_err(forget_err)
     }
 }
 
-impl<R: Read, W: Write> Write for InOut<R, W> {
-    fn write(&mut self, buf: &[u8]) -> Result<usize> {
-        self.w.write(buf)
+impl<R: Read, W: Write> kata_io::Write for InOut<R, W> {
+    fn write(&mut self, buf: &[u8]) -> kata_io::Result<usize> {
+        self.w.write(buf).map_err(forget_err)
     }
 
-    fn flush(&mut self) -> Result<()> {
-        self.w.flush()
+    fn flush(&mut self) -> kata_io::Result<()> {
+        self.w.flush().map_err(forget_err)
+    }
+}
+
+/// Minimal vector-backed kata_io::Read and kata_io::Write
+///
+/// This is a workaround to not being able to implement the kata_io traits for
+/// std::io::Cursor in this file, since none of those come from the current
+/// crate.
+struct WrappedCursor<T> {
+    c: std::io::Cursor<T>,
+}
+
+impl<T> WrappedCursor<T> {
+    pub fn into_inner(self) -> T {
+        self.c.into_inner()
+    }
+}
+
+impl kata_io::Read for WrappedCursor<&Vec<u8>> {
+    fn read(&mut self, buf: &mut [u8]) -> kata_io::Result<usize> {
+        self.c.read(buf).map_err(forget_err)
+    }
+}
+
+impl kata_io::Write for WrappedCursor<Vec<u8>> {
+    fn write(&mut self, buf: &[u8]) -> kata_io::Result<usize> {
+        self.c.write(buf).map_err(forget_err)
+    }
+
+    fn flush(&mut self) -> kata_io::Result<()> {
+        self.c.flush().map_err(forget_err)
+    }
+}
+
+impl kata_io::Seek for WrappedCursor<&Vec<u8>> {
+    fn seek(&mut self, pos: kata_io::SeekFrom) -> kata_io::Result<u64> {
+        let std_pos = match pos {
+            kata_io::SeekFrom::Start(n) => std::io::SeekFrom::Start(n),
+            kata_io::SeekFrom::End(n) => std::io::SeekFrom::End(n),
+            kata_io::SeekFrom::Current(n) => std::io::SeekFrom::Current(n),
+        };
+        self.c.seek(std_pos).map_err(forget_err)
     }
 }
 
 lazy_static! {
-    static ref LOG_INIT: result::Result<(), log::SetLoggerError> = env_logger::init();
+    static ref LOG_INIT: result::Result<(), log::SetLoggerError> = Ok(env_logger::init());
     static ref RND_VALUES: Vec<u8> = {
         use rand::Rng;
         let mut rng = rand::thread_rng();
@@ -69,7 +117,9 @@ fn recv_from_sz() {
     let child_stdout = sz.stdout.unwrap();
     let mut inout = InOut::new(child_stdout, child_stdin);
 
-    let mut c = Cursor::new(Vec::new());
+    let mut c = WrappedCursor {
+        c: Cursor::new(Vec::new()),
+    };
     zmodem::recv::recv(&mut inout, &mut c).unwrap();
 
     sleep(Duration::from_millis(300));
@@ -97,7 +147,9 @@ fn send_to_rz() {
 
     let len = RND_VALUES.len() as u32;
     let copy = RND_VALUES.clone();
-    let mut cur = Cursor::new(&copy);
+    let mut cur = WrappedCursor {
+        c: Cursor::new(&copy),
+    };
 
     sleep(Duration::from_millis(300));
 
@@ -141,12 +193,16 @@ fn lib_send_recv() {
         let mut inout = InOut::new(inf, outf);
 
         let origin = RND_VALUES.clone();
-        let mut c = Cursor::new(&origin);
+        let mut c = WrappedCursor {
+            c: Cursor::new(&origin),
+        };
 
         zmodem::send::send(&mut inout, &mut c, "test", None).unwrap();
     });
 
-    let mut c = Cursor::new(Vec::new());
+    let mut c = WrappedCursor {
+        c: Cursor::new(Vec::new()),
+    };
 
     let inf = File::open("test-fifo1").unwrap();
     let outf = OpenOptions::new().write(true).open("test-fifo2").unwrap();