//! pcap is a packet capture library available on Linux, Windows and Mac. This

//! crate supports creating and configuring capture contexts, sniffing packets,

//! sending packets to interfaces, listing devices, and recording packet captures

//! to pcap-format dump files.

//!

//! # Capturing packets

//! The easiest way to open an active capture handle and begin sniffing is to

//! use `.open()` on a `Device`. You can obtain the "default" device using

//! `Device::lookup()`, or you can obtain the device(s) you need via `Device::list()`.

//!

//! ```no_run

//! use pcap::Device;

//!

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

//!

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

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

//! }

//!

//! ```

//!

//! `Capture`'s `.next_packet()` will produce a `Packet` which can be dereferenced to access the

//! `&[u8]` packet contents.

//!

//! # Custom configuration

//!

//! You may want to configure the `timeout`, `snaplen` or other parameters for the capture

//! handle. In this case, use `Capture::from_device()` to obtain a `Capture<Inactive>`, and

//! proceed to configure the capture handle. When you're finished, run `.open()` on it to

//! turn it into a `Capture<Active>`.

//!

//! ```no_run

//! use pcap::{Device, Capture};

//!

//! let main_device = Device::lookup().unwrap().unwrap();

//! let mut cap = Capture::from_device(main_device).unwrap()

//!                   .promisc(true)

//!                   .snaplen(5000)

//!                   .open().unwrap();

//!

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

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

//! }

//! ```

//!

//! # Abstracting over different capture types

//!

//! You can abstract over live captures (`Capture<Active>`) and file captures

//! (`Capture<Offline>`) using generics and the [`Activated`] trait, for example:

//!

//! ```

//! use pcap::{Activated, Capture};

//!

//! fn read_packets<T: Activated>(mut capture: Capture<T>) {

//!     while let Ok(packet) = capture.next_packet() {

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

//!     }

//! }

//! ```

#![cfg_attr(docsrs, feature(doc_cfg))]

use std::ffi::{self, CStr};

use std::fmt;

use self::Error::*;

mod capture;

mod codec;

mod device;

mod linktype;

mod packet;

#[cfg(not(windows))]

pub use capture::activated::open_raw_fd;

pub use capture::{

    activated::{

        BpfInstruction, BpfProgram, BreakLoop, Direction, Savefile, Stat, iterator::PacketIter,

    },

    inactive::TimestampType,

    {Activated, Active, Capture, Dead, Inactive, Offline, Precision, State},

};

pub use codec::PacketCodec;

pub use device::{Address, ConnectionStatus, Device, DeviceFlags, IfFlags};

pub use linktype::Linktype;

pub use packet::{Packet, PacketHeader};

#[deprecated(note = "Renamed to TimestampType")]

/// An old name for `TimestampType`, kept around for backward-compatibility.

pub type TstampType = TimestampType;

mod raw;

#[cfg(windows)]

#[cfg_attr(docsrs, doc(cfg(windows)))]

pub mod sendqueue;

#[cfg(feature = "capture-stream")]

mod stream;

#[cfg(feature = "capture-stream")]

#[cfg_attr(docsrs, doc(cfg(feature = "capture-stream")))]

pub use stream::PacketStream;

/// An error received from pcap

#[derive(Debug, PartialEq, Eq)]

pub enum Error {

    /// The underlying library returned invalid UTF-8

    MalformedError(std::str::Utf8Error),

    /// The underlying library returned a null string

    InvalidString,

    /// The unerlying library returned an error

    PcapError(String),

    /// The linktype was invalid or unknown

    InvalidLinktype,

    /// The timeout expired while reading from a live capture

    TimeoutExpired,

    /// No more packets to read from the file

    NoMorePackets,

    /// Must be in non-blocking mode to function

    NonNonBlock,

    /// There is not sufficent memory to create a dead capture

    InsufficientMemory,

    /// An invalid input string (internal null)

    InvalidInputString,

    /// An IO error occurred

    IoError(std::io::ErrorKind),

    #[cfg(not(windows))]

    /// An invalid raw file descriptor was provided

    InvalidRawFd,

    /// Errno error

    ErrnoError(errno::Errno),

    /// Buffer size overflows capacity

    BufferOverflow,

}

impl Error {

        // libpcap truncates its messages at PCAP_ERRBUF_SIZE without regard for character

        // boundaries, so one quoting a long path can end in the middle of a UTF-8 sequence.

        // Take such a message lossily rather than lose it. Strings that are not error messages

        // still go through cstr_to_string, which rejects the malformed ones.

    {

}

    } else {

    };

impl fmt::Display for Error {

            #[cfg(not(windows))]

        }

}

// Using description is deprecated. Remove in next version.

impl std::error::Error for Error {

            #[cfg(not(windows))]

        }

        }

}

impl From<ffi::NulError> for Error {

}

impl From<std::str::Utf8Error> for Error {

}

impl From<std::io::Error> for Error {

}

impl From<std::io::ErrorKind> for Error {

}

/// Return size of a commonly used packet header.

///

/// On Windows this packet header is implicitly added to send queues, so this size must be known

/// if an application needs to precalculate the exact send queue buffer size.

#[cfg(test)]

mod tests {

    use std::error::Error as StdError;

    use std::{ffi::CString, io};

    use super::*;

    #[test]

    fn test_error_invalid_utf8() {

        let bytes: [u8; 8] = [0x78, 0xfe, 0xe9, 0x89, 0x00, 0x00, 0xed, 0x4f];

        let error = unsafe { Error::new(&bytes as *const _ as _) };

        // The message is kept, with the bytes that are not valid UTF-8 replaced.

        assert_eq!(error, Error::PcapError("x\u{fffd}\u{fffd}".to_string()));

    }

    #[test]

    fn test_error_null() {

        let error = unsafe { Error::new(std::ptr::null()) };

        assert_eq!(error, Error::PcapError("".to_string()));

    }

    #[test]

    #[allow(deprecated)]

    fn test_errors() {

        let mut errors: Vec<Error> = vec![];

        let bytes: [u8; 8] = [0x78, 0xfe, 0xe9, 0x89, 0x00, 0x00, 0xed, 0x4f];

        let cstr = unsafe { CStr::from_ptr(&bytes as *const _ as _) };

        errors.push(cstr.to_str().unwrap_err().into());

        errors.push(Error::InvalidString);

        errors.push(Error::PcapError("git rekt".to_string()));

        errors.push(Error::InvalidLinktype);

        errors.push(Error::TimeoutExpired);

        errors.push(Error::NoMorePackets);

        errors.push(Error::NonNonBlock);

        errors.push(Error::InsufficientMemory);

        errors.push(CString::new(b"f\0oo".to_vec()).unwrap_err().into());

        errors.push(io::Error::new(io::ErrorKind::Interrupted, "error").into());

        #[cfg(not(windows))]

        errors.push(Error::InvalidRawFd);

        errors.push(Error::ErrnoError(errno::Errno(125)));

        errors.push(Error::BufferOverflow);

        for error in errors.iter() {

            assert!(!error.to_string().is_empty());

            assert!(!error.description().is_empty());

            match error {

                Error::MalformedError(_) => assert!(error.cause().is_some()),

                _ => assert!(error.cause().is_none()),

            }

        }

    }

    #[test]

    fn test_packet_size() {

        assert_eq!(

            packet_header_size(),

            std::mem::size_of::<raw::pcap_pkthdr>()

        );

    }

}