FPS 0.0.3

Flow processing system (under construction). 
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

use n::packet::*;

extract_field!(extract_destination, ethernet, 6, destination);
fill_field!(fill_destination, ethernet, 6, destination);

extract_field!(extract_source, ethernet, 6, source);
fill_field!(fill_source, ethernet, 6, source);

extract_field_value!(extract_protocol_u16, ethernet, protocol, u16);
apply_field_value!(apply_protocol, ethernet, protocol, u16);

extract_field!(extract_protocol, ethernet, 2, protocol);
fill_field!(fill_protocol, ethernet, 2, protocol);

#[millefeuille]
pub fn extract_source_u64(packet: Packet) -> Packet {
    let mut packet = packet;
    let first_4;
    let later_2;
    {
        let field = packet.context.get_field("ethernet::source");
        first_4 = field.read_u32(0) as u64;
        later_2 = field.read_u16(4) as u64;
    }
    let val = (first_4 << 32) | (later_2 & 0xFFFF);
    packet.context.set_u64("ethernet::source_u64", val);
    packet
}

#[millefeuille]
pub fn extract_destination_u64(packet: Packet) -> Packet {
    let mut packet = packet;
    let first_4;
    let later_2;
    {
        let field = packet.context.get_field("ethernet::destination");
        first_4 = field.read_u32(0) as u64;
        later_2 = field.read_u16(4) as u64;
    }
    let val = (first_4 << 32) | (later_2 & 0xFFFF);
    packet.context.set_u64("ethernet::destination_u64", val);
    packet
}

#[millefeuille]
pub fn apply_source(packet: Packet) -> Packet {
    let mut packet = packet;
    let mut field = packet.context.take_field("ethernet::source");
    let value = packet.context.get_u64("ethernet::source_u64");
    field.write_u32(0, (value >> 32) as u32);
    field.write_u16(4, ((value >> 16) & 0xFFFF) as u16);
    packet.context.set_field("ethernet::source", field);
    packet
}

#[millefeuille]
pub fn apply_destination(packet: Packet) -> Packet {
    let mut packet = packet;
    let mut field = packet.context.take_field("ethernet::destination");
    let value = packet.context.get_u64("ethernet::destination_u64");
    field.write_u32(0, (value >> 32) as u32);
    field.write_u16(4, ((value >> 16) & 0xFFFF) as u16);
    packet.context.set_field("ethernet::destination", field);
    packet
}

#[millefeuille]
pub fn extract(packet: Packet) -> Packet {
    let packet = extract_destination(packet);
    let packet = extract_source(packet);
    let packet = extract_protocol(packet);

    packet
}

#[millefeuille]
pub fn fill(packet: Packet) -> Packet {
    let packet = fill_protocol(packet);
    let packet = fill_source(packet);
    let packet = fill_destination(packet);

    packet
}

#[millefeuille]
pub fn swap_address(mut packet: Packet) -> Packet {
    let mut temp_addr = &mut [0u8; 6];
    {
        let mut old_dst = packet.context.take_field("ethernet::destination");
        let mut old_src = packet.context.take_field("ethernet::source");
        move_field(old_dst, temp_addr);
        move_field(old_src, old_dst);
        move_field(temp_addr, old_src);
        packet.context.set_field("ethernet::destination", old_dst);
        packet.context.set_field("ethernet::source", old_src);
    }
    packet
}