Allow to read pcap data from stdin

Author: joerivanruth

src/main.rs

@@ -133,12 +133,22 @@ fn run_proxy(
 }
 
 fn run_pcap(path: &Path, mut mapi_state: mapi::State, renderer: &mut Renderer) -> AResult<()> {
-    let Ok(r) = File::open(path) else {
-        bail!("Could not open pcap file {}", path.display());
+    let mut owned_file;
+    let mut owned_stdin;
+
+    let reader: &mut dyn io::Read = if path == Path::new("-") {
+        owned_stdin = Some(io::stdin().lock());
+        owned_stdin.as_mut().unwrap()
+    } else {
+        let file = File::open(path)
+            .with_context(|| format!("Could not open pcap file {}", path.display()))?;
+        owned_file = Some(file);
+        owned_file.as_mut().unwrap()
     };
+
     let handler = |ev: MapiEvent| mapi_state.handle(&ev, renderer);
     let mut tracker = Tracker::new(handler);
-    pcap::parse_pcap_file(r, &mut tracker)
+    pcap::parse_pcap_file(reader, &mut tracker)
 }
 
 fn install_ctrl_c_handler(trigger: Box<dyn Fn() + Send + Sync>) -> AResult<()> {

src/pcap/mod.rs

@@ -15,7 +15,7 @@ use pcap_file::{
 use self::mybufread::MyBufReader;
 pub use self::tracker::Tracker;
 
-pub fn parse_pcap_file(mut rd: impl io::Read + 'static, tracker: &mut Tracker) -> AResult<()> {
+pub fn parse_pcap_file(mut rd: impl io::Read, tracker: &mut Tracker) -> AResult<()> {
     // read ahead to inspect the file header
     let mut signature = [0u8; 4];
     rd.read_exact(&mut signature)?;

src/pcap/mybufread.rs

@@ -1,14 +1,14 @@
 use std::io::{self, BufRead, Read};
 
-pub struct MyBufReader {
-    inner: Box<dyn io::Read>,
+pub struct MyBufReader<'a> {
+    inner: Box<dyn io::Read + 'a>,
     buffer: Vec<u8>,
     data: usize,
     free: usize,
 }
 
-impl MyBufReader {
-    pub fn new(reader: impl io::Read + 'static, mut buffer: Vec<u8>) -> Self {
+impl<'a> MyBufReader<'a> {
+    pub fn new(reader: impl io::Read + 'a, mut buffer: Vec<u8>) -> Self {
         let inner = Box::new(reader);
         let data = 0;
         let free = buffer.len();
@@ -22,7 +22,7 @@ impl MyBufReader {
     }
 }
 
-impl Read for MyBufReader {
+impl<'a> Read for MyBufReader<'a> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let data = self.fill_buf()?;
         let n = data.len().min(buf.len());
@@ -32,7 +32,7 @@ impl Read for MyBufReader {
     }
 }
 
-impl BufRead for MyBufReader {
+impl<'a> BufRead for MyBufReader<'a> {
     fn fill_buf(&mut self) -> io::Result<&[u8]> {
         assert_eq!(self.buffer.len(), self.buffer.capacity());
         if self.data == self.free {

src/usage.txt

@@ -12,6 +12,8 @@ Options:
     -r --raw            Dump bytes as they come in
     -B --binary         Force dumping as binary
     --color=WHEN        Colorize output, one of 'always', 'auto' or 'never'
-    --pcap=file         Read network capture data from FILE (Experimental!)
     --help              This help
     --version           Version info
+
+Experimental options:
+    --pcap=FILE         Read network capture data from FILE, use - for stdin