Decoder provides more information about end of file errors.

Author: Alex Helfet

src/bin/itmdump.rs

@@ -114,27 +114,24 @@ fn run() -> Result<()> {
                 // We don't know this header type; warn and continue.
                 debug!("{}", e);
             },
-            Err(Error(ErrorKind::Io(ref e), _))
-            if e.kind() == io::ErrorKind::UnexpectedEof => {
+            Err(Error(ErrorKind::EofBeforePacket, _)) => {
                 if follow {
-                    // FIXME: We can lose data here. UnexpectedEof is
-                    // returned when read_exact() encounters EOF
-                    // before it fills its buffer, but in that case it
-                    // may have already read _some_ data, which we
-                    // discard.
-                    //
-                    // Instead we could buffer input until we can read
-                    // a full packet, turn parsing into a state
-                    // machine, or create a reader that sleeps on EOF.
                     thread::sleep(Duration::from_millis(100));
                 } else {
                     // !follow and EOF. Exit.
-
-                    // FIXME: We may have reached EOF part way into a
-                    // packet but don't report missing data.
                     return Ok(())
                 }
             },
+
+            // FIXME: If in follow mode, we may try to read a packet
+            // but reach the end of the file in the middle. Currently
+            // we'd just return an error and hence exit. When we
+            // receive an error, we've already read and discarded some
+            // data, so we can't just go around this loop again.
+            //
+            // We could make a file following wrapper around `read`
+            // that blocks in a loop retrying the read and sleeping if
+            // there's no data.
             Err(e) => return Err(e),
         }
     } // end of read loop
@@ -155,4 +152,3 @@ fn open_read<'a>(matches: &ArgMatches) -> Result<impl io::Read + 'a> {
         None => Box::new(io::stdin()) as Box<io::Read + 'static>,
     })
 }
-

src/decoder.rs

@@ -3,7 +3,7 @@
 use error::{Error, ErrorKind, Result};
 use heapless::Vec as HVec;
 use packet::{self, Packet, Instrumentation};
-use std::io::{Cursor, Read};
+use std::io::{self, Cursor, Read};
 
 /// Parses ITM packets.
 pub struct Decoder<R: Read> {
@@ -29,7 +29,12 @@ impl<R: Read> Decoder<R> {
     /// for input if no full packet is currently an available.
     pub fn read_packet(&mut self) -> Result<Packet> {
         let mut header = [0; 1];
-        self.inner.read_exact(&mut header)?;
+        match self.inner.read_exact(&mut header) {
+            Err(ref e) if e.kind() == io::ErrorKind::UnexpectedEof =>
+                return Err(Error::from(ErrorKind::EofBeforePacket)),
+            Err(e) => return Err(Error::from(e)),
+            Ok(_) => (),
+        };
         let header = header[0];
         match header & 0b111 {
             0b001|0b010|0b011 => {
@@ -48,7 +53,12 @@ impl<R: Read> Decoder<R> {
                     };
                 ud.payload.resize_default(payload_size)
                     .expect("payload_size <= payload.capacity");
-                self.inner.read_exact(&mut *ud.payload)?;
+                match self.inner.read_exact(&mut *ud.payload) {
+                    Err(ref e) if e.kind() == io::ErrorKind::UnexpectedEof =>
+                        return Err(Error::from(ErrorKind::EofDuringPacket)),
+                    Err(e) => return Err(Error::from(e)),
+                    Ok(_) => (),
+                };
 
                 Ok(Packet {
                     header: header,
@@ -73,7 +83,6 @@ mod tests {
     use super::from_slice;
     use error::{Error, ErrorKind, Result};
     use packet::{Kind, Packet};
-    use std::io;
 
     #[test]
     fn header() {
@@ -146,8 +155,16 @@ mod tests {
     fn eof_before_payload() {
         let p = try_decode_one(&[0x01 /* Missing payload bytes */ ]);
         match p {
-            Err(Error(ErrorKind::Io(ref e), _))
-            if e.kind() == io::ErrorKind::UnexpectedEof => (),
+            Err(Error(ErrorKind::EofDuringPacket, _)) => (),
+            _ => panic!(),
+        }
+    }
+
+    #[test]
+    fn eof_before_packet() {
+        let p = try_decode_one(&[/* Missing packet bytes */]);
+        match p {
+            Err(Error(ErrorKind::EofBeforePacket, _)) => (),
             _ => panic!(),
         }
     }

src/error.rs

@@ -12,5 +12,13 @@ error_chain! {
             description("unknown header byte"),
             display("unknown header byte: {:x}", b),
         }
+        EofDuringPacket {
+            description("end of file during packet"),
+            display("end of file during packet"),
+        }
+        EofBeforePacket {
+            description("end of file before packet"),
+            display("end of file before packet"),
+        }
     }
 }