Struct Device 

pub struct Device {
    pub name: String,
    pub desc: Option<String>,
}

A network device name and (potentially) pcap’s description of it.

Fields

name: String

desc: Option<String>

Implementations

impl Device

pub fn open(self) -> Result<Capture<Active>, Error>

Opens a Capture<Active> on this device.

Examples found in repository

examples/easylisten.rs (line 5)

fn main() {
    // get the default Device
    let mut cap = pcap::Device::lookup().unwrap().open().unwrap();

    // get a packet and print its bytes
    println!("{:?}", cap.next());
}

examples/getstatistics.rs (line 5)

fn main() {
    // get the default Device
    let mut cap = pcap::Device::lookup().unwrap().open().unwrap();

    // get 10 packets
    for _ in 0..10 {
      cap.next().ok();
    }
    let stats = cap.stats().unwrap();
    println!("Received: {}, dropped: {}, if_dropped: {}", stats.received, stats.dropped, stats.if_dropped);
}

examples/getdevices.rs (line 9)

fn main() {
    // list all of the devices pcap tells us are available
    for device in pcap::Device::list().unwrap() {
        println!("Found device! {:?}", device);

        // now you can create a Capture with this Device if you want.
        let mut cap = device.open().unwrap();

        // get a packet from this capture
        let packet = cap.next();

        println!("got a packet! {:?}", packet);
    }
}

pub fn lookup() -> Result<Device, Error>

Returns the default Device suitable for captures according to pcap_lookupdev, or an error from pcap.

Examples found in repository

examples/easylisten.rs (line 5)

fn main() {
    // get the default Device
    let mut cap = pcap::Device::lookup().unwrap().open().unwrap();

    // get a packet and print its bytes
    println!("{:?}", cap.next());
}

examples/getstatistics.rs (line 5)

fn main() {
    // get the default Device
    let mut cap = pcap::Device::lookup().unwrap().open().unwrap();

    // get 10 packets
    for _ in 0..10 {
      cap.next().ok();
    }
    let stats = cap.stats().unwrap();
    println!("Received: {}, dropped: {}, if_dropped: {}", stats.received, stats.dropped, stats.if_dropped);
}

examples/savefile.rs (line 8)

fn main() {
	{
		// open capture from default device
		let mut cap = Capture::from_device(Device::lookup().unwrap()).unwrap().open().unwrap();

		// open savefile using the capture
		let mut savefile = cap.savefile("test.pcap").unwrap();

		// get a packet from the interface
		let p = cap.next().unwrap();

		// print the packet out
		println!("packet received on network: {:?}", p);

		// write the packet to the savefile
		savefile.write(&p);
	}

	// open a new capture from the test.pcap file we wrote to above
	let mut cap = Capture::from_file("test.pcap").unwrap();

	// get a packet
	let p = cap.next().unwrap();

	// print that packet out -- it should be the same as the one we printed above
	println!("packet obtained from file: {:?}", p);
}

pub fn list() -> Result<Vec<Device>, Error>

Returns a vector of Devices known by pcap via pcap_findalldevs.

Examples found in repository

examples/getdevices.rs (line 5)

fn main() {
    // list all of the devices pcap tells us are available
    for device in pcap::Device::list().unwrap() {
        println!("Found device! {:?}", device);

        // now you can create a Capture with this Device if you want.
        let mut cap = device.open().unwrap();

        // get a packet from this capture
        let packet = cap.next();

        println!("got a packet! {:?}", packet);
    }
}

Trait Implementations

impl Debug for Device

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Into<Device> for &'a str

fn into(self) -> Device

Converts this type into the (usually inferred) input type.