netring 0.4.0

High-performance zero-copy packet I/O for Linux (AF_PACKET TPACKET_V3 + AF_XDP)
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! Integration tests for loopback capture.
//!
//! Requires CAP_NET_RAW. Run with: cargo test --features integration-tests

#![cfg(feature = "integration-tests")]

mod helpers;

use netring::{Capture, CaptureBuilder};
use std::time::{Duration, Instant};

#[test]
fn capture_loopback_basic() {
    let port = helpers::unique_port();
    let marker = format!("netring_test_{port}");

    let mut rx = CaptureBuilder::default()
        .interface(helpers::LOOPBACK)
        .block_timeout_ms(10)
        .build()
        .expect("build rx");

    // Send packets in a background thread
    let marker_clone = marker.clone();
    let sender = std::thread::spawn(move || {
        std::thread::sleep(Duration::from_millis(50));
        helpers::send_udp_to_loopback(port, marker_clone.as_bytes(), 10);
    });

    // Capture until we see our marker or deadline
    let mut found = 0;
    let deadline = Instant::now() + Duration::from_secs(3);
    while Instant::now() < deadline {
        if let Some(batch) = rx.next_batch_blocking(Duration::from_millis(200)).unwrap() {
            for pkt in &batch {
                if pkt
                    .data()
                    .windows(marker.len())
                    .any(|w| w == marker.as_bytes())
                {
                    found += 1;
                }
            }
            if found >= 5 {
                break;
            }
        }
    }

    sender.join().unwrap();
    assert!(found > 0, "should have captured at least 1 marked packet");
}

#[test]
fn low_level_rx_next_batch() {
    let port = helpers::unique_port();
    let marker = format!("netring_batch_{port}");

    let mut rx = CaptureBuilder::default()
        .interface(helpers::LOOPBACK)
        .block_timeout_ms(10)
        .build()
        .expect("build rx");

    let marker_clone = marker.clone();
    let sender = std::thread::spawn(move || {
        std::thread::sleep(Duration::from_millis(50));
        helpers::send_udp_to_loopback(port, marker_clone.as_bytes(), 5);
    });

    let mut found = false;
    let deadline = Instant::now() + Duration::from_secs(3);
    while Instant::now() < deadline {
        if let Some(batch) = rx.next_batch_blocking(Duration::from_millis(100)).unwrap() {
            assert!(!batch.is_empty());
            for pkt in &batch {
                if pkt
                    .data()
                    .windows(marker.len())
                    .any(|w| w == marker.as_bytes())
                {
                    found = true;
                }
            }
            if found {
                break;
            }
        }
    }

    sender.join().unwrap();
    assert!(found, "should have found marker in batch");
}

#[test]
fn capture_promiscuous_no_crash() {
    let _cap = Capture::builder()
        .interface(helpers::LOOPBACK)
        .promiscuous(true)
        .build()
        .expect("promiscuous on loopback should work");
}