bitsock/
lib.rs

1use std::io::Cursor;
2
3use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
4
5#[cfg(test)]
6mod tests;
7
8pub mod client;
9pub mod server;
10
11#[derive(Debug)]
12pub enum ReadingError {
13    /// Error returned when the server fails to read data from the client.
14    Reading,
15
16    /// Error returned when the readed packet fails to be decoded
17    Decode,
18}
19
20#[derive(Debug)]
21pub enum ConnectionError {
22    /// Error returned when a client fail to connect.
23    Client(String),
24}
25
26/// Error returned when a packet cannot be decoded from [Packet::decode].
27#[derive(Debug)]
28pub struct PacketDecodeError;
29
30/// Enum containing all the possible packet types.
31#[derive(Debug)]
32pub enum Packet {
33    Invalid,
34    // Packet containing data in form of bytes.
35    Bytes(Vec<u8>),
36    /// Packet containing a [String].
37    String(String),
38    /// Packet containing a [i8].
39    I8(i8),
40    /// Packet containing a [i16].
41    I16(i16),
42    /// Packet containing a [i32].
43    I32(i32),
44    /// Packet containing a [i64].
45    I64(i64),
46    /// Packet containing a [f32].
47    F32(f32),
48    /// Packet containing a [f64].
49    F64(f64),
50    /// Packet containing a [u8].
51    U8(u8),
52    /// Packet containing a [u16].
53    U16(u16),
54    /// Packet containing a [u32].
55    U32(u32),
56    /// Packet containing a [u64].
57    U64(u64),
58    // Packet containing data in form of bytes with an identifier which can represent what type of data the packet contains.
59    Identified(u32, Vec<u8>),
60}
61
62impl Packet {
63    /// Encode the packet into bytes.
64    pub fn encode(&self) -> Vec<u8> {
65        let mut result = Vec::new();
66
67        match self {
68            Packet::Bytes(data) => {
69                result.insert(0, 1);
70                for _ in 0..(std::mem::size_of::<u8>() * data.len()) {
71                    result.push(0);
72                }
73                for b in data {
74                    result.push(*b)
75                }
76            }
77            Packet::String(data) => {
78                result.insert(0, 2);
79                for _ in 0..std::mem::size_of::<String>() {
80                    result.push(0);
81                }
82                for b in data.as_bytes() {
83                    result.push(*b);
84                }
85            }
86            Packet::I8(data) => {
87                result.insert(0, 3);
88                for _ in 0..std::mem::size_of::<i8>() {
89                    result.push(0);
90                }
91                let _ = &result[1..].as_mut().write_i8(*data);
92            }
93            Packet::I16(data) => {
94                result.insert(0, 4);
95                for _ in 0..std::mem::size_of::<i16>() {
96                    result.push(0);
97                }
98                let _ = &result[1..].as_mut().write_i16::<LittleEndian>(*data);
99            }
100            Packet::I32(data) => {
101                result.insert(0, 5);
102                for _ in 0..std::mem::size_of::<i32>() {
103                    result.push(0);
104                }
105                let _ = &result[1..]
106                    .as_mut()
107                    .write_i32::<LittleEndian>(*data)
108                    .unwrap();
109            }
110            Packet::I64(data) => {
111                result.insert(0, 6);
112                for _ in 0..std::mem::size_of::<i64>() {
113                    result.push(0);
114                }
115                let _ = &result[1..].as_mut().write_i64::<LittleEndian>(*data);
116            }
117            Packet::F32(data) => {
118                result.insert(0, 7);
119                for _ in 0..std::mem::size_of::<f32>() {
120                    result.push(0);
121                }
122                let _ = &result[1..].as_mut().write_f32::<LittleEndian>(*data);
123            }
124            Packet::F64(data) => {
125                result.insert(0, 8);
126                for _ in 0..std::mem::size_of::<f64>() {
127                    result.push(0);
128                }
129                let _ = &result[1..].as_mut().write_f64::<LittleEndian>(*data);
130            }
131            Packet::U8(data) => {
132                result.insert(0, 9);
133                for _ in 0..std::mem::size_of::<u8>() {
134                    result.push(0);
135                }
136                let _ = &result[1..].as_mut().write_u8(*data);
137            }
138            Packet::U16(data) => {
139                result.insert(0, 10);
140                for _ in 0..std::mem::size_of::<u16>() {
141                    result.push(0);
142                }
143                let _ = &result[1..].as_mut().write_u16::<LittleEndian>(*data);
144            }
145            Packet::U32(data) => {
146                result.insert(0, 11);
147                for _ in 0..std::mem::size_of::<u32>() {
148                    result.push(0);
149                }
150                let _: &Result<(), std::io::Error> =
151                    &result[1..].as_mut().write_u32::<LittleEndian>(*data);
152            }
153            Packet::U64(data) => {
154                result.insert(0, 12);
155                for _ in 0..std::mem::size_of::<u64>() {
156                    result.push(0);
157                }
158                let _ = &result[1..].as_mut().write_u64::<LittleEndian>(*data);
159            }
160            Packet::Identified(id, data) => {
161                result.insert(0, 13);
162                for _ in 0..std::mem::size_of::<u32>() {
163                    result.push(0);
164                }
165                let _ = &result[1..].as_mut().write_u32::<LittleEndian>(*id);
166
167                for b in data {
168                    result.push(*b)
169                }
170            }
171            Packet::Invalid => (),
172        }
173
174        result
175    }
176
177    /// Returns a [Packet] from a [Vec] of bytes.
178    pub fn decode(bytes: Vec<u8>) -> Result<Self, PacketDecodeError> {
179        if let Some(b) = bytes.first() {
180            match b {
181                1 => Ok(Packet::Bytes(bytes[1..].to_vec())),
182                2 => Ok(Packet::String(
183                    if let Ok(s) = String::from_utf8(bytes[1..].to_vec()) {
184                        s
185                    } else {
186                        return Err(PacketDecodeError);
187                    },
188                )),
189                3 => Ok(Packet::I8(
190                    if let Ok(n) = Cursor::new(bytes[1..].to_vec()).read_i8() {
191                        n
192                    } else {
193                        return Err(PacketDecodeError);
194                    },
195                )),
196                4 => Ok(Packet::I16(
197                    if let Ok(n) = Cursor::new(bytes[1..].to_vec()).read_i16::<LittleEndian>() {
198                        n
199                    } else {
200                        return Err(PacketDecodeError);
201                    },
202                )),
203                5 => Ok(Packet::I32(
204                    if let Ok(n) = Cursor::new(bytes[1..].to_vec()).read_i32::<LittleEndian>() {
205                        n
206                    } else {
207                        return Err(PacketDecodeError);
208                    },
209                )),
210                6 => Ok(Packet::I64(
211                    if let Ok(n) = Cursor::new(bytes[1..].to_vec()).read_i64::<LittleEndian>() {
212                        n
213                    } else {
214                        return Err(PacketDecodeError);
215                    },
216                )),
217                7 => Ok(Packet::F32(
218                    if let Ok(n) = Cursor::new(bytes[1..].to_vec()).read_f32::<LittleEndian>() {
219                        n
220                    } else {
221                        return Err(PacketDecodeError);
222                    },
223                )),
224                8 => Ok(Packet::F64(
225                    if let Ok(n) = Cursor::new(bytes[1..].to_vec()).read_f64::<LittleEndian>() {
226                        n
227                    } else {
228                        return Err(PacketDecodeError);
229                    },
230                )),
231                9 => Ok(Packet::U8(
232                    if let Ok(n) = Cursor::new(bytes[1..].to_vec()).read_u8() {
233                        n
234                    } else {
235                        return Err(PacketDecodeError);
236                    },
237                )),
238                10 => Ok(Packet::U16(
239                    if let Ok(n) = Cursor::new(bytes[1..].to_vec()).read_u16::<LittleEndian>() {
240                        n
241                    } else {
242                        return Err(PacketDecodeError);
243                    },
244                )),
245                11 => Ok(Packet::U32(
246                    if let Ok(n) = Cursor::new(bytes[1..].to_vec()).read_u32::<LittleEndian>() {
247                        n
248                    } else {
249                        return Err(PacketDecodeError);
250                    },
251                )),
252                12 => Ok(Packet::U64(
253                    if let Ok(n) = Cursor::new(bytes[1..].to_vec()).read_u64::<LittleEndian>() {
254                        n
255                    } else {
256                        return Err(PacketDecodeError);
257                    },
258                )),
259                13 => Ok(Packet::Identified(
260                    if let Ok(id) = Cursor::new(bytes[1..].to_vec()).read_u32::<LittleEndian>() {
261                        id
262                    } else {
263                        return Err(PacketDecodeError);
264                    },
265                    bytes[std::mem::size_of::<u32>()..].to_vec(),
266                )),
267                _ => Ok(Packet::Invalid),
268            }
269        } else {
270            Err(PacketDecodeError)
271        }
272    }
273}
bitsock/lib.rs

bitsock/
lib.rs
