pub mod active;

pub mod dead;

pub mod iterator;

pub mod offline;

use std::{

    any::Any,

    convert::TryInto,

    ffi::CString,

    fmt, mem,

    panic::{AssertUnwindSafe, catch_unwind, resume_unwind},

    path::Path,

    ptr::{self, NonNull},

    slice,

    sync::{Arc, Weak},

};

#[cfg(not(windows))]

use std::os::unix::io::RawFd;

#[cfg(not(windows))]

use libc::FILE;

use crate::{

    Error,

    capture::{Activated, Capture, PcapHandle},

    codec::PacketCodec,

    linktype::Linktype,

    packet::{Packet, PacketHeader},

    path_to_cstring, raw,

};

use iterator::PacketIter;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

/// Packet statistics for a capture

pub struct Stat {

    /// Number of packets received

    pub received: u32,

    /// Number of packets dropped because there was no room in the operating system's buffer when

    /// they arrived, because packets weren't being read fast enough

    pub dropped: u32,

    /// Number of packets dropped by the network interface or its driver

    pub if_dropped: u32,

}

impl Stat {

}

#[repr(u32)]

#[derive(Debug, PartialEq, Eq, Clone, Copy)]

/// The direction of packets to be captured. Use with `Capture::direction`.

pub enum Direction {

    /// Capture packets received by or sent by the device. This is the default.

    InOut = raw::PCAP_D_INOUT,

    /// Only capture packets received by the device.

    In = raw::PCAP_D_IN,

    /// Only capture packets sent by the device.

    Out = raw::PCAP_D_OUT,

}

///# Activated captures include `Capture<Active>` and `Capture<Offline>`.

impl<T: Activated + ?Sized> Capture<T> {

    /// List the datalink types that this captured device supports.

