add error handling

7 files changed, 299 insertions, 211 deletions

diff --git a/src/protocol/error/mod.rs b/src/protocol/error/mod.rs
new file mode 100644
index 0000000..488ae0d
--- /dev/null
+++ b/src/protocol/error/mod.rs
@@ -0,0 +1,28 @@
+#[derive(Debug)]
+pub enum ErrorKind {
+    WrongMsgType,
+    BoolOutOfRange,
+    UnknownVariant,
+    WrongVariant,
+    IOError(std::io::Error),
+    TryFromIntError(std::num::TryFromIntError),
+    Utf8Error(std::string::FromUtf8Error),
+}
+
+impl std::convert::From<std::io::Error> for ErrorKind {
+    fn from(error: std::io::Error) -> Self {
+        ErrorKind::IOError(error)
+    }
+}
+
+impl std::convert::From<std::num::TryFromIntError> for ErrorKind {
+    fn from(error: std::num::TryFromIntError) -> Self {
+        ErrorKind::TryFromIntError(error)
+    }
+}
+
+impl std::convert::From<std::string::FromUtf8Error> for ErrorKind {
+    fn from(error: std::string::FromUtf8Error) -> Self {
+        ErrorKind::Utf8Error(error)
+    }
+}
diff --git a/src/protocol/message/handshake.rs b/src/protocol/message/handshake.rs
index b346d8e..7713ed9 100644
--- a/src/protocol/message/handshake.rs
+++ b/src/protocol/message/handshake.rs
@@ -1,5 +1,7 @@
+use std::result::Result;
+
+use crate::protocol::error::ErrorKind;
 use crate::protocol::primitive::{String, StringList, Variant, VariantList};
-use crate::protocol::primitive::{serialize, deserialize, qread};
 
 mod types;
 pub use types::{VariantMap, HandshakeDeserialize, HandshakeSerialize, HandshakeQRead};
