net-wire 0.1.0

Allocation-free no_std wire views and codecs for network protocols.
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

use net_wire::ipv4::{
    Ipv4Address, Ipv4PacketBuildError, Ipv4PacketBuilder, Ipv4PacketMut, Ipv4Protocol,
};

fn complete<'a>(
    b: &'a mut [u8],
    options: &[u8],
) -> Result<Ipv4PacketMut<'a>, Ipv4PacketBuildError> {
    Ipv4PacketBuilder::new(b, 4)
        .source(Ipv4Address::new([192, 0, 2, 1]))
        .destination(Ipv4Address::new([198, 51, 100, 2]))
        .protocol(Ipv4Protocol::new(0xfd))
        .ttl(60)
        .identification(0x1234)
        .flags_fragment_offset(0x2005)
        .dscp_ecn(0xab)
        .options(options)
        .build()
}
fn built_from_local(buffer: &mut [u8]) -> Ipv4PacketMut<'_> {
    let options = [1, 2, 3, 4];
    complete(buffer, &options).unwrap()
}
#[test]
fn builder_is_exact_and_errors_atomic() {
    let mut b = [0xa5; 31];
    let p = built_from_local(&mut b);
    assert_eq!(
        p.as_bytes(),
        &[
            0x46, 0xab, 0, 28, 0x12, 0x34, 0x20, 5, 60, 0xfd, 0x59, 0xc4, 192, 0, 2, 1, 198, 51,
            100, 2, 1, 2, 3, 4, 0xa5, 0xa5, 0xa5, 0xa5,
        ]
    );
    assert_eq!(&b[24..], &[0xa5; 7]);
    macro_rules! e {
        ($x:expr,$want:expr) => {{
            let mut b = [0xa5; 64];
            let old = b;
            assert_eq!($x(&mut b), Err($want));
            assert_eq!(b, old)
        }};
    }
    fn m1(b: &mut [u8]) -> Result<Ipv4PacketMut<'_>, Ipv4PacketBuildError> {
        Ipv4PacketBuilder::new(b, 0).build()
    }
    fn m2(b: &mut [u8]) -> Result<Ipv4PacketMut<'_>, Ipv4PacketBuildError> {
        Ipv4PacketBuilder::new(b, 0)
            .source(Ipv4Address::new([1; 4]))
            .build()
    }
    fn m3(b: &mut [u8]) -> Result<Ipv4PacketMut<'_>, Ipv4PacketBuildError> {
        Ipv4PacketBuilder::new(b, 0)
            .source(Ipv4Address::new([1; 4]))
            .destination(Ipv4Address::new([2; 4]))
            .build()
    }
    fn m4(b: &mut [u8]) -> Result<Ipv4PacketMut<'_>, Ipv4PacketBuildError> {
        Ipv4PacketBuilder::new(b, 0)
            .source(Ipv4Address::new([1; 4]))
            .destination(Ipv4Address::new([2; 4]))
            .protocol(Ipv4Protocol::new(1))
            .build()
    }
    e!(m1, Ipv4PacketBuildError::MissingSource);
    e!(m2, Ipv4PacketBuildError::MissingDestination);
    e!(m3, Ipv4PacketBuildError::MissingProtocol);
    e!(m4, Ipv4PacketBuildError::MissingTtl);
    let mut b = [0xa5; 64];
    let old = b;
    assert_eq!(
        complete(&mut b, &[1, 2, 3]).map(|_| ()),
        Err(Ipv4PacketBuildError::InvalidOptionsLength)
    );
    assert_eq!(b, old);
    let mut b = [0xa5; 64];
    let old = b;
    assert_eq!(
        complete(&mut b, &[0; 44]).map(|_| ()),
        Err(Ipv4PacketBuildError::InvalidOptionsLength)
    );
    assert_eq!(b, old);
    let mut b = [0xa5; 64];
    let old = b;
    assert_eq!(
        Ipv4PacketBuilder::new(&mut b, 0)
            .source(Ipv4Address::new([1; 4]))
            .destination(Ipv4Address::new([2; 4]))
            .protocol(Ipv4Protocol::new(1))
            .ttl(1)
            .flags_fragment_offset(0x8000)
            .build(),
        Err(Ipv4PacketBuildError::ReservedFlagSet)
    );
    assert_eq!(b, old);
    let mut b = [0xa5; 64];
    let old = b;
    assert_eq!(
        Ipv4PacketBuilder::new(&mut b, usize::MAX)
            .source(Ipv4Address::new([1; 4]))
            .destination(Ipv4Address::new([2; 4]))
            .protocol(Ipv4Protocol::new(1))
            .ttl(1)
            .build(),
        Err(Ipv4PacketBuildError::TotalLengthTooLarge)
    );
    assert_eq!(b, old);
    let mut b = [0xa5; 64];
    let old = b;
    assert_eq!(
        Ipv4PacketBuilder::new(&mut b, 65_516)
            .source(Ipv4Address::new([1; 4]))
            .destination(Ipv4Address::new([2; 4]))
            .protocol(Ipv4Protocol::new(1))
            .ttl(1)
            .build(),
        Err(Ipv4PacketBuildError::TotalLengthTooLarge)
    );
    assert_eq!(b, old);
    let mut b = [0xa5; 23];
    let old = b;
    assert_eq!(
        complete(&mut b, &[]).map(|_| ()),
        Err(Ipv4PacketBuildError::BufferTooShort {
            required: 24,
            available: 23
        })
    );
    assert_eq!(b, old);
}