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

use net_wire::ethernet::{EtherType, EthernetFrameBuildError, EthernetFrameBuilder};

use super::fixtures::{DESTINATION, SOURCE};

#[test]
fn rfc_894_builder_writes_header_only_and_limits_returned_view() {
    let mut bytes = [
        0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xa1,
        0xb2, 0xc3, 0xee, 0xff,
    ];

    {
        let frame = EthernetFrameBuilder::new(&mut bytes, 3)
            .destination(DESTINATION)
            .source(SOURCE)
            .ether_type(EtherType::IPV4)
            .build()
            .unwrap();

        assert_eq!(
            frame.as_bytes(),
            [
                0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0x08, 0x00,
                0xa1, 0xb2, 0xc3,
            ]
        );
    }
    assert_eq!(bytes[17..], [0xee, 0xff]);
}

#[test]
fn builder_insufficient_buffer_writes_nothing() {
    let mut bytes = [0xa5; 16];

    let result = EthernetFrameBuilder::new(&mut bytes, 3)
        .destination(DESTINATION)
        .source(SOURCE)
        .ether_type(EtherType::IPV4)
        .build();

    assert_eq!(
        result,
        Err(EthernetFrameBuildError::BufferTooShort {
            required: 17,
            available: 16,
        })
    );
    assert_eq!(bytes, [0xa5; 16]);
}

#[test]
fn builder_length_overflow_writes_nothing() {
    let mut bytes = [0xa5; 14];

    let result = EthernetFrameBuilder::new(&mut bytes, usize::MAX)
        .destination(DESTINATION)
        .source(SOURCE)
        .ether_type(EtherType::IPV4)
        .build();

    assert_eq!(
        result,
        Err(EthernetFrameBuildError::LengthOverflow {
            header_length: 14,
            payload_length: usize::MAX,
        })
    );
    assert_eq!(bytes, [0xa5; 14]);
}

#[test]
fn builder_missing_destination_writes_nothing() {
    let mut bytes = [0xa5; 14];

    let result = EthernetFrameBuilder::new(&mut bytes, 0)
        .source(SOURCE)
        .ether_type(EtherType::IPV4)
        .build();

    assert_eq!(result, Err(EthernetFrameBuildError::MissingDestination));
    assert_eq!(bytes, [0xa5; 14]);
}

#[test]
fn builder_missing_source_writes_nothing() {
    let mut bytes = [0xa5; 14];

    let result = EthernetFrameBuilder::new(&mut bytes, 0)
        .destination(DESTINATION)
        .ether_type(EtherType::IPV4)
        .build();

    assert_eq!(result, Err(EthernetFrameBuildError::MissingSource));
    assert_eq!(bytes, [0xa5; 14]);
}

#[test]
fn builder_missing_ether_type_writes_nothing() {
    let mut bytes = [0xa5; 14];

    let result = EthernetFrameBuilder::new(&mut bytes, 0)
        .destination(DESTINATION)
        .source(SOURCE)
        .build();

    assert_eq!(result, Err(EthernetFrameBuildError::MissingEtherType));
    assert_eq!(bytes, [0xa5; 14]);
}