ethrecv 0.0.1

Receive ethernet packets at a high rate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use std::env;

use ethrecv::{PacketHandler, RecvThread};

#[derive(Debug)]
enum AppError {}

#[derive(Default)]
struct PktProc {}

impl PacketHandler for PktProc {
  type Error = AppError;

  fn proc(&mut self, _pkt: pcap::Packet) -> Result<(), Self::Error> {
    eprintln!("packet!");
    Ok(())
  }

  #[cfg(feature = "idle")]
  fn idle(&mut self) -> Result<(), Self::Error> {
    eprintln!("idle!");
    Ok(())
  }

  #[cfg(feature = "inspect")]
  fn inspect(&self, info: &ethrecv::RecvInfo) {
    eprintln!("inspect!");
    eprintln!("overflow drop: {}", info.overflow_dropped);
    eprintln!("if drop: {}", info.if_dropped);
    eprintln!("num raw pkts: {}", info.num_raw_pkts);
    eprintln!("raw pkt bytes: {}", info.raw_pkt_bytes);
    eprintln!("uptime: {:?}", info.runtime);
  }
}

fn main() {
  let args: Vec<String> = env::args().skip(1).collect();

  let rt = RecvThread::new(&args[0]);

  #[cfg(feature = "idle")]
  let rt = rt.idle_duration(std::time::Duration::from_secs(4));

  let pp = PktProc::default();

  #[cfg(feature = "inspect")]
  let mut ctrl = rt.run(pp).unwrap();

  #[cfg(not(feature = "inspect"))]
  let ctrl = rt.run(pp).unwrap();

  std::thread::sleep(std::time::Duration::from_secs(10));

  #[cfg(feature = "inspect")]
  ctrl.signal_inspect().unwrap();

  #[cfg(feature = "inspect")]
  {
    let stats = ctrl.inspect().unwrap();
    println!("{stats:#?}");
  }

  std::thread::sleep(std::time::Duration::from_secs(30));

  #[cfg(feature = "inspect")]
  {
    let stats = ctrl.inspect().unwrap();
    println!("{stats:#?}");
  }

  println!("Killing receiver thread..");

  ctrl.shutdown().unwrap();
}

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :