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
77
78
79
80
81
82
83
84
85
86

//! # pcap-async
//!
//! Async/await wrappers [pcap-sys](https://github.com/protectwise/pcap-sys).
//!
//!```no_run
//! use futures::StreamExt;
//! use pcap_async::{Config, Handle, PacketStream};
//! use std::sync::Arc;
//!
//! fn main() {
//!     let handle = Handle::lookup().expect("No handle created");
//!     smol::block_on(async move {
//!         let mut provider = PacketStream::new(Config::default(), Arc::clone(&handle))
//!             .expect("Could not create provider")
//!             .boxed();
//!         while let Some(packets) = provider.next().await {
//!
//!         }
//!         handle.interrupt();
//!     });
//! }
#![deny(unused_must_use, unused_imports, bare_trait_objects)]
#![allow(dead_code, unused_imports)]
pub mod bpf;
mod bridge_stream;
mod config;
pub mod errors;
mod handle;
mod info;
mod packet;
pub mod pcap_util;
mod stats;
mod stream;

pub use crate::{
    bridge_stream::BridgeStream, config::Config, errors::Error, handle::Handle, info::Info,
    packet::Packet, stats::Stats, stream::PacketStream, stream::StreamItem,
};
pub use byteorder::{BigEndian, LittleEndian, NativeEndian, WriteBytesExt};
use log::*;
use std::sync::Arc;

#[cfg(test)]
mod tests {
    use super::*;
    use futures::StreamExt;
    use std::path::PathBuf;

    #[test]
    fn capture_from_file() {
        let _ = env_logger::try_init();

        let pcap_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
            .join("resources")
            .join("4SICS-GeekLounge-151020.pcap");

        info!("Benchmarking against {:?}", pcap_path.clone());

        let clone_path = pcap_path.clone();

        let handle = Handle::file_capture(clone_path.to_str().expect("No path found"))
            .expect("No handle created");

        let mut cfg = Config::default();
        cfg.with_max_packets_read(5000);

        let packets = smol::block_on(async move {
            let packet_provider =
                PacketStream::new(Config::default(), std::sync::Arc::clone(&handle))
                    .expect("Failed to build");
            let fut_packets = packet_provider.collect::<Vec<_>>();
            let packets: Result<Vec<_>, Error> = fut_packets.await.into_iter().collect();
            let packets = packets
                .expect("Could not get packets")
                .iter()
                .flatten()
                .count();

            handle.interrupt();

            packets
        });

        assert_eq!(packets, 246137);
    }
}