Merge pull request #356 from tox-rs/invite

Add serde of invite packet for conferences

Author: Roman Proskuryakov

src/toxcore/friend_connection/packet/friend_requests.rs

@@ -24,7 +24,7 @@ pub const MAX_ONION_CLIENT_DATA_SIZE: usize = MAX_DATA_REQUEST_SIZE - MIN_ONION_
 
 This packet is used to transmit sender's long term public key, npspam and a message.
 It is sent by onion data packet or net-crypto.
-If the friend is already directly connected with me and not in group chat, it is sent using net-crypto.
+If the friend is already directly connected with me and not in conference, it is sent using net-crypto.
 Otherwise it is sent using onion.
 Both onion and net-crypto packet itself have real public key of sender.
 This is why this packet does not contain long term public key.

src/toxcore/messenger/conference/mod.rs

@@ -0,0 +1,4 @@
+/*! Conference Packets
+*/
+
+pub mod packet;

src/toxcore/messenger/conference/packet/invite.rs

@@ -0,0 +1,75 @@
+/*! Invite message struct.
+*/
+
+use nom::be_u16;
+
+use super::{ConferenceUID, ConferenceType};
+use crate::toxcore::binary_io::*;
+
+/** Invite is a struct that holds info to invite a peer to a conference.
+
+Serialized form:
+
+Length    | Content
+--------- | ------
+`1`       | `0x60`
+`1`       | `0x00`
+`2`       | `conference number`
+`1`       | `conference type`(0: text, 1: audio)
+`32`      | `unique id`
+
+*/
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Invite {
+    conference_number: u16,
+    conference_type: ConferenceType,
+    unique_id: ConferenceUID,
+}
+
+impl FromBytes for Invite {
+    named!(from_bytes<Invite>, do_parse!(
+        tag!("\x60") >>
+        tag!("\x00") >>
+        conference_number: be_u16 >>
+        conference_type: call!(ConferenceType::from_bytes) >>
+        unique_id: call!(ConferenceUID::from_bytes) >>
+        (Invite {
+            conference_number,
+            conference_type,
+            unique_id,
+        })
+    ));
+}
+
+impl ToBytes for Invite {
+    fn to_bytes<'a>(&self, buf: (&'a mut [u8], usize)) -> Result<(&'a mut [u8], usize), GenError> {
+        do_gen!(buf,
+            gen_be_u8!(0x60) >>
+            gen_be_u8!(0x00) >>
+            gen_be_u16!(self.conference_number) >>
+            gen_be_u8!(self.conference_type as u8) >>
+            gen_slice!(self.unique_id.0)
+        )
+    }
+}
+
+impl Invite {
+    /// Create new Invite object.
+    pub fn new(conference_number: u16, conference_type: ConferenceType, unique_id: ConferenceUID) -> Self {
+        Invite {
+            conference_number,
+            conference_type,
+            unique_id,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    encode_decode_test!(
+        invite_encode_decode,
+        Invite::new(1, ConferenceType::Text, ConferenceUID::random())
+    );
+}

src/toxcore/messenger/conference/packet/mod.rs

@@ -0,0 +1,85 @@
+/*! The implementation of conference packets.
+*/
+
+mod invite;
+
+pub use self::invite::*;
+
+use nom::be_u8;
+use crate::toxcore::binary_io::*;
+use crate::toxcore::crypto_core::*;
+
+/// Length of conference unique bytes
+pub const CONFERENCE_UID_BYTES: usize = 32;
+
+/// Unique id used in conference
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ConferenceUID([u8; CONFERENCE_UID_BYTES]);
+
+impl ConferenceUID {
+    /// Create new object
+    pub fn random() -> ConferenceUID {
+        let mut array = [0; CONFERENCE_UID_BYTES];
+        randombytes_into(&mut array);
+        ConferenceUID(array)
+    }
+
+    /// Custom from_slice function of ConferenceUID
+    pub fn from_slice(bs: &[u8]) -> Option<ConferenceUID> {
+        if bs.len() != CONFERENCE_UID_BYTES {
+            return None
+        }
+        let mut n = ConferenceUID([0; CONFERENCE_UID_BYTES]);
+        for (ni, &bsi) in n.0.iter_mut().zip(bs.iter()) {
+            *ni = bsi
+        }
+        Some(n)
+    }
+}
+
+impl FromBytes for ConferenceUID {
+    named!(from_bytes<ConferenceUID>, map_opt!(take!(CONFERENCE_UID_BYTES), ConferenceUID::from_slice));
+}
+
+impl ToBytes for ConferenceUID {
+    fn to_bytes<'a>(&self, buf: (&'a mut [u8], usize)) -> Result<(&'a mut [u8], usize), GenError> {
+        do_gen!(buf,
+            gen_slice!(self.0)
+        )
+    }
+}
+
+/// Type of conference
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ConferenceType {
+    /// Text conference.
+    Text = 0x00,
+    /// Audio conference.
+    Audio,
+}
+
+impl FromBytes for ConferenceType {
+    named!(from_bytes<ConferenceType>,
+        switch!(be_u8,
+            0 => value!(ConferenceType::Text) |
+            1 => value!(ConferenceType::Audio)
+        )
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    encode_decode_test!(
+        conference_uid_encode_decode,
+        ConferenceUID::random()
+    );
+
+    #[test]
+    fn conference_type_from_bytes() {
+        let raw = [0];
+        let (_, conference_type) = ConferenceType::from_bytes(&raw).unwrap();
+        assert_eq!(ConferenceType::Text, conference_type);
+    }
+}

src/toxcore/messenger/mod.rs

@@ -2,3 +2,4 @@
 */
 
 pub mod packet;
+pub mod conference;

src/toxcore/messenger/packet/offline.rs

@@ -6,7 +6,7 @@ use crate::toxcore::binary_io::*;
 /** Offline is a struct that holds nothing.
 
 This packet is used to notify that a friend is being deleted.
-Though the friend is deleted, because of group chat, Tox client
+Though the friend is deleted, because of conference, Tox client
 may try to connect to the friend, this message prevent this friend to
 be shown as Online.