        unsafe {

                )

        }

    /// Set the datalink type for the current capture handle.

    /// Get the current datalink type for this capture handle.

    /// Get the snapshot length, that is the maximum number of bytes captured from each packet.

    ///

    /// For a `Capture<Offline>` this is the length the savefile was recorded with, except that a

    /// header claiming zero, or a length too large for an `i32`, is replaced with the largest

    /// length the link-layer type can produce.

    /// Create a `Savefile` context for recording captured packets using this `Capture`'s

    /// configurations.

    ///

    /// On Windows a path outside ASCII needs `init(CharEncoding::Utf8)` first. The path always

    /// reaches libpcap as UTF-8, but until that call libpcap reads it in the local code page,

    /// which on most systems is not UTF-8: the name gets mangled and the file lands elsewhere.

        });

    /// Create a `Savefile` context for recording captured packets using this `Capture`'s

    /// configurations. The output is written to a raw file descriptor which is opened in `"w"`

    /// mode.

    ///

    /// # Safety

    ///

    /// Unsafe, because the returned Savefile assumes it is the sole owner of the file descriptor.

    #[cfg(not(windows))]

            });

    /// Reopen a `Savefile` context for recording captured packets using this `Capture`'s

    /// configurations. This is similar to `savefile()` but does not create the file if it

    /// does  not exist and, if it does already exist, and is a pcap file with the same

    /// byte order as the host opening the file, and has the same timestamp precision,

    /// link-layer header type,  and  snapshot length as p, it will write new packets

    /// at the end of the file.

    ///

    /// On Windows a path outside ASCII needs `init(CharEncoding::Utf8)` first. The path always

    /// reaches libpcap as UTF-8, but until that call libpcap reads it in the local code page,

    /// which on most systems is not UTF-8: the name gets mangled and the file lands elsewhere.

    #[cfg(libpcap_1_7_2)]

        });

    /// Set the direction of the capture

        })

    /// Blocks until a packet is returned from the capture handle or an error occurs.

    ///

    /// pcap captures packets and places them into a buffer which this function reads

    /// from.

    ///

    /// # Warning

    ///

    /// This buffer has a finite length, so if the buffer fills completely new

    /// packets will be discarded temporarily. This means that in realtime situations,

    /// you probably want to minimize the time between calls to next_packet() method.

    /// In high traffic situations, consider [`Self::dispatch()`] instead, which

    /// processes a whole batch of packets per call.

    ///

    /// A savefile that has run out gives [`Error::NoMorePackets`], and a capture stopped with

    /// [`BreakLoop::breakloop`] gives [`ErrorCode::Break`](crate::ErrorCode::Break). A savefile

    /// stopped rather than read to the end cannot be told from one that ended, as libpcap reports

    /// both alike.

        unsafe {

                    // packet was read without issue

                }

                0 => {

                    // packets are being read from a live capture and the

                    // timeout expired

                }

                -1 => {

                    // an error occured while reading the packet

                }

                -2 => {

                    // either a savefile ran out or the loop was stopped; libpcap answers -2 for

                    // both, and an interface has no end to reach

                    } else {

                    }

                }

                // GRCOV_EXCL_START

                _ => {

                    // libpcap only defines codes >=1, 0, -1, and -2

                    unreachable!()

                } // GRCOV_EXCL_STOP

            }

        }

    /// Return an iterator that call [`Self::next_packet()`] forever. Require a [`PacketCodec`]

    {

            // Actually passing 0 down to pcap_loop would mean read forever.

            // We interpret it as "read nothing", so we just succeed immediately.

        };

            )

        };

    /// Process a batch of packets from the capture using `pcap_dispatch`.

    ///

    /// Unlike [`Self::next_packet()`], which performs a system call for every packet, this

    /// processes a whole buffer of packets in a single call, making packet loss less likely

    /// in high traffic situations. Packets are still dropped when the buffer fills up between

    /// calls, so a busy interface also wants a larger [`Capture::buffer_size()`].

    ///

    /// At most `count` packets are processed. `None` processes all the packets received in

    /// one buffer when reading a live capture, or all the packets in the file when reading

    /// a savefile.

    ///

    /// Unlike [`Self::for_each()`], this does not block until `count` packets have been

    /// processed: it returns the number of packets processed as soon as one buffer has been

    /// handled, which may be zero if there are no more packets to read. Note that on most

    /// platforms the read timeout only starts once the first packet arrives, so a quiet live

    /// capture can block instead of returning zero.

    {

            // What passing 0 down to pcap_dispatch means depends on the libpcap version.

            // We interpret it as "read nothing", so we just succeed immediately.

        };

            )

        };

        // A successful pcap_dispatch returns the number of packets processed, not 0 like

        // pcap_loop.

    /// Returns a thread-safe `BreakLoop` handle for calling pcap_breakloop() on an active capture.

    ///

    /// # Example

    ///

    /// ```no_run

    /// // Using an active capture

    /// use pcap::Device;

    ///

    /// let mut cap = Device::lookup().unwrap().unwrap().open().unwrap();

    ///

    /// let break_handle = cap.breakloop_handle();

    ///

    /// let capture_thread = std::thread::spawn(move || {

    ///     while let Ok(packet) = cap.next_packet() {

    ///         println!("received packet! {:?}", packet);

    ///     }

    /// });

    ///

    /// // Send break_handle to a separate thread (e.g. user input, signal handler, etc.)

    /// std::thread::spawn(move || {

    ///     std::thread::sleep(std::time::Duration::from_secs(1));

    ///     break_handle.breakloop();

    /// });

    ///

    /// capture_thread.join().unwrap();

    /// ```

    /// Compiles the string into a filter program using `pcap_compile`.

        unsafe {

                0,

            );

        }

    /// Sets the filter on the capture using the given BPF program string. Internally this is

    /// compiled using `pcap_compile()`. `optimize` controls whether optimization on the resulting

    /// code is performed

    ///

    /// See <http://biot.com/capstats/bpf.html> for more information about this syntax.

    /// Get capture statistics about this capture. The values represent packet statistics from the

    /// start of the run to the time of the call.

    ///

    /// See <https://www.tcpdump.org/manpages/pcap_stats.3pcap.html> for per-platform caveats about

    /// how packet statistics are calculated.

        unsafe {

        }

}

// Handler and its associated function let us create an extern "C" fn which dispatches to a normal

// Rust FnMut, which may be a closure with a captured environment. The *only* purpose of this

// generic parameter is to ensure that in Capture::pcap_loop that we pass the right function

// pointer and the right data pointer to pcap_loop.

struct HandlerFn<F> {

    func: F,

    panic_payload: Option<Box<dyn Any + Send>>,

    handle: Arc<PcapHandle>,

}

impl<F> HandlerFn<F>

where

    F: FnMut(Packet),

{

        unsafe {

            );

            // If our handler function panics, we need to prevent it from unwinding across the

            // FFI boundary. If the handler panics we catch the unwind here, break out of

            // pcap_loop, and resume the unwind outside.

        }

}

impl<T: Activated> From<Capture<T>> for Capture<dyn Activated> {

}

/// BreakLoop can safely be sent to other threads such as signal handlers to abort

/// blocking capture loops such as `Capture::next_packet` and `Capture::for_each`.

///

/// See <https://www.tcpdump.org/manpages/pcap_breakloop.3pcap.html> for per-platform caveats about

/// how breakloop can wake up blocked threads.

pub struct BreakLoop {

    handle: Weak<PcapHandle>,

}

unsafe impl Send for BreakLoop {}

unsafe impl Sync for BreakLoop {}

impl BreakLoop {

    /// Calls `pcap_breakloop` to make the blocking loop of a pcap capture return.

    /// The call is a no-op if the handle is invalid.

    ///

    /// # Safety

    ///

    /// Can be called from any thread, but **must not** be used inside a

    /// signal handler unless the owning `Capture` is guaranteed to still

    /// be alive.

    ///

    /// The signal handler should defer the execution of `BreakLoop::breakloop()`

    /// to a thread instead for safety.

}

/// Abstraction for writing pcap savefiles, which can be read afterwards via `Capture::from_file()`.

pub struct Savefile {

    handle: NonNull<raw::pcap_dumper_t>,

}

// Just like a Capture, a Savefile is safe to Send as it encapsulates the entire lifetime of

// `raw::pcap_dumper_t *`, but it is not safe to Sync as libpcap does not promise thread-safe access

// to the same `raw::pcap_dumper_t *` from multiple threads.

unsafe impl Send for Savefile {}

impl Savefile {

    /// Write a packet to a capture file

    ///

    /// At most `packet.data.len()` bytes are written. A larger `caplen` in the header is capped

    /// to that, and `len` is raised to the number of bytes written if it is smaller.

    /// Flushes all the packets that haven't been written to the savefile

    /// Get the current offset of the savefile, that is the number of bytes written so far,

    /// including any that are still buffered

        // Prior to 1.9.0 when `pcap_dump_ftell64` was introduced, the offset was only reported as

        // a `long`. Where that is a 32-bit type, as it is on Windows, the call fails once the

        // savefile has grown past 2 GB.

        #[cfg(libpcap_1_9_0)]

        #[cfg(not(libpcap_1_9_0))]

        let offset = unsafe { raw::pcap_dump_ftell(self.handle.as_ptr()) };

    /// Get the `FILE *` the savefile is being written to

    ///

    /// This is not available on Windows, where wpcap may be linked against a different C runtime

    /// than its caller and the `FILE *` would belong to the wrong one.

    ///

    /// # Safety

    ///

    /// The caller must ensure that the `Savefile` outlives the returned `FILE *` since it is

    /// closed when the `Savefile` is dropped.

    #[cfg(not(windows))]

}

impl From<NonNull<raw::pcap_dumper_t>> for Savefile {

}

impl Drop for Savefile {

}

#[repr(transparent)]

pub struct BpfInstruction(raw::bpf_insn);

#[repr(transparent)]

pub struct BpfProgram(raw::bpf_program);

impl BpfProgram {

    /// checks whether a filter matches a packet

        unsafe {

        }

}

impl Drop for BpfProgram {

}

impl fmt::Display for BpfInstruction {

            "{} {} {} {}",

            self.0.code, self.0.jt, self.0.jf, self.0.k

        )

}

unsafe impl Send for BpfProgram {}

#[cfg(not(windows))]

/// Open a raw file descriptor.

///

