1use super::protocol_errors::{
2 gen_corruption_error_json, gen_crc_error_json, gen_deserializing_error_json,
3 gen_size_error_json,
4};
5
6use super::soeprotocol_functions::*;
7use super::{
8 crc::crc32,
9 lib_utils::{str_from_u8_nul_utf8_checked, u8_from_str_nul_utf8_unchecked},
10 soeprotocol_packets_structs::*,
11};
12use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
13use gloo_utils::format::JsValueSerdeExt;
14use std::io::Cursor;
15use wasm_bindgen::prelude::*;
16
17#[wasm_bindgen]
18pub struct Soeprotocol {
19 use_crc: bool,
20 crc_seed: u32,
21 wtr: Vec<u8>,
22}
23
24#[wasm_bindgen]
25pub enum EncryptMethod {
26 EncryptMethodNone = 0x0,
27 EncryptMethodUserSupplied = 0x1,
28 EncryptMethodUserSupplied2 = 0x2,
29 EncryptMethodXorBuffer = 0x3,
30 EncryptMethodXor = 0x4,
31}
32
33#[wasm_bindgen]
34#[derive(Debug)]
35pub enum SoeOpcode {
36 SessionRequest = 0x01,
37 SessionReply = 0x02,
38 MultiPacket = 0x03,
39 Disconnect = 0x05,
40 Ping = 0x06,
41 NetStatusRequest = 0x07,
42 NetStatusReply = 0x08,
43 Data = 0x09,
44 DataFragment = 0x0d,
45 OutOfOrder = 0x11,
46 Ack = 0x15,
47 Group = 0x19,
48 Ordered = 0x1B,
49 FatalError = 0x1D,
50 Unknown = 0x00,
51}
52
53impl Soeprotocol {
54 pub fn get_opcode(&mut self, rdr: &mut Cursor<&Vec<u8>>) -> SoeOpcode {
56 let opcode = rdr.read_u16::<BigEndian>().unwrap_or_default();
57 match opcode {
58 0x01 => SoeOpcode::SessionRequest,
59 0x02 => SoeOpcode::SessionReply,
60 0x03 => SoeOpcode::MultiPacket,
61 0x05 => SoeOpcode::Disconnect,
62 0x06 => SoeOpcode::Ping,
63 0x07 => SoeOpcode::NetStatusRequest,
64 0x08 => SoeOpcode::NetStatusReply,
65 0x09 => SoeOpcode::Data,
66 0x0d => SoeOpcode::DataFragment,
67 0x11 => SoeOpcode::OutOfOrder,
68 0x15 => SoeOpcode::Ack,
69 0x1B => SoeOpcode::Ordered,
70 0x1D => SoeOpcode::FatalError,
71 _ => SoeOpcode::Unknown,
72 }
73 }
74 pub fn get_session_request_object(
75 &mut self,
76 packet_string: String,
77 ) -> Result<SessionRequestPacket, serde_json::Error> {
78 serde_json::from_str(&packet_string)
79 }
80
81 pub fn pack_ordered_object(&mut self, packet: DataPacket) -> Vec<u8> {
82 self._pack_data_object(SoeOpcode::Ordered as u16, packet)
83 }
84
85 pub fn pack_session_request_object(&mut self, packet: SessionRequestPacket) -> Vec<u8> {
86 self.wtr.clear();
87 self.wtr
88 .write_u16::<BigEndian>(SoeOpcode::SessionRequest as u16)
89 .unwrap_or_default();
90 self.wtr
91 .write_u32::<BigEndian>(packet.protocol_version)
92 .unwrap_or_default();
93 self.wtr
94 .write_u32::<BigEndian>(packet.session_id)
95 .unwrap_or_default();
96 self.wtr
97 .write_u32::<BigEndian>(packet.udp_length)
98 .unwrap_or_default();
99 self.wtr.append(&mut u8_from_str_nul_utf8_unchecked(
100 packet.get_protocol().as_str(),
101 ));
102 self.wtr.clone()
103 }
104
105 pub fn get_session_reply_object(
106 &mut self,
107 packet_string: String,
108 ) -> Result<SessionReplyPacket, serde_json::Error> {
109 serde_json::from_str(&packet_string)
110 }
111
112 pub fn pack_session_reply_object(&mut self, packet: SessionReplyPacket) -> Vec<u8> {
113 self.wtr.clear();
114 self.wtr
115 .write_u16::<BigEndian>(SoeOpcode::SessionReply as u16)
116 .unwrap_or_default();
117 self.wtr
118 .write_u32::<BigEndian>(packet.session_id)
119 .unwrap_or_default();
120 self.wtr
121 .write_u32::<BigEndian>(packet.crc_seed)
122 .unwrap_or_default();
123 self.wtr.write_u8(packet.crc_length).unwrap_or_default();
124 self.wtr
125 .write_u16::<BigEndian>(packet.encrypt_method)
126 .unwrap_or_default();
127 self.wtr
128 .write_u32::<BigEndian>(packet.udp_length)
129 .unwrap_or_default();
130 self.wtr.write_u32::<BigEndian>(3).unwrap_or_default();
131 self.wtr.clone()
132 }
133
134 pub fn get_net_status_request_object(
135 &mut self,
136 packet_string: String,
137 ) -> Result<NetStatusRequestPacket, serde_json::Error> {
138 serde_json::from_str(&packet_string)
139 }
140
141 pub fn pack_net_status_request_object(&mut self, packet: NetStatusRequestPacket) -> Vec<u8> {
142 self.wtr.clear();
143 self.wtr
144 .write_u16::<BigEndian>(SoeOpcode::NetStatusRequest as u16)
145 .unwrap_or_default();
146 self.wtr
147 .write_u16::<BigEndian>(packet.client_tick_count)
148 .unwrap_or_default();
149 self.wtr
150 .write_u32::<BigEndian>(packet.last_client_update)
151 .unwrap_or_default();
152 self.wtr
153 .write_u32::<BigEndian>(packet.average_update)
154 .unwrap_or_default();
155 self.wtr
156 .write_u32::<BigEndian>(packet.shortest_update)
157 .unwrap_or_default();
158 self.wtr
159 .write_u32::<BigEndian>(packet.longest_update)
160 .unwrap_or_default();
161 self.wtr
162 .write_u32::<BigEndian>(packet.last_server_update)
163 .unwrap_or_default();
164 self.wtr
165 .write_u64::<BigEndian>(packet.packets_sent)
166 .unwrap_or_default();
167 self.wtr
168 .write_u64::<BigEndian>(packet.packets_received)
169 .unwrap_or_default();
170 self.wtr
171 .write_u16::<BigEndian>(packet.unknown_field)
172 .unwrap_or_default();
173 self.wtr.clone()
174 }
175
176 pub fn get_net_status_reply_object(&mut self, packet_string: String) -> NetStatusReplyPacket {
177 serde_json::from_str(&packet_string).unwrap_or({
178 NetStatusReplyPacket {
179 client_tick_count: 0,
180 server_tick_count: 0,
181 client_packet_sent: 0,
182 client_packet_received: 0,
183 server_packet_sent: 0,
184 server_packet_received: 0,
185 unknown_field: 0,
186 }
187 })
188 }
189
190 pub fn pack_net_status_reply_object(&mut self, packet: NetStatusReplyPacket) -> Vec<u8> {
191 self.wtr.clear();
192 self.wtr
193 .write_u16::<BigEndian>(SoeOpcode::NetStatusReply as u16)
194 .unwrap_or_default();
195 self.wtr
196 .write_u16::<BigEndian>(packet.client_tick_count)
197 .unwrap_or_default();
198 self.wtr
199 .write_u32::<BigEndian>(packet.server_tick_count)
200 .unwrap_or_default();
201 self.wtr
202 .write_u64::<BigEndian>(packet.client_packet_sent)
203 .unwrap_or_default();
204 self.wtr
205 .write_u64::<BigEndian>(packet.client_packet_received)
206 .unwrap_or_default();
207 self.wtr
208 .write_u64::<BigEndian>(packet.server_packet_sent)
209 .unwrap_or_default();
210 self.wtr
211 .write_u64::<BigEndian>(packet.server_packet_received)
212 .unwrap_or_default();
213 self.wtr
214 .write_u16::<BigEndian>(packet.unknown_field)
215 .unwrap_or_default();
216 self.wtr.clone()
217 }
218
219 pub fn get_multi_object(
220 &mut self,
221 packet_string: String,
222 ) -> Result<SubBasePackets, serde_json::Error> {
223 serde_json::from_str(&packet_string)
224 }
225
226 pub fn group_packets(&mut self, opcode: u16, packets: &Vec<Vec<u8>>) -> Vec<u8> {
227 self.wtr.clear();
228 self.wtr.write_u16::<BigEndian>(opcode).unwrap_or_default();
229 for packet in packets {
230 write_data_length(&mut self.wtr, packet.len());
231 let mut packet = packet.clone();
233 self.wtr.append(&mut packet);
234 }
235 self.wtr.clone()
236 }
237
238 pub fn pack_group_object(&mut self, group_packet: SubBasePackets) -> Vec<u8> {
239 self.group_packets(SoeOpcode::Group as u16, group_packet.get_sub_packets())
240 }
241
242 pub fn pack_multi_object(&mut self, multi_packet: SubBasePackets) -> Vec<u8> {
243 self.group_packets(
244 SoeOpcode::MultiPacket as u16,
245 multi_packet.get_sub_packets(),
246 )
247 }
248
249 pub fn get_data_object(
250 &mut self,
251 packet_string: String,
252 ) -> Result<DataPacket, serde_json::Error> {
253 serde_json::from_str(&packet_string)
254 }
255
256 fn _pack_data_object(&mut self, opcode: u16, mut packet: DataPacket) -> Vec<u8> {
257 self.wtr.clear();
258 self.wtr.write_u16::<BigEndian>(opcode).unwrap_or_default();
259 write_packet_data(&mut self.wtr, &mut packet);
260 self.wtr.clone()
261 }
262
263 pub fn pack_data_object(&mut self, packet: DataPacket) -> Vec<u8> {
264 self._pack_data_object(0x09, packet)
265 }
266
267 pub fn pack_fragment_data_object(&mut self, packet: DataPacket) -> Vec<u8> {
268 self._pack_data_object(0x0d, packet)
269 }
270
271 pub fn get_ack_object(
272 &mut self,
273 packet_string: String,
274 ) -> Result<AckPacket, serde_json::Error> {
275 serde_json::from_str(&packet_string)
276 }
277
278 fn _pack_ack_object(&mut self, opcode: u16, sequence: u16) -> Vec<u8> {
279 self.wtr.clear();
280 self.wtr.write_u16::<BigEndian>(opcode).unwrap_or_default();
281 self.wtr
282 .write_u16::<BigEndian>(sequence)
283 .unwrap_or_default();
284 self.wtr.clone()
285 }
286
287 pub fn pack_out_of_order_object(&mut self, packet: AckPacket) -> Vec<u8> {
288 self._pack_ack_object(0x11, packet.sequence)
289 }
290
291 pub fn pack_ack_object(&mut self, packet: AckPacket) -> Vec<u8> {
292 self._pack_ack_object(0x15, packet.sequence)
293 }
294}
295#[wasm_bindgen]
296impl Soeprotocol {
297 #[wasm_bindgen(constructor)]
299 pub fn initialize(use_crc: bool, crc_seed: u32) -> Soeprotocol {
300 Soeprotocol {
301 use_crc,
302 crc_seed,
303 wtr: vec![],
304 }
305 }
306 pub fn pack(&mut self, packet_opcode: SoeOpcode, packet: String) -> Vec<u8> {
307 match packet_opcode {
308 SoeOpcode::SessionRequest => self.pack_session_request(packet),
309 SoeOpcode::SessionReply => self.pack_session_reply(packet),
310 SoeOpcode::MultiPacket => self.pack_multi(packet),
311 SoeOpcode::Group => self.pack_group(packet),
312 SoeOpcode::Disconnect => vec![0, 5],
313 SoeOpcode::Ping => vec![0, 6],
314 SoeOpcode::NetStatusRequest => self.pack_net_status_request(packet),
315 SoeOpcode::NetStatusReply => self.pack_net_status_reply(packet),
316 SoeOpcode::Data => self.pack_data(packet),
317 SoeOpcode::DataFragment => self.pack_fragment_data(packet),
318 SoeOpcode::OutOfOrder => self.pack_out_of_order(packet),
319 SoeOpcode::Ack => self.pack_ack(packet),
320 SoeOpcode::Ordered => self.pack_ordered(packet),
321 SoeOpcode::FatalError => vec![],
322 SoeOpcode::Unknown => vec![],
323 }
324 }
325
326 pub fn pack_ordered(&mut self, packet: String) -> Vec<u8> {
327 let packet_object: Result<DataPacket, serde_json::Error> = self.get_data_object(packet);
328 if let Ok(packet_object) = packet_object {
329 self.pack_ordered_object(packet_object)
330 } else {
331 gen_deserializing_error_json(packet_object.err().unwrap())
332 }
333 }
334
335 pub fn pack_ordered_packet(&mut self, data: Vec<u8>, sequence: u16) -> Vec<u8> {
336 self.pack_ordered_object(DataPacket::new(data, sequence))
337 }
338
339 pub fn pack_session_request(&mut self, packet: String) -> Vec<u8> {
340 let packet_object: Result<SessionRequestPacket, serde_json::Error> =
341 self.get_session_request_object(packet);
342 if let Ok(packet_object) = packet_object {
343 self.pack_session_request_object(packet_object)
344 } else {
345 gen_deserializing_error_json(packet_object.err().unwrap())
346 }
347 }
348
349 pub fn pack_session_request_fromjs(&mut self, js_object: &JsValue) -> Vec<u8> {
350 let packet: SessionRequestPacket = js_object.into_serde().unwrap();
351 self.pack_session_request_object(packet)
352 }
353
354 pub fn pack_session_request_packet(
355 &mut self,
356 session_id: u32,
357 crc_length: u32,
358 udp_length: u32,
359 protocol: String,
360 ) -> Vec<u8> {
361 self.pack_session_request_object(SessionRequestPacket::new(
362 session_id, crc_length, udp_length, protocol,
363 ))
364 }
365
366 pub fn pack_session_reply(&mut self, packet: String) -> Vec<u8> {
367 let packet_object: Result<SessionReplyPacket, serde_json::Error> =
368 self.get_session_reply_object(packet);
369 if let Ok(packet_object) = packet_object {
370 self.pack_session_reply_object(packet_object)
371 } else {
372 gen_deserializing_error_json(packet_object.err().unwrap())
373 }
374 }
375
376 pub fn pack_session_reply_fromjs(&mut self, js_object: &JsValue) -> Vec<u8> {
377 let packet: SessionReplyPacket = js_object.into_serde().unwrap();
378 self.pack_session_reply_object(packet)
379 }
380
381 pub fn pack_session_reply_packet(
382 &mut self,
383 session_id: u32,
384 crc_seed: u32,
385 crc_length: u8,
386 encrypt_method: u16,
387 udp_length: u32,
388 ) -> Vec<u8> {
389 self.pack_session_reply_object(SessionReplyPacket {
390 session_id,
391 crc_seed,
392 crc_length,
393 encrypt_method,
394 udp_length,
395 })
396 }
397
398 pub fn pack_net_status_request(&mut self, packet: String) -> Vec<u8> {
399 let packet_object: Result<NetStatusRequestPacket, serde_json::Error> =
400 self.get_net_status_request_object(packet);
401 if let Ok(packet_object) = packet_object {
402 self.pack_net_status_request_object(packet_object)
403 } else {
404 gen_deserializing_error_json(packet_object.err().unwrap())
405 }
406 }
407
408 pub fn pack_net_status_request_fromjs(&mut self, js_object: &JsValue) -> Vec<u8> {
409 let packet: NetStatusRequestPacket = js_object.into_serde().unwrap();
410 self.pack_net_status_request_object(packet)
411 }
412
413 pub fn pack_net_status_reply(&mut self, packet: String) -> Vec<u8> {
414 let packet_object: NetStatusReplyPacket = self.get_net_status_reply_object(packet);
415 self.pack_net_status_reply_object(packet_object)
416 }
417
418 pub fn pack_net_status_reply_fromjs(&mut self, js_object: &JsValue) -> Vec<u8> {
419 let packet: NetStatusReplyPacket = js_object.into_serde().unwrap();
420 self.pack_net_status_reply_object(packet)
421 }
422
423 pub fn pack_multi(&mut self, packet: String) -> Vec<u8> {
424 let multi_packets: Result<SubBasePackets, serde_json::Error> =
425 self.get_multi_object(packet);
426 if let Ok(multi_packets) = multi_packets {
427 self.pack_multi_object(multi_packets)
428 } else {
429 gen_deserializing_error_json(multi_packets.err().unwrap())
430 }
431 }
432
433 pub fn pack_multi_fromjs(&mut self, js_object: &JsValue) -> Vec<u8> {
434 let packet: SubBasePackets = js_object.into_serde().unwrap();
435 self.pack_multi_object(packet)
436 }
437
438 pub fn pack_group(&mut self, packet: String) -> Vec<u8> {
439 let group_packets: Result<SubBasePackets, serde_json::Error> =
440 self.get_multi_object(packet);
441 if let Ok(group_packets) = group_packets {
442 self.pack_group_object(group_packets)
443 } else {
444 gen_deserializing_error_json(group_packets.err().unwrap())
445 }
446 }
447
448 pub fn pack_group_fromjs(&mut self, js_object: &JsValue) -> Vec<u8> {
449 let packet: SubBasePackets = js_object.into_serde().unwrap();
450 self.pack_group_object(packet)
451 }
452
453 pub fn pack_data(&mut self, packet: String) -> Vec<u8> {
454 let packet_object: Result<DataPacket, serde_json::Error> = self.get_data_object(packet);
455 if let Ok(packet_object) = packet_object {
456 self.pack_data_object(packet_object)
457 } else {
458 gen_deserializing_error_json(packet_object.err().unwrap())
459 }
460 }
461
462 pub fn pack_data_fromjs(&mut self, js_object: &JsValue) -> Vec<u8> {
463 let packet: DataPacket = js_object.into_serde().unwrap();
464 self.pack_data_object(packet)
465 }
466
467 pub fn pack_data_packet(&mut self, data: Vec<u8>, sequence: u16) -> Vec<u8> {
468 self.pack_data_object(DataPacket::new(data, sequence))
469 }
470
471 pub fn pack_fragment_data(&mut self, packet: String) -> Vec<u8> {
472 let packet_object: Result<DataPacket, serde_json::Error> = self.get_data_object(packet);
473 if let Ok(packet_object) = packet_object {
474 self.pack_fragment_data_object(packet_object)
475 } else {
476 gen_deserializing_error_json(packet_object.err().unwrap())
477 }
478 }
479
480 pub fn pack_fragment_data_fromjs(&mut self, js_object: &JsValue) -> Vec<u8> {
481 let packet: DataPacket = js_object.into_serde().unwrap();
482 self.pack_fragment_data_object(packet)
483 }
484
485 pub fn pack_fragment_data_packet(&mut self, data: Vec<u8>, sequence: u16) -> Vec<u8> {
486 self.pack_fragment_data_object(DataPacket::new(data, sequence))
487 }
488
489 pub fn pack_out_of_order(&mut self, packet: String) -> Vec<u8> {
490 let packet_object: Result<AckPacket, serde_json::Error> = self.get_ack_object(packet);
491 if let Ok(packet_object) = packet_object {
492 self.pack_out_of_order_object(packet_object)
493 } else {
494 gen_deserializing_error_json(packet_object.err().unwrap())
495 }
496 }
497
498 pub fn pack_out_of_order_fromjs(&mut self, js_object: &JsValue) -> Vec<u8> {
499 let packet: AckPacket = js_object.into_serde().unwrap();
500 self.pack_out_of_order_object(packet)
501 }
502
503 pub fn pack_out_of_order_packet(&mut self, sequence: u16) -> Vec<u8> {
504 self.pack_out_of_order_object(AckPacket { sequence })
505 }
506
507 pub fn pack_ack(&mut self, packet: String) -> Vec<u8> {
508 let packet_object: Result<AckPacket, serde_json::Error> = self.get_ack_object(packet);
509 if let Ok(packet_object) = packet_object {
510 self.pack_ack_object(packet_object)
511 } else {
512 gen_deserializing_error_json(packet_object.err().unwrap())
513 }
514 }
515
516 pub fn pack_ack_fromjs(&mut self, js_object: &JsValue) -> Vec<u8> {
517 let packet: AckPacket = js_object.into_serde().unwrap();
518 self.pack_ack_object(packet)
519 }
520
521 pub fn pack_ack_packet(&mut self, sequence: u16) -> Vec<u8> {
522 self.pack_ack_object(AckPacket { sequence })
523 }
524
525 pub fn parse(&mut self, data: Vec<u8>) -> String {
526 let mut rdr = Cursor::new(&data);
527 let opcode: SoeOpcode = if data.len() >= 2 {
528 self.get_opcode(&mut rdr)
529 } else {
530 SoeOpcode::Unknown
531 };
532
533 match opcode {
534 SoeOpcode::SessionRequest => self.parse_session_request(rdr),
535 SoeOpcode::SessionReply => self.parse_session_reply(rdr),
536 SoeOpcode::MultiPacket => self.parse_multi(rdr),
537 SoeOpcode::Group => self.parse_multi(rdr),
538 SoeOpcode::Disconnect => self.parse_disconnect(rdr),
539 SoeOpcode::Ping => r#"{"name":"Ping"}"#.to_string(),
540 SoeOpcode::NetStatusRequest => self.parse_net_status_request(rdr),
541 SoeOpcode::NetStatusReply => self.parse_net_status_reply(rdr),
542 SoeOpcode::Data => self.parse_data(rdr, opcode as u16),
543 SoeOpcode::DataFragment => self.parse_data(rdr, opcode as u16),
544 SoeOpcode::OutOfOrder => self.parse_ack(rdr, opcode as u16),
545 SoeOpcode::Ack => self.parse_ack(rdr, opcode as u16),
546 SoeOpcode::Ordered => self.parse_ordered(rdr),
547 SoeOpcode::FatalError => format!(r#"{{"name":"FatalError","raw":{:?}}}"#, data),
548 SoeOpcode::Unknown => format!(r#"{{"name":"Unknown","raw":{:?}}}"#, data),
549 }
550 }
551
552 fn parse_ordered(&mut self, mut rdr: Cursor<&std::vec::Vec<u8>>) -> String {
553 if !check_min_size(&rdr, PacketsMinSize::DataPacket as usize, self.use_crc) {
554 return gen_size_error_json(rdr);
555 }
556 let order = rdr.read_u16::<BigEndian>().unwrap_or_default();
557 let data_end: u64 = get_data_end(&rdr, self.use_crc);
558 let mut crc: u16 = 0;
559 if self.use_crc {
560 rdr.set_position(data_end);
561 crc = rdr.read_u16::<BigEndian>().unwrap_or_default();
562 }
563 let vec = rdr.get_ref().to_vec();
564 let data = &vec[4..data_end as usize];
565 if self.use_crc {
567 let packet_without_crc = &vec[0..data_end as usize];
568 let crc_value =
569 (crc32(&&mut packet_without_crc.to_vec(), self.crc_seed as usize) & 0xffff) as u16;
570 if crc_value != crc {
571 return gen_crc_error_json(&vec, crc_value, crc);
572 }
573 }
574 format!(
575 r#"{{"name":"Ordered","order":{},"data":{:?}}}"#,
576 order, data
577 )
578 }
579 fn parse_session_request(&mut self, mut rdr: Cursor<&std::vec::Vec<u8>>) -> String {
580 if !check_min_size(&rdr, PacketsMinSize::SessionRequest as usize, false) {
581 return gen_size_error_json(rdr);
582 }
583
584 let crc_length = rdr.read_u32::<BigEndian>().unwrap_or_default();
585 let session_id = rdr.read_u32::<BigEndian>().unwrap_or_default();
586 let udp_length = rdr.read_u32::<BigEndian>().unwrap_or_default();
587 let protocol_data_position = rdr.position() as usize;
588 let raw_data = rdr.into_inner();
589 let protocol = str_from_u8_nul_utf8_checked(&raw_data[protocol_data_position..]);
590 format!(
591 r#"{{"name":"SessionRequest","protocol_version":{},"session_id":{},"udp_length":{},"protocol":"{}"}}"#,
592 crc_length, session_id, udp_length, protocol
593 )
594 }
595
596 fn parse_session_reply(&mut self, mut rdr: Cursor<&std::vec::Vec<u8>>) -> String {
597 if rdr.get_ref().len() != PacketsMinSize::SessionReply as usize {
598 return gen_size_error_json(rdr);
599 }
600 let session_id = rdr.read_u32::<BigEndian>().unwrap_or_default();
601 let crc_seed = rdr.read_u32::<BigEndian>().unwrap_or_default();
602 let crc_length = rdr.read_u8().unwrap_or_default();
603 let encrypt_method = rdr.read_u16::<BigEndian>().unwrap_or_default();
604 let udp_length = rdr.read_u32::<BigEndian>().unwrap_or_default();
605 format!(
606 r#"{{"name":"SessionReply","session_id":{},"crc_seed":{},"crc_length":{},"encrypt_method":{},"udp_length":{}}}"#,
607 session_id, crc_seed, crc_length, encrypt_method, udp_length
608 )
609 }
610
611 fn parse_disconnect(&mut self, mut rdr: Cursor<&std::vec::Vec<u8>>) -> String {
612 if rdr.get_ref().len() < PacketsMinSize::Disconnect as usize {
613 return r#"{"name":"Disconnect" ,"session_id":null,"reason":"unknown"}"#.to_string();
614 }
615 let session_id = rdr.read_u32::<BigEndian>().unwrap_or_default();
616 let reason = disconnect_reason_to_string(rdr.read_u16::<BigEndian>().unwrap_or_default());
617 format!(
618 r#"{{"name":"Disconnect" ,"session_id":{},"reason":"{}"}}"#,
619 session_id, reason
620 )
621 }
622
623 fn parse_net_status_request(&mut self, mut rdr: Cursor<&std::vec::Vec<u8>>) -> String {
624 if rdr.get_ref().len() != PacketsMinSize::NetStatusPacket as usize {
625 return gen_size_error_json(rdr);
626 }
627 let client_tick_count = rdr.read_u16::<BigEndian>().unwrap_or_default();
628 let last_client_update = rdr.read_u32::<BigEndian>().unwrap_or_default();
629 let average_update = rdr.read_u32::<BigEndian>().unwrap_or_default();
630 let shortest_update = rdr.read_u32::<BigEndian>().unwrap_or_default();
631 let longest_update = rdr.read_u32::<BigEndian>().unwrap_or_default();
632 let last_server_update = rdr.read_u32::<BigEndian>().unwrap_or_default();
633 let packets_sent = rdr.read_u64::<BigEndian>().unwrap_or_default();
634 let packets_received = rdr.read_u64::<BigEndian>().unwrap_or_default();
635 let unknown_field = rdr.read_u16::<BigEndian>().unwrap_or_default();
636 format!(
637 r#"{{"name":"NetStatusRequest","client_tick_count":{},"last_client_update":{},"average_update":{},"shortest_update":{},"longest_update":{},"last_server_update":{},"packets_sent":{},"packets_received":{},"unknown_field":{}}}"#,
638 client_tick_count,
639 last_client_update,
640 average_update,
641 shortest_update,
642 longest_update,
643 last_server_update,
644 packets_sent,
645 packets_received,
646 unknown_field
647 )
648 }
649
650 fn parse_net_status_reply(&mut self, mut rdr: Cursor<&std::vec::Vec<u8>>) -> String {
651 if rdr.get_ref().len() != PacketsMinSize::NetStatusPacket as usize {
652 return gen_size_error_json(rdr);
653 }
654 let client_tick_count = rdr.read_u16::<BigEndian>().unwrap_or_default();
655 let server_tick_count = rdr.read_u32::<BigEndian>().unwrap_or_default();
656 let client_packet_sent = rdr.read_u64::<BigEndian>().unwrap_or_default();
657 let client_packet_received = rdr.read_u64::<BigEndian>().unwrap_or_default();
658 let server_packet_sent = rdr.read_u64::<BigEndian>().unwrap_or_default();
659 let server_packet_received = rdr.read_u64::<BigEndian>().unwrap_or_default();
660 let unknown_field = rdr.read_u16::<BigEndian>().unwrap_or_default();
661 format!(
662 r#"{{"name":"NetStatusReply","client_tick_count":{},"server_tick_count":{},"client_packet_sent":{},"client_packet_received":{},"server_packet_sent":{},"server_packet_received":{},"unknown_field":{}}}"#,
663 client_tick_count,
664 server_tick_count,
665 client_packet_sent,
666 client_packet_received,
667 server_packet_sent,
668 server_packet_received,
669 unknown_field
670 )
671 }
672
673 fn parse_multi(&mut self, mut rdr: Cursor<&std::vec::Vec<u8>>) -> String {
674 if !check_min_size(
676 &rdr,
677 PacketsMinSize::MultiPacket as usize,
678 self.is_using_crc(),
679 ) {
680 return gen_size_error_json(rdr);
681 }
682 let mut multi_result: String = r#"{"name": "MultiPacket","sub_packets":[ "#.to_owned();
683 let data_end: u64 = get_data_end(&rdr, self.is_using_crc());
684 let was_crc_enabled = self.is_using_crc();
685 if was_crc_enabled {
686 self.disable_crc();
687 rdr.set_position(data_end);
688 let crc: u16 = rdr.read_u16::<BigEndian>().unwrap_or_default();
689 let vec = rdr.clone().into_inner();
690 let packet_without_crc = &vec[0..data_end as usize];
691 let crc_value =
692 (crc32(&&mut packet_without_crc.to_vec(), self.crc_seed as usize) & 0xffff) as u16;
693 if crc_value != crc {
694 return gen_crc_error_json(vec, crc_value, crc);
695 }
696 rdr.set_position(2); }
698 loop {
699 let sub_packet_data_length = read_data_length(&mut rdr);
700 if sub_packet_data_length == 0
701 || sub_packet_data_length as u64 + rdr.position() > data_end
702 {
703 return gen_corruption_error_json(rdr, sub_packet_data_length, data_end);
704 }
705 let sub_packet_data =
706 extract_subpacket_data(&rdr, rdr.position(), sub_packet_data_length);
707 rdr.set_position(sub_packet_data_length as u64 + rdr.position());
708 let sub_packet = self.parse(sub_packet_data);
709 multi_result.push_str(&sub_packet);
710 if rdr.position() == data_end {
711 break;
712 } else {
713 multi_result.push(',');
714 }
715 }
716 multi_result.push_str("]}");
717 if was_crc_enabled {
718 self.enable_crc();
719 }
720 multi_result
721 }
722
723 fn parse_data(&mut self, mut rdr: Cursor<&std::vec::Vec<u8>>, opcode: u16) -> String {
724 if !check_min_size(&rdr, PacketsMinSize::DataPacket as usize, self.use_crc) {
725 return gen_size_error_json(rdr);
726 }
727 let name = if opcode == 0x09 {
728 "Data"
729 } else {
730 "DataFragment"
731 };
732 let sequence = rdr.read_u16::<BigEndian>().unwrap_or_default();
733
734 let data_end: u64 = get_data_end(&rdr, self.use_crc);
735 let mut crc: u16 = 0;
736 if self.use_crc {
737 rdr.set_position(data_end);
738 crc = rdr.read_u16::<BigEndian>().unwrap_or_default();
739 }
740 let vec = rdr.get_ref().to_vec();
741 let data = &vec[4..data_end as usize];
742 if self.use_crc {
744 let packet_without_crc = &vec[0..data_end as usize];
745 let crc_value =
746 (crc32(&&mut packet_without_crc.to_vec(), self.crc_seed as usize) & 0xffff) as u16;
747 if crc_value != crc {
748 return gen_crc_error_json(&vec, crc_value, crc);
749 }
750 }
751 format!(
752 r#"{{"name":"{}","sequence":{},"data":{:?}}}"#,
753 name, sequence, data
754 )
755 }
756
757 fn parse_ack(&mut self, mut rdr: Cursor<&std::vec::Vec<u8>>, opcode: u16) -> String {
758 if !check_min_size(&rdr, PacketsMinSize::Ack as usize, self.use_crc) {
759 return gen_size_error_json(rdr);
760 }
761 let name = if opcode == 0x15 { "Ack" } else { "OutOfOrder" };
762 let sequence = rdr.read_u16::<BigEndian>().unwrap_or_default();
763 if self.use_crc {
764 let crc = rdr.read_u16::<BigEndian>().unwrap_or_default();
765 let data_end: u64 = get_data_end(&rdr, self.use_crc);
766 let vec = rdr.into_inner();
767 let packet_without_crc = &vec[0..data_end as usize];
768 let crc_value =
769 (crc32(&&mut packet_without_crc.to_vec(), self.crc_seed as usize) & 0xffff) as u16;
770 if crc_value != crc {
771 return gen_crc_error_json(vec, crc_value, crc);
772 }
773 }
774 format!(r#"{{"name":"{}","sequence":{}}}"#, name, sequence)
775 }
776
777 pub fn get_crc_seed(&self) -> u32 {
778 self.crc_seed
779 }
780 pub fn set_crc_seed(&mut self, crc_seed: u32) {
781 self.crc_seed = crc_seed;
782 }
783 pub fn is_using_crc(&mut self) -> bool {
784 self.use_crc
785 }
786 pub fn disable_crc(&mut self) {
787 self.use_crc = false;
788 }
789 pub fn enable_crc(&mut self) {
790 self.use_crc = true;
791 }
792}
793
794#[cfg(test)]
795mod tests {
796
797 use super::super::crc::append_crc;
798
799 use super::super::protocol_errors::*;
800 use super::*;
801
802 #[test]
803 fn session_request_parse_test() {
804 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
805 let data_to_parse: [u8; 25] = [
806 0, 1, 0, 0, 0, 3, 60, 23, 140, 99, 0, 0, 2, 0, 76, 111, 103, 105, 110, 85, 100, 112,
807 95, 57, 0,
808 ];
809 let data_parsed: serde_json::Value =
810 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
811 .unwrap_or_default();
812 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"name":"SessionRequest","protocol_version":3,"session_id":1008176227,"udp_length":512,"protocol":"LoginUdp_9"}"#).unwrap_or_default();
813 assert_eq!(data_parsed, succesful_data)
814 }
815
816 #[test]
817 fn session_request_parse_size_error_test() {
818 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
819 let data_to_parse: [u8; 12] = [0, 1, 111, 103, 105, 110, 85, 100, 112, 95, 57, 2];
820 let data_parsed: serde_json::Value =
821 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
822 .unwrap_or_default();
823 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"error": "size", "name": "Error", "raw": [0, 1, 111, 103, 105, 110, 85, 100, 112,95, 57, 2], "size": 12}"#).unwrap_or_default();
824 assert_eq!(data_parsed, succesful_data)
825 }
826
827 #[test]
828 fn session_request_pack_test() {
829 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
830 let data_to_pack =
831 r#"{"protocol_version":3,"session_id":1008176227,"udp_length":512,"protocol":"LoginUdp_9"}"#
832 .to_string();
833 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::SessionRequest, data_to_pack);
834 assert_eq!(
835 data_pack,
836 [
837 0, 1, 0, 0, 0, 3, 60, 23, 140, 99, 0, 0, 2, 0, 76, 111, 103, 105, 110, 85, 100,
838 112, 95, 57, 0
839 ]
840 )
841 }
842
843 #[test]
844 fn session_request_pack_test_deserializing_error() {
845 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
846 let data_to_pack =
847 r#"{"protocol_version":3,"udp_length":512,"protocol":"LoginUdp_9"}"#.to_string();
848 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::SessionRequest, data_to_pack);
849 let data_pack_opcode: u16 = u16::from_be_bytes([data_pack[0], data_pack[1]]);
850 assert_eq!(data_pack_opcode, ErrorType::Deserializing as u16)
851 }
852
853 #[test]
854 fn session_reply_parse_size_error_test() {
855 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
856 let data_to_parse: [u8; 10] = [0, 2, 111, 103, 105, 110, 85, 100, 112, 95];
857 let data_parsed: serde_json::Value =
858 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
859 .unwrap_or_default();
860 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"error": "size", "name": "Error", "raw": [0,2,111,103,105,110,85,100,112,95], "size": 10}"#).unwrap_or_default();
861 assert_eq!(data_parsed, succesful_data)
862 }
863
864 #[test]
865 fn session_reply_parse_test() {
866 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
867 let data_to_parse: [u8; 21] = [
868 0, 2, 60, 23, 140, 99, 0, 0, 0, 0, 2, 1, 0, 0, 0, 2, 0, 0, 0, 0, 3,
869 ];
870 let data_parsed: serde_json::Value =
871 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
872 .unwrap_or_default();
873 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"name":"SessionReply","session_id":1008176227,"crc_seed":0,"crc_length":2,"encrypt_method":256,"udp_length":512}"#).unwrap_or_default();
874 assert_eq!(data_parsed, succesful_data)
875 }
876
877 #[test]
878 fn session_reply_pack_test() {
879 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
880 let data_to_pack = r#"{"session_id":1008176227,"crc_seed":0,"crc_length":2,"encrypt_method":256,"udp_length":512}"#.to_string();
881 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::SessionReply, data_to_pack);
882 assert_eq!(
883 data_pack,
884 [0, 2, 60, 23, 140, 99, 0, 0, 0, 0, 2, 1, 0, 0, 0, 2, 0, 0, 0, 0, 3]
885 )
886 }
887
888 #[test]
889 fn session_reply_pack_test_deserializing_error() {
890 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
891 let data_to_pack =
892 r#"{"crc_seed":0,"crc_length":2,"encrypt_method":256,"udp_length":512}"#.to_string();
893 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::SessionReply, data_to_pack);
894 let data_pack_opcode: u16 = u16::from_be_bytes([data_pack[0], data_pack[1]]);
895 assert_eq!(data_pack_opcode, ErrorType::Deserializing as u16)
896 }
897
898 #[test]
899 fn net_status_request_parse_test() {
900 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
901 let data_to_parse: [u8; 42] = [
902 0, 7, 251, 92, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
903 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 235, 216,
904 ];
905 let data_parsed: serde_json::Value =
906 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
907 .unwrap_or_default();
908 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"average_update": 0, "client_tick_count": 64348, "last_client_update": 0, "last_server_update": 0, "longest_update": 0, "name": "NetStatusRequest", "packets_received": 1, "packets_sent": 2, "shortest_update": 0, "unknown_field": 60376}"#).unwrap_or_default();
909 assert_eq!(data_parsed, succesful_data)
910 }
911
912 #[test]
913 fn net_status_request_parse_deserializing_error() {
914 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
915 let data_to_parse: [u8; 43] = [
916 0, 7, 251, 92, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
917 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 235, 216, 0,
918 ];
919 let data_parsed: serde_json::Value =
920 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
921 .unwrap_or_default();
922 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"error": "size", "name": "Error", "raw": [0,7,251,92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,1,235,216,0], "size": 43}"#).unwrap_or_default();
923 assert_eq!(data_parsed, succesful_data)
924 }
925
926 #[test]
927 fn net_status_request_pack_test() {
928 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
929 let data_to_pack =
930 r#"{"average_update": 0, "client_tick_count": 64348, "last_client_update": 0, "last_server_update": 0, "longest_update": 0, "name": "NetStatusRequest", "packets_received": 1, "packets_sent": 2, "shortest_update": 0, "unknown_field": 60376}"#
931 .to_string();
932 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::NetStatusRequest, data_to_pack);
933 assert_eq!(
934 data_pack,
935 [
936 0, 7, 251, 92, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
937 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 235, 216
938 ]
939 )
940 }
941
942 #[test]
943 fn net_status_request_pack_test_size_error() {
944 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
945 let data_to_pack =
946 r#"{"client_packet_received": 0, "client_packet_sent": 0, "client_tick_count": 64348, "name": "NetStatusRequest", "server_packet_received": 1, "server_packet_sent": 2, "server_tick_count": 0}"#.to_string();
947 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::NetStatusRequest, data_to_pack);
948 let data_pack_opcode: u16 = u16::from_be_bytes([data_pack[0], data_pack[1]]);
949 assert_eq!(data_pack_opcode, ErrorType::Deserializing as u16)
950 }
951
952 #[test]
953 fn net_status_reply_parse_test() {
954 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
955 let data_to_parse: [u8; 42] = [
956 0, 8, 251, 92, 33, 39, 197, 60, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
957 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 131, 212,
958 ];
959 let data_parsed: serde_json::Value =
960 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
961 .unwrap_or_default();
962 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"client_packet_received": 1, "client_packet_sent": 2, "client_tick_count": 64348, "name": "NetStatusReply", "server_packet_received": 2, "server_packet_sent": 1, "server_tick_count": 556254524, "unknown_field": 33748}"#).unwrap_or_default();
963 assert_eq!(data_parsed, succesful_data)
964 }
965
966 #[test]
967 fn net_status_reply_parse_size_error() {
968 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
969 let data_to_parse: [u8; 43] = [
970 0, 8, 251, 92, 33, 39, 197, 60, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
971 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 131, 212, 0,
972 ];
973 let data_parsed: serde_json::Value =
974 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
975 .unwrap_or_default();
976 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"error": "size", "name": "Error", "raw": [0,8,251,92,33,39,197,60,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,2,131,212,0], "size": 43}"#).unwrap_or_default();
977 assert_eq!(data_parsed, succesful_data)
978 }
979
980 #[test]
981 fn net_status_reply_pack_test() {
982 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
983 let data_to_pack =
984 r#"{"client_packet_received": 1, "client_packet_sent": 2, "client_tick_count": 64348, "name": "NetStatusReply", "server_packet_received": 2, "server_packet_sent": 1, "server_tick_count": 556254524, "unknown_field": 33748}"#
985 .to_string();
986 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::NetStatusReply, data_to_pack);
987 assert_eq!(
988 data_pack,
989 [
990 0, 8, 251, 92, 33, 39, 197, 60, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0,
991 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 131, 212
992 ]
993 )
994 }
995
996 #[test]
997 fn net_status_reply_pack_test_deserializing_error() {
998 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
999 let data_to_pack =
1000 r#"{"client_packet_received": 0, "client_packet_sent": 0, "client_tick_cozunt": 64348, "name": "NetStatusRequest", "server_packet_received": 1, "server_packet_sent": 2, "server_tick_count": 0}"#.to_string();
1001 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::NetStatusRequest, data_to_pack);
1002 let data_pack_opcode: u16 = u16::from_be_bytes([data_pack[0], data_pack[1]]);
1003 assert_eq!(data_pack_opcode, ErrorType::Deserializing as u16)
1004 }
1005
1006 #[test]
1007 fn ping_parse_test() {
1008 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1009 let data_to_parse: [u8; 2] = [0, 6];
1010 let data_parsed: String = soeprotocol_class.parse(data_to_parse.to_vec());
1011 assert_eq!(data_parsed, r#"{"name":"Ping"}"#)
1012 }
1013
1014 #[test]
1015 fn ping_pack_test() {
1016 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1017 let data_to_pack: String = r#"{"name":"Ping"}"#.to_owned();
1018 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::Ping, data_to_pack);
1019 assert_eq!(data_pack, [0, 6])
1020 }
1021
1022 #[test]
1023 fn outoforder_parse_size_error_test() {
1024 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1025 let data_to_parse: [u8; 3] = [0, 17, 111];
1026 let data_parsed: serde_json::Value =
1027 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1028 .unwrap_or_default();
1029 let succesful_data: serde_json::Value = serde_json::from_str(
1030 r#"{"error": "size", "name": "Error", "raw": [0, 17, 111], "size": 3}"#,
1031 )
1032 .unwrap_or_default();
1033 assert_eq!(data_parsed, succesful_data)
1034 }
1035
1036 #[test]
1037 fn outoforder_parse_test() {
1038 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1039 let data_to_parse: [u8; 6] = [0, 17, 0, 1, 38, 184];
1040 let data_parsed: serde_json::Value =
1041 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1042 .unwrap_or_default();
1043 let succesful_data: serde_json::Value =
1044 serde_json::from_str(r#"{"name":"OutOfOrder","sequence":1}"#).unwrap_or_default();
1045 assert_eq!(data_parsed, succesful_data)
1046 }
1047
1048 #[test]
1049 fn outoforder_parse_test_crc_fail() {
1050 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1051 let data_to_parse: [u8; 6] = [0, 17, 0, 1, 142, 100];
1052 let data_parsed: serde_json::Value =
1053 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1054 .unwrap_or_default();
1055 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"error": "crc", "expected_crc": 9912, "given_crc": 36452, "name": "Error", "raw": [0, 17, 0, 1, 142, 100]}"#).unwrap_or_default();
1056 assert_eq!(data_parsed, succesful_data)
1057 }
1058
1059 #[test]
1060 fn outoforder_pack_test() {
1061 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1062 let data_to_pack: String = r#"{"name":"OutOfOrder","sequence":1}"#.to_owned();
1063 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::OutOfOrder, data_to_pack);
1064 assert_eq!(data_pack, [0, 17, 0, 1])
1065 }
1066
1067 #[test]
1068 fn outoforder_pack_test_deserializing_error() {
1069 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1070 let data_to_pack: String = r#"{"sequednce":1}"#.to_owned();
1071 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::OutOfOrder, data_to_pack);
1072 let data_pack_opcode: u16 = u16::from_be_bytes([data_pack[0], data_pack[1]]);
1073 assert_eq!(data_pack_opcode, ErrorType::Deserializing as u16)
1074 }
1075
1076 #[test]
1077 fn ack_parse_size_error_test() {
1078 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1079 let data_to_parse: [u8; 3] = [0, 21, 111];
1080 let data_parsed: serde_json::Value =
1081 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1082 .unwrap_or_default();
1083 let succesful_data: serde_json::Value = serde_json::from_str(
1084 r#"{"error": "size", "name": "Error", "raw": [0, 21, 111], "size": 3}"#,
1085 )
1086 .unwrap_or_default();
1087 assert_eq!(data_parsed, succesful_data)
1088 }
1089
1090 #[test]
1091 fn ack_parse_test() {
1092 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1093 let data_to_parse: [u8; 6] = [0, 21, 0, 1, 142, 100];
1094 let data_parsed: serde_json::Value =
1095 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1096 .unwrap_or_default();
1097 let succesful_data: serde_json::Value =
1098 serde_json::from_str(r#"{"name":"Ack","sequence":1}"#).unwrap_or_default();
1099 assert_eq!(data_parsed, succesful_data)
1100 }
1101
1102 #[test]
1103 fn ack_pack_test() {
1104 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1105 let data_to_pack: String = r#"{"name":"Ack","sequence":1}"#.to_owned();
1106 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::Ack, data_to_pack);
1107 assert_eq!(data_pack, [0, 21, 0, 1])
1108 }
1109
1110 #[test]
1111 fn ack_pack_test_deserializing_error() {
1112 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1113 let data_to_pack: String = r#"{"name":"Ack"}"#.to_owned();
1114 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::Ack, data_to_pack);
1115 let data_pack_opcode: u16 = u16::from_be_bytes([data_pack[0], data_pack[1]]);
1116 assert_eq!(data_pack_opcode, ErrorType::Deserializing as u16)
1117 }
1118
1119 #[test]
1120 fn multi_parse_size_error_test() {
1121 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1122 let data_to_parse: [u8; 4] = [0, 3, 4, 0];
1123 let data_parsed: serde_json::Value =
1124 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1125 .unwrap_or_default();
1126 let succesful_data: serde_json::Value = serde_json::from_str(
1127 r#"{"error": "size", "name": "Error", "raw": [0, 3, 4, 0], "size": 4}"#,
1128 )
1129 .unwrap_or_default();
1130 assert_eq!(data_parsed, succesful_data)
1131 }
1132
1133 #[test]
1134 fn multi_parse_corrupted_test() {
1135 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1136 let data_to_parse: [u8; 75] = [
1137 0, 3, 54, 0, 21, 0, 206, 67, 0, 9, 0, 1, 0, 25, 41, 141, 45, 189, 85, 241, 64, 165, 71,
1138 228, 114, 81, 54, 5, 184, 205, 104, 0, 125, 184, 210, 74, 0, 247, 152, 225, 169, 102,
1139 204, 158, 233, 202, 228, 34, 202, 238, 136, 31, 3, 121, 222, 106, 11, 247, 177, 138,
1140 145, 21, 221, 187, 36, 170, 37, 171, 6, 32, 11, 180, 97, 10, 246,
1141 ];
1142 let data_parsed: serde_json::Value =
1143 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1144 .unwrap_or_default();
1145 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"error": "corruption", "name": "Error", "data_end": 75,"position": 58, "subpacket_length": 247,"raw":[0, 3, 54, 0, 21, 0, 206, 67, 0, 9, 0, 1, 0, 25, 41, 141, 45, 189, 85, 241, 64, 165, 71,228, 114, 81, 54, 5, 184, 205, 104, 0, 125, 184, 210, 74, 0, 247, 152, 225, 169, 102,204, 158, 233, 202, 228, 34, 202, 238, 136, 31, 3, 121, 222, 106, 11, 247, 177, 138,145, 21, 221, 187, 36, 170, 37, 171, 6, 32, 11, 180, 97, 10, 246]}"#).unwrap_or_default();
1146 assert_eq!(data_parsed, succesful_data)
1147 }
1148 #[test]
1149 fn multi_parse_crc_fail_test() {
1150 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1151 let data_to_parse: [u8; 75] = [
1152 0, 3, 54, 0, 21, 0, 206, 67, 0, 9, 0, 1, 0, 25, 41, 141, 45, 189, 85, 241, 64, 165, 71,
1153 228, 114, 81, 54, 5, 184, 205, 104, 0, 125, 184, 210, 74, 0, 247, 152, 225, 169, 102,
1154 204, 158, 233, 202, 228, 34, 202, 238, 136, 31, 3, 121, 222, 106, 11, 247, 177, 138,
1155 145, 21, 221, 187, 36, 170, 37, 171, 6, 32, 11, 180, 97, 10, 246,
1156 ];
1157 let data_parsed: serde_json::Value =
1158 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1159 .unwrap_or_default();
1160 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"error": "crc", "name": "Error", "expected_crc": 62304,"given_crc": 2806,"raw":[0, 3, 54, 0, 21, 0, 206, 67, 0, 9, 0, 1, 0, 25, 41, 141, 45, 189, 85, 241, 64, 165, 71,228, 114, 81, 54, 5, 184, 205, 104, 0, 125, 184, 210, 74, 0, 247, 152, 225, 169, 102,204, 158, 233, 202, 228, 34, 202, 238, 136, 31, 3, 121, 222, 106, 11, 247, 177, 138,145, 21, 221, 187, 36, 170, 37, 171, 6, 32, 11, 180, 97, 10, 246]}"#).unwrap_or_default();
1161 assert_eq!(data_parsed, succesful_data)
1162 }
1163
1164 #[test]
1165 fn multi_parse_test() {
1166 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1167 let data_to_parse: [u8; 75] = [
1168 0, 3, 4, 0, 21, 0, 206, 67, 0, 9, 0, 1, 0, 25, 41, 141, 45, 189, 85, 241, 64, 165, 71,
1169 228, 114, 81, 54, 5, 184, 205, 104, 0, 125, 184, 210, 74, 0, 247, 152, 225, 169, 102,
1170 204, 158, 233, 202, 228, 34, 202, 238, 136, 31, 3, 121, 222, 106, 11, 247, 177, 138,
1171 145, 21, 221, 187, 36, 170, 37, 171, 6, 32, 11, 180, 97, 10, 246,
1172 ];
1173 let data_parsed: serde_json::Value =
1174 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1175 .unwrap_or_default();
1176 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"name":"MultiPacket","sub_packets":[{"name":"Ack","sequence":206},{"name":"Data","sequence":1,"data":[0,25,41,141,45,189,85,241,64,165,71,228,114,81,54,5,184,205,104,0,125,184,210,74,0,247,152,225,169,102,204,158,233,202,228,34,202,238,136,31,3,121,222,106,11,247,177,138,145,21,221,187,36,170,37,171,6,32,11,180,97,10,246]}]}"#).unwrap_or_default();
1177 assert_eq!(data_parsed, succesful_data)
1178 }
1179
1180 #[test]
1181 fn multi_parse_with_crc_test() {
1182 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1183 let data_to_parse: [u8; 77] = [
1184 0, 3, 4, 0, 21, 0, 206, 67, 0, 9, 0, 1, 0, 25, 41, 141, 45, 189, 85, 241, 64, 165, 71,
1185 228, 114, 81, 54, 5, 184, 205, 104, 0, 125, 184, 210, 74, 0, 247, 152, 225, 169, 102,
1186 204, 158, 233, 202, 228, 34, 202, 238, 136, 31, 3, 121, 222, 106, 11, 247, 177, 138,
1187 145, 21, 221, 187, 36, 170, 37, 171, 6, 32, 11, 180, 97, 10, 246, 10, 27,
1188 ];
1189 let data_parsed: serde_json::Value =
1190 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1191 .unwrap_or_default();
1192 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"name":"MultiPacket","sub_packets":[{"name":"Ack","sequence":206},{"name":"Data","sequence":1,"data":[0,25,41,141,45,189,85,241,64,165,71,228,114,81,54,5,184,205,104,0,125,184,210,74,0,247,152,225,169,102,204,158,233,202,228,34,202,238,136,31,3,121,222,106,11,247,177,138,145,21,221,187,36,170,37,171,6,32,11,180,97,10,246]}]}"#).unwrap_or_default();
1193 assert_eq!(data_parsed, succesful_data)
1194 }
1195
1196 #[test]
1197 fn multi_pack_test() {
1198 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1199 let data_to_pack:String = r#"{"sub_packets":[[0, 21, 0, 1],[0, 9, 0, 1, 0, 25, 41, 141, 45, 189, 85, 241, 64, 165,
1200 71, 228, 114, 81, 54, 5, 184, 205, 104, 0, 125, 184, 210, 74, 0, 247, 152, 225,
1201 169, 102, 204, 158, 233, 202, 228, 34, 202, 238, 136, 31, 3, 121, 222, 106, 11,
1202 247, 177, 138, 145, 21, 221, 187, 36, 170, 37, 171, 6, 32, 11, 180, 97, 10, 246]]}"#.to_owned();
1203 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::MultiPacket, data_to_pack);
1204 assert_eq!(
1205 data_pack,
1206 [
1207 0, 3, 4, 0, 21, 0, 1, 67, 0, 9, 0, 1, 0, 25, 41, 141, 45, 189, 85, 241, 64, 165,
1208 71, 228, 114, 81, 54, 5, 184, 205, 104, 0, 125, 184, 210, 74, 0, 247, 152, 225,
1209 169, 102, 204, 158, 233, 202, 228, 34, 202, 238, 136, 31, 3, 121, 222, 106, 11,
1210 247, 177, 138, 145, 21, 221, 187, 36, 170, 37, 171, 6, 32, 11, 180, 97, 10, 246
1211 ]
1212 )
1213 }
1214
1215 #[test]
1216 fn multi_pack_test_deserializing_error() {
1217 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1218 let data_to_pack:String = r#"{"sub_packzts":[[4, 0, 21, 0, 206],[0, 9, 0, 1, 0, 25, 41, 141, 45, 189, 85, 241, 64, 165,
1219 71, 228, 114, 81, 54, 5, 184, 205, 104, 0, 125, 184, 210, 74, 0, 247, 152, 225,
1220 169, 102, 204, 158, 233, 202, 228, 34, 202, 238, 136, 31, 3, 121, 222, 106, 11,
1221 247, 177, 138, 145, 21, 221, 187, 36, 170, 37, 171, 6, 32, 11, 180, 97, 10, 246]]}"#.to_owned();
1222 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::MultiPacket, data_to_pack);
1223 let data_pack_opcode: u16 = u16::from_be_bytes([data_pack[0], data_pack[1]]);
1224 assert_eq!(data_pack_opcode, ErrorType::Deserializing as u16)
1225 }
1226
1227 #[test]
1228 fn data_parse_test() {
1229 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1230 let data_to_parse: [u8; 45] = [
1231 0, 9, 0, 4, 252, 100, 40, 209, 68, 247, 21, 93, 18, 172, 91, 68, 145, 53, 24, 155, 2,
1232 113, 179, 28, 217, 33, 80, 76, 9, 235, 87, 98, 233, 235, 220, 124, 107, 61, 62, 132,
1233 117, 146, 204, 94, 60,
1234 ];
1235 let data_parsed: serde_json::Value =
1236 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1237 .unwrap_or_default();
1238 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"name":"Data","sequence":4,"data":[252,100,40,209,68,247,21,93,18,172,91,68,145,53,24,155,2,113,179,28,217,33,80,76,9,235,87,98,233,235,220,124,107,61,62,132,117,146,204,94,60]}"#).unwrap_or_default();
1239 assert_eq!(data_parsed, succesful_data)
1240 }
1241
1242 #[test]
1243 fn data_parse_with_crc_test() {
1244 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1245 let data_to_parse: [u8; 45] = [
1246 0, 9, 0, 4, 252, 100, 40, 209, 68, 247, 21, 93, 18, 172, 91, 68, 145, 53, 24, 155, 2,
1247 113, 179, 28, 217, 33, 80, 76, 9, 235, 87, 98, 233, 235, 220, 124, 107, 61, 62, 132,
1248 117, 146, 204, 94, 60,
1249 ];
1250 let data_parsed: serde_json::Value =
1251 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1252 .unwrap_or_default();
1253 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"name":"Data","sequence":4,"data":[252,100,40,209,68,247,21,93,18,172,91,68,145,53,24,155,2,113,179,28,217,33,80,76,9,235,87,98,233,235,220,124,107,61,62,132,117,146,204]}"#).unwrap_or_default();
1254 assert_eq!(data_parsed, succesful_data)
1255 }
1256
1257 #[test]
1258 fn data_parse_with_crc_test_fail() {
1259 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1260 let data_to_parse: [u8; 45] = [
1261 0, 9, 0, 4, 252, 100, 40, 209, 68, 247, 21, 93, 18, 172, 91, 68, 145, 53, 24, 155, 2,
1262 113, 179, 28, 217, 33, 80, 76, 9, 235, 87, 98, 233, 235, 220, 124, 107, 61, 62, 132,
1263 117, 146, 204, 94, 61,
1264 ];
1265 let data_parsed: serde_json::Value =
1266 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1267 .unwrap_or_default();
1268 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"error": "crc", "expected_crc": 24124, "given_crc": 24125, "name": "Error", "raw": [0, 9, 0, 4, 252, 100, 40, 209, 68, 247, 21, 93, 18, 172, 91, 68, 145, 53, 24, 155, 2,113, 179, 28, 217, 33, 80, 76, 9, 235, 87, 98, 233, 235, 220, 124, 107, 61, 62, 132,117, 146, 204, 94, 61]}"#).unwrap_or_default();
1269 assert_eq!(data_parsed, succesful_data)
1270 }
1271
1272 #[test]
1273 fn ordered_data_parse_test() {
1274 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1275 let data_to_parse: [u8; 6] = [0, 27, 147, 127, 1, 0];
1276 let data_parsed: serde_json::Value =
1277 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1278 .unwrap_or_default();
1279 let succesful_data: serde_json::Value =
1280 serde_json::from_str(r#"{"name":"Ordered","order":37759,"data":[1,0]}"#)
1281 .unwrap_or_default();
1282 assert_eq!(data_parsed, succesful_data)
1283 }
1284
1285 #[test]
1286 fn ordered_data_with_crc_test() {
1287 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1288 let mut data_to_parse: Vec<u8> = [0, 27, 147, 127, 1, 0].to_vec();
1289 append_crc(&mut data_to_parse, 0);
1290 let data_parsed: serde_json::Value =
1291 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1292 .unwrap_or_default();
1293 let succesful_data: serde_json::Value =
1294 serde_json::from_str(r#"{"name":"Ordered","order":37759,"data":[1,0]}"#)
1295 .unwrap_or_default();
1296 assert_eq!(data_parsed, succesful_data)
1297 }
1298
1299 #[test]
1300 fn ordered_data_with_crc_test_fail() {
1301 let mut soeprotocol_class = super::Soeprotocol::initialize(true, 0);
1302 let data_to_parse: [u8; 6] = [0, 27, 147, 127, 1, 1];
1303 let data_parsed: serde_json::Value =
1304 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1305 .unwrap_or_default();
1306 let succesful_data: serde_json::Value =
1307 serde_json::from_str(r#"{"name":"Ordered","order":37759,"data":[1,0]}"#)
1308 .unwrap_or_default();
1309 assert_ne!(data_parsed, succesful_data)
1310 }
1311
1312 #[test]
1313 fn data_pack_test() {
1314 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1315 let data_to_pack =
1316 r#"{"sequence":0,"data":[2,1,1,0,0,0,1,1,3,0,0,0,115,111,101,0,0,0,0]}"#.to_string();
1317 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::Data, data_to_pack);
1318 assert_eq!(
1319 data_pack,
1320 [0, 9, 0, 0, 2, 1, 1, 0, 0, 0, 1, 1, 3, 0, 0, 0, 115, 111, 101, 0, 0, 0, 0]
1321 )
1322 }
1323
1324 #[test]
1325 fn data_ordered_pack_test() {
1326 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1327 let data_to_pack =
1328 r#"{"sequence":1,"data":[2,1,1,0,0,0,1,1,3,0,0,0,115,111,101,0,0,0,0]}"#.to_string();
1329 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::Ordered, data_to_pack);
1330 assert_eq!(
1331 data_pack,
1332 [0, 27, 0, 1, 2, 1, 1, 0, 0, 0, 1, 1, 3, 0, 0, 0, 115, 111, 101, 0, 0, 0, 0]
1333 )
1334 }
1335
1336 #[test]
1337 fn data_pack_test_deserializing_error() {
1338 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1339 let data_to_pack = r#"{"data":[2,1,1,0,0,0,1,1,3,0,0,0,115,111,101,0,0,0,0]}"#.to_string();
1340 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::Data, data_to_pack);
1341 let data_pack_opcode: u16 = u16::from_be_bytes([data_pack[0], data_pack[1]]);
1342 assert_eq!(data_pack_opcode, ErrorType::Deserializing as u16)
1343 }
1344
1345 #[test]
1346 fn data_fragment_parse_test() {
1347 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1348 let data_to_parse: [u8; 257] = [
1349 0, 13, 0, 2, 208, 127, 31, 117, 87, 54, 201, 180, 188, 226, 247, 253, 136, 66, 78, 125,
1350 224, 112, 23, 87, 147, 110, 18, 68, 183, 87, 20, 3, 65, 116, 82, 111, 93, 219, 229, 20,
1351 61, 238, 143, 63, 8, 137, 8, 196, 128, 89, 59, 4, 198, 191, 207, 141, 23, 164, 242, 77,
1352 176, 206, 49, 45, 207, 210, 17, 33, 75, 177, 157, 242, 169, 37, 60, 87, 245, 58, 2,
1353 130, 102, 146, 227, 66, 193, 153, 155, 105, 230, 203, 120, 114, 160, 223, 229, 190,
1354 129, 106, 19, 25, 8, 52, 55, 8, 100, 68, 109, 228, 178, 186, 148, 108, 138, 242, 136,
1355 66, 219, 25, 73, 129, 110, 31, 121, 32, 246, 86, 156, 212, 85, 217, 213, 119, 165, 140,
1356 83, 95, 6, 183, 184, 251, 73, 102, 221, 156, 240, 204, 50, 217, 217, 13, 218, 2, 19,
1357 44, 143, 73, 168, 109, 67, 176, 129, 225, 187, 171, 12, 146, 21, 66, 252, 150, 143,
1358 142, 46, 39, 72, 12, 22, 222, 7, 29, 63, 201, 227, 251, 9, 28, 0, 100, 84, 153, 84,
1359 212, 163, 78, 135, 33, 66, 20, 195, 223, 62, 214, 32, 59, 6, 187, 222, 99, 29, 34, 87,
1360 81, 61, 63, 174, 255, 1, 85, 241, 6, 10, 152, 237, 52, 51, 126, 149, 218, 125, 232,
1361 199, 40, 113, 139, 187, 43, 232, 209, 167, 226, 91, 236, 212, 165, 117, 19, 118, 110,
1362 18, 0, 26, 152, 33, 115, 61, 208, 21,
1363 ];
1364 let data_parsed: serde_json::Value =
1365 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1366 .unwrap_or_default();
1367 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"name":"DataFragment","sequence":2,"data":[208,127,31,117,87,54,201,180,188,226,247,253,136,66,78,125,224,112,23,87,147,110,18,68,183,87,20,3,65,116,82,111,93,219,229,20,61,238,143,63,8,137,8,196,128,89,59,4,198,191,207,141,23,164,242,77,176,206,49,45,207,210,17,33,75,177,157,242,169,37,60,87,245,58,2,130,102,146,227,66,193,153,155,105,230,203,120,114,160,223,229,190,129,106,19,25,8,52,55,8,100,68,109,228,178,186,148,108,138,242,136,66,219,25,73,129,110,31,121,32,246,86,156,212,85,217,213,119,165,140,83,95,6,183,184,251,73,102,221,156,240,204,50,217,217,13,218,2,19,44,143,73,168,109,67,176,129,225,187,171,12,146,21,66,252,150,143,142,46,39,72,12,22,222,7,29,63,201,227,251,9,28,0,100,84,153,84,212,163,78,135,33,66,20,195,223,62,214,32,59,6,187,222,99,29,34,87,81,61,63,174,255,1,85,241,6,10,152,237,52,51,126,149,218,125,232,199,40,113,139,187,43,232,209,167,226,91,236,212,165,117,19,118,110,18,0,26,152,33,115,61,208,21]}"#).unwrap_or_default();
1368 assert_eq!(data_parsed, succesful_data)
1369 }
1370
1371 #[test]
1372 fn data_fragment_parse_with_crc_test() {
1373 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1374 let data_to_parse: [u8; 257] = [
1375 0, 13, 0, 2, 208, 127, 31, 117, 87, 54, 201, 180, 188, 226, 247, 253, 136, 66, 78, 125,
1376 224, 112, 23, 87, 147, 110, 18, 68, 183, 87, 20, 3, 65, 116, 82, 111, 93, 219, 229, 20,
1377 61, 238, 143, 63, 8, 137, 8, 196, 128, 89, 59, 4, 198, 191, 207, 141, 23, 164, 242, 77,
1378 176, 206, 49, 45, 207, 210, 17, 33, 75, 177, 157, 242, 169, 37, 60, 87, 245, 58, 2,
1379 130, 102, 146, 227, 66, 193, 153, 155, 105, 230, 203, 120, 114, 160, 223, 229, 190,
1380 129, 106, 19, 25, 8, 52, 55, 8, 100, 68, 109, 228, 178, 186, 148, 108, 138, 242, 136,
1381 66, 219, 25, 73, 129, 110, 31, 121, 32, 246, 86, 156, 212, 85, 217, 213, 119, 165, 140,
1382 83, 95, 6, 183, 184, 251, 73, 102, 221, 156, 240, 204, 50, 217, 217, 13, 218, 2, 19,
1383 44, 143, 73, 168, 109, 67, 176, 129, 225, 187, 171, 12, 146, 21, 66, 252, 150, 143,
1384 142, 46, 39, 72, 12, 22, 222, 7, 29, 63, 201, 227, 251, 9, 28, 0, 100, 84, 153, 84,
1385 212, 163, 78, 135, 33, 66, 20, 195, 223, 62, 214, 32, 59, 6, 187, 222, 99, 29, 34, 87,
1386 81, 61, 63, 174, 255, 1, 85, 241, 6, 10, 152, 237, 52, 51, 126, 149, 218, 125, 232,
1387 199, 40, 113, 139, 187, 43, 232, 209, 167, 226, 91, 236, 212, 165, 117, 19, 118, 110,
1388 18, 0, 26, 152, 33, 115, 61, 208, 21,
1389 ];
1390 let data_parsed: serde_json::Value =
1391 serde_json::from_str(&soeprotocol_class.parse(data_to_parse.to_vec()))
1392 .unwrap_or_default();
1393 let succesful_data:serde_json::Value = serde_json::from_str(r#"{"name":"DataFragment","sequence":2,"data":[208,127,31,117,87,54,201,180,188,226,247,253,136,66,78,125,224,112,23,87,147,110,18,68,183,87,20,3,65,116,82,111,93,219,229,20,61,238,143,63,8,137,8,196,128,89,59,4,198,191,207,141,23,164,242,77,176,206,49,45,207,210,17,33,75,177,157,242,169,37,60,87,245,58,2,130,102,146,227,66,193,153,155,105,230,203,120,114,160,223,229,190,129,106,19,25,8,52,55,8,100,68,109,228,178,186,148,108,138,242,136,66,219,25,73,129,110,31,121,32,246,86,156,212,85,217,213,119,165,140,83,95,6,183,184,251,73,102,221,156,240,204,50,217,217,13,218,2,19,44,143,73,168,109,67,176,129,225,187,171,12,146,21,66,252,150,143,142,46,39,72,12,22,222,7,29,63,201,227,251,9,28,0,100,84,153,84,212,163,78,135,33,66,20,195,223,62,214,32,59,6,187,222,99,29,34,87,81,61,63,174,255,1,85,241,6,10,152,237,52,51,126,149,218,125,232,199,40,113,139,187,43,232,209,167,226,91,236,212,165,117,19,118,110,18,0,26,152,33,115,61,208,21]}"#).unwrap_or_default();
1394 assert_eq!(data_parsed, succesful_data)
1395 }
1396
1397 #[test]
1398 fn data_fragment_pack_test() {
1399 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1400 let data_to_pack =
1401 r#"{"sequence":2,"data":[2,1,1,0,0,0,1,1,3,0,0,0,115,111,101,0,0,0,0]}"#.to_string();
1402 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::DataFragment, data_to_pack);
1403 assert_eq!(
1404 data_pack,
1405 [0, 13, 0, 2, 2, 1, 1, 0, 0, 0, 1, 1, 3, 0, 0, 0, 115, 111, 101, 0, 0, 0, 0]
1406 )
1407 }
1408
1409 #[test]
1410 fn data_fragment_pack_test_deserializing_error() {
1411 let mut soeprotocol_class = super::Soeprotocol::initialize(false, 0);
1412 let data_to_pack = r#"{"data":[2,1,1,0,0,0,1,1,3,0,0,0,115,111,101,0,0,0,0]}"#.to_string();
1413 let data_pack: Vec<u8> = soeprotocol_class.pack(SoeOpcode::DataFragment, data_to_pack);
1414 let data_pack_opcode: u16 = u16::from_be_bytes([data_pack[0], data_pack[1]]);
1415 assert_eq!(data_pack_opcode, ErrorType::Deserializing as u16)
1416 }
1417}