use libc::mkfifo instead of the external mkfifo command

Author: Jorge Aparicio

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Changed
+
+- `itmdump` no longer depends on the `mkfifo` command.
+
 ## v0.1.0 - 2016-10-03
 
 ### Added

Cargo.lock

@@ -9,4 +9,7 @@ repository = "https://github.com/japaric/itm"
 version = "0.1.0"
 
 [dependencies]
+clap = "2.14.0"
+error-chain = "0.5.0"
+libc = "0.2.17"
 ref_slice = "1.1.0"

Cargo.toml

@@ -1,40 +1,84 @@
+extern crate clap;
+extern crate libc;
 extern crate ref_slice;
 
+#[macro_use]
+extern crate error_chain;
+
+use std::ffi::CString;
 use std::fs::File;
 use std::io::{Read, Write};
+use std::os::unix::ffi::OsStringExt;
 use std::path::PathBuf;
-use std::process::Command;
 use std::{env, fs, io, process};
 
+use clap::{App, Arg};
+use ref_slice::ref_slice_mut;
+
+use errors::*;
+
+mod errors {
+    error_chain!();
+}
+
 fn main() {
-    let pipe = &PathBuf::from(env::args_os()
-        .skip(1)
-        .next()
-        .unwrap_or_else(|| exit("expected one argument: the path to the named pipe")));
+    if let Err(e) = run() {
+        let stderr = io::stderr();
+        let mut stderr = stderr.lock();
+
+        writeln!(stderr, "{}", e).ok();
+
+        for e in e.iter().skip(1) {
+            writeln!(stderr, "caused by: {}", e).ok();
+        }
+
+        if show_backtrace() {
+            if let Some(backtrace) = e.backtrace() {
+                writeln!(stderr, "backtrace:").ok();
+                writeln!(stderr, "{:?}", backtrace).ok();
+            }
+        }
+
+        process::exit(1)
+    }
+}
+
+fn run() -> Result<()> {
+    let matches = App::new("itmdump")
+        .version(env!("CARGO_PKG_VERSION"))
+        .arg(Arg::with_name("PATH").help("Named pipe to use").required(true))
+        .get_matches();
+
+    let pipe = PathBuf::from(matches.value_of("PATH").unwrap());
+    let pipe_ = pipe.display();
 
     if pipe.exists() {
-        fs::remove_file(pipe)
-            .unwrap_or_else(|_| exit(&format!("couldn't remove {}", pipe.display())));
+        try!(fs::remove_file(&pipe)
+            .chain_err(|| format!("couldn't remove {}", pipe_)));
     }
 
-    let output = Command::new("mkfifo").arg(pipe).output().unwrap_or_else(|_| {
-        exit("`mkfifo` not found");
-    });
+    let cpipe = try!(CString::new(pipe.clone().into_os_string().into_vec())
+        .chain_err(|| format!("error converting {} to a C string", pipe_)));
 
-    if !output.status.success() {
-        exit(&String::from_utf8_lossy(&output.stderr))
+    match unsafe { libc::mkfifo(cpipe.as_ptr(), 0o644) } {
+        0 => {}
+        e => {
+            try!(Err(io::Error::from_raw_os_error(e)).chain_err(|| {
+                format!("couldn't create a named pipe in {}", pipe_)
+            }))
+        }
     }
 
-    let mut stream = File::open(pipe)
-        .unwrap_or_else(|_| exit(&format!("couldn't open {}", pipe.display())));
+    let mut stream = try!(File::open(&pipe)
+        .chain_err(|| format!("couldn't open {}", pipe_)));
 
     let mut header = 0;
 
     let (stdout, stderr) = (io::stdout(), io::stderr());
     let (mut stdout, mut stderr) = (stdout.lock(), stderr.lock());
     loop {
         if let Err(e) = (|| {
-            try!(stream.read_exact(ref_slice::ref_slice_mut(&mut header)));
+            try!(stream.read_exact(ref_slice_mut(&mut header)));
             let port = header >> 3;
 
             // Ignore all the packets that don't come from the stimulus port 0
@@ -45,7 +89,7 @@ fn main() {
             match header & 0b111 {
                 0b01 => {
                     let mut payload = 0;
-                    try!(stream.read_exact(ref_slice::ref_slice_mut(&mut payload)));
+                    try!(stream.read_exact(ref_slice_mut(&mut payload)));
                     stdout.write_all(&[payload])
                 }
                 0b10 => {
@@ -69,8 +113,6 @@ fn main() {
     }
 }
 
-fn exit(msg: &str) -> ! {
-    let stderr = io::stderr();
-    writeln!(stderr.lock(), "{}", msg).ok();
-    process::exit(1)
+fn show_backtrace() -> bool {
+    env::var("RUST_BACKTRACE").as_ref().map(|s| &s[..]) == Ok("1")
 }

src/bin/itmdump.rs

@@ -2,25 +2,28 @@
 //!
 //! [ITM]: http://infocenter.arm.com/help/topic/com.arm.doc.ddi0314h/Chdbicbg.html
 //!
-//! Right now, this tool only handles instrumentation packets from the stimulus port 0.
+//! Right now, this tool only handles instrumentation packets from the stimulus
+//! port 0.
 //!
 //! # Usage
 //!
 //! ``` text
 //! $ itmdump /tmp/itm.fifo
 //! ```
 //!
-//! This will create a named pipe: `/tmp/itm.fifo`. Another application, e.g. OpenOCD, will have to
-//! be connected (open+write) to this pipe. Here's an example command for OpenOCD+GDB that does
-//! that. (But [read their documentation!]).
+//! This will create a named pipe: `/tmp/itm.fifo`. Another application, e.g.
+//! OpenOCD, will have to be connected (open+write) to this pipe. Here's an
+//! example command for OpenOCD+GDB that does that. (But
+//! [read their documentation!]).
 //!
 //! [read their documentation!]: http://openocd.org/doc/html/Architecture-and-Core-Commands.html
 //!
 //! ``` text
 //! (gdb) monitor tpiu config internal /tmp/itm.fifo uart off 8000000
 //! ```
 //!
-//! `itmdump` will read from the pipe, parse the packets and write the payload to `stdout`:
+//! `itmdump` will read from the pipe, parse the packets and write the payload
+//! to `stdout`:
 //!
 //! ``` text
 //! PANIC at 'Hello, world!', examples/panic.rs:13