/// # Safety

///

/// Unsafe, because the returned FILE assumes it is the sole owner of the file descriptor.

// GRCOV_EXCL_START

#[cfg(test)]

pub mod testmod {

    use super::*;

    pub static TS: libc::timeval = libc::timeval {

        tv_sec: 5,

        tv_usec: 50,

    };

    pub static LEN: u32 = DATA.len() as u32;

    pub static CAPLEN: u32 = LEN;

    pub static mut PKTHDR: raw::pcap_pkthdr = raw::pcap_pkthdr {

        ts: TS,

        caplen: CAPLEN,

        len: LEN,

    };

    pub static PACKET_HEADER: PacketHeader = PacketHeader {

        ts: TS,

        caplen: CAPLEN,

        len: LEN,

    };

    pub static DATA: [u8; 4] = [4, 5, 6, 7];

    pub static PACKET: Packet = Packet {

        header: &PACKET_HEADER,

        data: &DATA,

    };

    pub struct NextExContext(raw::__pcap_next_ex::Context);

    pub fn next_ex_expect(pcap: *mut raw::pcap_t) -> NextExContext {

        let data_ptr: *const libc::c_uchar = DATA.as_ptr();

        #[allow(unused_unsafe)] // unsafe still needed to compile on MSRV

        let pkthdr_ptr: *mut raw::pcap_pkthdr = unsafe { std::ptr::addr_of_mut!(PKTHDR) };

        let ctx = raw::pcap_next_ex_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _, _| *arg1 == pcap)

            .return_once_st(move |_, arg2, arg3| {

                unsafe {

                    *arg2 = pkthdr_ptr;

                    *arg3 = data_ptr;

                }

                CAPLEN as i32

            });

        NextExContext(ctx)

    }

}

// GRCOV_EXCL_STOP

#[cfg(test)]

mod tests {

    use crate::{

        capture::{

            Active, Capture, Offline,

            activated::testmod::{DATA, PACKET, TS, next_ex_expect},

            testmod::test_capture,

        },

        raw::testmod::{RAWMTX, as_file, as_pcap_dumper_t, as_pcap_t, geterr_expect},

    };

    use super::*;

    #[test]

    fn test_list_datalinks() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_list_datalinks_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once_st(|_, _| 0);

        let ctx = raw::pcap_free_datalinks_context();

        ctx.expect().return_once(|_| {});

        let _err = geterr_expect(pcap);

        let result = capture.list_datalinks();

        assert!(result.is_err());

        let mut datalinks: [i32; 4] = [0, 1, 2, 3];

        let links: *mut i32 = datalinks.as_mut_ptr();

        let len = datalinks.len();

        let ctx = raw::pcap_list_datalinks_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once_st(move |_, arg2| {

                unsafe { *arg2 = links };

                len as i32

            });

        let ctx = raw::pcap_free_datalinks_context();

        ctx.checkpoint();

        ctx.expect().return_once(|_| {});

        let pcap_datalinks = capture.list_datalinks().unwrap();

