stackforge-core 0.7.1

Core networking logic for Stackforge.
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use criterion::{Criterion, black_box, criterion_group, criterion_main};
use stackforge_core::layer::{LayerIndex, LayerKind};
use stackforge_core::packet::Packet;

/// Build a TCP/HTTP packet for dispatch benchmarks.
fn tcp_packet() -> Vec<u8> {
    let mut pkt = vec![
        // Ethernet (14 bytes)
        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x08, 0x00,
        // IPv4 (20 bytes)
        0x45, 0x00, 0x00, 0x3c, 0x00, 0x01, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 0xc0, 0xa8, 0x01,
        0x01, 0xc0, 0xa8, 0x01, 0x02, // TCP (20 bytes)
        0x00, 0x50, 0x1f, 0x90, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02, 0x20,
        0x00, 0x00, 0x00, 0x00, 0x00,
    ];
    pkt.extend_from_slice(b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n");
    pkt
}

fn bench_layer_enum_dispatch(c: &mut Criterion) {
    let data = tcp_packet();
    let mut pkt = Packet::from_bytes(data);
    pkt.parse().unwrap();

    let buf = pkt.as_bytes();
    let enums = pkt.layer_enums();

    let mut group = c.benchmark_group("layer_dispatch");

    // Benchmark kind() dispatch
    group.bench_function("kind", |b| {
        b.iter(|| {
            for le in &enums {
                black_box(le.kind());
            }
        })
    });

    // Benchmark summary() dispatch (the most expensive — allocates String)
    group.bench_function("summary", |b| {
        b.iter(|| {
            for le in &enums {
                black_box(le.summary(buf));
            }
        })
    });

    // Benchmark header_len() dispatch
    group.bench_function("header_len", |b| {
        b.iter(|| {
            for le in &enums {
                black_box(le.header_len(buf));
            }
        })
    });

    // Benchmark index() dispatch
    group.bench_function("index", |b| {
        b.iter(|| {
            for le in &enums {
                black_box(le.index());
            }
        })
    });

    // Benchmark field_names() dispatch
    group.bench_function("field_names", |b| {
        b.iter(|| {
            for le in &enums {
                black_box(le.field_names());
            }
        })
    });

    group.finish();
}

fn bench_layer_enum_construction(c: &mut Criterion) {
    let data = tcp_packet();
    let mut pkt = Packet::from_bytes(data);
    pkt.parse().unwrap();

    let layers: Vec<LayerIndex> = pkt.layers().to_vec();

    c.bench_function("layer_enum_construction", |b| {
        b.iter(|| {
            for idx in &layers {
                black_box(pkt.layer_enum(idx));
            }
        })
    });
}

fn bench_get_layer_linear_search(c: &mut Criterion) {
    let data = tcp_packet();
    let mut pkt = Packet::from_bytes(data);
    pkt.parse().unwrap();

    let mut group = c.benchmark_group("get_layer");

    // Search for first layer (best case)
    group.bench_function("first_layer", |b| {
        b.iter(|| {
            black_box(pkt.get_layer(LayerKind::Ethernet));
        })
    });

    // Search for last layer (worst case for linear scan)
    group.bench_function("last_layer", |b| {
        b.iter(|| {
            black_box(pkt.get_layer(LayerKind::Http));
        })
    });

    // Search for missing layer
    group.bench_function("missing_layer", |b| {
        b.iter(|| {
            black_box(pkt.get_layer(LayerKind::Dns));
        })
    });

    group.finish();
}

criterion_group!(
    benches,
    bench_layer_enum_dispatch,
    bench_layer_enum_construction,
    bench_get_layer_linear_search,
);
criterion_main!(benches);