Struct L2Receiver 

pub struct L2Receiver { /* private fields */ }

Receiver for raw L2 Ethernet frames via AF_PACKET socket.

Implementations

impl L2Receiver

pub fn new(ifname: &str) -> Result<Self, IoError>

Open an AF_PACKET socket and bind to the given interface.

Examples found in repository

examples/packet_dump.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use wireforge_io::{L2Receiver, IoError};

    let ifname = std::env::args().nth(1).unwrap_or_else(|| "lo".into());
    let mut rx = L2Receiver::new(&ifname)?;
    println!("Listening on {}...", ifname);

    loop {
        match rx.recv() {
            Ok(eth) => {
                println!(
                    "{} -> {}  EtherType={:?}  payload={} bytes",
                    hex_mac(&eth.src_mac()),
                    hex_mac(&eth.dst_mac()),
                    eth.ethertype(),
                    eth.payload().len(),
                );
            }
            Err(IoError::Timeout) => continue,
            Err(e) => {
                eprintln!("Error: {}", e);
                break;
            }
        }
    }
    Ok(())
}

examples/cross_platform_dump.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let ifname = std::env::args().nth(1).unwrap_or_else(|| {
        list_interfaces()
            .ok()
            .and_then(|ifaces| ifaces.into_iter().find(|i| !i.is_loopback && i.is_up).map(|i| i.name))
            .unwrap_or_else(|| "lo".into())
    });

    println!("Opening {} ...", ifname);
    let mut rx = DefaultL2Reader::new(&ifname)?;
    rx.set_timeout(Some(Duration::from_secs(1)))?;

    println!("Listening on {} (Ctrl+C to stop)...\n", ifname);
    for i in 0..10 {
        match rx.recv() {
            Ok(eth) => {
                println!("#{}: {} → {}  EtherType={:?}  len={}",
                    i + 1,
                    mac_hex(&eth.src_mac()),
                    mac_hex(&eth.dst_mac()),
                    eth.ethertype(),
                    eth.payload().len() + 14,
                );
            }
            Err(wireforge_io::IoError::Timeout) => continue,
            Err(e) => { eprintln!("Error: {e}"); break; }
        }
    }
    Ok(())
}

pub fn recv(&mut self) -> Result<EthernetPacket<'_>, IoError>

Receive a single Ethernet frame and parse it.

Examples found in repository

examples/packet_dump.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use wireforge_io::{L2Receiver, IoError};

    let ifname = std::env::args().nth(1).unwrap_or_else(|| "lo".into());
    let mut rx = L2Receiver::new(&ifname)?;
    println!("Listening on {}...", ifname);

    loop {
        match rx.recv() {
            Ok(eth) => {
                println!(
                    "{} -> {}  EtherType={:?}  payload={} bytes",
                    hex_mac(&eth.src_mac()),
                    hex_mac(&eth.dst_mac()),
                    eth.ethertype(),
                    eth.payload().len(),
                );
            }
            Err(IoError::Timeout) => continue,
            Err(e) => {
                eprintln!("Error: {}", e);
                break;
            }
        }
    }
    Ok(())
}

examples/cross_platform_dump.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let ifname = std::env::args().nth(1).unwrap_or_else(|| {
        list_interfaces()
            .ok()
            .and_then(|ifaces| ifaces.into_iter().find(|i| !i.is_loopback && i.is_up).map(|i| i.name))
            .unwrap_or_else(|| "lo".into())
    });

    println!("Opening {} ...", ifname);
    let mut rx = DefaultL2Reader::new(&ifname)?;
    rx.set_timeout(Some(Duration::from_secs(1)))?;

    println!("Listening on {} (Ctrl+C to stop)...\n", ifname);
    for i in 0..10 {
        match rx.recv() {
            Ok(eth) => {
                println!("#{}: {} → {}  EtherType={:?}  len={}",
                    i + 1,
                    mac_hex(&eth.src_mac()),
                    mac_hex(&eth.dst_mac()),
                    eth.ethertype(),
                    eth.payload().len() + 14,
                );
            }
            Err(wireforge_io::IoError::Timeout) => continue,
            Err(e) => { eprintln!("Error: {e}"); break; }
        }
    }
    Ok(())
}

pub fn set_promiscuous(&mut self, on: bool) -> Result<(), IoError>

Enable or disable promiscuous mode.

pub fn set_timeout(&mut self, dur: Option<Duration>) -> Result<(), IoError>

Set receive timeout.

Examples found in repository

examples/cross_platform_dump.rs (line 27)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let ifname = std::env::args().nth(1).unwrap_or_else(|| {
        list_interfaces()
            .ok()
            .and_then(|ifaces| ifaces.into_iter().find(|i| !i.is_loopback && i.is_up).map(|i| i.name))
            .unwrap_or_else(|| "lo".into())
    });

    println!("Opening {} ...", ifname);
    let mut rx = DefaultL2Reader::new(&ifname)?;
    rx.set_timeout(Some(Duration::from_secs(1)))?;

    println!("Listening on {} (Ctrl+C to stop)...\n", ifname);
    for i in 0..10 {
        match rx.recv() {
            Ok(eth) => {
                println!("#{}: {} → {}  EtherType={:?}  len={}",
                    i + 1,
                    mac_hex(&eth.src_mac()),
                    mac_hex(&eth.dst_mac()),
                    eth.ethertype(),
                    eth.payload().len() + 14,
                );
            }
            Err(wireforge_io::IoError::Timeout) => continue,
            Err(e) => { eprintln!("Error: {e}"); break; }
        }
    }
    Ok(())
}

Trait Implementations

impl L2Reader for L2Receiver

fn recv(&mut self) -> Result<EthernetPacket<'_>, IoError>

Receive a single Ethernet frame and parse it.

fn set_timeout(&mut self, dur: Option<Duration>) -> Result<(), IoError>

Set the receive timeout. None means blocking (no timeout).

fn set_promiscuous(&mut self, on: bool) -> Result<(), IoError>

Enable or disable promiscuous mode.