Tokio2

Bring in tokio 0.2, converting to async/await. Futures next makes
PacketProvider redundant, so remove.  Use lefthook for commit hooks,
setup travis, use criterion for benches.

Crate is now renamed to pcap-async.

Author: Danny Browning

.travis.yml

@@ -0,0 +1,32 @@
+---
+language: rust
+rust:
+    - nightly
+sudo: true
+cache:
+  - apt
+  - cargo
+
+matrix:
+  include:
+    - os: linux
+      addons:
+        apt:
+          update: true
+          packages:
+            - libpcap-dev
+      env: TARGET=i686-unknown-linux-gnu
+
+before_script:
+  - cargo +nightly install --force rustfmt-nightly
+
+script:
+  - export PATH="/usr/include:$PATH"
+  - cargo +nightly fmt --all -- --check
+  - cargo test
+  - cargo doc --no-deps
+
+notifications:
+  email:
+    on_success: never
+

Cargo.toml

@@ -1,17 +1,42 @@
 [package]
-name = "pcap"
-version = "0.1.0"
-authors = ["Danny Browning <[email protected]>"]
+name = "pcap-async"
 edition = "2018"
+# When releasing to crates.io:
+# - Update html_root_url.
+# - Update CHANGELOG.md.
+# - Update doc URL.
+# - Create "v0.1.x" git tag.
+version = "0.1.0-alpha.1"
+license = "MIT"
+readme = "README.md"
+description = """
+Async/Stream Extensions for libpcap
+"""
+authors = ["Danny Browning <[email protected]>"]
+categories = ["asynchronous", "network-programming"]
+documentation = "https://docs.rs/pcap-async/"
+repository = "https://github.com/dbcfd/pcap-async"
 
 [dependencies]
-failure = "~0.1"
-failure_derive = "~0.1"
-futures-preview = { version ="0.3.0-alpha.14", features = ["compat"] }
-libc = "~0.2"
-log = "~0.4"
-pcap-sys = { git = "https://github.com/protectwise/pcap-sys.git" }
-tokio-timer = "~0.2"
+byteorder = "1.3"
+failure = "0.1"
+failure_derive = "0.1"
+futures-preview = { version ="0.3.0-alpha.19", features = ["async-await"] }
+libc = "0.2"
+log = "0.4"
+pin-project = "0.4.0-alpha.9"
+pcap-sys = { git = "https://github.com/protectwise/pcap-sys.git", tag = "v0.2.0" }
+tokio-timer = "0.3.0-alpha.6"
 
 [dev-dependencies]
-env_logger = "~0.6"
+criterion = "0.2"
+env_logger = "0.6"
+tokio = "0.2.0-alpha.6"
+
+[lib]
+path = "src/lib.rs"
+
+[[bench]]
+path = "benches/bench_capture.rs"
+name = "bench_capture"
+harness = false

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 Danny Browning
+Copyright (c) 2019 Danny Browning
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,3 +1,47 @@
-# PCAP
+# pcap-async
 
