internet 0.0.5

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

//!

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

///
#[allow(non_camel_case_types)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct u24(pub u32);

impl Codec for u24 {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        writer.write_u8((self.0 >> 16) as u8)?;
        writer.write_u8((self.0 >> 8) as u8)?;
        writer.write_u8(self.0 as u8)?;
        Ok(())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let b0 = reader.read_u8()? as u32;
        let b1 = reader.read_u8()? as u32;
        let b2 = reader.read_u8()? as u32;
        Ok(u24((b0 << 16) | (b1 << 8) | b2))
    }
}

impl From<u32> for u24 {
    fn from(val: u32) -> Self {
        u24(val & 0x00FF_FFFF)
    }
}
impl From<u24> for usize {
    fn from(val: u24) -> Self {
        val.0 as usize
    }
}

///
pub trait LengthPrefix: Codec {
    ///
    fn as_usize(&self) -> usize;
    ///
    fn from_usize(val: usize) -> BufResult<Self>;
}

impl LengthPrefix for u8 {
    fn as_usize(&self) -> usize {
        *self as usize
    }
    fn from_usize(val: usize) -> BufResult<Self> {
        val.try_into().map_err(|_| BufError::InvalidLength)
    }
}

impl LengthPrefix for u16 {
    fn as_usize(&self) -> usize {
        *self as usize
    }
    fn from_usize(val: usize) -> BufResult<Self> {
        val.try_into().map_err(|_| BufError::InvalidLength)
    }
}

impl LengthPrefix for u24 {
    fn as_usize(&self) -> usize {
        self.0 as usize
    }
    fn from_usize(val: usize) -> BufResult<Self> {
        if val > 0x00FF_FFFF {
            return Err(BufError::InvalidLength);
        }
        Ok(u24(val as u32))
    }
}

use std::marker::PhantomData;

///
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct TlsVec<T, P> {
    ///
    pub items: Vec<T>,
    _marker: PhantomData<P>,
}

impl<T, P> TlsVec<T, P> {
    ///
    pub fn new(items: Vec<T>) -> Self {
        Self {
            items,
            _marker: PhantomData,
        }
    }
}

impl<T: Codec, P: LengthPrefix> Codec for TlsVec<T, P> {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        let mut prefix = P::from_usize(0)?;
        let initial_cursor_position = writer.position();
        prefix.encode(writer, ())?;
        let mid_position = writer.position();
        let prefix_length = mid_position as isize - initial_cursor_position as isize;
        if prefix_length < 0 {
            return Err(BufError::UnexpectedValue);
        }

        for item in &self.items {
            item.encode(writer, ())?;
        }

        let last_position = writer.position();
        let data_length = last_position as isize - mid_position as isize;
        if data_length < 0 {
            return Err(BufError::UnexpectedValue);
        }
        writer.rewind(data_length as usize + prefix_length as usize)?;
        prefix = P::from_usize(data_length as usize)?;
        prefix.encode(writer, ())?;
        writer.advance(data_length as usize)?;
        Ok(())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let prefix = P::decode(reader, ())?;
        let expected_bytes = prefix.as_usize();

        let start_pos = reader.position();
        let mut items = Vec::new();

        while reader.position() - start_pos < expected_bytes {
            items.push(T::decode(reader, ())?);
        }

        if reader.position() - start_pos > expected_bytes {
            return Err(BufError::InvalidLength);
        }

        Ok(TlsVec::new(items))
    }
}

#[cfg(test)]
mod tests {
    #[test]
    fn test() {}
}