parse user state diff and handle connecting clients

3 files changed, 89 insertions, 46 deletions

diff --git a/mumd/src/network/tcp.rs b/mumd/src/network/tcp.rs
index 88d2b59..c4804f8 100644
--- a/mumd/src/network/tcp.rs
+++ b/mumd/src/network/tcp.rs
@@ -285,23 +285,18 @@ async fn listen(
                         ControlPacket::UserState(msg) => {
                             let mut state = state.lock().unwrap();
                             let session = msg.get_session();
-                            if *state.phase_receiver().borrow() == StatePhase::Connecting {
-                                state.audio_mut().add_client(msg.get_session());
-                                state.parse_initial_user_state(*msg);
-                            } else {
-                                state.server_mut().unwrap().parse_user_state(*msg);
-                            }
+
+                            let user_state_diff = state.parse_user_state(*msg);
+                            //TODO do something with user state diff
+                            debug!("user state diff: {:#?}", &user_state_diff);
+
                             let server = state.server_mut().unwrap();
                             let user = server.users().get(&session).unwrap();
                             info!("User {} connected to {}", user.name(), user.channel());
                         }
                         ControlPacket::UserRemove(msg) => {
                             info!("User {} left", msg.get_session());
-                            state
-                                .lock()
-                                .unwrap()
-                                .audio_mut()
-                                .remove_client(msg.get_session());
+                            state.lock().unwrap().remove_client(msg.get_session());
                         }
                         ControlPacket::ChannelState(msg) => {
                             debug!("Channel state received");
diff --git a/mumd/src/state.rs b/mumd/src/state.rs
index 0dbf9c5..494f61f 100644
--- a/mumd/src/state.rs
+++ b/mumd/src/state.rs
@@ -8,6 +8,7 @@ use mumble_protocol::voice::Serverbound;
 use mumlib::command::{Command, CommandResponse};
 use mumlib::config::Config;
 use mumlib::error::{ChannelIdentifierError, Error};
+use mumlib::state::UserDiff;
 use serde::{Deserialize, Serialize};
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
@@ -178,33 +179,33 @@ impl State {
         }
     }
 
-    pub fn parse_initial_user_state(&mut self, msg: msgs::UserState) {
+    pub fn parse_user_state(&mut self, msg: msgs::UserState) -> Option<UserDiff> {
         if !msg.has_session() {
             warn!("Can't parse user state without session");
-            return;
+            return None;
         }
-        if !msg.has_name() {
-            warn!("Missing name in initial user state");
-        } else if msg.get_name() == self.server.as_ref().unwrap().username.as_ref().unwrap() {
-            match self.server.as_ref().unwrap().session_id {
-                None => {
-                    debug!("Found our session id: {}", msg.get_session());
-                    self.server_mut().unwrap().session_id = Some(msg.get_session());
-                }
-                Some(session) => {
-                    if session != msg.get_session() {
-                        error!(
-                            "Got two different session IDs ({} and {}) for ourselves",
-                            session,
-                            msg.get_session()
-                        );
-                    } else {
-                        debug!("Got our session ID twice");
-                    }
-                }
+        let sess = msg.get_session();
+        // check if this is initial state
+        if !self.server().unwrap().users().contains_key(&sess) {
+            if !msg.has_name() {
+                warn!("Missing name in initial user state");
+            }
+            if msg.get_name() == self.server().unwrap().username.as_ref().unwrap() {
+                // this is us
+                self.server_mut().unwrap().session_id = Some(sess);
+            } else {
+                // this is someone else
+                self.audio_mut().add_client(sess);
             }
+            self.server_mut().unwrap().users_mut().insert(sess, User::new(msg));
+            return None;
+        } else {
+            return Some(self.server_mut().unwrap().users_mut().get(&sess).unwrap().parse_state_diff(msg));
         }
-        self.server.as_mut().unwrap().parse_user_state(msg);
+    }
+
+    pub fn remove_client(&mut self, session: u32) {
+
     }
 
     pub fn reload_config(&mut self) {
@@ -309,19 +310,6 @@ impl Server {
         }
     }
 
-    pub fn parse_user_state(&mut self, msg: msgs::UserState) {
-        if !msg.has_session() {
-            warn!("Can't parse user state without session");
-            return;
-        }
-        match self.users.entry(msg.get_session()) {
-            Entry::Vacant(e) => {
-                e.insert(User::new(msg));
-            }
-            Entry::Occupied(mut e) => e.get_mut().parse_user_state(msg),
-        }
-    }
-
     pub fn channels(&self) -> &HashMap<u32, Channel> {
         &self.channels
     }
@@ -330,6 +318,10 @@ impl Server {
         &self.users
     }
 
+    pub fn users_mut(&mut self) -> &mut HashMap<u32, User> {
+        &mut self.users
+    }
+
     pub fn username(&self) -> Option<&str> {
         self.username.as_ref().map(|e| e.as_str())
     }
@@ -602,6 +594,41 @@ impl User {
         }
     }
 
+    pub fn parse_state_diff(&self, mut msg: msgs::UserState) -> UserDiff {
+        let mut ud = UserDiff::new();
+        if msg.has_comment() {
+            ud.comment = Some(msg.take_comment());
+        }
+        if msg.has_hash() {
+            ud.hash = Some(msg.take_hash());
+        }
+        if msg.has_name() {
+            ud.name = Some(msg.take_name());
+        }
+        if msg.has_priority_speaker() {
+            ud.priority_speaker = Some(msg.get_priority_speaker());
+        }
+        if msg.has_recording() {
+            ud.recording = Some(msg.get_recording());
+        }
+        if msg.has_suppress() {
+            ud.suppress = Some(msg.get_suppress());
+        }
+        if msg.has_self_mute() {
+            ud.self_mute = Some(msg.get_self_mute());
+        }
+        if msg.has_self_deaf() {
+            ud.self_deaf = Some(msg.get_self_deaf());
+        }
+        if msg.has_mute() {
+            ud.mute = Some(msg.get_mute());
+        }
+        if msg.has_deaf() {
+            ud.deaf = Some(msg.get_deaf());
+        }
+        ud
+    }
+
     pub fn name(&self) -> &str {
         &self.name
     }
diff --git a/mumlib/src/state.rs b/mumlib/src/state.rs
index b09726e..ef25a79 100644
--- a/mumlib/src/state.rs
+++ b/mumlib/src/state.rs
@@ -134,3 +134,24 @@ impl Display for User {
         write!(f, "{}", self.name)
     }
 }
+
+#[derive(Debug, Default)]
+pub struct UserDiff {
+    pub comment: Option<String>,
+    pub hash: Option<String>,
+    pub name: Option<String>,
+    pub priority_speaker: Option<bool>,
+    pub recording: Option<bool>,
+
+    pub suppress: Option<bool>,  // by me
+    pub self_mute: Option<bool>, // by self
+    pub self_deaf: Option<bool>, // by self
+    pub mute: Option<bool>,      // by admin
+    pub deaf: Option<bool>,      // by admin
+}
+
+impl UserDiff {
+    pub fn new() -> Self {
+        UserDiff::default()
+    }
+}