update

10 files changed, 293 insertions, 52 deletions

diff --git a/src/bin/quassel-client.rs b/src/bin/quassel-client.rs
deleted file mode 100644
index 233d3ae..0000000
--- a/src/bin/quassel-client.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-use failure::Error;
-
-extern crate libquassel;
-use libquassel::client;
-
-extern crate tokio;
-extern crate pretty_env_logger;
-
-#[tokio::main]
-async fn main() -> Result<(), Error> {
-    pretty_env_logger::init();
-
-//    let mut client = client::Client::<tokio::net::TcpStream>::connect(
-//        "cocaine.farm",
-//        4242,
-//        true,
-//    ).await.unwrap();
-
-    let username = std::env::args().nth(1).expect("no username given");
-    let password = std::env::args().nth(2).expect("no password given");
-
-
-    let mut client = client::Client::<tokio_tls::TlsStream<tokio::net::TcpStream>>::connect_tls(
-        "cocaine.farm",
-        4242,
-        true,
-        client::User {
-            name: username,
-            password: password,
-        }
-    ).await.unwrap();
-
-    client.run().await;
-//    client.login("audron", "audron", client_init);
-
-    Ok(())
-} // the stream is closed here
diff --git a/src/client/mod.rs b/src/client/mod.rs
index 9f0d66c..1b6139f 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -31,6 +31,11 @@ pub struct Client<T: AsyncRead + AsyncWrite + Unpin> {
     pub compression: bool,
     pub state: ClientState,
     pub user: User,
+    pub funcs: Funcs,
+}
+
+pub struct Funcs {
+    pub rpc_call: crate::message::RpcCallClient,
 }
 
 pub struct User {
@@ -75,7 +80,7 @@ impl <T: AsyncRead + AsyncWrite + Unpin> Client<T> {
         };
     }
 
-    pub async fn connect(address: &'static str, port: u64, compression: bool, user: User) -> Result<Client<TcpStream>, Error> {
+    pub async fn connect(address: &'static str, port: u64, compression: bool, user: User, funcs: Funcs) -> Result<Client<TcpStream>, Error> {
         let mut stream = TcpStream::connect(format!("{}:{}", address, port)).await?;
 
         info!(target: "init", "Establishing Connection");
@@ -97,10 +102,11 @@ impl <T: AsyncRead + AsyncWrite + Unpin> Client<T> {
             compression,
             state: ClientState::Handshake,
             user,
+            funcs,
         });
     }
 
-    pub async fn connect_tls(address: &'static str, port: u64, compression: bool, user: User) -> Result<Client<TlsStream<TcpStream>>, Error> {
+    pub async fn connect_tls(address: &'static str, port: u64, compression: bool, user: User, funcs: Funcs) -> Result<Client<TlsStream<TcpStream>>, Error> {
         let mut stream: TcpStream = TcpStream::connect(format!("{}:{}", address, port)).await?;
 
         info!(target: "init", "Establishing Connection");
@@ -126,6 +132,7 @@ impl <T: AsyncRead + AsyncWrite + Unpin> Client<T> {
             compression,
             state: ClientState::Handshake,
             user,
+            funcs,
         });
     }
 
