tunneler_core/message/
entire.rs

1use crate::message::{MessageHeader, MessageType};
2
3/// A single Message that is send between the Server and Client
4#[derive(Debug)]
5pub struct Message {
6    header: MessageHeader,
7    data: Vec<u8>, // X bytes
8}
9
10impl Message {
11    /// Creates a new Message with the given "raw" Data
12    pub fn new(header: MessageHeader, data: Vec<u8>) -> Self {
13        Self { header, data }
14    }
15
16    /// Serializes the Message into a Vector of Bytes that can
17    /// then be send over to the other side (Server or Client)
18    pub fn serialize(&self, header: &mut [u8; 13]) -> &[u8] {
19        let data = &self.data;
20
21        self.header.serialize(header);
22
23        &data[0..self.header.length as usize]
24    }
25
26    /// The Header of this message
27    pub fn get_header(&self) -> &MessageHeader {
28        &self.header
29    }
30    /// The Raw underlying data that belong to do this message
31    pub fn get_data(&self) -> &[u8] {
32        &self.data
33    }
34
35    /// Checks if the messsage is marked as an EOF(End-Of-File)
36    ///
37    /// This is useful for cases where the requests may be over, but the
38    /// connections are not actually closed
39    pub fn is_eof(&self) -> bool {
40        self.header.kind == MessageType::EOF
41    }
42}
43
44impl PartialEq for Message {
45    fn eq(&self, other: &Self) -> bool {
46        self.header == other.header && self.get_data() == other.get_data()
47    }
48}
49
50#[cfg(test)]
51mod tests {
52    use super::*;
53
54    #[test]
55    fn message_serialize_connect() {
56        let mut inner_data = vec![0; 2];
57        inner_data[0] = 1;
58        inner_data[1] = 1;
59        let msg = Message::new(
60            MessageHeader {
61                id: 13,
62                kind: MessageType::Connect,
63                length: 2,
64            },
65            inner_data,
66        );
67
68        let mut h_output = [0; 13];
69        let d_output = msg.serialize(&mut h_output);
70
71        let mut expected_header = [0; 13];
72        expected_header[0] = 13;
73        expected_header[4] = 1;
74        expected_header[5] = 2;
75        assert_eq!(expected_header, h_output);
76
77        let mut expected_data = vec![0; 2];
78        expected_data[0] = 1;
79        expected_data[1] = 1;
80        assert_eq!(expected_data, d_output);
81    }
82    #[test]
83    fn message_serialize_data() {
84        let mut inner_data = vec![0; 12];
85        inner_data[2] = 33;
86        let msg = Message::new(
87            MessageHeader {
88                id: 13,
89                kind: MessageType::Data,
90                length: 12,
91            },
92            inner_data,
93        );
94        let mut h_output = [0; 13];
95        let d_output = msg.serialize(&mut h_output);
96
97        let mut header_expect = [0; 13];
98        header_expect[0] = 13;
99        header_expect[4] = 3;
100        header_expect[5] = 12;
101        assert_eq!(header_expect, h_output);
102
103        let mut data_expect = vec![0; 12];
104        data_expect[2] = 33;
105        assert_eq!(&data_expect, d_output);
106    }
107
108    #[test]
109    fn message_serialize_length_less_than_vec_size() {
110        let mut inner_data = vec![0; 20];
111        inner_data[2] = 33;
112        let msg = Message::new(
113            MessageHeader {
114                id: 13,
115                kind: MessageType::Data,
116                length: 12,
117            },
118            inner_data,
119        );
120        let mut h_output = [0; 13];
121        let d_output = msg.serialize(&mut h_output);
122
123        let mut header_expect = [0; 13];
124        header_expect[0] = 13;
125        header_expect[4] = 3;
126        header_expect[5] = 12;
127        assert_eq!(header_expect, h_output);
128
129        let mut data_expect = vec![0; 12];
130        data_expect[2] = 33;
131        assert_eq!(&data_expect, d_output);
132    }
133
134    #[test]
135    fn message_is_eof() {
136        let header = MessageHeader::new(0, MessageType::EOF, 0);
137        let msg = Message::new(header, vec![]);
138
139        assert_eq!(true, msg.is_eof());
140    }
141    #[test]
142    fn message_is_not_eof() {
143        let header = MessageHeader::new(0, MessageType::Data, 0);
144        let msg = Message::new(header, vec![]);
145
146        assert_eq!(false, msg.is_eof());
147    }
148}
tunneler_core/message/entire.rs

tunneler_core/message/
entire.rs
