1 files changed, 41 insertions, 26 deletions

diff --git a/mumd/src/state.rs b/mumd/src/state.rs
index e9db616..1a02068 100644
--- a/mumd/src/state.rs
+++ b/mumd/src/state.rs
@@ -14,6 +14,7 @@ use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::net::ToSocketAddrs;
 use tokio::sync::{mpsc, watch};
+use crate::network::tcp::{TcpEvent, TcpEventData};
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum StatePhase {
@@ -55,11 +56,11 @@ impl State {
     pub async fn handle_command(
         &mut self,
         command: Command,
-    ) -> (bool, mumlib::error::Result<Option<CommandResponse>>) {
+    ) -> (Option<TcpEvent>, Box<dyn FnOnce(Option<&TcpEventData>) -> mumlib::error::Result<Option<CommandResponse>>>) {
         match command {
             Command::ChannelJoin { channel_identifier } => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {
-                    return (false, Err(Error::DisconnectedError));
+                    return (None, Box::new(|_| Err(Error::DisconnectedError)));
                 }
 
                 let channels = self.server()
@@ -77,33 +78,34 @@ impl State {
                             .filter(|e| e.1.ends_with(&channel_identifier.to_lowercase()))
                             .collect::<Vec<_>>();
                         match soft_matches.len() {
-                            0 => return (false, Err(Error::ChannelIdentifierError(channel_identifier, ChannelIdentifierError::Invalid))),
+                            0 => return (None, Box::new(|_| Err(Error::ChannelIdentifierError(channel_identifier, ChannelIdentifierError::Invalid)))),
                             1 => *soft_matches.get(0).unwrap().0,
-                            _ => return (false, Err(Error::ChannelIdentifierError(channel_identifier, ChannelIdentifierError::Invalid))),
+                            _ => return (None, Box::new(|_| Err(Error::ChannelIdentifierError(channel_identifier, ChannelIdentifierError::Invalid)))),
                         }
                     },
                     1 => *matches.get(0).unwrap().0,
-                    _ => return (false, Err(Error::ChannelIdentifierError(channel_identifier, ChannelIdentifierError::Ambiguous))),
+                    _ => return (None, Box::new(|_| Err(Error::ChannelIdentifierError(channel_identifier, ChannelIdentifierError::Ambiguous)))),
                 };
 
                 let mut msg = msgs::UserState::new();
                 msg.set_session(self.server.as_ref().unwrap().session_id.unwrap());
                 msg.set_channel_id(id);
                 self.packet_sender.send(msg.into()).unwrap();
-                (false, Ok(None))
+                (None, Box::new(|_| Ok(None)))
             }
             Command::ChannelList => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {
-                    return (false, Err(Error::DisconnectedError));
+                    return (None, Box::new(|_| Err(Error::DisconnectedError)));
                 }
+                let list = into_channel(
+                    self.server.as_ref().unwrap().channels(),
+                    self.server.as_ref().unwrap().users(),
+                );
                 (
-                    false,
-                    Ok(Some(CommandResponse::ChannelList {
-                        channels: into_channel(
-                            self.server.as_ref().unwrap().channels(),
-                            self.server.as_ref().unwrap().users(),
-                        ),
-                    })),
+                    None,
+                    Box::new(move |_| Ok(Some(CommandResponse::ChannelList {
+                        channels: list,
+                    }))),
                 )
             }
             Command::ServerConnect {
@@ -113,7 +115,7 @@ impl State {
                 accept_invalid_cert,
             } => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Disconnected) {
-                    return (false, Err(Error::AlreadyConnectedError));
+                    return (None, Box::new(|_| Err(Error::AlreadyConnectedError)));
                 }
                 let mut server = Server::new();
                 server.username = Some(username);
@@ -131,7 +133,7 @@ impl State {
                     Ok(Some(v)) => v,
                     _ => {
                         warn!("Error parsing server addr");
-                        return (false, Err(Error::InvalidServerAddrError(host, port)));
+                        return (None, Box::new(move |_| Err(Error::InvalidServerAddrError(host, port))));
                     }
                 };
                 self.connection_info_sender
@@ -141,22 +143,35 @@ impl State {
                         accept_invalid_cert,
                     )))
                     .unwrap();
-                (true, Ok(None))
+                (Some(TcpEvent::Connected), Box::new(|e| { //runs the closure when the client is connected
+                    if let Some(TcpEventData::Connected(msg)) = e {
+                        Ok(Some(CommandResponse::ServerConnect {
+                            welcome_message: if msg.has_welcome_text() {
+                                Some(msg.get_welcome_text().to_string())
+                            } else {
+                                None
+                            }
+                        }))
+                    } else {
+                        unreachable!("callback should be provided with a TcpEventData::Connected");
+                    }
+                }))
             }
             Command::Status => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {
-                    return (false, Err(Error::DisconnectedError));
+                    return (None, Box::new(|_| Err(Error::DisconnectedError)));
                 }
+                let state = self.server.as_ref().unwrap().into();
                 (
-                    false,
-                    Ok(Some(CommandResponse::Status {
-                        server_state: self.server.as_ref().unwrap().into(), //guaranteed not to panic because if we are connected, server is guaranteed to be Some
-                    })),
+                    None,
+                    Box::new(move |_| Ok(Some(CommandResponse::Status {
+                        server_state: state, //guaranteed not to panic because if we are connected, server is guaranteed to be Some
+                    }))),
                 )
             }
             Command::ServerDisconnect => {
                 if !matches!(*self.phase_receiver().borrow(), StatePhase::Connected) {
-                    return (false, Err(Error::DisconnectedError));
+                    return (None, Box::new(|_| Err(Error::DisconnectedError)));
                 }
 
                 self.server = None;
@@ -166,15 +181,15 @@ impl State {
                     .0
                     .broadcast(StatePhase::Disconnected)
                     .unwrap();
-                (false, Ok(None))
+                (None, Box::new(|_| Ok(None)))
             }
             Command::InputVolumeSet(volume) => {
                 self.audio.set_input_volume(volume);
-                (false, Ok(None))
+                (None, Box::new(|_| Ok(None)))
             }
             Command::ConfigReload => {
                 self.reload_config();
-                (false, Ok(None))
+                (None, Box::new(|_| Ok(None)))
             }
         }
     }