internet 0.1.0

Network library for rust
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! UDP Header Mapping.
//!
//! [RFC 768]: https://datatracker.ietf.org/doc/html/rfc768

use crate::ietf::udp::{Checksum, Port};
use crate::{Buf, BufError, BufMut, BufResult};

/// UDP header mapping following [RFC 768].
///
/// [RFC 768]: https://datatracker.ietf.org/doc/html/rfc768
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct HeaderMapping<T: Buf> {
    buffer: T,
}

impl<T: Buf> HeaderMapping<T> {
    /// Creates a new header mapping.
    pub fn new(buffer: T) -> Self {
        Self { buffer }
    }

    /// Consumes the mapping and returns the underlying buffer.
    pub fn into_inner(self) -> T {
        self.buffer
    }

    /// Returns a reference to the underlying buffer.
    pub fn as_inner(&self) -> &T {
        &self.buffer
    }
}

impl<T: Buf> HeaderMapping<T> {
    /// Reads the source port.
    pub fn read_source_port(&self) -> Port {
        unsafe { Port::from(self.buffer.get_u16_be_unchecked(0)) }
    }

    /// Reads the destination port.
    pub fn read_destination_port(&self) -> Port {
        unsafe { Port::from(self.buffer.get_u16_be_unchecked(2)) }
    }

    /// Reads the length.
    pub fn read_length(&self) -> u16 {
        unsafe { self.buffer.get_u16_be_unchecked(4) }
    }

    /// Reads the checksum.
    pub fn read_checksum(&self) -> Checksum {
        unsafe { Checksum(self.buffer.get_u16_be_unchecked(6)) }
    }
}

impl<T: BufMut> HeaderMapping<T> {
    /// Writes the source port.
    pub fn write_source_port(&mut self, port: Port) -> BufResult<()> {
        if self.buffer.length() < 2 {
            return Err(BufError::BufferTooSmall);
        }
        unsafe { self.buffer.set_u16_be_unchecked(0, port.into()) }
        Ok(())
    }

    /// Writes the destination port.
    pub fn write_destination_port(&mut self, port: Port) -> BufResult<()> {
        if self.buffer.length() < 4 {
            return Err(BufError::BufferTooSmall);
        }
        unsafe { self.buffer.set_u16_be_unchecked(2, port.into()) }
        Ok(())
    }

    /// Writes the length field.
    pub fn write_length(&mut self, length: u16) -> BufResult<()> {
        if self.buffer.length() < 6 {
            return Err(BufError::BufferTooSmall);
        }
        unsafe { self.buffer.set_u16_be_unchecked(4, length) }
        Ok(())
    }

    /// Writes the checksum.
    pub fn write_checksum(&mut self, checksum: Checksum) -> BufResult<()> {
        if self.buffer.length() < 8 {
            return Err(BufError::BufferTooSmall);
        }
        unsafe { self.buffer.set_u16_be_unchecked(6, checksum.0) }
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::{Checksum, HeaderMapping, Port};

    #[test]
    fn read_fields() {
        let buffer = [
            0x00, 0x35, // source port: 53 (DNS)
            0xC3, 0x50, // destination port: 50000
            0x00, 0x10, // length: 16
            0x12, 0x34, // checksum: 0x1234
        ];

        let mapping = HeaderMapping::new(&buffer[..]);

        assert_eq!(mapping.read_source_port(), Port::DNS);
        assert_eq!(mapping.read_destination_port(), Port::from(50000));
        assert_eq!(mapping.read_length(), 16);
        assert_eq!(mapping.read_checksum(), Checksum(0x1234));
    }

    #[test]
    fn write_fields() {
        let mut buffer = [0u8; 8];
        let mut mapping = HeaderMapping::new(&mut buffer[..]);

        mapping.write_source_port(Port::DNS).unwrap();
        mapping.write_destination_port(Port::from(50000)).unwrap();
        mapping.write_length(16).unwrap();
        mapping.write_checksum(Checksum(0x1234)).unwrap();

        assert_eq!(buffer, [0x00, 0x35, 0xC3, 0x50, 0x00, 0x10, 0x12, 0x34,]);
    }

    #[test]
    fn roundtrip() {
        let mut buffer = [0u8; 8];
        let mut mapping = HeaderMapping::new(&mut buffer[..]);

        let source_port = Port::DNS;
        let destination_port = Port::from(50000);
        let length = 16u16;
        let checksum = Checksum(0x1234);

        mapping.write_source_port(source_port).unwrap();
        mapping.write_destination_port(destination_port).unwrap();
        mapping.write_length(length).unwrap();
        mapping.write_checksum(checksum).unwrap();

        let read_mapping = HeaderMapping::new(&buffer[..]);

        assert_eq!(read_mapping.read_source_port(), source_port);
        assert_eq!(read_mapping.read_destination_port(), destination_port);
        assert_eq!(read_mapping.read_length(), length);
        assert_eq!(read_mapping.read_checksum(), checksum);
    }

    #[test]
    fn into_inner() {
        let buffer = [0u8; 8];
        let mapping = HeaderMapping::new(&buffer[..]);
        let inner = mapping.into_inner();
        assert_eq!(inner.len(), 8);
    }
}