aboutsummaryrefslogtreecommitdiff
path: root/src/protocol
diff options
context:
space:
mode:
Diffstat (limited to 'src/protocol')
-rw-r--r--src/protocol/message/handshake.rs215
-rw-r--r--src/protocol/message/handshake/types.rs49
-rw-r--r--src/protocol/message/login.rs1
-rw-r--r--src/protocol/message/mod.rs4
-rw-r--r--src/protocol/primitive/basic.rs282
-rw-r--r--src/protocol/primitive/bufferinfo.rs74
-rw-r--r--src/protocol/primitive/datetime.rs93
-rw-r--r--src/protocol/primitive/message.rs184
-rw-r--r--src/protocol/primitive/mod.rs64
-rw-r--r--src/protocol/primitive/signedint.rs62
-rw-r--r--src/protocol/primitive/string.rs91
-rw-r--r--src/protocol/primitive/stringlist.rs45
-rw-r--r--src/protocol/primitive/unsignedint.rs81
-rw-r--r--src/protocol/primitive/variant.rs337
-rw-r--r--src/protocol/primitive/variantlist.rs46
-rw-r--r--src/protocol/primitive/variantmap.rs63
16 files changed, 1107 insertions, 584 deletions
diff --git a/src/protocol/message/handshake.rs b/src/protocol/message/handshake.rs
index b38d03f..357d1a4 100644
--- a/src/protocol/message/handshake.rs
+++ b/src/protocol/message/handshake.rs
@@ -1,50 +1,67 @@
-use std::result::Result;
use failure::Error;
+use std::result::Result;
use crate::protocol::error::ProtocolError;
use crate::protocol::primitive::{String, StringList, Variant, VariantList};
use crate::util::get_msg_type;
mod types;
-pub use types::{VariantMap, HandshakeDeserialize, HandshakeSerialize, HandshakeQRead};
+pub use types::{HandshakeDeserialize, HandshakeSerialize, VariantMap};
use crate::match_variant;
-
#[derive(Debug)]
pub struct ConnAck {
flags: u8,
extra: i16,
- version: i8
+ version: i8,
}
impl crate::protocol::primitive::deserialize::Deserialize for ConnAck {
fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
let (flen, flags) = u8::parse(b)?;
let (elen, extra) = i16::parse(&b[flen..])?;
- let (vlen, version) = i8::parse(&b[(flen+elen)..])?;
-
- return Ok((flen+elen+vlen, Self {flags, extra, version}));
+ let (vlen, version) = i8::parse(&b[(flen + elen)..])?;
+
+ return Ok((
+ flen + elen + vlen,
+ Self {
+ flags,
+ extra,
+ version,
+ },
+ ));
}
}
-
#[derive(Debug)]
pub struct ClientInit {
pub client_version: String, // Version of the client
- pub client_date: String, // Build date of the client
+ pub client_date: String, // Build date of the client
pub client_features: u32,
- pub feature_list: StringList // List of supported extended features
+ pub feature_list: StringList, // List of supported extended features
}
impl HandshakeSerialize for ClientInit {
fn serialize(&self) -> Result<Vec<u8>, Error> {
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()));
- values.insert("ClientDate".to_string(), Variant::String(self.client_date.clone()));
+ values.insert(
+ "MsgType".to_string(),
+ Variant::String("ClientInit".to_string()),
+ );
+ values.insert(
+ "ClientVersion".to_string(),
+ Variant::String(self.client_version.clone()),
+ );
+ values.insert(
+ "ClientDate".to_string(),
+ Variant::String(self.client_date.clone()),
+ );
values.insert("Features".to_string(), Variant::u32(self.client_features));
- values.insert("FeatureList".to_string(), Variant::StringList(self.feature_list.clone()));
+ values.insert(
+ "FeatureList".to_string(),
+ Variant::StringList(self.feature_list.clone()),
+ );
return HandshakeSerialize::serialize(&values);
}
}
@@ -56,12 +73,15 @@ impl HandshakeDeserialize for ClientInit {
let msgtype = get_msg_type(&values["MsgType"])?;
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")
- }));
+ 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 {
bail!(ProtocolError::WrongMsgType);
}
@@ -70,14 +90,20 @@ impl HandshakeDeserialize for ClientInit {
#[derive(Debug)]
pub struct ClientInitReject {
- pub error_string: String
+ pub error_string: String,
}
impl HandshakeSerialize for ClientInitReject {
fn serialize(&self) -> Result<Vec<u8>, Error> {
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()));
+ values.insert(
+ "MsgType".to_string(),
+ Variant::String("ClientInitReject".to_string()),
+ );
+ values.insert(
+ "ErrorString".to_string(),
+ Variant::String(self.error_string.clone()),
+ );
return HandshakeSerialize::serialize(&values);
}
}
@@ -89,9 +115,12 @@ impl HandshakeDeserialize for ClientInitReject {
let msgtype = get_msg_type(&values["MsgType"])?;
if msgtype == "ClientInitReject" {
- return Ok((len, Self {
- error_string: match_variant!(values, Variant::String, "ErrorString")
- }));
+ return Ok((
+ len,
+ Self {
+ error_string: match_variant!(values, Variant::String, "ErrorString"),
+ },
+ ));
} else {
bail!(ProtocolError::WrongMsgType);
}
@@ -100,22 +129,37 @@ impl HandshakeDeserialize for ClientInitReject {
#[derive(Debug)]
pub struct ClientInitAck {
- pub core_features: u32, // Flags of supported legacy features
- pub core_configured: bool, // If the core has already been configured
+ pub core_features: u32, // Flags of supported legacy features
+ pub core_configured: bool, // If the core has already been configured
pub storage_backends: VariantList, // List of VariantMaps of info on available backends
- pub authenticators: VariantList, // List of VariantMaps of info on available authenticators
- pub feature_list: StringList, // List of supported extended features
+ pub authenticators: VariantList, // List of VariantMaps of info on available authenticators
+ pub feature_list: StringList, // List of supported extended features
}
impl HandshakeSerialize for ClientInitAck {
fn serialize(&self) -> Result<Vec<u8>, Error> {
let mut values: VariantMap = VariantMap::with_capacity(6);
- values.insert("MsgType".to_string(), Variant::String("ClientInitAck".to_string()));
+ values.insert(
+ "MsgType".to_string(),
+ Variant::String("ClientInitAck".to_string()),
+ );
values.insert("CoreFeatures".to_string(), Variant::u32(self.core_features));
- values.insert("Configured".to_string(), Variant::bool(self.core_configured));
- values.insert("StorageBackends".to_string(), Variant::VariantList(self.storage_backends.clone()));
- values.insert("Authenticators".to_string(), Variant::VariantList(self.authenticators.clone()));
- values.insert("FeatureList".to_string(), Variant::StringList(self.feature_list.clone()));
+ values.insert(
+ "Configured".to_string(),
+ Variant::bool(self.core_configured),
+ );
+ values.insert(
+ "StorageBackends".to_string(),
+ Variant::VariantList(self.storage_backends.clone()),
+ );
+ values.insert(
+ "Authenticators".to_string(),
+ Variant::VariantList(self.authenticators.clone()),
+ );
+ values.insert(
+ "FeatureList".to_string(),
+ Variant::StringList(self.feature_list.clone()),
+ );
return HandshakeSerialize::serialize(&values);
}
}
@@ -127,13 +171,20 @@ impl HandshakeDeserialize for ClientInitAck {
let msgtype = get_msg_type(&values["MsgType"])?;
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")
- }));
+ 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 {
bail!(ProtocolError::WrongMsgType);
}
@@ -143,15 +194,21 @@ impl HandshakeDeserialize for ClientInitAck {
#[derive(Debug)]
pub struct ClientLogin {
pub user: String,
- pub password: String
+ pub password: String,
}
impl HandshakeSerialize for ClientLogin {
fn serialize(&self) -> Result<Vec<u8>, Error> {
let mut values: VariantMap = VariantMap::new();
- values.insert("MsgType".to_string(), Variant::String("ClientLogin".to_string()));
+ values.insert(
+ "MsgType".to_string(),
+ Variant::String("ClientLogin".to_string()),
+ );
values.insert("User".to_string(), Variant::String(self.user.clone()));
- values.insert("Password".to_string(), Variant::String(self.password.clone()));
+ values.insert(
+ "Password".to_string(),
+ Variant::String(self.password.clone()),
+ );
return HandshakeSerialize::serialize(&values);
}
}
@@ -163,10 +220,13 @@ impl HandshakeDeserialize for ClientLogin {
let msgtype = get_msg_type(&values["MsgType"])?;
if msgtype == "ClientLogin" {
- return Ok((len, Self {
- user: match_variant!(values, Variant::String, "User"),
- password: match_variant!(values, Variant::String, "Password")
- }));
+ return Ok((
+ len,
+ Self {
+ user: match_variant!(values, Variant::String, "User"),
+ password: match_variant!(values, Variant::String, "Password"),
+ },
+ ));
} else {
bail!(ProtocolError::WrongMsgType);
}
@@ -179,7 +239,10 @@ pub struct ClientLoginAck;
impl HandshakeSerialize for ClientLoginAck {
fn serialize(&self) -> Result<Vec<u8>, Error> {
let mut values: VariantMap = VariantMap::with_capacity(1);
- values.insert("MsgType".to_string(), Variant::String("ClientLoginAck".to_string()));
+ values.insert(
+ "MsgType".to_string(),
+ Variant::String("ClientLoginAck".to_string()),
+ );
return HandshakeSerialize::serialize(&values);
}
}
@@ -200,14 +263,20 @@ impl HandshakeDeserialize for ClientLoginAck {
#[derive(Debug)]
pub struct ClientLoginReject {
- error: String
+ error: String,
}
impl HandshakeSerialize for ClientLoginReject {
fn serialize(&self) -> Result<Vec<u8>, Error> {
let mut values: VariantMap = VariantMap::with_capacity(1);
- values.insert("MsgType".to_string(), Variant::String("ClientLoginReject".to_string()));
- values.insert("ErrorString".to_string(), Variant::String(self.error.clone()));
+ values.insert(
+ "MsgType".to_string(),
+ Variant::String("ClientLoginReject".to_string()),
+ );
+ values.insert(
+ "ErrorString".to_string(),
+ Variant::String(self.error.clone()),
+ );
return HandshakeSerialize::serialize(&values);
}
}
@@ -219,7 +288,12 @@ impl HandshakeDeserialize for ClientLoginReject {
let msgtype = get_msg_type(&values["MsgType"])?;
if msgtype == "ClientLogin" {
- return Ok((len, Self { error: match_variant!(values, Variant::String, "ErrorString")}));
+ return Ok((
+ len,
+ Self {
+ error: match_variant!(values, Variant::String, "ErrorString"),
+ },
+ ));
} else {
bail!(ProtocolError::WrongMsgType);
}
@@ -236,10 +310,22 @@ pub struct SessionInit {
impl HandshakeSerialize for SessionInit {
fn serialize(&self) -> Result<Vec<u8>, Error> {
let mut values: VariantMap = VariantMap::with_capacity(1);
- values.insert("MsgType".to_string(), Variant::String("SessionInit".to_string()));
- values.insert("Identities".to_string(), Variant::VariantList(self.identities.clone()));
- values.insert("BufferInfos".to_string(), Variant::VariantList(self.buffers.clone()));
- values.insert("NetworkIds".to_string(), Variant::VariantList(self.network_ids.clone()));
+ values.insert(
+ "MsgType".to_string(),
+ Variant::String("SessionInit".to_string()),
+ );
+ values.insert(
+ "Identities".to_string(),
+ Variant::VariantList(self.identities.clone()),
+ );
+ values.insert(
+ "BufferInfos".to_string(),
+ Variant::VariantList(self.buffers.clone()),
+ );
+ values.insert(
+ "NetworkIds".to_string(),
+ Variant::VariantList(self.network_ids.clone()),
+ );
return HandshakeSerialize::serialize(&values);
}
}
@@ -251,11 +337,14 @@ impl HandshakeDeserialize for SessionInit {
let msgtype = get_msg_type(&values["MsgType"])?;
if msgtype == "ClientLogin" {
- return Ok((len, Self {
- identities: match_variant!(values, Variant::VariantList, "Identities"),
- buffers: match_variant!(values, Variant::VariantList, "BufferInfos"),
- network_ids: match_variant!(values, Variant::VariantList, "NetworkIds")
- }));
+ return Ok((
+ len,
+ Self {
+ identities: match_variant!(values, Variant::VariantList, "Identities"),
+ buffers: match_variant!(values, Variant::VariantList, "BufferInfos"),
+ network_ids: match_variant!(values, Variant::VariantList, "NetworkIds"),
+ },
+ ));
} else {
bail!(ProtocolError::WrongMsgType);
}
diff --git a/src/protocol/message/handshake/types.rs b/src/protocol/message/handshake/types.rs
index 0c70914..99864b9 100644
--- a/src/protocol/message/handshake/types.rs
+++ b/src/protocol/message/handshake/types.rs
@@ -1,28 +1,24 @@
-use std::io::Read;
-use std::vec::Vec;
-use std::result::Result;
-use std::convert::TryInto;
use std::collections::HashMap;
+use std::convert::TryInto;
+use std::result::Result;
+use std::vec::Vec;
use failure::Error;
-use crate::util;
-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::ProtocolError;
+use crate::protocol::primitive::deserialize::Deserialize;
+use crate::protocol::primitive::serialize::Serialize;
+use crate::protocol::primitive::{String, Variant};
+use crate::util;
pub trait HandshakeSerialize {
fn serialize(&self) -> Result<Vec<u8>, Error>;
}
pub trait HandshakeDeserialize {
- fn parse(b: &[u8]) -> Result<(usize, Self), Error> where Self: std::marker::Sized ;
-}
-
-pub trait HandshakeQRead {
- fn read<T: Read>(stream: &mut T, buf: &mut [u8]) -> Result<usize, Error>;
+ fn parse(b: &[u8]) -> Result<(usize, Self), Error>
+ where
+ Self: std::marker::Sized;
}
pub type VariantMap = HashMap<String, Variant>;
@@ -61,33 +57,10 @@ impl HandshakeDeserialize for VariantMap {
match name {
Variant::String(x) => map.insert(x, value),
Variant::StringUTF8(x) => map.insert(x, value),
- _ => bail!(ProtocolError::WrongVariant)
+ _ => bail!(ProtocolError::WrongVariant),
};
}
return Ok((pos, map));
}
}
-
-impl HandshakeQRead for VariantMap {
- fn read<T: Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- s.read(&mut b[0..4])?;
- let (_, len) = i32::parse(&b[0..4])?;
-
- let mut pos = 4;
- for _ in 0..(len / 2) {
- pos += Variant::read(s, &mut b[pos..])?;
- pos += Variant::read(s, &mut b[pos..])?;
- }
-
-// let mut pos = 8;
-// let len: usize = len as usize;
-// loop {
-// if pos >= len { break; }
-// pos += Variant::read(s, &mut b[pos..])?;
-// pos += Variant::read(s, &mut b[pos..])?;
-// }
-
- return Ok(pos);
- }
-}
diff --git a/src/protocol/message/login.rs b/src/protocol/message/login.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/src/protocol/message/login.rs
@@ -0,0 +1 @@
+
diff --git a/src/protocol/message/mod.rs b/src/protocol/message/mod.rs
index 3b6d1a8..f1d4750 100644
--- a/src/protocol/message/mod.rs
+++ b/src/protocol/message/mod.rs
@@ -1,3 +1,5 @@
pub mod handshake;
-
pub use handshake::*;
+
+pub mod login;
+pub use login::*;
diff --git a/src/protocol/primitive/basic.rs b/src/protocol/primitive/basic.rs
deleted file mode 100644
index c9f462d..0000000
--- a/src/protocol/primitive/basic.rs
+++ /dev/null
@@ -1,282 +0,0 @@
-#[allow(dead_code)]
-pub const VOID: u32 = 0x00000000;
-pub const BOOL: u32 = 0x00000001;
-pub const QCHAR: u32 = 0x00000007;
-
-pub const QVARIANT: u32 = 0x00000090;
-pub const QVARIANTMAP: u32 = 0x00000008;
-pub const QVARIANTLIST: u32 = 0x00000009;
-
-pub const QSTRING: u32 = 0x0000000a;
-pub const QSTRINGLIST: u32 = 0x0000000b;
-pub const QBYTEARRAY: u32 = 0x0000000c;
-
-pub const QTIME: u32 = 0x0000000f;
-pub const QDATETIME: u32 = 0x00000010;
-pub const USERTYPE: u32 = 0x0000007f;
-
-
-// Basic types
-pub const LONG: u32 = 0x00000081; // int64_t
-pub const INT: u32 = 0x00000002; // int32_t
-pub const SHORT: u32 = 0x00000082; // int16_t
-pub const CHAR: u32 = 0x00000083; // int8_t
-
-pub const ULONG: u32 = 0x00000084; // uint64_t
-pub const UINT: u32 = 0x00000003; // uint32_t
-pub const USHORT: u32 = 0x00000085; // uint16_t
-pub const UCHAR: u32 = 0x00000086; // uint8_t
-
-extern crate byteorder;
-use std::io::Cursor;
-use byteorder::{BigEndian, ReadBytesExt};
-
-use std::vec::Vec;
-use std::result::Result;
-use std::convert::TryInto;
-
-use failure::Error;
-
-use crate::util;
-use crate::protocol::error::ProtocolError;
-use crate::protocol::primitive::{deserialize, serialize, qread};
-
-impl deserialize::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 qread::QRead for bool {
- fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- Ok(s.read(&mut b[0..1])?)
- }
-}
-
-impl deserialize::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 qread::QRead for u64 {
- fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- Ok(s.read(&mut b[0..8])?)
- }
-}
-
-impl deserialize::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 qread::QRead for u32 {
- fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- Ok(s.read(&mut b[0..4])?)
- }
-}
-
-impl deserialize::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 qread::QRead for u16 {
- fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- Ok(s.read(&mut b[0..2])?)
- }
-}
-
-impl deserialize::Deserialize for u8 {
- fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
- return Ok((1, b[0]));
- }
-}
-
-impl qread::QRead for u8 {
- fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- Ok(s.read(&mut [b[0]])?)
- }
-}
-
-impl deserialize::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 qread::QRead for i64 {
- fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- Ok(s.read(&mut b[0..8])?)
- }
-}
-
-impl deserialize::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 qread::QRead for i32 {
- fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- Ok(s.read(&mut b[0..4])?)
- }
-}
-
-impl deserialize::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 qread::QRead for i16 {
- fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- Ok(s.read(&mut b[0..2])?)
- }
-}
-
-impl deserialize::Deserialize for i8 {
- fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
- return Ok((1, b[0].try_into()?));
- }
-}
-
-impl qread::QRead for i8 {
- fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- return Ok(s.read(&mut [b[0]])?)
- }
-}
-
-
-
-pub type String = std::string::String;
-impl serialize::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 serialize::SerializeUTF8 for String {
- fn serialize_utf8(&self) -> Result<Vec<u8>, Error> {
- let mut res: Vec<u8> = Vec::new();
- res.extend(self.clone().into_bytes());
- util::prepend_byte_len(&mut res);
- return Ok(res);
- }
-}
-
-impl deserialize::Deserialize for String {
- fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
- 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)])?;
- chars.push(uchar);
- pos += slen;
- }
-
- let res: String = String::from_utf16(&chars).unwrap();
- return Ok((pos, res));
- }
-}
-
-impl deserialize::DeserializeUTF8 for String {
- fn parse_utf8(b: &[u8]) -> Result<(usize, Self), Error> {
- use crate::protocol::primitive::deserialize::Deserialize;
- let (_, len) = i32::parse(&b[0..4])?;
-
- let ulen = len as usize;
-
- 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: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- use crate::protocol::primitive::deserialize::Deserialize;
-
- 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)])?;
-
- return Ok(4 + ulen);
- }
-}
-
-pub type StringList = Vec<String>;
-impl serialize::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::Deserialize for StringList {
- fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
- 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..])?;
- pos += lpos;
- res.push(val);
- }
- }
-
- return Ok((pos, res));
- }
-}
-
-impl qread::QRead for StringList {
- fn read<T: std::io::Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- use crate::protocol::primitive::deserialize::Deserialize;
-
- 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..])?;
- }
-
- return Ok(pos);
- }
-}
diff --git a/src/protocol/primitive/bufferinfo.rs b/src/protocol/primitive/bufferinfo.rs
new file mode 100644
index 0000000..4c69286
--- /dev/null
+++ b/src/protocol/primitive/bufferinfo.rs
@@ -0,0 +1,74 @@
+use std::vec::Vec;
+
+use failure::Error;
+
+use crate::protocol::primitive::deserialize::{Deserialize, DeserializeUTF8};
+use crate::protocol::primitive::serialize::{Serialize, SerializeUTF8};
+use crate::protocol::primitive::String;
+
+extern crate bytes;
+
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct BufferInfo {
+ pub id: i32, // a unique, sequential id for the buffer
+ pub network_id: i32, // NetworkId of the network the buffer belongs to
+ pub buffer_type: BufferType,
+ pub name: String, // BufferName as displayed to the user
+}
+
+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 undocumted 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,
+ },
+ ));
+ }
+}
+
+#[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/protocol/primitive/datetime.rs b/src/protocol/primitive/datetime.rs
new file mode 100644
index 0000000..688a022
--- /dev/null
+++ b/src/protocol/primitive/datetime.rs
@@ -0,0 +1,93 @@
+use crate::protocol::primitive::deserialize::Deserialize;
+use crate::protocol::primitive::serialize::Serialize;
+
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct DateTime {
+ julian_day: i32, // Day in Julian calendar, unknown if signed or unsigned
+ millis_of_day: i32, // Milliseconds since start of day
+ zone: u8, // Timezone of DateTime, 0x00 is local, 0x01 is UTC
+}
+
+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,
+ },
+ ));
+ }
+}
+
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct Date {
+ julian_day: i32, // Day in Julian calendar, unknown if signed or unsigned
+}
+
+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 }));
+ }
+}
+
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct Time {
+ millis_of_day: i32, // Milliseconds since start of day
+}
+
+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/protocol/primitive/message.rs b/src/protocol/primitive/message.rs
new file mode 100644
index 0000000..4ae895d
--- /dev/null
+++ b/src/protocol/primitive/message.rs
@@ -0,0 +1,184 @@
+use std::vec::Vec;
+
+use failure::Error;
+
+use crate::protocol::primitive::deserialize::{Deserialize, DeserializeUTF8};
+use crate::protocol::primitive::serialize::{Serialize, SerializeUTF8};
+
+use crate::protocol::primitive::BufferInfo;
+use crate::protocol::primitive::String;
+
+extern crate bytes;
+
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct Message {
+ pub msg_id: i32, // The unique, sequential id for the message
+ pub timestamp: i64, // The timestamp of the message in UNIX time (32-bit, seconds, 64-bit if LONGMESSAGE feature enabled)
+ pub msg_type: MessageType,
+ pub flags: i8,
+ pub buffer: BufferInfo, // The buffer the message belongs to, usually everything but BufferId is set to NULL
+ pub sender: String, // The sender as nick!ident@host
+ pub sender_prefixes: Option<String>, // The prefix modes of the sender
+ pub real_name: Option<String>, // The realName of the sender
+ pub avatar_url: Option<String>, // The avatarUrl of the sender, if available
+ pub content: String, // The message content, already stripped from CTCP formatting, but containing mIRC format codes
+}
+
+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,
+}
+
+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,
+ _ => unimplemented!(),
+ }
+ }
+}
diff --git a/src/protocol/primitive/mod.rs b/src/protocol/primitive/mod.rs
index fb843ad..5656d71 100644
--- a/src/protocol/primitive/mod.rs
+++ b/src/protocol/primitive/mod.rs
@@ -1,10 +1,53 @@
-#[allow(dead_code)]
-pub mod basic;
+pub mod bufferinfo;
+pub mod datetime;
+pub mod message;
+pub mod signedint;
+pub mod string;
+pub mod stringlist;
+pub mod unsignedint;
pub mod variant;
+pub mod variantlist;
+pub mod variantmap;
-pub use basic::*;
+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::*;
+// Static Type Definitions
+pub const VOID: u32 = 0x00000000;
+pub const BOOL: u32 = 0x00000001;
+pub const QCHAR: u32 = 0x00000007;
+
+pub const QVARIANT: u32 = 0x00000090;
+pub const QVARIANTMAP: u32 = 0x00000008;
+pub const QVARIANTLIST: u32 = 0x00000009;
+
+pub const QSTRING: u32 = 0x0000000a;
+pub const QSTRINGLIST: u32 = 0x0000000b;
+pub const QBYTEARRAY: u32 = 0x0000000c;
+
+pub const QDATE: u32 = 0x0000000e;
+pub const QTIME: u32 = 0x0000000f;
+pub const QDATETIME: u32 = 0x00000010;
+pub const USERTYPE: u32 = 0x0000007f;
+
+// Basic types
+pub const LONG: u32 = 0x00000081; // int64_t
+pub const INT: u32 = 0x00000002; // int32_t
+pub const SHORT: u32 = 0x00000082; // int16_t
+pub const CHAR: u32 = 0x00000083; // int8_t
+
+pub const ULONG: u32 = 0x00000084; // uint64_t
+pub const UINT: u32 = 0x00000003; // uint32_t
+pub const USHORT: u32 = 0x00000085; // uint16_t
+pub const UCHAR: u32 = 0x00000086; // uint8_t
pub mod serialize {
use failure::Error;
@@ -19,16 +62,13 @@ pub mod serialize {
pub mod deserialize {
use failure::Error;
pub trait Deserialize {
- fn parse(b: &[u8]) -> Result<(usize, Self), Error> where Self: std::marker::Sized ;
+ fn parse(b: &[u8]) -> Result<(usize, Self), Error>
+ where
+ Self: std::marker::Sized;
}
pub trait DeserializeUTF8 {
- fn parse_utf8(b: &[u8]) -> Result<(usize, Self), Error> where Self: std::marker::Sized ;
- }
-}
-
-pub mod qread {
- use failure::Error;
- pub trait QRead {
- fn read<T: std::io::Read>(stream: &mut T, buf: &mut [u8]) -> Result<usize, Error>;
+ fn parse_utf8(b: &[u8]) -> Result<(usize, Self), Error>
+ where
+ Self: std::marker::Sized;
}
}
diff --git a/src/protocol/primitive/signedint.rs b/src/protocol/primitive/signedint.rs
new file mode 100644
index 0000000..67ffb9d
--- /dev/null
+++ b/src/protocol/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::protocol::primitive::{deserialize, serialize};
+
+impl serialize::Serialize for i64 {
+ fn serialize(&self) -> Result<Vec<u8>, Error> {
+ Ok(Vec::from(self.to_be_bytes()))
+ }
+}
+
+impl deserialize::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::Serialize for i32 {
+ fn serialize(&self) -> Result<Vec<u8>, Error> {
+ Ok(Vec::from(self.to_be_bytes()))
+ }
+}
+
+impl deserialize::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::Serialize for i16 {
+ fn serialize(&self) -> Result<Vec<u8>, Error> {
+ Ok(Vec::from(self.to_be_bytes()))
+ }
+}
+
+impl deserialize::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::Serialize for i8 {
+ fn serialize(&self) -> Result<Vec<u8>, Error> {
+ Ok(Vec::from(self.to_be_bytes()))
+ }
+}
+
+impl deserialize::Deserialize for i8 {
+ fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+ return Ok((1, b[0].try_into()?));
+ }
+}
diff --git a/src/protocol/primitive/string.rs b/src/protocol/primitive/string.rs
new file mode 100644
index 0000000..470f018
--- /dev/null
+++ b/src/protocol/primitive/string.rs
@@ -0,0 +1,91 @@
+extern crate byteorder;
+
+use std::result::Result;
+use std::vec::Vec;
+
+use failure::Error;
+
+use log::trace;
+
+use crate::protocol::primitive::{deserialize, serialize};
+use crate::util;
+
+pub type String = std::string::String;
+impl serialize::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 serialize::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::Deserialize for String {
+ fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+ // Parse Length
+ let (_, len) = i32::parse(&b[0..4])?;
+ trace!(target: "protocol::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 deserialize::DeserializeUTF8 for String {
+ fn parse_utf8(b: &[u8]) -> Result<(usize, Self), Error> {
+ use crate::protocol::primitive::deserialize::Deserialize;
+ let (_, len) = i32::parse(&b[0..4])?;
+
+ trace!(target: "protocol::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/protocol/primitive/stringlist.rs b/src/protocol/primitive/stringlist.rs
new file mode 100644
index 0000000..d2902f2
--- /dev/null
+++ b/src/protocol/primitive/stringlist.rs
@@ -0,0 +1,45 @@
+extern crate byteorder;
+
+use std::convert::TryInto;
+use std::result::Result;
+use std::vec::Vec;
+
+use failure::Error;
+
+use log::trace;
+
+use crate::protocol::primitive::{deserialize, serialize};
+
+pub type StringList = Vec<String>;
+impl serialize::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::Deserialize for StringList {
+ fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+ let (_, len) = i32::parse(&b[0..4])?;
+ trace!(target: "protocol::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/protocol/primitive/unsignedint.rs b/src/protocol/primitive/unsignedint.rs
new file mode 100644
index 0000000..5b42e3c
--- /dev/null
+++ b/src/protocol/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::protocol::error::ProtocolError;
+use crate::protocol::primitive::{deserialize, serialize};
+
+impl serialize::Serialize for bool {
+ fn serialize(&self) -> Result<Vec<u8>, Error> {
+ Ok({
+ let i = *self as i8;
+ Vec::from(i.to_be_bytes())
+ })
+ }
+}
+impl deserialize::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::Serialize for u64 {
+ fn serialize(&self) -> Result<Vec<u8>, Error> {
+ Ok(Vec::from(self.to_be_bytes()))
+ }
+}
+
+impl deserialize::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::Serialize for u32 {
+ fn serialize(&self) -> Result<Vec<u8>, Error> {
+ Ok(Vec::from(self.to_be_bytes()))
+ }
+}
+
+impl deserialize::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::Serialize for u16 {
+ fn serialize(&self) -> Result<Vec<u8>, Error> {
+ Ok(Vec::from(self.to_be_bytes()))
+ }
+}
+
+impl deserialize::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::Serialize for u8 {
+ fn serialize(&self) -> Result<Vec<u8>, Error> {
+ Ok(Vec::from(self.to_be_bytes()))
+ }
+}
+
+impl deserialize::Deserialize for u8 {
+ fn parse(b: &[u8]) -> Result<(usize, Self), Error> {
+ return Ok((1, b[0]));
+ }
+}
diff --git a/src/protocol/primitive/variant.rs b/src/protocol/primitive/variant.rs
index 1c90574..84150a8 100644
--- a/src/protocol/primitive/variant.rs
+++ b/src/protocol/primitive/variant.rs
@@ -1,130 +1,37 @@
-use std::io::Read;
use std::vec::Vec;
-use std::convert::TryInto;
-use std::collections::HashMap;
use failure::Error;
-use crate::util;
-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 log::{error, trace};
+
use crate::protocol::error::ProtocolError;
use crate::protocol::primitive;
+use crate::protocol::primitive::deserialize::{Deserialize, DeserializeUTF8};
+use crate::protocol::primitive::serialize::{Serialize, SerializeUTF8};
+use crate::protocol::primitive::{String, StringList};
-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])?;
-
- let mut pos = 4;
- let mut map = VariantMap::new();
- for _ in 0..len {
- let (nlen, name) = String::parse(&b[(pos)..])?;
- pos += nlen;
-
- let (vlen, value) = Variant::parse(&b[(pos)..])?;
- pos += vlen;
-
- map.insert(name, value);
- }
-
- return Ok((pos, map));
- }
-}
-
-impl QRead for VariantMap {
- fn read<T: Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- s.read(&mut 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..)])?;
- }
-
- return Ok(pos);
- }
-}
-
-/////////////////////////////////////////////////////////////////////////
-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])?;
-
- let mut res: VariantList = VariantList::new();
- let mut pos: usize = 4;
- for _ in 0..len {
- let (vlen, val) = Variant::parse(&b[pos..])?;
- res.push(val);
- pos += vlen;
- }
-
- return Ok((pos, res));
- }
-}
-
-impl QRead for VariantList {
- fn read<T: Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
- s.read(&mut 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..)])?;
- }
+extern crate bytes;
+use bytes::BytesMut;
- return Ok(pos);
- }
-}
+use crate::protocol::primitive::{
+ BufferInfo, Date, DateTime, Message, Time, VariantList, VariantMap,
+};
-/////////////////////////////////////////////////////////////////////////
#[allow(non_camel_case_types, dead_code)]
#[derive(Clone, Debug, std::cmp::PartialEq)]
pub enum Variant {
Unknown,
+ UserType(String, BytesMut),
+ BufferInfo(BufferInfo),
+ Message(Message),
+ Time(Time),
+ Date(Date),
+ DateTime(DateTime),
VariantMap(VariantMap),
VariantList(VariantList),
String(String),
StringUTF8(String),
+ ByteArray(String),
StringList(StringList),
bool(bool),
u64(u64),
@@ -144,82 +51,106 @@ impl Serialize for Variant {
match self {
Variant::Unknown => {
- bail!(ProtocolError::UnknownVariant);
- },
+ 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::ByteArray(v) => {
+ res.extend(primitive::QBYTEARRAY.to_be_bytes().iter());
+ res.extend(unknown.to_be_bytes().iter());
+ res.extend(v.serialize_utf8()?.iter());
+ res.extend(vec![0x00]);
+ }
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(_, _) => unimplemented!(),
+ Variant::BufferInfo(_) => unimplemented!(),
+ Variant::Message(_) => unimplemented!(),
+ 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)
+ return Ok(res);
}
}
@@ -234,96 +165,126 @@ impl Deserialize for Variant {
let len = 5;
match qtype {
primitive::QVARIANTMAP => {
+ trace!(target: "protocol::primitive::Variant", "Parsing Variant: VariantMap");
let (vlen, value) = VariantMap::parse(&b[len..])?;
- return Ok((len+vlen, Variant::VariantMap(value)));
- },
+ return Ok((len + vlen, Variant::VariantMap(value)));
+ }
primitive::QVARIANTLIST => {
+ trace!(target: "protocol::primitive::Variant", "Parsing Variant: VariantList");
let (vlen, value) = VariantList::parse(&b[len..])?;
- return Ok((len+vlen, Variant::VariantList(value)));
- },
+ return Ok((len + vlen, Variant::VariantList(value)));
+ }
primitive::QSTRING => {
+ trace!(target: "protocol::primitive::Variant", "Parsing Variant: String");
let (vlen, value) = String::parse(&b[len..])?;
- return Ok((len+vlen, Variant::String(value.clone())));
- },
+ return Ok((len + vlen, Variant::String(value.clone())));
+ }
primitive::QBYTEARRAY => {
+ trace!(target: "protocol::primitive::Variant", "Parsing Variant: ByteArray");
let (vlen, value) = String::parse_utf8(&b[len..])?;
- return Ok((len+vlen, Variant::StringUTF8(value.clone())));
- },
+ return Ok((len + vlen, Variant::StringUTF8(value.clone())));
+ }
primitive::QSTRINGLIST => {
+ trace!(target: "protocol::primitive::Variant", "Parsing Variant: StringList");
let (vlen, value) = StringList::parse(&b[len..])?;
- return Ok((len+vlen, Variant::StringList(value.clone())));
- },
+ return Ok((len + vlen, Variant::StringList(value.clone())));
+ }
+ primitive::QDATETIME => {
+ trace!(target: "protocol::primitive::Variant", "Parsing Variant: Date");
+ let (vlen, value) = Date::parse(&b[len..])?;
+ return Ok((len + vlen, Variant::Date(value.clone())));
+ }
+ primitive::QDATE => {
+ trace!(target: "protocol::primitive::Variant", "Parsing Variant: Date");
+ let (vlen, value) = Date::parse(&b[len..])?;
+ return Ok((len + vlen, Variant::Date(value.clone())));
+ }
+ primitive::QTIME => {
+ trace!(target: "protocol::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)));
- },
+ return Ok((len + vlen, Variant::bool(value)));
+ }
primitive::ULONG => {
let (vlen, value) = u64::parse(&b[len..])?;
- return Ok((len+vlen, Variant::u64(value)));
- },
+ return Ok((len + vlen, Variant::u64(value)));
+ }
primitive::UINT => {
let (vlen, value) = u32::parse(&b[len..])?;
- return Ok((len+vlen, Variant::u32(value)));
- },
+ return Ok((len + vlen, Variant::u32(value)));
+ }
primitive::USHORT => {
let (vlen, value) = u16::parse(&b[len..])?;
- return Ok((len+vlen, Variant::u16(value)));
- },
+ return Ok((len + vlen, Variant::u16(value)));
+ }
primitive::UCHAR => {
let (vlen, value) = u8::parse(&b[len..])?;
- return Ok((len+vlen, Variant::u8(value)));
- },
+ return Ok((len + vlen, Variant::u8(value)));
+ }
primitive::LONG => {
let (vlen, value) = i64::parse(&b[len..])?;
- return Ok((len+vlen, Variant::i64(value)));
- },
+ return Ok((len + vlen, Variant::i64(value)));
+ }
primitive::INT => {
let (vlen, value) = i32::parse(&b[len..])?;
- return Ok((len+vlen, Variant::i32(value)));
- },
+ return Ok((len + vlen, Variant::i32(value)));
+ }
primitive::SHORT => {
let (vlen, value) = i16::parse(&b[len..])?;
- return Ok((len+vlen, Variant::i16(value)));
- },
+ return Ok((len + vlen, Variant::i16(value)));
+ }
primitive::CHAR => {
let (vlen, value) = i8::parse(&b[len..])?;
- return Ok((len+vlen, Variant::i8(value)));
- },
- _ => {
+ return Ok((len + vlen, Variant::i8(value)));
+ }
+ primitive::USERTYPE => {
+ trace!(target: "protocol::primitive::Variant", "Parsing UserType");
+ // Parse UserType name
+ let (user_type_len, user_type) = String::parse_utf8(&b[len..])?;
+
+ trace!(target: "protocol::primitive::Variant", "Parsing UserType: {:?}", user_type);
+
+ // Match Possible User Types to basic structures
+ match user_type.as_str() {
+ // As VariantMap
+ "IrcUser" | "IrcChannel" | "Identity" | "NetworkInfo" | "Network::Server" => {
+ trace!(target: "protocol::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: "protocol::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: "protocol::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: "protocol::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: "protocol::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);
}
}
}
}
-
-impl QRead for Variant {
- fn read<T: Read>(s: &mut T, b: &mut [u8]) -> Result<usize, Error> {
-
- s.read(&mut b[0..4])?;
- let (_, qtype) = i32::parse(&b[0..4])?;
- let qtype = qtype as u32;
-
- 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..])?,
- _ => bail!(ProtocolError::UnknownVariant)
- }
-
- return Ok(len);
- }
-}
diff --git a/src/protocol/primitive/variantlist.rs b/src/protocol/primitive/variantlist.rs
new file mode 100644
index 0000000..2481b32
--- /dev/null
+++ b/src/protocol/primitive/variantlist.rs
@@ -0,0 +1,46 @@
+use std::convert::TryInto;
+use std::vec::Vec;
+
+use failure::Error;
+
+use log::trace;
+
+use crate::protocol::primitive::{deserialize::Deserialize, serialize::Serialize};
+
+extern crate bytes;
+
+use crate::protocol::primitive::Variant;
+
+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: "protocol::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: "protocol::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/protocol/primitive/variantmap.rs b/src/protocol/primitive/variantmap.rs
new file mode 100644
index 0000000..22ca0f1
--- /dev/null
+++ b/src/protocol/primitive/variantmap.rs
@@ -0,0 +1,63 @@
+use std::collections::HashMap;
+use std::{convert::TryInto, vec::Vec};
+
+use failure::Error;
+
+use log::trace;
+
+use crate::protocol::error::ProtocolError;
+use crate::protocol::primitive::deserialize::Deserialize;
+use crate::protocol::primitive::serialize::Serialize;
+use crate::protocol::primitive::String;
+
+use crate::protocol::primitive::Variant;
+use crate::util;
+
+extern crate bytes;
+
+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: "protocol::primitive::VariantMap", "Parsing VariantMap with {:?} elements", len);
+
+ let mut pos: usize = 4;
+ let mut map = VariantMap::new();
+ for _ in 0..len {
+ trace!(target: "protocol::primitive::VariantMap", "Parsing entry name");
+ // let (nlen, name) = Variant::parse(&b[pos..])?;
+ let (nlen, name) = String::parse(&b[pos..])?;
+ pos += nlen;
+
+ trace!(target: "protocol::primitive::VariantMap", "Parsing entry: {:?} with len {:?}", name, &b[(pos)..(pos + 4)]);
+ 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),
+ // _ => bail!(ProtocolError::WrongVariant),
+ // };
+ map.insert(name, value);
+ }
+
+ return Ok((pos, map));
+ }
+}
generated by cgit v1.2.3 (git 2.46.0) at 2026-03-02 12:44:29 +0000