Extract read_packet() function.

Author: Alex Helfet

Cargo.lock

@@ -14,6 +14,7 @@ chrono = "^0.4"
 clap = "^2.14.0"
 env_logger = "^0.4.3"
 error-chain = "^0.11.0"
+heapless = "^0.2.0"
 libc = "^0.2.17"
 log = "^0.3.8"
 ref_slice = "^1.1.0"

Cargo.toml

@@ -6,24 +6,51 @@ extern crate clap;
 extern crate env_logger;
 #[macro_use]
 extern crate error_chain;
+extern crate heapless;
 extern crate libc;
 #[macro_use]
 extern crate log;
 extern crate ref_slice;
 
 
 use clap::{Arg, App, ArgMatches};
+use heapless::Vec as HVec;
 use log::{LogRecord, LogLevelFilter};
-use ref_slice::ref_slice_mut;
 use std::fs::File;
 use std::io::{Read, Write};
 use std::time::Duration;
 use std::{env, io, process, thread};
 
-use errors::*;
+use errors::{Error, ErrorKind, Result, ResultExt};
 
 mod errors {
-    error_chain!();
+    error_chain! {
+        foreign_links {
+            Io(::std::io::Error);
+        }
+
+        errors {
+            UnknownHeader(b: u8) {
+                description("unknown header byte"),
+                display("unknown header byte: {:x}", b),
+            }
+        }
+    }
+}
+
+pub const MAX_PAYLOAD_SIZE: usize = 4;
+
+// TODO: Probably add a .kind field and Kind enum when we need to handle more
+// kinds of packets.
+struct Packet {
+    // The header byte received for this packet.
+    pub header: u8,
+
+    /// Data in this packet.
+    pub payload: HVec<u8, [u8; MAX_PAYLOAD_SIZE]>,
+
+    /// Stimuls port this packet was sent from.
+    pub port: u8,
 }
 
 fn main() {
@@ -96,7 +123,7 @@ fn run() -> Result<()> {
                                 }))
         .get_matches();
 
-    let stim_port = matches.value_of("port")
+    let port = matches.value_of("port")
                            .unwrap() // We supplied a default value
                            .parse::<u8>()
                            .expect("Arg validator should ensure this parses");
@@ -108,60 +135,40 @@ fn run() -> Result<()> {
     let stdout = io::stdout();
     let mut stdout = stdout.lock();
     loop {
-        let mut header = 0;
-
-        if let Err(e) = (|| {
-            try!(stream.read_exact(ref_slice_mut(&mut header)));
-            let port = header >> 3;
-
-            // Ignore packets not from the chosen stimulus port
-            if port != stim_port {
-                return Ok(());
-            }
-
-            match header & 0b111 {
-                0b01 => {
-                    let mut payload = 0;
-                    try!(stream.read_exact(ref_slice_mut(&mut payload)));
-                    stdout.write_all(&[payload])
-                }
-                0b10 => {
-                    let mut payload = [0; 2];
-                    try!(stream.read_exact(&mut payload));
-                    stdout.write_all(&payload)
-                }
-                0b11 => {
-                    let mut payload = [0; 4];
-                    try!(stream.read_exact(&mut payload));
-                    stdout.write_all(&payload)
-                }
-                _ => {
-                    // We don't know this header type, skip.
-                    debug!("Unhandled header type = {:x}", header);
-                    Ok(())
+        let p = read_packet(&mut stream);
+        match p {
+            Ok(p) => {
+                if p.port == port {
+                    stdout.write_all(&p.payload)?;
                 }
             }
-        })() {
-            // Error caught in main loop as `e`.
-            if e.kind() == io::ErrorKind::UnexpectedEof {
+            Err(e @ Error(ErrorKind::UnknownHeader(_), _)) => {
+                // We don't know this header type; warn and continue.
+                debug!("{}", e);
+            },
+            Err(Error(ErrorKind::Io(ref e), _))
+            if e.kind() == io::ErrorKind::UnexpectedEof => {
                 if follow {
-                    // TODO: There's a bug here where we can lose data.
-                    // 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 here.
+                    // TODO: There's a bug here where we can lose
+                    // data.  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 here.
                     //
-                    // We could buffer input until we can read a full packet,
-                    // or turn parsing into a state machine.
+                    // Instead we could buffer input until we can read
+                    // a full packet, or turn parsing into a state
+                    // machine.
                     thread::sleep(Duration::from_millis(100));
                 } else {
                     // !follow and EOF. Exit.
                     return Ok(())
                 }
-            } else {
-                error!("{}", e);
-            }
+            },
+            Err(e) => return Err(e),
         }
-    }
+    } // end of read loop
+
+    // Unreachable.
 }
 
 fn open_read<'a>(matches: &ArgMatches) -> Result<impl io::Read + 'a> {
@@ -177,3 +184,39 @@ fn open_read<'a>(matches: &ArgMatches) -> Result<impl io::Read + 'a> {
         None => Box::new(io::stdin()) as Box<io::Read + 'static>,
     })
 }
+
+fn read_packet(input: &mut Read) -> Result<Packet> {
+    let mut header = [0; 1];
+    input.read_exact(&mut header)?;
+    let header = header[0];
+    let mut packet = Packet {
+        header: header,
+        payload: HVec::new(),
+        port: header >> 3,
+    };
+    match header & 0b111 {
+        0b01|0b10|0b11 => {
+            // Data packet.
+            let payload_size =
+                match header & 0b11 {
+                    0b01 => 1,
+                    0b10 => 2,
+                    0b11 => 4,
+                    _ => return Err(Error::from(
+                                    ErrorKind::UnknownHeader(header))),
+                };
+            // TODO: payload.resize_default(), would be nice.
+            for _ in 0..payload_size {
+                packet.payload.push(0)
+                      .expect("payload_size <= packet.payload.capacity");
+            }
+            input.read_exact(&mut *packet.payload)?;
+            Ok(packet)
+        },
+        _ => {
+            return Err(Error::from(ErrorKind::UnknownHeader(header)));
+        }
+    }
+}
+
+// TODO: Add parse tests.