From fc64e11cdd35051a2ea87237f548ae0497a2f7f9 Mon Sep 17 00:00:00 2001 From: Max Audron Date: Wed, 29 Apr 2020 00:00:44 +0200 Subject: refactor everything --- src/primitive/bufferinfo.rs | 81 ++++++++++++ src/primitive/datetime.rs | 107 +++++++++++++++ src/primitive/message.rs | 201 ++++++++++++++++++++++++++++ src/primitive/mod.rs | 70 ++++++++++ src/primitive/signedint.rs | 62 +++++++++ src/primitive/string.rs | 94 +++++++++++++ src/primitive/stringlist.rs | 49 +++++++ src/primitive/unsignedint.rs | 81 ++++++++++++ src/primitive/variant.rs | 304 +++++++++++++++++++++++++++++++++++++++++++ src/primitive/variantlist.rs | 49 +++++++ src/primitive/variantmap.rs | 58 +++++++++ 11 files changed, 1156 insertions(+) create mode 100644 src/primitive/bufferinfo.rs create mode 100644 src/primitive/datetime.rs create mode 100644 src/primitive/message.rs create mode 100644 src/primitive/mod.rs create mode 100644 src/primitive/signedint.rs create mode 100644 src/primitive/string.rs create mode 100644 src/primitive/stringlist.rs create mode 100644 src/primitive/unsignedint.rs create mode 100644 src/primitive/variant.rs create mode 100644 src/primitive/variantlist.rs create mode 100644 src/primitive/variantmap.rs (limited to 'src/primitive') 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, Error> { + let mut values: Vec = 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 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, failure::Error> { + let mut values: Vec = 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, failure::Error> { + let mut values: Vec = 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, failure::Error> { + let mut values: Vec = 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, + /// The realName of the sender + /// Only Some when the RichMessage features is enabled + pub real_name: Option, + /// The avatarUrl of the sender, if available + /// Only Some when the RichMessage features is enabled + pub avatar_url: Option, + /// The message content, already stripped from CTCP formatting, but containing mIRC format codes + pub content: String, +} + +impl Serialize for Message { + fn serialize(&self) -> Result, Error> { + let mut values: Vec = 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 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, 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::()?)); + } +} + +impl Serialize for i32 { + fn serialize(&self) -> Result, 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::()?)); + } +} + +impl Serialize for i16 { + fn serialize(&self) -> Result, 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::()?)); + } +} + +impl Serialize for i8 { + fn serialize(&self) -> Result, 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, Error> { + let mut res: Vec = Vec::new(); + + let utf16: Vec = 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, Error> { + let mut res: Vec = 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 = 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; + +impl Serialize for StringList { + fn serialize(&self) -> Result, Error> { + let len: i32 = self.len().try_into()?; + let mut res: Vec = 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, 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, 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::()?)); + } +} + +impl Serialize for u32 { + fn serialize(&self) -> Result, 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::()?)); + } +} + +impl Serialize for u16 { + fn serialize(&self) -> Result, 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::()?)); + } +} + +impl Serialize for u8 { + fn serialize(&self) -> Result, 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), + 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, Error> { + let unknown: u8 = 0x00; + let mut res: Vec = 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; + +impl Serialize for VariantList { + fn serialize(&self) -> Result, Error> { + let len: i32 = self.len().try_into()?; + let mut res: Vec = 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; + +impl Serialize for VariantMap { + fn serialize<'a>(&'a self) -> Result, Error> { + let mut res: Vec = 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)); + } +} -- cgit v1.2.3