plabble_codec/codec/request/
request_packet.rs

1use crate::{
2    abstractions::MAC_SIZE,
3    codec::{header::RequestHeader, ptp_packet::PtpPacket},
4};
5
6use super::RequestBody;
7
8/// The request packet
9///
10/// # Fields
11///
12/// * `header` - the header of the packet
13/// * `body` - the body of the packet
14/// * `mac` - the mac of the packet (optional)
15pub struct RequestPacket {
16    pub header: RequestHeader,
17    pub body: RequestBody,
18    pub mac: Option<[u8; MAC_SIZE]>,
19}
20
21impl PtpPacket<RequestHeader, RequestBody> for RequestPacket {
22    fn get_header(&self) -> &RequestHeader {
23        &self.header
24    }
25
26    fn get_body(&self) -> &RequestBody {
27        &self.body
28    }
29
30    fn new(header: RequestHeader, body: RequestBody, mac: Option<[u8; MAC_SIZE]>) -> Self {
31        /*if body.get_type() != header.packet_type() {
32            // TODO: return error?
33        }*/
34
35        Self { header, body, mac }
36    }
37
38    fn get_mac(&self) -> Option<&[u8; MAC_SIZE]> {
39        self.mac.as_ref()
40    }
41}
42
43#[cfg(test)]
44mod parse_test {
45    use crate::{
46        abstractions::{SerializationError, SerializationInfo},
47        codec::common::SlotRange,
48    };
49
50    use super::*;
51
52    #[test]
53    fn cant_deserialize_nothing() {
54        let bytes = &[];
55        let packet = RequestPacket::from_bytes(bytes, SerializationInfo::PacketType(0));
56        assert_eq!(SerializationError::TooFewBytes(17), packet.err().unwrap()); // 17 is minimum request size
57    }
58
59    #[test]
60    fn cant_deserialize_connect_without_key() {
61        let bytes = &[
62            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0x01,
63        ];
64        let packet = RequestPacket::from_bytes(bytes, SerializationInfo::PacketType(0));
65        assert_eq!(SerializationError::TooFewBytes(16), packet.err().unwrap()); // because header is already sliced off in ptp_packet::from_bytes method
66    }
67
68    #[test]
69    fn can_deserialize_plain_packet() {
70        let data = &[
71            0x01, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0, 5, 0, 10,
72        ];
73        let packet = RequestPacket::from_bytes(data, SerializationInfo::None).unwrap();
74        if let RequestBody::CREATE(SlotRange { from, to }) = packet.body {
75            assert_eq!(Some(5), from);
76            assert_eq!(Some(10), to);
77        } else {
78            panic!("Not a create");
79        }
80    }
81}
82
83#[cfg(test)]
84mod serialization_test {
85    use std::collections::HashMap;
86
87    use crate::{
88        abstractions::{Serializable, SerializationInfo},
89        codec::{
90            common::SlotRange,
91            objects::BucketId,
92            ptp_packet::{PtpBody, PtpHeader},
93        },
94    };
95
96    use super::*;
97
98    #[test]
99    fn can_serialize_plain_packet() {
100        let body = RequestBody::CREATE(SlotRange {
101            from: Some(5),
102            to: Some(10),
103        });
104        let id = BucketId::from_bytes(
105            &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
106            None,
107        )
108        .unwrap();
109
110        let header = RequestHeader::new(body.packet_type(), Some(id));
111        let packet = RequestPacket::new(header, body, None);
112
113        assert_eq!(
114            vec!(21, 0x01, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0, 5, 0, 10),
115            packet.get_bytes(SerializationInfo::None, true).unwrap()
116        );
117    }
118
119    #[test]
120    fn can_serialize_simple_packet_with_authentication() {
121        let key = &[1u8; 32];
122        let body = RequestBody::CREATE(SlotRange {
123            from: Some(5),
124            to: Some(10),
125        });
126        let id = BucketId::from_bytes(
127            &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
128            None,
129        )
130        .unwrap();
131
132        let mut header = RequestHeader::new(body.packet_type(), Some(id));
133        header.set_mac(true);
134        let packet = RequestPacket::new(header, body, None);
135
136        let bytes = packet
137            .get_bytes(
138                SerializationInfo::UseAuthentication(key.clone(), None),
139                false,
140            )
141            .unwrap();
142        assert_eq!(
143            vec![
144                17, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0, 5, 0, 10, 34, 167,
145                182, 64, 46, 228, 223, 54, 255, 240, 62, 82, 191, 236, 68, 50
146            ],
147            bytes
148        );
149
150        let packet = RequestPacket::from_bytes(
151            &bytes,
152            SerializationInfo::UseAuthentication(key.clone(), None),
153        )
154        .unwrap();
155        assert_eq!(
156            bytes,
157            packet
158                .get_bytes(
159                    SerializationInfo::UseAuthentication(key.clone(), None),
160                    false
161                )
162                .unwrap()
163        );
164    }
165
166    #[test]
167    fn can_serialize_complex_packet_with_authentication() {
168        let key = &[1u8; 32];
169        let body = RequestBody::PUT {
170            slots: HashMap::from([
171                (5, vec![1, 2, 3, 4, 5, 6, 7, 8]),
172                (19412, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
173            ]),
174        };
175        let id = BucketId::from_bytes(
176            &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
177            None,
178        )
179        .unwrap();
180
181        let mut header = RequestHeader::new(body.packet_type(), Some(id));
182        header.set_mac(true);
183        let packet = RequestPacket::new(header, body, None);
184
185        let bytes = packet
186            .get_bytes(
187                SerializationInfo::UseAuthentication(key.clone(), None),
188                false,
189            )
190            .unwrap();
191        assert_eq!(
192            vec![
193                18, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0, 5, 8, 1, 2, 3, 4, 5,
194                6, 7, 8, 75, 212, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 74, 151, 106, 78, 124, 179,
195                92, 165, 78, 72, 27, 181, 100, 37, 243, 29
196            ],
197            bytes
198        );
199
200        let packet = RequestPacket::from_bytes(
201            &bytes,
202            SerializationInfo::UseAuthentication(key.clone(), None),
203        )
204        .unwrap();
205        assert_eq!(
206            bytes,
207            packet
208                .get_bytes(
209                    SerializationInfo::UseAuthentication(key.clone(), None),
210                    false
211                )
212                .unwrap()
213        );
214    }
215}
plabble_codec/codec/request/request_packet.rs

plabble_codec/codec/request/
request_packet.rs
