refactor everything

11 files changed, 1156 insertions, 0 deletions

diff --git a/src/primitive/bufferinfo.rs b/src/primitive/bufferinfo.rs
new file mode 100644
index 0000000..9cbaa2d
--- /dev/null
+++ b/src/primitive/bufferinfo.rs
@@ -0,0 +1,81 @@
+use std::vec::Vec;
+
+use failure::Error;
+
+use crate::{Deserialize, DeserializeUTF8};
+use crate::{Serialize, SerializeUTF8};
+
+extern crate bytes;
+
+/// The BufferInfo struct represents a BufferInfo as received in IRC
+///
+/// BufferInfo is, like all other struct based types, serialized sequentially.
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct BufferInfo {
+    /// a unique, sequential id for the buffer
+    pub id: i32,
+    /// NetworkId of the network the buffer belongs to
+    pub network_id: i32,
+    /// The Type of the Buffer
+    pub buffer_type: BufferType,
+    /// BufferName as displayed to the user
+    pub name: String,
+}
+
+impl Serialize for BufferInfo {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        let mut values: Vec<u8> = Vec::new();
+
+        values.append(&mut i32::serialize(&self.id)?);
+        values.append(&mut i32::serialize(&self.network_id)?);
+        values.append(&mut i16::serialize(&(self.buffer_type as i16))?);
+        values.append(&mut vec![0, 0, 0, 0]);
+        values.append(&mut String::serialize_utf8(&self.name)?);
+
+        Ok(values)
+    }
+}
+
+impl Deserialize for BufferInfo {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        let (_, id) = i32::parse(&b[0..4])?;
+        let (_, network_id) = i32::parse(&b[4..8])?;
+        let (_, buffer_type) = i16::parse(&b[8..10])?;
+
+        // There are 4 additional undocumented Bytes in the BufferInfo
+        // so we start at byte 14
+        let (size, name) = String::parse_utf8(&b[14..])?;
+
+        return Ok((
+            14 + size,
+            Self {
+                id,
+                network_id,
+                buffer_type: BufferType::from(buffer_type),
+                name,
+            },
+        ));
+    }
+}
+
+/// The Type of the Buffer
+#[repr(i16)]
+#[derive(Copy, Clone, Debug, std::cmp::PartialEq)]
+pub enum BufferType {
+    Status = 0x01,
+    Channel = 0x02,
+    Query = 0x04,
+    Group = 0x08,
+}
+
+impl From<i16> for BufferType {
+    fn from(value: i16) -> Self {
+        match value {
+            0x01 => return Self::Status,
+            0x02 => return Self::Channel,
+            0x04 => return Self::Query,
+            0x08 => return Self::Group,
+            _ => unimplemented!(),
+        }
+    }
+}
diff --git a/src/primitive/datetime.rs b/src/primitive/datetime.rs
new file mode 100644
index 0000000..e6946b9
--- /dev/null
+++ b/src/primitive/datetime.rs
@@ -0,0 +1,107 @@
+use crate::Deserialize;
+use crate::Serialize;
+
+/// The DateTime struct represents a DateTime as received in IRC
+///
+/// DateTime is, like all other struct based types, serialized sequentially.
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct DateTime {
+    /// Day in Julian calendar, unknown if signed or unsigned
+    julian_day: i32,
+    /// Milliseconds since start of day
+    millis_of_day: i32,
+    /// Timezone of DateTime, 0x00 is local, 0x01 is UTC
+    zone: u8,
+}
+
+impl Serialize for DateTime {
+    fn serialize(&self) -> Result<Vec<std::primitive::u8>, failure::Error> {
+        let mut values: Vec<u8> = Vec::new();
+
+        values.append(&mut i32::serialize(&self.julian_day)?);
+        values.append(&mut i32::serialize(&self.millis_of_day)?);
+        values.append(&mut u8::serialize(&(self.zone))?);
+
+        Ok(values)
+    }
+}
+
+impl Deserialize for DateTime {
+    fn parse(b: &[std::primitive::u8]) -> Result<(std::primitive::usize, Self), failure::Error>
+    where
+        Self: Sized,
+    {
+        let (_, julian_day) = i32::parse(&b[0..4])?;
+        let (_, millis_of_day) = i32::parse(&b[4..8])?;
+        let (_, zone) = u8::parse(&b[8..9])?;
+
+        return Ok((
+            9,
+            DateTime {
+                julian_day,
+                millis_of_day,
+                zone,
+            },
+        ));
+    }
+}
+
+/// The Date struct represents a Date as received in IRC
+///
+/// Date is, like all other struct based types, serialized sequentially.
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct Date {
+    /// Day in Julian calendar, unknown if signed or unsigned
+    julian_day: i32,
+}
+
+impl Serialize for Date {
+    fn serialize(&self) -> Result<Vec<std::primitive::u8>, failure::Error> {
+        let mut values: Vec<u8> = Vec::new();
+
+        values.append(&mut i32::serialize(&self.julian_day)?);
+
+        Ok(values)
+    }
+}
+
+impl Deserialize for Date {
+    fn parse(b: &[std::primitive::u8]) -> Result<(std::primitive::usize, Self), failure::Error>
+    where
+        Self: Sized,
+    {
+        let (_, julian_day) = i32::parse(&b[0..4])?;
+
+        return Ok((9, Date { julian_day }));
+    }
+}
+
+/// The Time struct represents a Time as received in IRC
+///
+/// Time is, like all other struct based types, serialized sequentially.
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct Time {
+    /// Milliseconds since start of day
+    millis_of_day: i32,
+}
+
+impl Serialize for Time {
+    fn serialize(&self) -> Result<Vec<std::primitive::u8>, failure::Error> {
+        let mut values: Vec<u8> = Vec::new();
+
+        values.append(&mut i32::serialize(&self.millis_of_day)?);
+
+        Ok(values)
+    }
+}
+
+impl Deserialize for Time {
+    fn parse(b: &[std::primitive::u8]) -> Result<(std::primitive::usize, Self), failure::Error>
+    where
+        Self: Sized,
+    {
+        let (_, millis_of_day) = i32::parse(&b[0..4])?;
+
+        return Ok((4, Time { millis_of_day }));
+    }
+}
diff --git a/src/primitive/message.rs b/src/primitive/message.rs
new file mode 100644
index 0000000..64b132d
--- /dev/null
+++ b/src/primitive/message.rs
@@ -0,0 +1,201 @@
+use std::vec::Vec;
+
+use failure::Error;
+
+use crate::{Deserialize, DeserializeUTF8};
+use crate::{Serialize, SerializeUTF8};
+
+use crate::primitive::BufferInfo;
+
+extern crate bytes;
+
+/// The Message struct represents a Message as received in IRC
+///
+/// Messages are, like all other struct based types, serialized sequentially.
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct Message {
+    /// The unique, sequential id for the message
+    pub msg_id: i32,
+    /// The timestamp of the message in UNIX time (32-bit, seconds, 64-bit if LONGMESSAGE feature enabled)
+    pub timestamp: i64,
+    /// The message type as it's own type serialized as i32
+    pub msg_type: MessageType,
+    /// The flags
+    pub flags: i8,
+    /// The buffer the message belongs to, usually everything but BufferId is set to NULL
+    pub buffer: BufferInfo,
+    /// The sender as nick!ident@host
+    pub sender: String,
+    /// The prefix modes of the sender.
+    /// Only Some when the SenderPrefix features is enabled
+    pub sender_prefixes: Option<String>,
+    /// The realName of the sender
+    /// Only Some when the RichMessage features is enabled
+    pub real_name: Option<String>,
+    /// The avatarUrl of the sender, if available
+    /// Only Some when the RichMessage features is enabled
+    pub avatar_url: Option<String>,
+    /// The message content, already stripped from CTCP formatting, but containing mIRC format codes
+    pub content: String,
+}
+
+impl Serialize for Message {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        let mut values: Vec<u8> = Vec::new();
+
+        values.append(&mut i32::serialize(&self.msg_id)?);
+
+        // TODO LONGMESSAGE feature
+        if false {
+            values.append(&mut i64::serialize(&self.timestamp)?);
+        } else {
+            values.append(&mut i32::serialize(&(self.timestamp as i32))?);
+        }
+
+        values.append(&mut i32::serialize(&(self.msg_type as i32))?);
+        values.append(&mut i8::serialize(&(self.flags as i8))?);
+        values.append(&mut BufferInfo::serialize(&self.buffer)?);
+        values.append(&mut String::serialize_utf8(&self.sender)?);
+
+        // TODO SenderPrefixes feature
+        if false {
+            if let Some(x) = &self.sender_prefixes {
+                values.append(&mut String::serialize_utf8(&x)?);
+            }
+        }
+
+        // TODO RichMessages feature
+        if false {
+            if let Some(x) = &self.real_name {
+                values.append(&mut String::serialize_utf8(&x)?);
+            }
+            if let Some(x) = &self.avatar_url {
+                values.append(&mut String::serialize_utf8(&x)?);
+            }
+        }
+
+        values.append(&mut String::serialize_utf8(&self.content)?);
+
+        return Ok(values);
+    }
+}
+
+impl Deserialize for Message {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        let mut pos = 0;
+        let (parsed, msg_id) = i32::parse(&b[pos..])?;
+        pos += parsed;
+
+        // TODO LONGMESSAGES feature
+        let timestamp;
+        if false {
+            let (parsed, temp_timestamp) = i64::parse(&b[pos..])?;
+            pos += parsed;
+            timestamp = temp_timestamp;
+        } else {
+            let (parsed, temp_timestamp) = i32::parse(&b[pos..])?;
+            pos += parsed;
+            timestamp = temp_timestamp as i64;
+        }
+
+        let (parsed, msg_type) = i32::parse(&b[pos..])?;
+        pos += parsed;
+        let (parsed, flags) = i8::parse(&b[pos..])?;
+        pos += parsed;
+        let (parsed, buffer) = BufferInfo::parse(&b[pos..])?;
+        pos += parsed;
+        let (parsed, sender) = String::parse_utf8(&b[pos..])?;
+        pos += parsed;
+
+        // TODO SenderPrefixes feature
+        let mut sender_prefixes = None;
+        if false {
+            let (parsed, temp) = String::parse_utf8(&b[pos..])?;
+            sender_prefixes = Some(temp);
+            pos += parsed;
+        }
+
+        // TODO SenderPrefixes feature
+        let mut real_name = None;
+        let mut avatar_url = None;
+        if false {
+            let (parsed, temp) = String::parse_utf8(&b[pos..])?;
+            real_name = Some(temp);
+            pos += parsed;
+
+            let (parsed, temp) = String::parse_utf8(&b[pos..])?;
+            avatar_url = Some(temp);
+            pos += parsed;
+        }
+
+        let (parsed, content) = String::parse_utf8(&b[pos..])?;
+        pos += parsed;
+
+        return Ok((
+            pos,
+            Self {
+                msg_id,
+                timestamp,
+                msg_type: MessageType::from(msg_type),
+                flags,
+                buffer,
+                sender,
+                sender_prefixes,
+                real_name,
+                avatar_url,
+                content,
+            },
+        ));
+    }
+}
+
+#[repr(i32)]
+#[derive(Copy, Clone, Debug, std::cmp::PartialEq)]
+pub enum MessageType {
+    Plain = 0x00000001,
+    Notice = 0x00000002,
+    Action = 0x00000004,
+    Nick = 0x00000008,
+    Mode = 0x00000010,
+    Join = 0x00000020,
+    Part = 0x00000040,
+    Quit = 0x00000080,
+    Kick = 0x00000100,
+    Kill = 0x00000200,
+    Server = 0x00000400,
+    Info = 0x00000800,
+    Error = 0x00001000,
+    DayChange = 0x00002000,
+    Topic = 0x00004000,
+    NetsplitJoin = 0x00008000,
+    NetsplitQuit = 0x00010000,
+    Invite = 0x00020000,
+    Markerline = 0x00040000,
+}
+
+impl From<i32> for MessageType {
+    fn from(val: i32) -> Self {
+        match val {
+            0x00000001 => MessageType::Plain,
+            0x00000002 => MessageType::Notice,
+            0x00000004 => MessageType::Action,
+            0x00000008 => MessageType::Nick,
+            0x00000010 => MessageType::Mode,
+            0x00000020 => MessageType::Join,
+            0x00000040 => MessageType::Part,
+            0x00000080 => MessageType::Quit,
+            0x00000100 => MessageType::Kick,
+            0x00000200 => MessageType::Kill,
+            0x00000400 => MessageType::Server,
+            0x00000800 => MessageType::Info,
+            0x00001000 => MessageType::Error,
+            0x00002000 => MessageType::DayChange,
+            0x00004000 => MessageType::Topic,
+            0x00008000 => MessageType::NetsplitJoin,
+            0x00010000 => MessageType::NetsplitQuit,
+            0x00020000 => MessageType::Invite,
+            0x00040000 => MessageType::Markerline,
+            _ => unimplemented!(),
+        }
+    }
+}
diff --git a/src/primitive/mod.rs b/src/primitive/mod.rs
new file mode 100644
index 0000000..a3d2dcd
--- /dev/null
+++ b/src/primitive/mod.rs
@@ -0,0 +1,70 @@
+mod bufferinfo;
+mod datetime;
+mod message;
+mod signedint;
+mod string;
+mod stringlist;
+mod unsignedint;
+mod variant;
+mod variantlist;
+mod variantmap;
+
+pub use bufferinfo::*;
+pub use datetime::*;
+pub use message::*;
+pub use signedint::*;
+pub use string::*;
+pub use stringlist::*;
+pub use unsignedint::*;
+pub use variant::*;
+pub use variantlist::*;
+pub use variantmap::*;
+
+/// Byte Representation of the type used in Variant to identify it
+pub const VOID: u32 = 0x00000000;
+/// Byte Representation of the type used in Variant to identify it
+pub const BOOL: u32 = 0x00000001;
+/// Byte Representation of the type used in Variant to identify it
+pub const QCHAR: u32 = 0x00000007;
+
+/// Byte Representation of the type used in Variant to identify it
+pub const QVARIANT: u32 = 0x00000090;
+/// Byte Representation of the type used in Variant to identify it
+pub const QVARIANTMAP: u32 = 0x00000008;
+/// Byte Representation of the type used in Variant to identify it
+pub const QVARIANTLIST: u32 = 0x00000009;
+
+/// Byte Representation of the type used in Variant to identify it
+pub const QSTRING: u32 = 0x0000000a;
+/// Byte Representation of the type used in Variant to identify it
+pub const QSTRINGLIST: u32 = 0x0000000b;
+/// Byte Representation of the type used in Variant to identify it
+pub const QBYTEARRAY: u32 = 0x0000000c;
+
+/// Byte Representation of the type used in Variant to identify it
+pub const QDATE: u32 = 0x0000000e;
+/// Byte Representation of the type used in Variant to identify it
+pub const QTIME: u32 = 0x0000000f;
+/// Byte Representation of the type used in Variant to identify it
+pub const QDATETIME: u32 = 0x00000010;
+/// Byte Representation of the type used in Variant to identify it
+pub const USERTYPE: u32 = 0x0000007f;
+
+// Basic types
+/// Byte Representation of the type used in Variant to identify it
+pub const LONG: u32 = 0x00000081; // int64_t
+/// Byte Representation of the type used in Variant to identify it
+pub const INT: u32 = 0x00000002; // int32_t
+/// Byte Representation of the type used in Variant to identify it
+pub const SHORT: u32 = 0x00000082; // int16_t
+/// Byte Representation of the type used in Variant to identify it
+pub const CHAR: u32 = 0x00000083; // int8_t
+
+/// Byte Representation of the type used in Variant to identify it
+pub const ULONG: u32 = 0x00000084; // uint64_t
+/// Byte Representation of the type used in Variant to identify it
+pub const UINT: u32 = 0x00000003; // uint32_t
+/// Byte Representation of the type used in Variant to identify it
+pub const USHORT: u32 = 0x00000085; // uint16_t
+/// Byte Representation of the type used in Variant to identify it
+pub const UCHAR: u32 = 0x00000086; // uint8_t
diff --git a/src/primitive/signedint.rs b/src/primitive/signedint.rs
new file mode 100644
index 0000000..4c21a69
--- /dev/null
+++ b/src/primitive/signedint.rs
@@ -0,0 +1,62 @@
+extern crate byteorder;
+use byteorder::{BigEndian, ReadBytesExt};
+use std::io::Cursor;
+
+use std::convert::TryInto;
+use std::result::Result;
+use std::vec::Vec;
+
+use failure::Error;
+
+use crate::{Deserialize, Serialize};
+
+impl Serialize for i64 {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        Ok(Vec::from(self.to_be_bytes()))
+    }
+}
+
+impl Deserialize for i64 {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        let mut rdr = Cursor::new(&b[0..8]);
+        return Ok((8, rdr.read_i64::<BigEndian>()?));
+    }
+}
+
+impl Serialize for i32 {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        Ok(Vec::from(self.to_be_bytes()))
+    }
+}
+
+impl Deserialize for i32 {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        let mut rdr = Cursor::new(&b[0..4]);
+        return Ok((4, rdr.read_i32::<BigEndian>()?));
+    }
+}
+
+impl Serialize for i16 {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        Ok(Vec::from(self.to_be_bytes()))
+    }
+}
+
+impl Deserialize for i16 {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        let mut rdr = Cursor::new(&b[0..2]);
+        return Ok((2, rdr.read_i16::<BigEndian>()?));
+    }
+}
+
+impl Serialize for i8 {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        Ok(Vec::from(self.to_be_bytes()))
+    }
+}
+
+impl Deserialize for i8 {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        return Ok((1, b[0].try_into()?));
+    }
+}
diff --git a/src/primitive/string.rs b/src/primitive/string.rs
new file mode 100644
index 0000000..86bcdec
--- /dev/null
+++ b/src/primitive/string.rs
@@ -0,0 +1,94 @@
+extern crate byteorder;
+
+use std::result::Result;
+use std::vec::Vec;
+
+use failure::Error;
+
+use log::trace;
+
+use crate::{Deserialize, DeserializeUTF8, Serialize, SerializeUTF8};
+use crate::util;
+
+/// We Shadow the String type here as we can only use impl on types in our own scope.
+///
+/// Strings are serialized as an i32 for the length in bytes, then the chars represented in UTF-16 in bytes.
+///
+/// Strings can only be serialized as UTF-8 null-terminated ByteArrays with (de)serialize_utf8().
+impl Serialize for String {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        let mut res: Vec<u8> = Vec::new();
+
+        let utf16: Vec<u16> = self.encode_utf16().collect();
+        for i in utf16 {
+            res.extend(i.to_be_bytes().iter());
+        }
+
+        util::prepend_byte_len(&mut res);
+        return Ok(res);
+    }
+}
+
+impl SerializeUTF8 for String {
+    fn serialize_utf8(&self) -> Result<Vec<u8>, Error> {
+        let mut res: Vec<u8> = Vec::new();
+        res.extend(self.clone().into_bytes());
+        res.extend(vec![0x00]);
+        util::prepend_byte_len(&mut res);
+        return Ok(res);
+    }
+}
+
+impl Deserialize for String {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        // Parse Length
+        let (_, len) = i32::parse(&b[0..4])?;
+        trace!(target: "primitive::String", "Parsing with length: {:?}, from bytes: {:x?}", len, &b[0..4]);
+
+        if len == -1 {
+            return Ok((4, "".to_string()));
+        }
+
+        // length as usize
+        let ulen = len as usize;
+        let mut pos: usize = 4;
+        let mut chars: Vec<u16> = Vec::new();
+        loop {
+            // if position is behind the length plus our 4 bytes of the length we already parsed
+            if pos >= (ulen + 4) {
+                break;
+            }
+            let (slen, uchar) = u16::parse(&b[pos..(pos + 2)])?;
+            chars.push(uchar);
+            pos += slen;
+        }
+
+        let res: String = String::from_utf16(&chars).unwrap();
+        return Ok((pos, res));
+    }
+}
+
+impl DeserializeUTF8 for String {
+    fn parse_utf8(b: &[u8]) -> Result<(usize, Self), Error> {
+        let (_, len) = i32::parse(&b[0..4])?;
+
+        trace!(target: "primitive::String", "Parsing with length: {:?}, from bytes: {:x?}", len, &b[0..4]);
+
+        if len <= 0 {
+            return Ok((4, "".to_string()));
+        }
+
+        let ulen = len as usize;
+
+        let mut res: String = String::from_utf8(b[4..(ulen + 4)].to_vec())?;
+
+        // If the last byte is zero remove it
+        // Receiving a string as bytearray will sometimes have
+        // the string null terminated
+        if res.chars().last().unwrap() == '\u{0}' {
+            let _ = res.pop();
+        }
+
+        return Ok((ulen + 4, res));
+    }
+}
diff --git a/src/primitive/stringlist.rs b/src/primitive/stringlist.rs
new file mode 100644
index 0000000..e5d1a44
--- /dev/null
+++ b/src/primitive/stringlist.rs
@@ -0,0 +1,49 @@
+extern crate byteorder;
+
+use std::convert::TryInto;
+use std::result::Result;
+use std::vec::Vec;
+
+use failure::Error;
+
+use log::trace;
+
+use crate::{Deserialize, Serialize};
+
+/// StringList are represented as a Vec of Strings
+///
+/// StringLists are serialized as an i32 of the amount of elements and then each element as a String
+pub type StringList = Vec<String>;
+
+impl Serialize for StringList {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        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()?);
+        }
+
+        return Ok(res);
+    }
+}
+
+impl Deserialize for StringList {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        let (_, len) = i32::parse(&b[0..4])?;
+        trace!(target: "primitive::StringList", "Parsing with length: {:?}, from bytes: {:x?}", len, &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..])?;
+                pos += lpos;
+                res.push(val);
+            }
+        }
+
+        return Ok((pos, res));
+    }
+}
diff --git a/src/primitive/unsignedint.rs b/src/primitive/unsignedint.rs
new file mode 100644
index 0000000..6e91e2a
--- /dev/null
+++ b/src/primitive/unsignedint.rs
@@ -0,0 +1,81 @@
+extern crate byteorder;
+use byteorder::{BigEndian, ReadBytesExt};
+use std::io::Cursor;
+
+use std::result::Result;
+use std::vec::Vec;
+
+use failure::Error;
+
+use crate::error::ProtocolError;
+use crate::{Deserialize, Serialize};
+
+impl Serialize for bool {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        Ok({
+            let i = *self as i8;
+            Vec::from(i.to_be_bytes())
+        })
+    }
+}
+impl Deserialize for bool {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        if b[0] == 0 {
+            return Ok((1, false));
+        } else if b[0] == 1 {
+            return Ok((1, true));
+        } else {
+            bail!(ProtocolError::BoolOutOfRange);
+        };
+    }
+}
+impl Serialize for u64 {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        Ok(Vec::from(self.to_be_bytes()))
+    }
+}
+
+impl Deserialize for u64 {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        let mut rdr = Cursor::new(&b[0..8]);
+        return Ok((8, rdr.read_u64::<BigEndian>()?));
+    }
+}
+
+impl Serialize for u32 {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        Ok(Vec::from(self.to_be_bytes()))
+    }
+}
+
+impl Deserialize for u32 {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        let mut rdr = Cursor::new(&b[0..4]);
+        return Ok((4, rdr.read_u32::<BigEndian>()?));
+    }
+}
+
+impl Serialize for u16 {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        Ok(Vec::from(self.to_be_bytes()))
+    }
+}
+
+impl Deserialize for u16 {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        let mut rdr = Cursor::new(&b[0..2]);
+        return Ok((2, rdr.read_u16::<BigEndian>()?));
+    }
+}
+
+impl Serialize for u8 {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        Ok(Vec::from(self.to_be_bytes()))
+    }
+}
+
+impl Deserialize for u8 {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        return Ok((1, b[0]));
+    }
+}
diff --git a/src/primitive/variant.rs b/src/primitive/variant.rs
new file mode 100644
index 0000000..71ddc4a
--- /dev/null
+++ b/src/primitive/variant.rs
@@ -0,0 +1,304 @@
+use std::vec::Vec;
+
+use failure::Error;
+
+use log::{error, trace};
+
+use crate::error::ProtocolError;
+use crate::primitive;
+use crate::primitive::StringList;
+use crate::{Deserialize, DeserializeUTF8};
+use crate::{Serialize, SerializeUTF8};
+
+extern crate bytes;
+
+use crate::primitive::{
+    BufferInfo, Date, DateTime, Message, Time, VariantList, VariantMap,
+};
+
+/// Variant represents the possible types we can receive
+///
+/// Variant's are serizalized as the Type as a i32 and then the Type in it's own format
+///
+/// BufferInfo and Message are UserTypes
+/// but we represent them as a native Type here.
+///
+/// StringUTF8 is de-/serialized as a C ByteArray.
+#[allow(non_camel_case_types, dead_code)]
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub enum Variant {
+    Unknown,
+    UserType(String, Vec<u8>),
+    BufferInfo(BufferInfo),
+    Message(Message),
+    Time(Time),
+    Date(Date),
+    DateTime(DateTime),
+    VariantMap(VariantMap),
+    VariantList(VariantList),
+    String(String),
+    StringUTF8(String),
+    StringList(StringList),
+    bool(bool),
+    u64(u64),
+    u32(u32),
+    u16(u16),
+    u8(u8),
+    i64(i64),
+    i32(i32),
+    i16(i16),
+    i8(i8),
+}
+
+impl Serialize for Variant {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        let unknown: u8 = 0x00;
+        let mut res: Vec<u8> = Vec::new();
+
+        match self {
+            Variant::Unknown => {
+                bail!(ProtocolError::UnknownVariant);
+            }
+            Variant::VariantMap(v) => {
+                res.extend(primitive::QVARIANTMAP.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().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());
+            }
+            Variant::String(v) => {
+                res.extend(primitive::QSTRING.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().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());
+            }
+            Variant::StringList(v) => {
+                res.extend(primitive::QSTRINGLIST.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.extend(v.serialize()?.iter());
+            }
+            Variant::bool(v) => {
+                res.extend(primitive::BOOL.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                let i = *v as i8;
+                res.extend(i.to_be_bytes().iter());
+            }
+            Variant::u64(v) => {
+                res.extend(primitive::ULONG.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.extend(v.to_be_bytes().iter());
+            }
+            Variant::u32(v) => {
+                res.extend(primitive::UINT.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.extend(v.to_be_bytes().iter());
+            }
+            Variant::u16(v) => {
+                res.extend(primitive::USHORT.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.extend(v.to_be_bytes().iter());
+            }
+            Variant::u8(v) => {
+                res.extend(primitive::UCHAR.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.extend(v.to_be_bytes().iter());
+            }
+            Variant::i64(v) => {
+                res.extend(primitive::LONG.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.extend(v.to_be_bytes().iter());
+            }
+            Variant::i32(v) => {
+                res.extend(primitive::INT.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.extend(v.to_be_bytes().iter());
+            }
+            Variant::i16(v) => {
+                res.extend(primitive::SHORT.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.extend(v.to_be_bytes().iter());
+            }
+            Variant::i8(v) => {
+                res.extend(primitive::CHAR.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.extend(v.to_be_bytes().iter());
+            }
+            Variant::UserType(name, bytes) => {
+                res.extend(primitive::USERTYPE.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.append(&mut name.serialize_utf8()?);
+                res.extend(bytes);
+            }
+            Variant::BufferInfo(v) => {
+                let bytes = BufferInfo::serialize(v)?;
+                let user = Variant::UserType("BufferInfo".to_string(), bytes);
+                Variant::serialize(&user).unwrap();
+            }
+            Variant::Message(v) => {
+                let bytes = Message::serialize(v)?;
+                let user = Variant::UserType("Message".to_string(), bytes);
+                Variant::serialize(&user).unwrap();
+            }
+            Variant::DateTime(v) => {
+                res.extend(primitive::QDATETIME.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.append(&mut v.serialize()?);
+            }
+            Variant::Time(v) => {
+                res.extend(primitive::QTIME.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.append(&mut v.serialize()?);
+            }
+            Variant::Date(v) => {
+                res.extend(primitive::QDATE.to_be_bytes().iter());
+                res.extend(unknown.to_be_bytes().iter());
+                res.append(&mut v.serialize()?);
+            }
+        }
+
+        return Ok(res);
+    }
+}
+
+impl Deserialize for Variant {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        let (_, qtype) = i32::parse(&b[0..4])?;
+        let qtype = qtype as u32;
+
+        #[allow(unused_variables)]
+        let unknown: u8 = b[4];
+
+        let len = 5;
+        match qtype {
+            primitive::QVARIANTMAP => {
+                trace!(target: "primitive::Variant", "Parsing Variant: VariantMap");
+                let (vlen, value) = VariantMap::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::VariantMap(value)));
+            }
+            primitive::QVARIANTLIST => {
+                trace!(target: "primitive::Variant", "Parsing Variant: VariantList");
+                let (vlen, value) = VariantList::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::VariantList(value)));
+            }
+            primitive::QSTRING => {
+                trace!(target: "primitive::Variant", "Parsing Variant: String");
+                let (vlen, value) = String::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::String(value.clone())));
+            }
+            primitive::QBYTEARRAY => {
+                trace!(target: "primitive::Variant", "Parsing Variant: ByteArray");
+                let (vlen, value) = String::parse_utf8(&b[len..])?;
+                return Ok((len + vlen, Variant::StringUTF8(value.clone())));
+            }
+            primitive::QSTRINGLIST => {
+                trace!(target: "primitive::Variant", "Parsing Variant: StringList");
+                let (vlen, value) = StringList::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::StringList(value.clone())));
+            }
+            primitive::QDATETIME => {
+                trace!(target: "primitive::Variant", "Parsing Variant: Date");
+                let (vlen, value) = Date::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::Date(value.clone())));
+            }
+            primitive::QDATE => {
+                trace!(target: "primitive::Variant", "Parsing Variant: Date");
+                let (vlen, value) = Date::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::Date(value.clone())));
+            }
+            primitive::QTIME => {
+                trace!(target: "primitive::Variant", "Parsing Variant: Time");
+                let (vlen, value) = Time::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::Time(value.clone())));
+            }
+            primitive::BOOL => {
+                let (vlen, value) = bool::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::bool(value)));
+            }
+            primitive::ULONG => {
+                let (vlen, value) = u64::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::u64(value)));
+            }
+            primitive::UINT => {
+                let (vlen, value) = u32::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::u32(value)));
+            }
+            primitive::USHORT => {
+                let (vlen, value) = u16::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::u16(value)));
+            }
+            primitive::UCHAR => {
+                let (vlen, value) = u8::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::u8(value)));
+            }
+            primitive::LONG => {
+                let (vlen, value) = i64::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::i64(value)));
+            }
+            primitive::INT => {
+                let (vlen, value) = i32::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::i32(value)));
+            }
+            primitive::SHORT => {
+                let (vlen, value) = i16::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::i16(value)));
+            }
+            primitive::CHAR => {
+                let (vlen, value) = i8::parse(&b[len..])?;
+                return Ok((len + vlen, Variant::i8(value)));
+            }
+            primitive::USERTYPE => {
+                trace!(target: "primitive::Variant", "Parsing UserType");
+                // Parse UserType name
+                let (user_type_len, user_type) = String::parse_utf8(&b[len..])?;
+
+                trace!(target: "primitive::Variant", "Parsing UserType: {:?}", user_type);
+
+                // TODO implement all these types
+                // Match Possible User Types to basic structures
+                match user_type.as_str() {
+                    // As VariantMap
+                    "IrcUser" | "IrcChannel" | "Identity" | "NetworkInfo" | "Network::Server" => {
+                        trace!(target: "primitive::Variant", "UserType is VariantMap");
+                        let (vlen, value) = VariantMap::parse(&b[(len + user_type_len)..])?;
+                        return Ok((len + user_type_len + vlen, Variant::VariantMap(value)));
+                    }
+                    // As i32
+                    "BufferId" | "IdentityId" | "NetworkId" | "MsgId" => {
+                        trace!(target: "primitive::Variant", "UserType is i32");
+
+                        let (vlen, value) = i32::parse(&b[(len + user_type_len)..])?;
+                        return Ok((len + user_type_len + vlen, Variant::i32(value)));
+                    }
+                    // As i64
+                    "PeerPtr" => {
+                        trace!(target: "primitive::Variant", "UserType is i64");
+                        let (vlen, value) = i64::parse(&b[(len + user_type_len)..])?;
+                        return Ok((len + user_type_len + vlen, Variant::i64(value)));
+                    }
+                    "BufferInfo" => {
+                        trace!(target: "primitive::Variant", "UserType is BufferInfo");
+                        let (vlen, value) = BufferInfo::parse(&b[(len + user_type_len)..])?;
+                        return Ok((len + user_type_len + vlen, Variant::BufferInfo(value)));
+                    }
+                    "Message" => {
+                        trace!(target: "primitive::Variant", "UserType is Message");
+                        let (vlen, value) = Message::parse(&b[(len + user_type_len)..])?;
+                        return Ok((len + user_type_len + vlen, Variant::Message(value)));
+                    }
+                    _ => unimplemented!(),
+                }
+            }
+            err => {
+                error!(target: "parser", "UnknownVariant: {:x?}", err);
+                bail!(ProtocolError::UnknownVariant);
+            }
+        }
+    }
+}
diff --git a/src/primitive/variantlist.rs b/src/primitive/variantlist.rs
new file mode 100644
index 0000000..452b927
--- /dev/null
+++ b/src/primitive/variantlist.rs
@@ -0,0 +1,49 @@
+use std::convert::TryInto;
+use std::vec::Vec;
+
+use failure::Error;
+
+use log::trace;
+
+use crate::{Deserialize, Serialize};
+
+extern crate bytes;
+
+use crate::primitive::Variant;
+
+/// VariantLists are represented as a Vec of Variants.
+///
+/// They are serialized as the amount of entries as a i32 and then a Variant for each entry
+pub type VariantList = Vec<Variant>;
+
+impl Serialize for VariantList {
+    fn serialize(&self) -> Result<Vec<u8>, Error> {
+        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());
+        }
+
+        return Ok(res);
+    }
+}
+
+impl Deserialize for VariantList {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        let (_, len) = i32::parse(&b[0..4])?;
+        trace!(target: "primitive::VariantList", "Parsing VariantList with {:?} elements", len);
+
+        let mut res: VariantList = VariantList::new();
+        let mut pos: usize = 4;
+        for i in 0..len {
+            trace!(target: "primitive::VariantList", "Parsing VariantList element: {:?}", i);
+            let (vlen, val) = Variant::parse(&b[pos..])?;
+            res.push(val);
+            pos += vlen;
+        }
+
+        return Ok((pos, res));
+    }
+}
diff --git a/src/primitive/variantmap.rs b/src/primitive/variantmap.rs
new file mode 100644
index 0000000..4f017f3
--- /dev/null
+++ b/src/primitive/variantmap.rs
@@ -0,0 +1,58 @@
+use std::collections::HashMap;
+use std::{convert::TryInto, vec::Vec};
+
+use failure::Error;
+
+use log::trace;
+
+use crate::Deserialize;
+use crate::Serialize;
+
+use crate::primitive::Variant;
+use crate::util;
+
+extern crate bytes;
+
+/// VariantMaps are represented as a HashMap with String as key and Variant as value
+///
+/// They are serialized as the amount of keys as an i32 then for each entry a String and a Variant.
+pub type VariantMap = HashMap<String, Variant>;
+
+impl Serialize for VariantMap {
+    fn serialize<'a>(&'a self) -> Result<Vec<u8>, Error> {
+        let mut res: Vec<u8> = Vec::new();
+
+        for (k, v) in self {
+            res.extend(k.serialize()?);
+            res.extend(v.serialize()?);
+        }
+
+        let len: i32 = self.len().try_into()?;
+        util::insert_bytes(0, &mut res, &mut len.to_be_bytes());
+
+        return Ok(res);
+    }
+}
+
+impl Deserialize for VariantMap {
+    fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+        let (_, len) = i32::parse(&b[0..4])?;
+        trace!(target: "primitive::VariantMap", "Parsing VariantMap with {:?} elements", len);
+
+        let mut pos: usize = 4;
+        let mut map = VariantMap::new();
+        for _ in 0..len {
+            trace!(target: "primitive::VariantMap", "Parsing entry name");
+            let (nlen, name) = String::parse(&b[pos..])?;
+            pos += nlen;
+
+            trace!(target: "primitive::VariantMap", "Parsing entry: {:?} with len {:?}", name, &b[(pos)..(pos + 4)]);
+            let (vlen, value) = Variant::parse(&b[(pos)..])?;
+            pos += vlen;
+
+            map.insert(name, value);
+        }
+
+        return Ok((pos, map));
+    }
+}