@@ -171,7 +178,7 @@ pub async fn handle_login_message<T: AsyncRead + AsyncWrite + Unpin>(client: &mu
 
 pub async fn handle_message<T: AsyncRead + AsyncWrite + Unpin>(client: &mut Client<T>, buf: &[u8]) -> Result<(), Error> {
     use crate::message::Message;
-    use crate::primitive::VariantList;
+    use crate::primitive::{VariantList, Variant};
     use crate::Deserialize;
     use crate::Serialize;
 
@@ -179,6 +186,23 @@ pub async fn handle_message<T: AsyncRead + AsyncWrite + Unpin>(client: &mut Clie
     let (_, res) = Message::parse(buf)?;
     debug!(target: "init", "Received Messsage: {:#?}", res);
 
+    match res {
+        Message::SyncMessage(_) => {}
+        Message::RpcCall(msg) => {
+            match msg.slot_name.as_str() {
+                "2displayMsg(Message)" => {
+                    (client.funcs.rpc_call.display_message)(match_variant!(msg.params[0], Variant::Message));
+                },
+                _ => {},
+            }
+
+        }
+        Message::InitRequest(_) => {}
+        Message::InitData(_) => {}
+        Message::HeartBeat(_) => {}
+        Message::HeartBeatReply(_) => {}
+    }
+
     return Ok(());
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index 215dcfc..a11ccf2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -13,6 +13,8 @@ extern crate failure;
 pub mod message;
 pub mod primitive;
 
+pub mod session;
+
 #[allow(dead_code)]
 pub mod error;
 
diff --git a/src/message/signalproxy/mod.rs b/src/message/signalproxy/mod.rs
index b0fd9ea..b69c6b0 100644
--- a/src/message/signalproxy/mod.rs
+++ b/src/message/signalproxy/mod.rs
@@ -3,6 +3,7 @@ use crate::{Deserialize, Serialize};
 mod heartbeat;
 mod initdata;
 mod initrequest;
+mod objects;
 mod rpccall;
 mod syncmessage;
 
@@ -26,6 +27,19 @@ pub enum Message {
     HeartBeatReply(HeartBeatReply),
 }
 
+// impl Message {
+//     fn act(&self) {
+//         match &self {
+//             Message::SyncMessage(value) => value.serialize(),
+//             Message::RpcCall(value) => value.serialize(),
+//             Message::InitRequest(value) => value.serialize(),
+//             Message::InitData(value) => value.serialize(),
+//             Message::HeartBeat(value) => value.serialize(),
+//             Message::HeartBeatReply(value) => value.serialize(),
+//         }
+//     }
+// }
+
 impl Serialize for Message {
     fn serialize(&self) -> Result<Vec<std::primitive::u8>, failure::Error> {
         match &self {
diff --git a/src/message/signalproxy/objects/aliasmanager.rs b/src/message/signalproxy/objects/aliasmanager.rs
new file mode 100644
index 0000000..7e9cfca
--- /dev/null
+++ b/src/message/signalproxy/objects/aliasmanager.rs
@@ -0,0 +1,46 @@
+use crate::primitive::{Variant, VariantMap};
+
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct AliasManager {
+    pub aliases: Vec<Alias>,
+}
+
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct Alias {
+    name: String,
+    expansion: String,
+}
+
+// impl AliasManager {
+//     /// Client to Server
+//     ///
+//     /// Replaces all properties of the object with the content of the
+//     /// "properties" parameter. This parameter is in network representation.
+//     ///
+//     fn request_update(self: Self, properties: VariantMap) {
+//         self.update(properties);
+//     }
+//
+//     /// Server to Client
+//     fn add_alias(self: Self, name: String, expansion: String) {
+//         self.aliases.push(Alias { name, expansion });
+//     }
+//
+//     /// Server to Client
+//     ///
+//     /// Replaces all properties of the object with the content of the
+//     /// "properties" parameter. This parameter is in network representation.
+//     ///
+//     fn update(self: Self, properties: VariantMap) {
+//         let mut alias: Vec<Alias> = Vec::new();
+//
+//         // for (i, name) in match_variant!(properties[&"Aliases".to_string()], Variant::String) {
+//         //     alias.push(Alias {
+//         //         name,
+//         //         expansion: match_variant!(properties["Aliases"], Variant::String)["expansions"][i],
+//         //     })
+//         // }
+//
+//         self.aliases = alias
+//     }
+// }
diff --git a/src/message/signalproxy/objects/backlogmanager.rs b/src/message/signalproxy/objects/backlogmanager.rs
new file mode 100644
index 0000000..86a7f61
--- /dev/null
+++ b/src/message/signalproxy/objects/backlogmanager.rs
@@ -0,0 +1,161 @@
+// interface BacklogManager {
+//
+//
+//     // C->S calls
+//
+//     /**
+//      * Loads backlog for `bufferId`, starting at message `first`, up to `last`
+//      * (plus `additional` more messages after `last`) but at most `limit`
+//      * messages total.
+//      */
+//     requestBacklog(bufferId: BufferId, first: MsgId, last: MsgId, limit: Int, additional: Int)
+//     /**
+//      * Same as `requestBacklog`, but only messages of a certain message `type`
+//      * with certain `flags` set.
+//      */
+//     requestBacklogFiltered(bufferId: BufferId, first: MsgId, last: MsgId, limit: Int, additional: Int, type: Int, flags: Int)
+//     /**
+//      * Same as `requestBacklog`, but applied to all buffers.
+//      */
+//     requestBacklogAll(first: MsgId, last: MsgId, limit: Int, additional: Int)
+//     /**
+//      * Same as `requestBacklogFiltered`, but applied to all buffers.
+//      */
+//     requestBacklogAllFiltered(first: MsgId, last: MsgId, limit: Int, additional: Int, type: Int, flags: Int)
+//
+//
+//     // S->C calls
+//
+//     /**
+//      * The response to `requestBacklog`, with the messages encoded as QVariants
+//      * in the `messages` parameter.
+//      */
+//     receiveBacklog(bufferId: BufferId, first: MsgId, last: MsgId, limit: Int, additional: Int, messages: QVariantList)
+//     /**
+//      * The response to `requestBacklogFiltered`, with the messages encoded as
+//      * QVariants in the `messages` parameter.
+//      */
+//     receiveBacklogFiltered(bufferId: BufferId, first: MsgId, last: MsgId, limit: Int, additional: Int, type: Int, flags: Int, messages: QVariantList)
+//     /**
+//      * The response to `requestBacklogAll`, with the messages encoded as
+//      * QVariants in the `messages` parameter.
+//      */
+//     receiveBacklogAll(first: MsgId, last: MsgId, limit: Int, additional: Int, messages: QVariantList)
+//     /**
+//      * The response to `requestBacklogAllFiltered`, with the messages encoded as
+//      * QVariants in the `messages` parameter.
+//      */
+//     receiveBacklogAllFiltered(first: MsgId, last: MsgId, limit: Int, additional: Int, type: Int, flags: Int, messages: QVariantList)
+// }
+
+use crate::primitive::VariantList;
+
+/// Receive and Request Backlog
+/// All "request" functions are Client to Server and all "receive" functions are Server to Client
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct BacklogManager {}
+
+impl BacklogManager {
+    /// Loads backlog for `bufferId`, starting at message `first`, up to `last`
+    /// (plus `additional` more messages after `last`) but at most `limit`
+    /// messages total.
+    fn requestBacklog(
+        self: Self,
+        buffer_id: u32,
+        first: u32,
+        last: u32,
+        limit: u32,
+        additional: u32,
+    ) {
+        unimplemented!()
+    }
+
+    /// Same as `requestBacklog`, but only messages of a certain message `type`
+    /// with certain `flags` set.
+    fn requestBacklogFiltered(
+        self: Self,
+        buffer_id: u32,
+        first: u32,
+        last: u32,
+        limit: u32,
+        additional: u32,
+        msgtype: u32,
+        flags: u32,
+    ) {
+        unimplemented!()
+    }
+
+    /// Same as `requestBacklog`, but applied to all buffers.
+    fn requestBacklogAll(self: Self, first: u32, last: u32, limit: u32, additional: u32) {
+        unimplemented!()
+    }
+
+    /// Same as `requestBacklogFiltered`, but applied to all buffers.
+    fn requestBacklogAllFiltered(
+        self: Self,
+        first: u32,
+        last: u32,
+        limit: u32,
+        additional: u32,
+        msgtype: u32,
+        flags: u32,
+    ) {
+        unimplemented!()
+    }
+
+    /// The response to `requestBacklog`, with the messages encoded as Variants
+    /// in the `messages` parameter.
+    fn receiveBacklog(
+        self: Self,
+        buffer_id: u32,
+        first: u32,
+        last: u32,
+        limit: u32,
+        additional: u32,
+        messages: VariantList,
+    ) {
+        unimplemented!()
+    }
+
+    /// The response to `requestBacklogFiltered`, with the messages encoded as
+    /// Variants in the `messages` parameter.
+    fn receiveBacklogFiltered(
+        self: Self,
+        buffer_id: u32,
+        first: u32,
+        last: u32,
+        limit: u32,
+        additional: u32,
+        msgtype: u32,
+        flags: u32,
+        messages: VariantList,
+    ) {
+        unimplemented!()
+    }
+
+    /// Same as `receiveBacklog`, but applied to all buffers.
+    fn receiveBacklogAll(
+        self: Self,
+        first: u32,
+        last: u32,
+        limit: u32,
+        additional: u32,
+        messages: VariantList,
+    ) {
+        unimplemented!()
+    }
+
+    /// Same as `receiveBacklogFiltered`, but applied to all buffers.
+    fn receiveBacklogAllFiltered(
+        self: Self,
+        first: u32,
+        last: u32,
+        limit: u32,
+        additional: u32,
+        msgtype: u32,
+        flags: u32,
+        messages: VariantList,
+    ) {
+        unimplemented!()
+    }
+}
diff --git a/src/message/signalproxy/objects/mod.rs b/src/message/signalproxy/objects/mod.rs
new file mode 100644
index 0000000..14dc42f
--- /dev/null
+++ b/src/message/signalproxy/objects/mod.rs
@@ -0,0 +1,6 @@
+mod aliasmanager;
+mod backlogmanager;
+
+pub trait Act {
+    fn act(self: Self);
+}
diff --git a/src/message/signalproxy/rpccall.rs b/src/message/signalproxy/rpccall.rs
index 748b226..2eac86d 100644
--- a/src/message/signalproxy/rpccall.rs
+++ b/src/message/signalproxy/rpccall.rs
@@ -1,21 +1,36 @@
 use crate::message::MessageType;
+use crate::primitive::Message;
 use crate::primitive::{Variant, VariantList};
 use crate::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, std::cmp::PartialEq)]
-pub struct RpcCall {
-    slot_name: String,
-    params: VariantList,
+pub enum RpcCall {
+    DisplayMessage(DisplayMessage),
 }
 
+#[derive(Clone, Debug, std::cmp::PartialEq)]
+pub struct DisplayMessage {
+    pub message: Message,
+}
+
+// #[derive(Clone, Debug, std::cmp::PartialEq)]
+// pub struct RpcCall {
+//     pub slot_name: String,
+//     pub params: VariantList,
+// }
+
 impl Serialize for RpcCall {
     fn serialize(&self) -> Result<Vec<std::primitive::u8>, failure::Error> {
         let mut res = VariantList::new();
 
         res.push(Variant::i32(MessageType::RpcCall as i32));
-        res.push(Variant::StringUTF8(self.slot_name.clone()));
 
-        res.append(&mut self.params.clone());
+        match self {
+            RpcCall::DisplayMessage(msg) => {
+                res.push(Variant::StringUTF8("2displayMsg(Message)".to_string()));
+                res.push(Variant::Message(msg.message.clone()));
+            }
+        }
 
         res.serialize()
     }
@@ -27,12 +42,18 @@ impl Deserialize for RpcCall {
 
         res.remove(0);
 
-        Ok((
-            size,
-            Self {
-                slot_name: match_variant!(res.remove(0), Variant::StringUTF8),
-                params: res,
-            },
-        ))
+        let rpc = match_variant!(res.remove(0), Variant::StringUTF8);
+
+        match rpc.as_str() {
+            "2displayMsg(Message)" => {
+                return Ok((
+                    size,
+                    RpcCall::DisplayMessage(DisplayMessage {
+                        message: match_variant!(res.remove(0), Variant::Message),
+                    }),
+                ))
+            }
+            _ => unimplemented!(),
+        }
     }
 }
diff --git a/src/message/signalproxy/syncmessage.rs b/src/message/signalproxy/syncmessage.rs
index fe69cf1..737f3e0 100644
--- a/src/message/signalproxy/syncmessage.rs
+++ b/src/message/signalproxy/syncmessage.rs
@@ -10,6 +10,8 @@ pub struct SyncMessage {
     params: VariantList,
 }
 
+// impl Act for SyncMessage {}
+
 impl Serialize for SyncMessage {
     fn serialize(&self) -> Result<Vec<std::primitive::u8>, failure::Error> {
         let mut res = VariantList::new();
diff --git a/src/session/mod.rs b/src/session/mod.rs
new file mode 100644
index 0000000..67045c9
--- /dev/null
+++ b/src/session/mod.rs
@@ -0,0 +1,2 @@
+/// The Session Trait is the main point of entry and implements the basic logic
+pub trait Session {}