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

//! Transport Port encoding.
//!
//! Encoding is supported for the following structures:
//!
//!  - [`Port`]
//!

use std::fmt;
use std::num::ParseIntError;
use std::str::FromStr;

use crate::{Buf, BufMut, BufResult, Codec, Cursor};

/// A port number following [IANA service-names-port-numbers].
///
/// A 16-bit number used to identify a transport-layer endpoint on a host.
///
/// [IANA service-names-port-numbers]: https://www.iana.org/assignments/service-names-port-numbers
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct Port(pub u16);

impl Port {
    /// Creates a new port from a u16 value.
    pub const fn new(port: u16) -> Self {
        Port(port)
    }

    /// Returns the port number as a u16.
    pub const fn as_u16(self) -> u16 {
        self.0
    }

    /// Returns true if this is a system port (0-1023).
    pub const fn is_system(self) -> bool {
        self.0 <= 1023
    }

    /// Returns true if this is a user port (1024-49151).
    pub const fn is_user(self) -> bool {
        self.0 >= 1024 && self.0 <= 49151
    }

    /// Returns true if this is a dynamic/private port (49152-65535).
    pub const fn is_dynamic(self) -> bool {
        self.0 >= 49152
    }
}

impl Default for Port {
    fn default() -> Self {
        Self(0)
    }
}

impl From<u16> for Port {
    #[inline]
    fn from(val: u16) -> Self {
        Port(val)
    }
}

impl From<Port> for u16 {
    #[inline]
    fn from(port: Port) -> Self {
        port.0
    }
}

impl fmt::Display for Port {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl FromStr for Port {
    type Err = ParseIntError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        s.parse::<u16>().map(Port)
    }
}

impl Codec for Port {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.0.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self(u16::decode(reader, ())?))
    }
}

#[cfg(test)]
mod tests {
    use core::fmt::Debug;

    use super::Port;
    use crate::{Codec, Cursor};

    fn codec_roundtrip<T: Codec<C> + Debug + Eq, C: Copy>(
        etalon_struct: T,
        etalon_bytes: &[u8],
        context: C,
    ) {
        let mut encoded_bytes = vec![];
        {
            let writer = &mut Cursor::new(&mut encoded_bytes);
            etalon_struct.encode(writer, context).unwrap();
        }
        assert_eq!(etalon_bytes, &encoded_bytes);

        let decoded_struct = {
            let reader = &mut Cursor::new(&mut encoded_bytes);
            T::decode(reader, context).unwrap()
        };
        assert_eq!(etalon_struct, decoded_struct);

        encoded_bytes.fill(0x00);
        {
            let writer = &mut Cursor::new(&mut encoded_bytes);
            decoded_struct.encode(writer, context).unwrap();
        }
        assert_eq!(etalon_bytes, &encoded_bytes);
    }

    #[test]
    fn port() {
        let etalon_bytes = &[0x00, 0x50]; // Port 80
        let etalon_struct = Port::new(80);

        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn port_ranges() {
        let system_port = Port::new(80);
        assert!(system_port.is_system());
        assert!(!system_port.is_user());
        assert!(!system_port.is_dynamic());

        let user_port = Port::new(8080);
        assert!(!user_port.is_system());
        assert!(user_port.is_user());
        assert!(!user_port.is_dynamic());

        let dynamic_port = Port::new(50000);
        assert!(!dynamic_port.is_system());
        assert!(!dynamic_port.is_user());
        assert!(dynamic_port.is_dynamic());
    }
}