@@ -14,7 +16,7 @@ pub struct ClientInit {
 }
 
 impl HandshakeSerialize for ClientInit {
-    fn serialize(&self) -> Vec<u8> {
+    fn serialize(&self) -> Result<Vec<u8>, ErrorKind> {
         let mut values: VariantMap = VariantMap::with_capacity(5);
         values.insert("MsgType".to_string(), Variant::String("ClientInit".to_string()));
         values.insert("ClientVersion".to_string(), Variant::String(self.client_version.clone()));
@@ -26,15 +28,27 @@ impl HandshakeSerialize for ClientInit {
 }
 
 impl HandshakeDeserialize for ClientInit {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        let (len, values): (usize, VariantMap) = HandshakeDeserialize::parse(b);
-
-        return (len, Self {
-            client_version: match_variant!(values, Variant::String, "ClientVersion"),
-            client_date: match_variant!(values, Variant::String, "ClientDate"),
-            feature_list: match_variant!(values, Variant::StringList, "FeatureList"),
-            client_features: match_variant!(values, Variant::u32, "Features")
-        });
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        let (len, values): (usize, VariantMap) = HandshakeDeserialize::parse(b)?;
+
+        let msgtypev = &values["MsgType"];
+        let msgtype;
+        match msgtypev {
+            Variant::String(x) => msgtype = x,
+            Variant::StringUTF8(x) => msgtype = x,
+            _ => return Err(ErrorKind::WrongVariant)
+        };
+
+        if msgtype == "ClientInit" {
+            return Ok((len, Self {
+                client_version: match_variant!(values, Variant::String, "ClientVersion"),
+                client_date: match_variant!(values, Variant::String, "ClientDate"),
+                feature_list: match_variant!(values, Variant::StringList, "FeatureList"),
+                client_features: match_variant!(values, Variant::u32, "Features")
+            }));
+        } else {
+            return Err(ErrorKind::WrongMsgType);
+        }
     }
 }
 
@@ -44,7 +58,7 @@ pub struct ClientInitReject {
 }
 
 impl HandshakeSerialize for ClientInitReject {
-    fn serialize(&self) -> Vec<u8> {
+    fn serialize(&self) -> Result<Vec<u8>, ErrorKind> {
         let mut values: VariantMap = VariantMap::with_capacity(2);
         values.insert("MsgType".to_string(), Variant::String("ClientInitReject".to_string()));
         values.insert("ErrorString".to_string(), Variant::String(self.error_string.clone()));
@@ -53,12 +67,24 @@ impl HandshakeSerialize for ClientInitReject {
 }
 
 impl HandshakeDeserialize for ClientInitReject {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        let (len, values): (usize, VariantMap) = HandshakeDeserialize::parse(b);
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        let (len, values): (usize, VariantMap) = HandshakeDeserialize::parse(b)?;
 
-        return (len, Self {
-            error_string: match_variant!(values, Variant::String, "ErrorString")
-        });
+        let msgtypev = &values["MsgType"];
+        let msgtype;
+        match msgtypev {
+            Variant::String(x) => msgtype = x,
+            Variant::StringUTF8(x) => msgtype = x,
+            _ => return Err(ErrorKind::WrongVariant)
+        };
+
+        if msgtype == "ClientInitReject" {
+            return Ok((len, Self {
+                error_string: match_variant!(values, Variant::String, "ErrorString")
+            }));
+        } else {
+            return Err(ErrorKind::WrongMsgType);
+        }
     }
 }
 
@@ -72,7 +98,7 @@ pub struct ClientInitAck {
 }
 
 impl HandshakeSerialize for ClientInitAck {
-    fn serialize(&self) -> Vec<u8> {
+    fn serialize(&self) -> Result<Vec<u8>, ErrorKind> {
         let mut values: VariantMap = VariantMap::with_capacity(2);
         values.insert("MsgType".to_string(), Variant::String("ClientInitAck".to_string()));
         values.insert("CoreFeatures".to_string(), Variant::u32(self.core_features));
@@ -85,15 +111,27 @@ impl HandshakeSerialize for ClientInitAck {
 }
 
 impl HandshakeDeserialize for ClientInitAck {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        let (len, values): (usize, VariantMap) = HandshakeDeserialize::parse(b);
-
-        return (len, Self {
-            core_features: 0x00008000,
-            core_configured: match_variant!(values, Variant::bool, "Configured"),
-            storage_backends: match_variant!(values, Variant::VariantList, "StorageBackends"),
-            authenticators: match_variant!(values, Variant::VariantList, "Authenticators"),
-            feature_list: match_variant!(values, Variant::StringList, "FeatureList")
-        });
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        let (len, values): (usize, VariantMap) = HandshakeDeserialize::parse(b)?;
+
+        let msgtypev = &values["MsgType"];
+        let msgtype;
+        match msgtypev {
+            Variant::String(x) => msgtype = x,
+            Variant::StringUTF8(x) => msgtype = x,
+            _ => return Err(ErrorKind::WrongVariant)
+        };
+
+        if msgtype == "ClientInitAck" {
+            return Ok((len, Self {
+                core_features: 0x00008000,
+                core_configured: match_variant!(values, Variant::bool, "Configured"),
+                storage_backends: match_variant!(values, Variant::VariantList, "StorageBackends"),
+                authenticators: match_variant!(values, Variant::VariantList, "Authenticators"),
+                feature_list: match_variant!(values, Variant::StringList, "FeatureList")
+            }));
+        } else {
+            return Err(ErrorKind::WrongMsgType);
+        }
     }
 }
diff --git a/src/protocol/message/handshake/types.rs b/src/protocol/message/handshake/types.rs
index dadd058..be290e9 100644
--- a/src/protocol/message/handshake/types.rs
+++ b/src/protocol/message/handshake/types.rs
@@ -1,5 +1,6 @@
 use std::io::Read;
 use std::vec::Vec;
+use std::result::Result;
 use std::convert::TryInto;
 use std::collections::HashMap;
 
@@ -8,82 +9,83 @@ use crate::protocol::primitive::{String, Variant};
 use crate::protocol::primitive::serialize::Serialize;
 use crate::protocol::primitive::deserialize::Deserialize;
 use crate::protocol::primitive::qread::QRead;
+use crate::protocol::error::ErrorKind;
 
 pub trait HandshakeSerialize {
-    fn serialize(&self) -> Vec<u8>;
+    fn serialize(&self) -> Result<Vec<u8>, ErrorKind>;
 }
 
 pub trait HandshakeDeserialize {
-    fn parse(b: &[u8]) -> (usize, Self);
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> where Self: std::marker::Sized ;
 }
 
 pub trait HandshakeQRead {
-    fn read<T: Read>(stream: &mut T, buf: &mut [u8]) -> usize;
+    fn read<T: Read>(stream: &mut T, buf: &mut [u8]) -> Result<usize, ErrorKind>;
 }
 
 pub type VariantMap = HashMap<String, Variant>;
 
 impl HandshakeSerialize for VariantMap {
-    fn serialize<'a>(&'a self) -> Vec<u8> {
+    fn serialize<'a>(&'a self) -> Result<Vec<u8>, ErrorKind> {
         let mut res: Vec<u8> = Vec::new();
 
         for (k, v) in self {
             let key = Variant::String(k.clone());
-            res.extend(key.serialize());
-            res.extend(v.serialize());
+            res.extend(key.serialize()?);
+            res.extend(v.serialize()?);
         }
 
         util::insert_bytes(0, &mut res, &mut [0, 0, 0, 10]);
 
-        let len: i32 = res.len().try_into().unwrap();
+        let len: i32 = res.len().try_into()?;
         util::insert_bytes(0, &mut res, &mut ((len).to_be_bytes()));
 
-        return res;
+        return Ok(res);
     }
 }
 
 impl HandshakeDeserialize for VariantMap {
-    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 pos: usize = 8;
         let mut map = VariantMap::new();
         let ulen: usize = len as usize;
         loop {
             if (pos) >= ulen { break; }
-            let (nlen, name) = Variant::parse(&b[pos..]);
+            let (nlen, name) = Variant::parse(&b[pos..])?;
             pos += nlen;
 
-            let (vlen, value) = Variant::parse(&b[pos..]);
+            let (vlen, value) = Variant::parse(&b[pos..])?;
             pos += vlen;
 
             match name {
                 Variant::String(x) => map.insert(x, value),
                 Variant::StringUTF8(x) => map.insert(x, value),
-                _ => panic!()
+                _ => return Err(ErrorKind::WrongVariant)
             };
         }
 
-        return (pos, map);
+        return Ok((pos, map));
     }
 }
 
 impl HandshakeQRead for VariantMap {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
-        s.read(&mut b[0..4]).unwrap();
-        let (_, len) = i32::parse(&b[0..4]);
+    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+        s.read(&mut b[0..4])?;
+        let (_, len) = i32::parse(&b[0..4])?;
 
         // Read the 00 00 00 0a VariantType bytes and discard
-        s.read(&mut b[4..8]).unwrap();
+        s.read(&mut b[4..8])?;
 
         let mut pos = 8;
         let len: usize = len as usize;
         loop {
             if pos >= (len - 4) { break; }
-            pos += Variant::read(s, &mut b[pos..]);
-            pos += Variant::read(s, &mut b[pos..]);
+            pos += Variant::read(s, &mut b[pos..])?;
+            pos += Variant::read(s, &mut b[pos..])?;
         }
 
-        return pos;
+        return Ok(pos);
     }
 }
diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index 044a28b..8739fd8 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -1,2 +1,3 @@
 pub mod message;
 pub mod primitive;
+pub mod error;
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);
     }
 }
