specify if we accept invalid server certs or not

1 files changed, 26 insertions, 7 deletions

diff --git a/mumd/src/network/tcp.rs b/mumd/src/network/tcp.rs
index 5cc2bf7..1c7123f 100644
--- a/mumd/src/network/tcp.rs
+++ b/mumd/src/network/tcp.rs
@@ -35,17 +35,23 @@ type TcpReceiver =
 pub(crate) type TcpEventCallback = Box<dyn FnOnce(TcpEventData)>;
 pub(crate) type TcpEventSubscriber = Box<dyn FnMut(TcpEventData) -> bool>; //the bool indicates if it should be kept or not
 
-#[derive(Debug, Clone, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
+pub enum DisconnectedReason {
+    InvalidTls,
+    Other,
+}
+
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 pub enum TcpEvent {
     Connected,    //fires when the client has connected to a server
-    Disconnected, //fires when the client has disconnected from a server
+    Disconnected(DisconnectedReason), //fires when the client has disconnected from a server
     TextMessage,  //fires when a text message comes in
 }
 
 #[derive(Clone)]
 pub enum TcpEventData<'a> {
     Connected(Result<&'a msgs::ServerSync, mumlib::Error>),
-    Disconnected,
+    Disconnected(DisconnectedReason),
     TextMessage(&'a msgs::TextMessage),
 }
 
@@ -53,7 +59,7 @@ impl<'a> From<&TcpEventData<'a>> for TcpEvent {
     fn from(t: &TcpEventData) -> Self {
         match t {
             TcpEventData::Connected(_) => TcpEvent::Connected,
-            TcpEventData::Disconnected => TcpEvent::Disconnected,
+            TcpEventData::Disconnected(reason) => TcpEvent::Disconnected(*reason),
             TcpEventData::TextMessage(_) => TcpEvent::TextMessage,
         }
     }
@@ -141,12 +147,25 @@ pub async fn handle(
             }
             return Err(TcpError::NoConnectionInfoReceived);
         };
-        let (mut sink, stream) = connect(
+        let connect_result = connect(
             connection_info.socket_addr,
             connection_info.hostname,
             connection_info.accept_invalid_cert,
         )
-        .await?;
+        .await;
+        
+        let (mut sink, stream) = match connect_result {
+            Ok(ok) => ok,
+            Err(TcpError::TlsConnectError(_)) => {
+                warn!("Invalid TLS");
+                state.read().unwrap().broadcast_phase(StatePhase::Disconnected);
+                event_queue.resolve(TcpEventData::Disconnected(DisconnectedReason::InvalidTls));
+                continue;
+            }
+            Err(e) => {
+                return Err(e);
+            }
+        };
 
         // Handshake (omitting `Version` message for brevity)
         let (username, password) = {
@@ -193,7 +212,7 @@ pub async fn handle(
         .await
         .unwrap_or(Ok(()))?;
 
-        event_queue.resolve(TcpEventData::Disconnected);
+        event_queue.resolve(TcpEventData::Disconnected(DisconnectedReason::Other));
 
         debug!("Fully disconnected TCP stream, waiting for new connection info");
     }