add error handling

1 files changed, 80 insertions, 69 deletions

diff --git a/src/protocol/primitive/basic.rs b/src/protocol/primitive/basic.rs
index 30de1c7..15b712f 100644
--- a/src/protocol/primitive/basic.rs
+++ b/src/protocol/primitive/basic.rs
@@ -29,122 +29,133 @@ pub const UCHAR: u32        = 0x00000086; // uint8_t
 
 extern crate byteorder;
 use std::io::Cursor;
-use byteorder::{ByteOrder, BigEndian, ReadBytesExt};
+use byteorder::{BigEndian, ReadBytesExt};
 
-use std::io::Read;
 use std::vec::Vec;
+use std::result::Result;
 use std::convert::TryInto;
 
 use crate::util;
+use crate::protocol::error::ErrorKind;
 use crate::protocol::primitive::{deserialize, serialize, qread};
 
 impl deserialize::Deserialize for bool {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        if b[0] == 0 { return (1, false) } else { return (1, true) };
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        if b[0] == 0 {
+            return Ok((1, false))
+        } else if b[0] == 1 {
+            return Ok((1, true))
+        } else {
+            return Err(ErrorKind::BoolOutOfRange);
+        };
     }
 }
 
 impl qread::QRead for bool {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
-        s.read(&mut b[0..1]).unwrap()
+    fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+        Ok(s.read(&mut b[0..1])?)
     }
 }
 
 impl deserialize::Deserialize for u64 {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        return (8, BigEndian::read_u64(b));
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        let mut rdr = Cursor::new(&b[0..8]);
+        return Ok((8, rdr.read_u64::<BigEndian>()?));
     }
 }
 
 impl qread::QRead for u64 {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
-        s.read(&mut b[0..8]).unwrap()
+    fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+        Ok(s.read(&mut b[0..8])?)
     }
 }
 
 impl deserialize::Deserialize for u32 {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        // self = &rdr.read_u32::<BigEndian>().unwrap()
-        return (4, BigEndian::read_u32(b));
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        let mut rdr = Cursor::new(&b[0..4]);
+        return Ok((4, rdr.read_u32::<BigEndian>()?));
     }
 }
 
 impl qread::QRead for u32 {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
-        s.read(&mut b[0..4]).unwrap()
+    fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+        Ok(s.read(&mut b[0..4])?)
     }
 }
 
 impl deserialize::Deserialize for u16 {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        return (2, BigEndian::read_u16(b));
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        let mut rdr = Cursor::new(&b[0..2]);
+        return Ok((2, rdr.read_u16::<BigEndian>()?));
     }
 }
 
 impl qread::QRead for u16 {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
-        s.read(&mut b[0..2]).unwrap()
+    fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+        Ok(s.read(&mut b[0..2])?)
     }
 }
 
 impl deserialize::Deserialize for u8 {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        return (1, b[0]);
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        return Ok((1, b[0]));
     }
 }
 
 impl qread::QRead for u8 {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
-        s.read(&mut [b[0]]).unwrap()
+    fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+        Ok(s.read(&mut [b[0]])?)
     }
 }
 
 impl deserialize::Deserialize for i64 {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        return (8, BigEndian::read_i64(b));
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        let mut rdr = Cursor::new(&b[0..8]);
+        return Ok((8, rdr.read_i64::<BigEndian>()?));
     }
 }
 
 impl qread::QRead for i64 {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
-        s.read(&mut b[0..8]).unwrap()
+    fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+        Ok(s.read(&mut b[0..8])?)
     }
 }
 
 impl deserialize::Deserialize for i32 {
-    fn parse(b: &[u8]) -> (usize, Self) {
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
         let mut rdr = Cursor::new(&b[0..4]);
-        return (4, rdr.read_i32::<BigEndian>().unwrap());
+        return Ok((4, rdr.read_i32::<BigEndian>()?));
     }
 }
 
 impl qread::QRead for i32 {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
-        s.read(&mut b[0..4]).unwrap()
+    fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+        Ok(s.read(&mut b[0..4])?)
     }
 }
 
 impl deserialize::Deserialize for i16 {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        return (2, BigEndian::read_i16(b));
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        let mut rdr = Cursor::new(&b[0..2]);
+        return Ok((2, rdr.read_i16::<BigEndian>()?));
     }
 }
 
 impl qread::QRead for i16 {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
-        s.read(&mut b[0..2]).unwrap()
+    fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+        Ok(s.read(&mut b[0..2])?)
     }
 }
 
 impl deserialize::Deserialize for i8 {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        return (1, b[0].try_into().unwrap());
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        return Ok((1, b[0].try_into()?));
     }
 }
 
 impl qread::QRead for i8 {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
-        s.read(&mut [b[0]]).unwrap()
+    fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+        return Ok(s.read(&mut [b[0]])?)
     }
 }
 