diff --git a/src/protocol/primitive/mod.rs b/src/protocol/primitive/mod.rs
index 2cdd20a..42f6aae 100644
--- a/src/protocol/primitive/mod.rs
+++ b/src/protocol/primitive/mod.rs
@@ -5,26 +5,33 @@ pub mod variant;
 pub use basic::*;
 pub use variant::*;
 
+
 pub mod serialize {
+    use crate::protocol::error::ErrorKind;
+
     pub trait Serialize {
-        fn serialize(&self) -> Vec<u8>;
+        fn serialize(&self) -> Result<Vec<u8>, ErrorKind>;
     }
     pub trait SerializeUTF8 {
-        fn serialize_utf8(&self) -> Vec<u8>;
+        fn serialize_utf8(&self) -> Result<Vec<u8>, ErrorKind>;
     }
 }
 
 pub mod deserialize {
+    use crate::protocol::error::ErrorKind;
+
     pub trait Deserialize {
-        fn parse(b: &[u8]) -> (usize, Self);
+        fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> where Self: std::marker::Sized ;
     }
     pub trait DeserializeUTF8 {
-        fn parse_utf8(b: &[u8]) -> (usize, Self);
+        fn parse_utf8(b: &[u8]) -> Result<(usize, Self), ErrorKind> where Self: std::marker::Sized ;
     }
 }
 
 pub mod qread {
+    use crate::protocol::error::ErrorKind;
+
     pub trait QRead {
-        fn read<T: std::io::Read>(stream: &mut T, buf: &mut [u8]) -> usize;
+        fn read<T: std::io::Read>(stream: &mut T, buf: &mut [u8]) -> Result<usize, ErrorKind>;
     }
 }
