g_rust/protocol/
hpacket.rs1use encoding::all::ISO_8859_1;
2use encoding::{DecoderTrap, EncoderTrap, Encoding};
3use crate::services::packetinfo::packetinfomanager::PacketInfoManager;
4use super::hdirection::HDirection;
5use super::vars::packetvariable::PacketVariable;
6
7#[derive(Debug, Clone, Eq, PartialEq)]
8pub struct HPacket {
9 is_edited: bool,
10 packet_in_bytes: Vec<u8>,
11 pub read_index: usize,
12
13 pub identifier: String,
14 pub identifier_direction: HDirection
15}
16
17impl Default for HPacket {
18 fn default() -> Self {
19 HPacket {
20 is_edited: false,
21 packet_in_bytes: vec![0, 0, 0, 2, 0, 0],
22 read_index: 6,
23 identifier: String::from(""),
24 identifier_direction: HDirection::None
25 }
26 }
27}
28
29impl HPacket {
30 pub fn from_bytes(bytes: Vec<u8>) -> Self {
31 let mut res = HPacket::default();
32 res.packet_in_bytes = bytes.clone();
33 res.fix_length();
34 res
35 }
36
37 pub fn from_packet(packet: HPacket) -> Self {
38 let mut res = HPacket::default();
39 res.packet_in_bytes = packet.packet_in_bytes.clone();
40 res.is_edited = packet.is_edited;
41 res
42 }
43
44 pub fn from_header_id(header_id: i16) -> Self {
45 let mut res = HPacket::default();
46 res.replace::<i16>(4, header_id);
47 res.is_edited = false;
48 res
49 }
50
51 pub fn from_header_id_and_bytes(header_id: i16, bytes: Vec<u8>) -> Self {
52 let mut res = Self::from_header_id(header_id);
53 res.append_bytes(bytes);
54 res.is_edited = false;
55 res
56 }
57
58 pub fn from_identifier_and_direction(identifier: String, direction: HDirection) -> HPacket {
59 let mut res = HPacket::default();
60 res.identifier = identifier.clone();
61 res.identifier_direction = direction.clone();
62 res
63 }
64
65 pub fn from_string(s: String) -> HPacket {
66 let mut res = HPacket::default();
67 res.is_edited = s.chars().nth(0).unwrap() == '1';
68 res.packet_in_bytes = ISO_8859_1.encode(&s[1..], EncoderTrap::Ignore).unwrap();
69 res
70 }
71
72 pub fn get_bytes_available(&mut self) -> usize {
73 self.packet_in_bytes.len() - self.read_index
74 }
75
76 pub fn eof(&mut self) -> i8 {
77 if self.read_index < self.packet_in_bytes.len() { 0 }
78 else if self.read_index > self.packet_in_bytes.len() { 2 }
79 else { 1 }
80 }
81
82 pub(crate) fn can_complete(&mut self, manager: PacketInfoManager) -> bool {
83 if self.is_corrupted() || self.identifier == "" || self.identifier_direction == HDirection::None {
84 return false;
85 }
86
87 let packet_info = manager.clone()
88 .get_packet_info_from_name(self.identifier_direction.clone(), self.identifier.clone())
89 .or(manager.clone().get_packet_info_from_hash(self.identifier_direction.clone(), self.identifier.clone()));
90
91 return packet_info.is_some();
92 }
93
94 pub fn can_send_to_client(&mut self) -> bool {
95 self.identifier_direction == HDirection::ToClient
96 }
97
98 pub fn can_send_to_server(&mut self) -> bool {
99 self.identifier_direction == HDirection::ToServer
100 }
101
102 pub(crate) fn complete_packet(&mut self, manager: PacketInfoManager) {
103 if self.is_corrupted() || self.identifier == "" || self.identifier_direction == HDirection::None {
104 return;
105 }
106
107 let packet_info = manager.clone()
108 .get_packet_info_from_name(self.identifier_direction.clone(), self.identifier.clone())
109 .or(manager.clone().get_packet_info_from_hash(self.identifier_direction.clone(), self.identifier.clone()));
110
111 if packet_info.is_none() {
112 return;
113 }
114
115 self.replace(4, packet_info.unwrap().header_id as u16);
116 }
117
118 pub fn is_complete(&mut self) -> bool {
119 self.identifier == ""
120 }
121
122 pub fn get_bytes(&self) -> Vec<u8> {
123 self.packet_in_bytes.clone()
124 }
125
126 pub fn reset_read_index(&mut self) {
127 self.read_index = 6;
128 }
129
130 pub fn is_corrupted(&mut self) -> bool {
131 !(self.bytes_length() >= 6 && self.length() == self.bytes_length() - 4)
132 }
133
134 pub fn length(&mut self) -> usize {
135 self.read_at::<i32>(0) as usize
136 }
137
138 pub fn bytes_length(&self) -> usize {
139 self.packet_in_bytes.len()
140 }
141
142 pub fn header_id(&mut self) -> i16 {
143 self.read_at::<i16>(4)
144 }
145
146 fn fix_length(&mut self) {
147 self.replace_internal::<i32>(0, self.bytes_length() as i32 - 4);
148 }
149
150 pub fn read_bytes(&mut self, length: usize) -> Vec<u8> {
151 self.read_index += length;
152 self.packet_in_bytes[self.read_index-length..self.read_index].to_vec()
153 }
154
155 pub fn read_bytes_at(&mut self, length: usize, index: usize) -> Vec<u8> {
156 self.packet_in_bytes[index..index+length].to_vec()
157 }
158
159 pub fn read<T: PacketVariable>(&mut self) -> T {
160 let bytes = self.packet_in_bytes[self.read_index..].to_vec();
161 let (res, size) = T::from_packet(bytes.clone());
162 self.read_index += size;
163 res
164 }
165
166 pub fn read_at<T: PacketVariable>(&mut self, index: usize) -> T {
167 let bytes = self.packet_in_bytes[index..].to_vec();
168 T::from_packet(bytes.clone()).0
169 }
170
171 pub fn append_bytes(&mut self, bytes: Vec<u8>) {
172 self.packet_in_bytes.extend(bytes);
173 self.is_edited = true;
174 self.fix_length();
175 }
176
177 pub fn append<T: PacketVariable>(&mut self, v: T) {
178 let bytes = v.to_packet();
179 self.packet_in_bytes.extend(bytes);
180 self.is_edited = true;
181 self.fix_length();
182 }
183
184 pub fn replace_bytes(&mut self, index: usize, bytes: Vec<u8>) {
185 let mut res = self.packet_in_bytes[..index].to_vec();
186 res.extend(bytes.clone());
187 res.extend(self.packet_in_bytes[index+bytes.len()..].to_vec());
188 self.packet_in_bytes = res.clone();
189 self.is_edited = true;
190 self.fix_length();
191 }
192
193 fn replace_internal<T: PacketVariable>(&mut self, index: usize, v: T) {
194 let old_bytes = self.packet_in_bytes[index..].to_vec();
195 let (_, old_size) = T::from_packet(old_bytes.clone());
196 let mut res = self.packet_in_bytes[..index].to_vec();
197 res.extend(v.to_packet());
198 res.extend(old_bytes[old_size..].to_vec());
199 self.packet_in_bytes = res.clone();
200 }
201
202 pub fn replace<T: PacketVariable>(&mut self, index: usize, v: T) {
203 self.replace_internal(index, v);
204 self.is_edited = true;
205 self.fix_length();
206 }
207
208 pub fn insert_bytes(&mut self, index: usize, bytes: Vec<u8>) {
209 let mut res = self.packet_in_bytes[..index].to_vec();
210 res.extend(bytes);
211 res.extend(self.packet_in_bytes[index..].to_vec());
212 self.packet_in_bytes = res.clone();
213 self.is_edited = true;
214 self.fix_length();
215 }
216
217 pub fn insert<T: PacketVariable>(&mut self, index: usize, v: T) {
218 let mut res = self.packet_in_bytes[..index].to_vec();
219 res.extend(v.to_packet());
220 res.extend(self.packet_in_bytes[index..].to_vec());
221 self.packet_in_bytes = res.clone();
222 }
223
224 pub fn stringify(&self) -> String {
225 if self.is_edited { "1" } else { "0" }.to_string() + &*ISO_8859_1.decode(&self.packet_in_bytes[..], DecoderTrap::Ignore).unwrap()
226 }
227}