imitating the coax structure a little, adding the protos api + part of the JSON API definiton

src/irssi/mod.rs

@@ -0,0 +1 @@
+pub mod bindings;

src/lib.rs

@@ -1,8 +1,13 @@
-use std::os::raw::{c_char, c_int};
+use std::os::raw::c_int;
 use std::ffi::CString;
-mod bindings;
+use std::thread;
+use std::time::Duration;
 
-use bindings::*;
+mod irssi;
+mod net;
+mod storage;
+
+use irssi::bindings::*;
 
 #[no_mangle]
 pub extern fn wire_core_abicheck(version: *mut c_int) {
@@ -17,6 +22,14 @@ pub extern fn wire_core_init() {
     unsafe {
         module_register_full(CString::new("wire").unwrap().as_ptr(), CString::new("core").unwrap().as_ptr(), CString::new("wire/core").unwrap().as_ptr());
     }
+    thread::spawn(|| {
+        let mut i = 0;
+        loop {
+            thread::sleep(Duration::from_secs(10));
+            println!("{} iteration", i);
+            i += 1;
+        }
+    });
 }
 
 #[no_mangle]

src/net/mod.rs

@@ -0,0 +1,2 @@
+pub(crate) mod protos;
+pub(crate) mod model;

src/net/model/client.rs

@@ -0,0 +1,97 @@
+#![allow(non_camel_case_types)]
+use std::collections::{HashMap, HashSet};
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use uuid::Uuid;
+
+ use crate::net::model::prekeys::{PreKey, LastPreKey};
+// Client
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct Client {
+    pub id: String,
+    pub class: Option<Class>,
+    pub time: Option<DateTime<Utc>>,
+    pub r#type: Option<ClientType>,
+    pub cookie_label: Option<String>,
+    pub label: Option<String>,
+    pub model: Option<String>
+}
+
+#[derive(Serialize, Deserialize, Copy, Clone, Debug)]
+pub enum Class {
+    phone,
+    tablet,
+    desktop
+}
+
+#[derive(Serialize, Deserialize, Copy, Clone, Debug)]
+pub enum ClientType {
+    permanent,
+    temporary
+}
+
+// PubClientView
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct PubClientView {
+    pub id: String,
+    pub class: Class
+}
+
+// SignalingKeys
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct SignalingKeys {
+    #[serde(serialize_with = "b64_encode", deserialize_with = "b64_decode")]
+    pub enc: Vec<u8>,
+    #[serde(serialize_with = "b64_encode", deserialize_with = "b64_decode")]
+    pub mac: Vec<u8>
+}
+
+fn b64_encode<'a, S>(bytes: &'a Vec<u8>, serialzer: S) -> Result<S::Ok, S::Error>
+    where S: Serializer
+{
+    serialzer.serialize_str(&base64::encode(&bytes))
+}
+
+fn b64_decode<'de, D>(deserialzer: D) -> Result<Vec<u8>, D::Error>
+    where D: Deserializer<'de>
+{
+    use serde::de::Error;
+
+    String::deserialize(deserialzer)
+        .and_then(|string|
+                  base64::decode(&string)
+                  .map_err(|e| Error::custom(e.to_string()))
+        )
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct User2Clients {
+    pub value: HashMap<Uuid, HashSet<String>>
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct ClientMismatch {
+    pub time: DateTime<Utc>,
+    pub redundant: User2Clients,
+    pub missing: User2Clients,
+    pub deleted: User2Clients
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct RegisterParams{
+    pub prekeys: Vec<PreKey>,
+    pub last_prekey: LastPreKey,
+    pub sig_keys: SignalingKeys,
+    pub ctype: ClientType,
+    pub class: Class,
+    pub cookie_label: String,
+    pub label: Option<String>,
+    pub password: Option<String>,
+    pub model: Option<String>
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+struct DeleteParams {
+    password: String
+}

src/net/model/mod.rs

@@ -0,0 +1,2 @@
+pub mod client;
+pub mod prekeys;

src/net/model/prekeys.rs

@@ -0,0 +1,28 @@
+#![allow(non_camel_case_types)]
+use std::collections::HashMap;
+
+use proteus::keys::PreKeyBundle;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct PreKeyMap {
+    pub value: HashMap<Uuid, HashMap<String, Option<PreKey>>>
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct PreKey {
+    pub key: PreKeyBundle
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct LastPreKey(PreKey);
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct ClientPreKey {
+    pub id: String,
+    pub key: PreKey
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct ClientPreKeys(Vec<ClientPreKey>);

src/net/protos/mod.rs

@@ -0,0 +1 @@
+pub mod wire_api;