diff --git a/src/protocol/primitive/variant.rs b/src/protocol/primitive/variant.rs
index fdf93ad..8c6173f 100644
--- a/src/protocol/primitive/variant.rs
+++ b/src/protocol/primitive/variant.rs
@@ -8,60 +8,61 @@ use crate::protocol::primitive::serialize::{Serialize, SerializeUTF8};
 use crate::protocol::primitive::deserialize::{Deserialize, DeserializeUTF8};
 use crate::protocol::primitive::qread::QRead;
 use crate::protocol::primitive::{String,StringList};
+use crate::protocol::error::ErrorKind;
 use crate::protocol::primitive;
 
 pub type VariantMap = HashMap<String, Variant>;
 
 impl Serialize for VariantMap {
-    fn serialize<'a>(&'a self) -> Vec<u8> {
+    fn serialize<'a>(&'a self) -> Result<Vec<u8>, ErrorKind> {
         let mut res: Vec<u8> = Vec::new();
 
         for (k, v) in self {
-            res.extend(k.serialize());
-            res.extend(v.serialize());
+            res.extend(k.serialize()?);
+            res.extend(v.serialize()?);
         }
 
-        let len: i32 = self.len().try_into().unwrap();
+        let len: i32 = self.len().try_into()?;
         util::insert_bytes(0, &mut res, &mut len.to_be_bytes());
 
-        return res;
+        return Ok(res);
     }
 }
 
 impl Deserialize for VariantMap {
-    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 pos = 4;
         let mut map = VariantMap::new();
         for _ in 0..len {
-            let (nlen, name) = String::parse(&b[(pos)..]);
+            let (nlen, name) = String::parse(&b[(pos)..])?;
             pos += nlen;
 
-            let (vlen, value) = Variant::parse(&b[(pos)..]);
+            let (vlen, value) = Variant::parse(&b[(pos)..])?;
             pos += vlen;
 
             map.insert(name, value);
         }
 
-        return (pos, map);
+        return Ok((pos, map));
     }
 }
 
 impl QRead for VariantMap {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
-        s.read(&mut b[0..4]).unwrap();
+    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+        s.read(&mut b[0..4])?;
 
 
-        let (_, len) = i32::parse(&b[0..4]);
+        let (_, len) = i32::parse(&b[0..4])?;
 
         let mut pos = 4;
         for _ in 0..len {
-            pos += String::read(s, &mut b[pos..]);
-            pos += Variant::read(s, &mut b[(pos+3..)]);
+            pos += String::read(s, &mut b[pos..])?;
+            pos += Variant::read(s, &mut b[(pos+3..)])?;
         }
 
-        return pos;
+        return Ok(pos);
     }
 }
 
