zond-engine 0.6.1

A lightweight, fast, and highly concurrent networking backend for packet crafting, protocol fingerprinting, and host discovery.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

// Copyright (c) 2026 Erik Lening (hollowpointer) and Contributors
//
// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
// If a copy of the MPL was not distributed with this file, You can obtain one at
// https://mozilla.org/MPL/2.0/.

// use crate::adapters::outbound::terminal::print;
use anyhow::{self, Context};
use pnet::datalink;
use pnet::datalink::{Channel, Config, DataLinkReceiver, DataLinkSender, NetworkInterface};
use std::thread;
use std::time::Duration;
use tokio::sync::mpsc;

const READ_TIMEOUT_MS: u64 = 50;

pub struct EthernetHandle {
    pub tx: Box<dyn DataLinkSender>,
    pub rx: mpsc::UnboundedReceiver<Vec<u8>>,
}

pub fn start_capture(intf: &NetworkInterface) -> anyhow::Result<EthernetHandle> {
    let cfg = Config {
        read_timeout: Some(Duration::from_millis(READ_TIMEOUT_MS)),
        ..Default::default()
    };
    let (tx, rx_socket) = open_eth_channel(intf, datalink::channel, cfg)?;
    let (queue_tx, queue_rx) = mpsc::unbounded_channel();
    spawn_eth_listener(queue_tx, rx_socket);
    Ok(EthernetHandle { tx, rx: queue_rx })
}

pub fn open_eth_channel<F>(
    intf: &NetworkInterface,
    channel_opener: F,
    cfg: Config,
) -> anyhow::Result<(Box<dyn DataLinkSender>, Box<dyn DataLinkReceiver>)>
where
    F: FnOnce(&NetworkInterface, Config) -> std::io::Result<datalink::Channel>,
{
    let ch: Channel =
        channel_opener(intf, cfg).with_context(|| format!("opening on {}", intf.name))?;

    match ch {
        Channel::Ethernet(tx, rx) => Ok((tx, rx)),
        _ => anyhow::bail!("non-ethernet channel for {}", intf.name),
    }
}

pub fn spawn_eth_listener(
    eth_tx: mpsc::UnboundedSender<Vec<u8>>,
    eth_rx: Box<dyn DataLinkReceiver>,
) {
    thread::spawn(move || {
        let mut eth_iter = eth_rx;
        loop {
            if let Ok(frame) = eth_iter.next()
                && eth_tx.send(frame.to_vec()).is_err()
            {
                break;
            }
        }
    });
}