First packet decoded

src/utils/buffer_reader.rs

@@ -1,9 +1,8 @@
 use crate::encoding::variable_byte_integer::VariableByteIntegerDecoder;
-use crate::encoding::variable_byte_integer::VariableByteIntegerError;
 use core::str;
 use core::mem;
 
-#[derive(Clone)]
+#[derive(Debug)]
 pub struct EncodedString<'a> {
     pub string: &'a str,
     pub len: u16
@@ -15,7 +14,7 @@ impl EncodedString<'_> {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug)]
 pub struct BinaryData<'a> {
     pub bin: &'a [u8],
     pub len: u16
@@ -27,7 +26,7 @@ impl BinaryData<'_> {
     }
 }
 
-#[derive(Clone)]
+#[derive(Debug)]
 pub struct StringPair<'a> {
     pub name: EncodedString<'a>,
     pub value: EncodedString<'a>
@@ -42,11 +41,13 @@ impl StringPair<'_> {
 
 #[derive(core::fmt::Debug)]
 #[derive(Clone)]
-pub enum ProperyParseError {
+pub enum ParseError {
     Utf8Error,
     IndexOutOfBounce,
     VariableByteIntegerError,
-    IdNotFound
+    IdNotFound,
+    EncodingError,
+    DecodingError
 }
 
 pub struct BuffReader<'a> {
@@ -63,35 +64,45 @@ impl<'a> BuffReader<'a> {
         return BuffReader { buffer: buffer, position: 0 };
     }
 
-    pub fn readVariableByteInt(& mut self) -> Result<u32, VariableByteIntegerError> { 
+    pub fn readVariableByteInt(& mut self) -> Result<u32, ParseError> { 
         let variable_byte_integer: [u8; 4] = [self.buffer[self.position], self.buffer[self.position + 1], self.buffer[self.position + 2], self.buffer[self.position + 3]];
-        self.incrementPosition(4);
+        let mut len: usize = 1;
+        if variable_byte_integer[0] & 0x80 == 1 { 
+            len = len + 1; 
+            if variable_byte_integer[1] & 0x80 == 1 { 
+                len = len + 1; 
+                if variable_byte_integer[2] & 0x80 == 1 { 
+                    len = len + 1; 
+                }
+            }
+        }
+        self.incrementPosition(len);
         return VariableByteIntegerDecoder::decode(variable_byte_integer);
     }
     
-    pub fn readU32(& mut self) -> Result<u32, ProperyParseError> {
-        let (int_bytes, rest) = self.buffer.split_at(mem::size_of::<u32>());
-        let ret: u32 = u32::from_le_bytes(int_bytes.try_into().unwrap());
+    pub fn readU32(& mut self) -> Result<u32, ParseError> {
+        let (int_bytes, rest) = self.buffer[self.position..].split_at(mem::size_of::<u32>());
+        let ret: u32 = u32::from_be_bytes(int_bytes.try_into().unwrap());
         //let ret: u32 = (((self.buffer[self.position] as u32) << 24) | ((self.buffer[self.position + 1] as u32) << 16) | ((self.buffer[self.position + 2] as u32) << 8) | (self.buffer[self.position + 3] as u32)) as u32;
         self.incrementPosition(4);
         return Ok(ret);
     }
     
-    pub fn readU16(& mut self) -> Result<u16, ProperyParseError> {
-        let (int_bytes, rest) = self.buffer.split_at(mem::size_of::<u16>());
-        let ret: u16 =  u16::from_le_bytes(int_bytes.try_into().unwrap());
+    pub fn readU16(& mut self) -> Result<u16, ParseError> {
+        let (int_bytes, rest) = self.buffer[self.position..].split_at(mem::size_of::<u16>());
+        let ret: u16 =  u16::from_be_bytes(int_bytes.try_into().unwrap());
         //(((self.buffer[self.position] as u16) << 8) | (self.buffer[self.position + 1] as u16)) as u16;
         self.incrementPosition(2);
         return Ok(ret);
     }
     
-    pub fn readU8(& mut self) -> Result<u8, ProperyParseError> {
+    pub fn readU8(& mut self) -> Result<u8, ParseError> {
         let ret: u8 = self.buffer[self.position];
         self.incrementPosition(1);
         return Ok(ret);
     }
     
-    pub fn readString(& mut self) -> Result<EncodedString<'a>, ProperyParseError> {
+    pub fn readString(& mut self) -> Result<EncodedString<'a>, ParseError> {
         let len = self.readU16();
         match len {
             Err(err) => return Err(err),
@@ -101,13 +112,13 @@ impl<'a> BuffReader<'a> {
         let res_str = str::from_utf8(&(self.buffer[self.position..(self.position + len_res as usize)]));
         if res_str.is_err() {
             log::error!("Could not parse utf-8 string");
-            return Err(ProperyParseError::Utf8Error);
+            return Err(ParseError::Utf8Error);
         }
         return Ok(EncodedString { string: res_str.unwrap(), len: len_res });
     }
     
     //TODO: Index out of bounce err !!!!!
-    pub fn readBinary(& mut self) -> Result<BinaryData<'a>, ProperyParseError> {
+    pub fn readBinary(& mut self) -> Result<BinaryData<'a>, ParseError> {
         let len = self.readU16();
         match len {
             Err(err) => return Err(err),
@@ -118,7 +129,7 @@ impl<'a> BuffReader<'a> {
         return Ok(BinaryData { bin: res_bin, len: len_res });
     }
     
-    pub fn readStringPair(& mut self) -> Result<StringPair<'a>, ProperyParseError> {
+    pub fn readStringPair(& mut self) -> Result<StringPair<'a>, ParseError> {
         let name = self.readString();
         match name {
             Err(err) => return Err(err),