@@ -69,47 +70,47 @@ impl QRead for VariantMap {
 pub type VariantList = Vec<Variant>;
 
 impl Serialize for VariantList {
-    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 v in self {
-            res.extend(v.serialize().iter());
+            res.extend(v.serialize()?.iter());
         }
 
-        return res;
+        return Ok(res);
     }
 }
 
 impl Deserialize for VariantList {
-    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: VariantList = VariantList::new();
         let mut pos: usize = 4;
         for _ in 0..len {
-            let (vlen, val) = Variant::parse(&b[pos..]);
+            let (vlen, val) = Variant::parse(&b[pos..])?;
             res.push(val);
             pos += vlen;
         }
 
-        return (pos, res);
+        return Ok((pos, res));
     }
 }
 
 impl QRead for VariantList {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
-        s.read(&mut b[0..4]).unwrap();
+    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
+        s.read(&mut b[0..4])?;
 
-        let (_, len) = i32::parse(&b[0..4]);
+        let (_, len) = i32::parse(&b[0..4])?;
 
         let mut pos = 4;
         for _ in 0..len {
-            pos += Variant::read(s, &mut b[(pos+3..)]);
+            pos += Variant::read(s, &mut b[(pos+3..)])?;
         }
 
-        return pos;
+        return Ok(pos);
     }
 }
 