@@ -152,7 +163,7 @@ impl qread::QRead for i8 {
 
 pub type String = std::string::String;
 impl serialize::Serialize for String {
-    fn serialize(&self) -> Vec<u8> {
+    fn serialize(&self) -> Result<Vec<u8>, ErrorKind> {
         let mut res: Vec<u8> = Vec::new();
 
         let utf16: Vec<u16> = self.encode_utf16().collect();
@@ -161,109 +172,109 @@ impl serialize::Serialize for String {
         }
 
         util::prepend_byte_len(&mut res);
-        return res;
+        return Ok(res);
     }
 }
 
 impl serialize::SerializeUTF8 for String {
-    fn serialize_utf8(&self) -> Vec<u8> {
+    fn serialize_utf8(&self) -> Result<Vec<u8>, ErrorKind> {
         let mut res: Vec<u8> = Vec::new();
         res.extend(self.clone().into_bytes());
         util::prepend_byte_len(&mut res);
-        return res;
+        return Ok(res);
     }
 }
 
 impl deserialize::Deserialize for String {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        let (_, len) = i32::parse(&b[0..4]);
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        let (_, len) = i32::parse(&b[0..4])?;
 
         let ulen = len as usize;
         let mut pos: usize = 4;
         let mut chars: Vec<u16> = Vec::new();
         loop {
             if pos >= (ulen + 4) { break; }
-            let (slen, uchar) = u16::parse(&b[pos..(pos+2)]);
+            let (slen, uchar) = u16::parse(&b[pos..(pos+2)])?;
             chars.push(uchar);
             pos += slen;
         }
 
         let res: String = String::from_utf16(&chars).unwrap();
-        return (pos, res);
+        return Ok((pos, res));
     }
 }
 
 impl deserialize::DeserializeUTF8 for String {
-    fn parse_utf8(b: &[u8]) -> (usize, Self) {
+    fn parse_utf8(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
         use crate::protocol::primitive::deserialize::Deserialize;
-        let (_, len) = i32::parse(&b[0..4]);
+        let (_, len) = i32::parse(&b[0..4])?;
 
         let ulen = len as usize;
 
-        let res: String = String::from_utf8(b[4..(ulen+4)].to_vec()).unwrap();
-        return (ulen + 4, res);
+        let res: String = String::from_utf8(b[4..(ulen+4)].to_vec())?;
+        return Ok((ulen + 4, res));
     }
 }
 
 impl qread::QRead for String {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
+    fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
         use crate::protocol::primitive::deserialize::Deserialize;
 
-        s.read(&mut b[0..4]).unwrap();
-        let (_, len) = i32::parse(&b[0..4]);
+        s.read(&mut b[0..4])?;
+        let (_, len) = i32::parse(&b[0..4])?;
 
         let ulen = len as usize;
-        s.read(&mut b[4..(4+ulen)]).unwrap();
+        s.read(&mut b[4..(4+ulen)])?;
 
-        return 4 + ulen;
+        return Ok(4 + ulen);
     }
 }
 
 pub type StringList = Vec<String>;
 impl serialize::Serialize for StringList {
-    fn serialize(&self) -> Vec<u8> {
-        let len: i32 = self.len().try_into().unwrap();
+    fn serialize(&self) -> Result<Vec<u8>, ErrorKind> {
+        let len: i32 = self.len().try_into()?;
         let mut res: Vec<u8> = Vec::new();
 
         res.extend(len.to_be_bytes().iter());
         for x in self {
-            res.extend(x.serialize());
+            res.extend(x.serialize()?);
         }
 
-        return res;
+        return Ok(res);
     }
 }
 
 impl deserialize::Deserialize for StringList {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        let (_, len) = i32::parse(&b[0..4]);
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        let (_, len) = i32::parse(&b[0..4])?;
         let mut res: StringList = StringList::new();
 
         let mut pos = 4;
         if len > 0 {
             for _ in 0..len {
-                let (lpos, val) = String::parse(&b[pos..]);
+                let (lpos, val) = String::parse(&b[pos..])?;
                 pos += lpos;
                 res.push(val);
             }
         }
 
-        return (pos, res);
+        return Ok((pos, res));
     }
 }
 
 impl qread::QRead for StringList {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
+    fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
         use crate::protocol::primitive::deserialize::Deserialize;
 
-        s.read(&mut b[0..4]).unwrap();
-        let (_, len) = i32::parse(&b[0..4]);
+        s.read(&mut b[0..4])?;
+        let (_, len) = i32::parse(&b[0..4])?;
 
         let mut pos: usize = 4;
         for _ in 0..len {
-            pos += String::read(s, &mut b[pos..]);
+            pos += String::read(s, &mut b[pos..])?;
         }
 
-        return pos;
+        return Ok(pos);
     }
 }