-Rust wrapper around [pcap-sys](https://github.com/protectwise/pcap-sys)
+[![build status][travis-badge]][travis-url]
+[![crates.io version][crates-badge]][crates-url]
+[![docs.rs docs][docs-badge]][docs-url]
+[![MIT licensed][mit-badge]][mit-url]
+
+Rust async wrapper around [pcap-sys](https://github.com/protectwise/pcap-sys). Utilizes [Futures 0.3](https://github.com/rust-lang-nursery/futures-rs) and [Tokio](https://github.com/tokio-rs/tokio).
+
+[Documentation](https://docs.rs/pcap-async/latest/)
+
+[travis-badge]: https://travis-ci.com/dbcfd/pcap-async.svg?branch=master
+[travis-url]: https://travis-ci.com/dbcfd/pcap-async
+[crates-badge]: https://img.shields.io/crates/v/pcap-async.svg?style=flat-square
+[crates-url]: https://crates.io/crates/pcap-async
+[docs-badge]: https://img.shields.io/badge/docs.rs-latest-blue.svg?style=flat-square
+[docs-url]: https://docs.rs/pcap-async
+[mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square
+[mit-url]: LICENSE-MIT
+
+## Usage
+
+First, add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+channel-async = "0.1.0-alpha.1"
+```
+
+Next, add this to your crate:
+
+```rust
+use futures::StreamExt;
+use pcap_async::{Config, Handle, PacketStream};
+
+#[tokio::main]
+async fn main() {
+    let handle = Handle::lookup().expect("No handle created");
+    let mut provider = PacketProvider::new(Config::default(), handle)
+        .expect("Could not create provider")
+        .fuse();
+    while let Some(packets) = provider.next().await {
+
+    }
+    handle.interrupt();
+}
+```

benches/bench_capture.rs

@@ -0,0 +1,111 @@
+#![deny(unused_must_use, unused_imports, bare_trait_objects)]
+use criterion::{criterion_group, criterion_main, Bencher, Criterion};
+use futures::StreamExt;
+use log::*;
+use pcap_async::{Config, Handle, PacketStream};
+use std::path::PathBuf;
+
+fn bench_stream_from_large_file(b: &mut Bencher) {
+    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());
+
+    b.iter(|| {
+        let rt = tokio::runtime::Runtime::new().expect("Failed to create runtime");
+
+        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 packet_provider = PacketStream::new(Config::default(), std::sync::Arc::clone(&handle))
+            .expect("Failed to build");
+        let packets = rt.block_on(packet_provider.collect::<Vec<_>>());
+        let packets: Result<Vec<_>, pcap_async::Error> = packets.into_iter().collect();
+        let packets = packets
+            .expect("Failed to get packets")
+            .iter()
+            .flatten()
+            .count();
+
+        handle.interrupt();
+
+        assert_eq!(packets, 246137);
+    });
+}
+
+fn bench_stream(c: &mut Criterion) {
+    let benchmark = criterion::Benchmark::new("4sics", bench_stream_from_large_file);
+
+    c.bench(
+        "stream",
+        benchmark
+            .sample_size(20)
+            .nresamples(1)
+            .measurement_time(std::time::Duration::from_secs(15)),
+    );
+}
+
+fn bench_stream_next_from_large_file(b: &mut Bencher) {
+    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());
+
+    b.iter(|| {
+        let rt = tokio::runtime::Runtime::new().expect("Failed to create runtime");
+
+        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 packet_provider = PacketStream::new(Config::default(), std::sync::Arc::clone(&handle))
+            .expect("Failed to build");
+        let fut_packets = async move {
+            let mut packet_provider = packet_provider.boxed();
+            let mut packets = vec![];
+            while let Some(p) = packet_provider.next().await {
+                let p = p.expect("Could not get packets");
+                packets.extend(p);
+            }
+            packets
+        };
+        let packets = rt.block_on(fut_packets).len();
+
+        handle.interrupt();
+
+        assert_eq!(packets, 246137);
+    });
+}
+
+fn bench_stream_next(c: &mut Criterion) {
+    let benchmark = criterion::Benchmark::new("4sics", bench_stream_next_from_large_file);
+
+    c.bench(
+        "stream_next",
+        benchmark
+            .sample_size(20)
+            .nresamples(1)
+            .measurement_time(std::time::Duration::from_secs(15)),
+    );
+}
+
+criterion_group!(benches, bench_stream, bench_stream_next);
+
+// Benchmark: cargo bench --verbose
+
+criterion_main!(benches);

lefthook.yml

@@ -0,0 +1,15 @@
+format:
+  piped: true
+  commands:
+    1_install:
+      run: rustup component add rustfmt
+    2_cargo_fmt:
+      run: cargo +nightly fmt --all
+
+pre-push:
+  piped: true
+  commands:
+    1_install:
+      run: rustup component add rustfmt
+    2_fmt:
+      run: cargo +nightly fmt --all -- --check

src/bpf.rs

@@ -6,9 +6,7 @@ pub struct Bpf {
 
 impl Bpf {
     pub fn new(inner: pcap_sys::bpf_program) -> Bpf {
-        Bpf {
-            inner
-        }
+        Bpf { inner }
     }
     pub fn inner_mut(&mut self) -> &mut pcap_sys::bpf_program {
         &mut self.inner
@@ -21,4 +19,4 @@ impl Drop for Bpf {
             pcap_sys::pcap_freecode(&mut self.inner);
         }
     }
-}
+}

src/errors.rs

@@ -10,8 +10,8 @@ pub enum Error {
     FfiNul(#[fail(cause)] std::ffi::FromBytesWithNulError),
     #[fail(display = "Utf8 conversion error")]
     Utf8(#[fail(cause)] std::str::Utf8Error),
-    #[fail(display = "TokioTimer error")]
-    TokioTimer(#[fail(cause)] tokio_timer::Error),
+    #[fail(display = "Time conversion error")]
+    Time(#[fail(cause)] std::time::SystemTimeError),
     #[fail(display = "Null ptr returned")]
     NullPtr,
     #[fail(display = "Libpcap failed populate header")]