@@ -135,38 +136,38 @@ pub enum Variant {
 }
 
 impl Serialize for Variant {
-    fn serialize(&self) -> Vec<u8> {
+    fn serialize(&self) -> Result<Vec<u8>, ErrorKind> {
         let unknown: u8 = 0x00;
         let mut res: Vec<u8> = Vec::new();
 
         match self {
             Variant::Unknown => {
-               return res;
+               return Err(ErrorKind::UnknownVariant);
             },
             Variant::VariantMap(v) => {
                 res.extend(primitive::QVARIANTMAP.to_be_bytes().iter());
                 res.extend(unknown.to_be_bytes().iter());
-                res.extend(v.serialize().iter());
+                res.extend(v.serialize()?.iter());
             },
             Variant::VariantList(v) => {
                 res.extend(primitive::QVARIANTLIST.to_be_bytes().iter());
                 res.extend(unknown.to_be_bytes().iter());
-                res.extend(v.serialize().iter());
+                res.extend(v.serialize()?.iter());
             },
             Variant::String(v) => {
                 res.extend(primitive::QSTRING.to_be_bytes().iter());
                 res.extend(unknown.to_be_bytes().iter());
-                res.extend(v.serialize().iter());
+                res.extend(v.serialize()?.iter());
             },
             Variant::StringUTF8(v) => {
                 res.extend(primitive::QBYTEARRAY.to_be_bytes().iter());
                 res.extend(unknown.to_be_bytes().iter());
-                res.extend(v.serialize_utf8().iter());
+                res.extend(v.serialize_utf8()?.iter());
             },
             Variant::StringList(v) => {
                 res.extend(primitive::QSTRINGLIST.to_be_bytes().iter());
                 res.extend(unknown.to_be_bytes().iter());
-                res.extend(v.serialize().iter());
+                res.extend(v.serialize()?.iter());
             },
             Variant::bool(v) => {
                 res.extend(primitive::BOOL.to_be_bytes().iter());
@@ -216,13 +217,13 @@ impl Serialize for Variant {
             },
         }
 
-        return res
+        return Ok(res)
     }
 }
 
 impl Deserialize for Variant {
-    fn parse(b: &[u8]) -> (usize, Self) {
-        let (_, qtype) = i32::parse(&b[0..4]);
+    fn parse(b: &[u8]) -> Result<(usize, Self), ErrorKind> {
+        let (_, qtype) = i32::parse(&b[0..4])?;
         let qtype = qtype as u32;
 
         #[allow(unused_variables)]
@@ -231,96 +232,96 @@ impl Deserialize for Variant {
         let len = 5;
         match qtype {
             primitive::QVARIANTMAP => {
-                let (vlen, value) = VariantMap::parse(&b[len..]);
-                return (len+vlen, Variant::VariantMap(value));
+                let (vlen, value) = VariantMap::parse(&b[len..])?;
+                return Ok((len+vlen, Variant::VariantMap(value)));
             },
             primitive::QVARIANTLIST => {
-                let (vlen, value) = VariantList::parse(&b[len..]);
-                return (len+vlen, Variant::VariantList(value));
+                let (vlen, value) = VariantList::parse(&b[len..])?;
+                return Ok((len+vlen, Variant::VariantList(value)));
             },
             primitive::QSTRING => {
-                let (vlen, value) = String::parse(&b[len..]);
-                return (len+vlen, Variant::String(value.clone()));
+                let (vlen, value) = String::parse(&b[len..])?;
+                return Ok((len+vlen, Variant::String(value.clone())));
             },
             primitive::QBYTEARRAY => {
-                let (vlen, value) = String::parse_utf8(&b[len..]);
-                return (len+vlen, Variant::StringUTF8(value.clone()));
+                let (vlen, value) = String::parse_utf8(&b[len..])?;
+                return Ok((len+vlen, Variant::StringUTF8(value.clone())));
             },
             primitive::QSTRINGLIST => {
-                let (vlen, value) = StringList::parse(&b[len..]);
-                return (len+vlen, Variant::StringList(value.clone()));
+                let (vlen, value) = StringList::parse(&b[len..])?;
+                return Ok((len+vlen, Variant::StringList(value.clone())));
             },
             primitive::BOOL => {
-                let (vlen, value) = bool::parse(&b[len..]);
-                return (len+vlen, Variant::bool(value));
+                let (vlen, value) = bool::parse(&b[len..])?;
+                return Ok((len+vlen, Variant::bool(value)));
             },
             primitive::ULONG => {
-                let (vlen, value) = u64::parse(&b[len..]);
-                return (len+vlen, Variant::u64(value));
+                let (vlen, value) = u64::parse(&b[len..])?;
+                return Ok((len+vlen, Variant::u64(value)));
             },
             primitive::UINT => {
-                let (vlen, value) = u32::parse(&b[len..]);
-                return (len+vlen, Variant::u32(value));
+                let (vlen, value) = u32::parse(&b[len..])?;
+                return Ok((len+vlen, Variant::u32(value)));
             },
             primitive::USHORT => {
-                let (vlen, value) = u16::parse(&b[len..]);
-                return (len+vlen, Variant::u16(value));
+                let (vlen, value) = u16::parse(&b[len..])?;
+                return Ok((len+vlen, Variant::u16(value)));
             },
             primitive::UCHAR => {
-                let (vlen, value) = u8::parse(&b[len..]);
-                return (len+vlen, Variant::u8(value));
+                let (vlen, value) = u8::parse(&b[len..])?;
+                return Ok((len+vlen, Variant::u8(value)));
             },
             primitive::LONG => {
-                let (vlen, value) = i64::parse(&b[len..]);
-                return (len+vlen, Variant::i64(value));
+                let (vlen, value) = i64::parse(&b[len..])?;
+                return Ok((len+vlen, Variant::i64(value)));
             },
             primitive::INT => {
-                let (vlen, value) = i32::parse(&b[len..]);
-                return (len+vlen, Variant::i32(value));
+                let (vlen, value) = i32::parse(&b[len..])?;
+                return Ok((len+vlen, Variant::i32(value)));
             },
             primitive::SHORT => {
-                let (vlen, value) = i16::parse(&b[len..]);
-                return (len+vlen, Variant::i16(value));
+                let (vlen, value) = i16::parse(&b[len..])?;
+                return Ok((len+vlen, Variant::i16(value)));
             },
             primitive::CHAR => {
-                let (vlen, value) = i8::parse(&b[len..]);
-                return (len+vlen, Variant::i8(value));
+                let (vlen, value) = i8::parse(&b[len..])?;
+                return Ok((len+vlen, Variant::i8(value)));
             },
             _ => {
-                return (0, Variant::Unknown);
+                return Err(ErrorKind::UnknownVariant);
             }
         }
     }
 }
 
 impl QRead for Variant {
-    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> usize {
+    fn read<T: Read>(s: &mut T, b: &mut [u8]) -> Result<usize, ErrorKind> {
 
-        s.read(&mut b[0..4]).unwrap();
-        let (_, qtype) = i32::parse(&b[0..4]);
+        s.read(&mut b[0..4])?;
+        let (_, qtype) = i32::parse(&b[0..4])?;
         let qtype = qtype as u32;
 
-        s.read(&mut [b[4]]).unwrap();
+        s.read(&mut [b[4]])?;
 
         let mut len = 5;
         match qtype {
-            primitive::QVARIANTMAP  => len += VariantMap::read(s, &mut b[len..]),
-            primitive::QVARIANTLIST => len += VariantList::read(s, &mut b[len..]),
-            primitive::QSTRING      => len += String::read(s, &mut b[len..]),
-            primitive::QBYTEARRAY   => len += String::read(s, &mut b[len..]),
-            primitive::QSTRINGLIST  => len += StringList::read(s, &mut b[len..]),
-            primitive::BOOL         => len += bool::read(s, &mut b[len..]),
-            primitive::ULONG        => len += u64::read(s, &mut b[len..]),
-            primitive::UINT         => len += u32::read(s, &mut b[len..]),
-            primitive::USHORT       => len += u16::read(s, &mut b[len..]),
-            primitive::UCHAR        => len += u8::read(s, &mut b[len..]),
-            primitive::LONG         => len += i64::read(s, &mut b[len..]),
-            primitive::INT          => len += i32::read(s, &mut b[len..]),
-            primitive::SHORT        => len += i16::read(s, &mut b[len..]),
-            primitive::CHAR         => len += i8::read(s, &mut b[len..]),
-            _ => return len
+            primitive::QVARIANTMAP  => len += VariantMap::read(s, &mut b[len..])?,
+            primitive::QVARIANTLIST => len += VariantList::read(s, &mut b[len..])?,
+            primitive::QSTRING      => len += String::read(s, &mut b[len..])?,
+            primitive::QBYTEARRAY   => len += String::read(s, &mut b[len..])?,
+            primitive::QSTRINGLIST  => len += StringList::read(s, &mut b[len..])?,
+            primitive::BOOL         => len += bool::read(s, &mut b[len..])?,
+            primitive::ULONG        => len += u64::read(s, &mut b[len..])?,
+            primitive::UINT         => len += u32::read(s, &mut b[len..])?,
+            primitive::USHORT       => len += u16::read(s, &mut b[len..])?,
+            primitive::UCHAR        => len += u8::read(s, &mut b[len..])?,
+            primitive::LONG         => len += i64::read(s, &mut b[len..])?,
+            primitive::INT          => len += i32::read(s, &mut b[len..])?,
+            primitive::SHORT        => len += i16::read(s, &mut b[len..])?,
+            primitive::CHAR         => len += i8::read(s, &mut b[len..])?,
+            _ => return Err(ErrorKind::UnknownVariant)
         }
 
-        return len;
+        return Ok(len);
     }
 }