        assert_eq!(

            pcap_datalinks,

            datalinks.iter().cloned().map(Linktype).collect::<Vec<_>>()

        );

    }

    #[test]

    fn test_set_datalink() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_set_datalink_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| 0);

        let result = capture.set_datalink(Linktype::ETHERNET);

        assert!(result.is_ok());

        let ctx = raw::pcap_set_datalink_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| -1);

        let _err = geterr_expect(pcap);

        let result = capture.set_datalink(Linktype::ETHERNET);

        assert!(result.is_err());

    }

    #[test]

    fn test_get_datalink() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_datalink_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap)

            .return_once(|_| 1);

        let linktype = capture.get_datalink();

        assert_eq!(linktype, Linktype::ETHERNET);

    }

    #[test]

    fn test_snaplen() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_snapshot_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap)

            .return_once(|_| 65535);

        assert_eq!(capture.snaplen(), 65535);

    }

    #[test]

    fn unify_activated() {

        #![allow(dead_code)]

        fn test1() -> Capture<Active> {

            panic!();

        }

        fn test2() -> Capture<Offline> {

            panic!();

        }

        fn maybe(a: bool) -> Capture<dyn Activated> {

            if a { test1().into() } else { test2().into() }

        }

        fn also_maybe(a: &mut Capture<dyn Activated>) {

            a.filter("whatever filter string, this won't be run anyway", false)

                .unwrap();

        }

    }

    #[test]

    fn test_breakloop_capture_dropped() {

        let _m = RAWMTX.lock();

        let mut value: isize = 1234;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture: Capture<dyn Activated> = test_capture.capture.into();

        let ctx = raw::pcap_breakloop_context();

        ctx.expect()

            .withf_st(move |h| *h == pcap)

            .return_const(())

            .times(1);

        let break_handle = capture.breakloop_handle();

        break_handle.breakloop();

        drop(capture);

        break_handle.breakloop(); // this call does not trigger mock after drop

    }

    #[test]

    fn test_savefile() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let mut value: isize = 888;

        let pcap_dumper = as_pcap_dumper_t(&mut value);

        let test_capture = test_capture::<Offline>(pcap);

        let capture = test_capture.capture;

        let ctx = raw::pcap_dump_open_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once_st(move |_, _| pcap_dumper);

        let ctx = raw::pcap_dump_close_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap_dumper)

            .return_once(|_| {});

        let result = capture.savefile("path/to/nowhere");

        assert!(result.is_ok());

    }

    #[test]

    #[cfg(libpcap_1_7_2)]

    fn test_savefile_append() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let mut value: isize = 888;

        let pcap_dumper = as_pcap_dumper_t(&mut value);

        let test_capture = test_capture::<Offline>(pcap);

        let capture = test_capture.capture;

        let ctx = raw::pcap_dump_open_append_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once_st(move |_, _| pcap_dumper);

        let ctx = raw::pcap_dump_close_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap_dumper)

            .return_once(|_| {});

        let result = capture.savefile_append("path/to/nowhere");

        assert!(result.is_ok());

    }

    #[test]

    fn test_savefile_error() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Offline>(pcap);

        let capture = test_capture.capture;

        let ctx = raw::pcap_dump_open_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| std::ptr::null_mut());

        let _err = geterr_expect(pcap);

        let result = capture.savefile("path/to/nowhere");

        assert!(result.is_err());

    }

    #[test]

    #[cfg(libpcap_1_7_2)]

    fn test_savefile_append_error() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Offline>(pcap);

        let capture = test_capture.capture;

        let ctx = raw::pcap_dump_open_append_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| std::ptr::null_mut());

        let _err = geterr_expect(pcap);

        let result = capture.savefile_append("path/to/nowhere");

        assert!(result.is_err());

    }

    #[cfg(libpcap_1_9_0)]

    struct DumpFtellExpect(raw::__pcap_dump_ftell64::Context);

    #[cfg(not(libpcap_1_9_0))]

    struct DumpFtellExpect(raw::__pcap_dump_ftell::Context);

    fn dump_ftell_expect(pcap_dumper: *mut raw::pcap_dumper_t, offset: i64) -> DumpFtellExpect {

        // Lock must be acquired by caller.

        assert!(RAWMTX.try_lock().is_err());

        #[cfg(libpcap_1_9_0)]

        {

            let ctx = raw::pcap_dump_ftell64_context();

            ctx.checkpoint();

            ctx.expect()

                .withf_st(move |arg1| *arg1 == pcap_dumper)

                .return_once(move |_| offset);

            DumpFtellExpect(ctx)

        }

        #[cfg(not(libpcap_1_9_0))]

        {

            let ctx = raw::pcap_dump_ftell_context();

            ctx.checkpoint();

            ctx.expect()

                .withf_st(move |arg1| *arg1 == pcap_dumper)

                .return_once(move |_| offset as _);

            DumpFtellExpect(ctx)

        }

    }

    #[test]

    fn test_savefile_ops() {

        let _m = RAWMTX.lock();

        let mut value: isize = 888;

        let pcap_dumper = as_pcap_dumper_t(&mut value);

        let ctx = raw::pcap_dump_close_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap_dumper)

            .return_once(|_| {});

        let mut savefile = Savefile {

            handle: NonNull::new(pcap_dumper).unwrap(),

        };

        let ctx = raw::pcap_dump_context();

        ctx.expect()

            .withf_st(move |arg1, _, _| *arg1 == pcap_dumper as _)

            .return_once(|_, _, _| {});

        savefile.write(&PACKET);

        let ctx = raw::pcap_dump_flush_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap_dumper)

            .return_once(|_| 0);

        let result = savefile.flush();

        assert!(result.is_ok());

        let ctx = raw::pcap_dump_flush_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap_dumper)

            .return_once(|_| -1);

        let result = savefile.flush();

        assert!(result.is_err());

        let _ctx = dump_ftell_expect(pcap_dumper, 6144);

        let result = savefile.offset();

        assert_eq!(result.unwrap(), 6144);

        let _ctx = dump_ftell_expect(pcap_dumper, -1);

        let result = savefile.offset();

        assert!(result.is_err());

        #[cfg(not(windows))]

        {

            let mut dummy: isize = 999;

            let file = &mut dummy as *mut isize as *mut FILE;

            let ctx = raw::pcap_dump_file_context();

            ctx.expect()

                .withf_st(move |arg1| *arg1 == pcap_dumper)

                .return_once_st(move |_| file);

            assert_eq!(unsafe { savefile.file() }, file);

        }

    }

    // A caplen past the end of the data, and a len shorter than what is written, are covered by

    // the savefile tests. What is left to check here is that a truncated packet, which is what a

    // caplen within the data means, still goes through with the header it came with.

    #[test]

    fn test_savefile_write_truncated() {

        let _m = RAWMTX.lock();

        let mut value: isize = 888;

        let pcap_dumper = as_pcap_dumper_t(&mut value);

        let ctx = raw::pcap_dump_close_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap_dumper)

            .return_once(|_| {});

        let mut savefile = Savefile {

            handle: NonNull::new(pcap_dumper).unwrap(),

        };

        let header = PacketHeader {

            ts: TS,

            caplen: 2,

            len: 60,

        };

        let ctx = raw::pcap_dump_context();

        ctx.expect()

            .withf_st(move |arg1, arg2, arg3| {

                let header = unsafe { &**arg2 };

                *arg1 == pcap_dumper as _

                    && *arg3 == DATA.as_ptr()

                    && header.caplen == 2

                    && header.len == 60

                    && header.ts.tv_sec == TS.tv_sec

                    && header.ts.tv_usec == TS.tv_usec

            })

            .return_once(|_, _, _| {});

        savefile.write(&Packet::new(&header, &DATA));

    }

    #[test]

    fn test_direction() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let capture = test_capture.capture;

        let ctx = raw::pcap_setdirection_context();

        ctx.expect()

            .withf_st(move |arg1, arg2| (*arg1 == pcap) && (*arg2 == raw::PCAP_D_OUT))

            .return_once(|_, _| 0);

        let result = capture.direction(Direction::Out);

        assert!(result.is_ok());

        let ctx = raw::pcap_setdirection_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, arg2| (*arg1 == pcap) && (*arg2 == raw::PCAP_D_OUT))

            .return_once(|_, _| -1);

        let _err = geterr_expect(pcap);

        let result = capture.direction(Direction::Out);

        assert!(result.is_err());

        // For code coverage of the derive line.

        assert_ne!(Direction::In, Direction::InOut);

        assert_ne!(Direction::In, Direction::Out);

        assert_ne!(Direction::InOut, Direction::Out);

    }

    #[test]

    fn test_next_packet() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture = test_capture.capture;

        let _nxt = next_ex_expect(pcap);

        let next_packet = capture.next_packet().unwrap();

        assert_eq!(next_packet, PACKET);

    }

    #[test]

    fn test_next_packet_timeout() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture = test_capture.capture;

        let ctx = raw::pcap_next_ex_context();

        ctx.expect()

            .withf_st(move |arg1, _, _| *arg1 == pcap)

            .return_once_st(move |_, _, _| 0);

        let err = capture.next_packet().unwrap_err();

        assert_eq!(err, Error::TimeoutExpired);

    }

    #[test]

    fn test_next_packet_read_error() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture = test_capture.capture;

        let ctx = raw::pcap_next_ex_context();

        ctx.expect()

            .withf_st(move |arg1, _, _| *arg1 == pcap)

            .return_once_st(move |_, _, _| -1);

        let _err = geterr_expect(pcap);

        let result = capture.next_packet();

        assert!(result.is_err());

    }

    #[test]

    fn test_next_packet_no_more_packets() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Offline>(pcap);

        let mut capture = test_capture.capture;

        let ctx = raw::pcap_next_ex_context();

        ctx.expect()

            .withf_st(move |arg1, _, _| *arg1 == pcap)

            .return_once_st(move |_, _, _| -2);

        let mut value: isize = 888;

        let file = as_file(&mut value);

        let ctx = raw::pcap_file_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap)

            .return_once_st(move |_| file);

        let err = capture.next_packet().unwrap_err();

        assert_eq!(err, Error::NoMorePackets);

    }

    #[test]

    fn test_next_packet_broken_loop() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture = test_capture.capture;

        let ctx = raw::pcap_next_ex_context();

        ctx.expect()

            .withf_st(move |arg1, _, _| *arg1 == pcap)

            .return_once_st(move |_, _, _| -2);

        // An interface reads no savefile, so the -2 came from pcap_breakloop.

        let ctx = raw::pcap_file_context();

        ctx.expect()

            .withf_st(move |arg1| *arg1 == pcap)

            .return_once_st(|_| ptr::null_mut());

        // The message left over from an earlier failure is not the reason the loop stopped.

        let _err = geterr_expect(pcap);

        let err = capture.next_packet().unwrap_err();

        assert_eq!(

            err,

            Error::PcapErrorCode(crate::ErrorCode::Break, String::new())

        );

    }

    #[test]

    fn test_compile() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let capture = test_capture.capture;

        let ctx = raw::pcap_compile_context();

        ctx.expect()

            .withf_st(move |arg1, _, _, _, _| *arg1 == pcap)

            .return_once(|_, _, _, _, _| -1);

        let _err = geterr_expect(pcap);

        let ctx = raw::pcap_freecode_context();

        ctx.expect().return_once(|_| {});

        let result = capture.compile("some bpf program", false);

        assert!(result.is_err());

        let ctx = raw::pcap_compile_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _, _, _, _| *arg1 == pcap)

            .return_once(|_, _, _, _, _| 0);

        let ctx = raw::pcap_freecode_context();

        ctx.checkpoint();

        ctx.expect().return_once(|_| {});

        let result = capture.compile("some bpf program", false);

        assert!(result.is_ok());

    }

    #[test]

    fn test_filter() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture = test_capture.capture;

        let ctx = raw::pcap_compile_context();

        ctx.expect()

            .withf_st(move |arg1, _, _, _, _| *arg1 == pcap)

            .return_once(|_, _, _, _, _| 0);

        let ctx = raw::pcap_setfilter_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| -1);

        let _err = geterr_expect(pcap);

        let ctx = raw::pcap_freecode_context();

        ctx.expect().return_once(|_| {});

        let result = capture.filter("some bpf program", false);

        assert!(result.is_err());

        let ctx = raw::pcap_compile_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _, _, _, _| *arg1 == pcap)

            .return_once(|_, _, _, _, _| 0);

        let ctx = raw::pcap_setfilter_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| 0);

        let ctx = raw::pcap_freecode_context();

        ctx.checkpoint();

        ctx.expect().return_once(|_| {});

        let result = capture.compile("some bpf program", false);

        assert!(result.is_ok());

    }

    #[test]

    fn test_stats() {

        let _m = RAWMTX.lock();

        let mut value: isize = 777;

        let pcap = as_pcap_t(&mut value);

        let test_capture = test_capture::<Active>(pcap);

        let mut capture = test_capture.capture;

        let stat = raw::pcap_stat {

            ps_recv: 1,

            ps_drop: 2,

            ps_ifdrop: 3,

        };