wip handle more commands (panics)

3 files changed, 54 insertions, 13 deletions

diff --git a/mumd/src/network/mod.rs b/mumd/src/network/mod.rs
index f7a6a76..777faad 100644
--- a/mumd/src/network/mod.rs
+++ b/mumd/src/network/mod.rs
@@ -1,2 +1,25 @@
 pub mod tcp;
 pub mod udp;
+
+use std::net::SocketAddr;
+
+#[derive(Clone, Debug)]
+pub struct ConnectionInfo {
+    socket_addr: SocketAddr,
+    hostname: String,
+    accept_invalid_cert: bool,
+}
+
+impl ConnectionInfo {
+    pub fn new(
+        socket_addr: SocketAddr,
+        hostname: String,
+        accept_invalid_cert: bool,
+    ) -> Self {
+        Self {
+            socket_addr,
+            hostname,
+            accept_invalid_cert,
+        }
+    }
+}
diff --git a/mumd/src/network/tcp.rs b/mumd/src/network/tcp.rs
index 6f60b63..9fb5ae4 100644
--- a/mumd/src/network/tcp.rs
+++ b/mumd/src/network/tcp.rs
@@ -1,4 +1,5 @@
-use crate::state::State;
+use crate::network::ConnectionInfo;
+use crate::state::{State, StatePhase};
 use log::*;
 
 use futures::channel::oneshot;
@@ -11,7 +12,7 @@ use std::convert::{Into, TryInto};
 use std::net::{SocketAddr};
 use std::sync::{Arc, Mutex};
 use tokio::net::TcpStream;
-use tokio::sync::mpsc;
+use tokio::sync::{mpsc, watch};
 use tokio::time::{self, Duration};
 use tokio_tls::{TlsConnector, TlsStream};
 use tokio_util::codec::{Decoder, Framed};
@@ -25,16 +26,24 @@ type TcpReceiver =
 
 pub async fn handle(
     state: Arc<Mutex<State>>,
-    server_addr: SocketAddr,
-    server_host: String,
-    accept_invalid_cert: bool,
+    mut connection_info_receiver: watch::Receiver<Option<ConnectionInfo>>,
     crypt_state_sender: oneshot::Sender<ClientCryptState>,
     packet_receiver: mpsc::UnboundedReceiver<ControlPacket<Serverbound>>,
 ) {
-    let (mut sink, stream) = connect(server_addr, server_host, accept_invalid_cert).await;
+    let connection_info = loop {
+        match connection_info_receiver.recv().await {
+            None => { return; }
+            Some(None) => {}
+            Some(Some(connection_info)) => { break connection_info; }
+        }
+    };
+    let (mut sink, stream) = connect(connection_info.socket_addr,
+                                        connection_info.hostname,
+                                        connection_info.accept_invalid_cert)
+        .await;
 
     // Handshake (omitting `Version` message for brevity)
-    authenticate(&mut sink, state.lock().unwrap().username().to_string()).await;
+    authenticate(&mut sink, state.lock().unwrap().username().unwrap().to_string()).await;
 
     info!("Logging in...");
 
@@ -158,10 +167,10 @@ async fn listen(
                 let mut state = state.lock().unwrap();
                 let session = msg.get_session();
                 state.audio_mut().add_client(msg.get_session()); //TODO
-                if *state.initialized_receiver().borrow() {
-                    state.server_mut().parse_user_state(msg);
-                } else {
+                if *state.phase_receiver().borrow() == StatePhase::Connecting {
                     state.parse_initial_user_state(msg);
+                } else {
+                    state.server_mut().parse_user_state(msg);
                 }
                 let server = state.server_mut();
                 let user = server.users().get(&session).unwrap();
diff --git a/mumd/src/network/udp.rs b/mumd/src/network/udp.rs
index 5f76501..cf0305b 100644
--- a/mumd/src/network/udp.rs
+++ b/mumd/src/network/udp.rs
@@ -1,3 +1,4 @@
+use crate::network::ConnectionInfo;
 use crate::state::State;
 use log::*;
 
@@ -11,6 +12,7 @@ use mumble_protocol::Serverbound;
 use std::net::{Ipv6Addr, SocketAddr};
 use std::sync::{Arc, Mutex};
 use tokio::net::UdpSocket;
+use tokio::sync::watch;
 use tokio_util::udp::UdpFramed;
 
 type UdpSender = SplitSink<UdpFramed<ClientCryptState>, (VoicePacket<Serverbound>, SocketAddr)>;
@@ -38,20 +40,27 @@ pub async fn connect(
 
 pub async fn handle(
     state: Arc<Mutex<State>>,
-    server_addr: SocketAddr,
+    mut connection_info_receiver: watch::Receiver<Option<ConnectionInfo>>,
     crypt_state: oneshot::Receiver<ClientCryptState>,
 ) {
+    let connection_info = loop {
+        match connection_info_receiver.recv().await {
+            None => { return; }
+            Some(None) => {}
+            Some(Some(connection_info)) => { break connection_info; }
+        }
+    };
     let (mut sink, source) = connect(crypt_state).await;
 
     // Note: A normal application would also send periodic Ping packets, and its own audio
     //       via UDP. We instead trick the server into accepting us by sending it one
     //       dummy voice packet.
-    send_ping(&mut sink, server_addr).await;
+    send_ping(&mut sink, connection_info.socket_addr).await;
 
     let sink = Arc::new(Mutex::new(sink));
     join!(
         listen(Arc::clone(&state), source),
-        send_voice(state, sink, server_addr)
+        send_voice(state, sink, connection_info.socket_addr),
     );
 }