move mumble backend code to new client

1 files changed, 4 insertions, 39 deletions

diff --git a/mumd/src/main.rs b/mumd/src/main.rs
index db6d2ef..67481f9 100644
--- a/mumd/src/main.rs
+++ b/mumd/src/main.rs
@@ -1,23 +1,17 @@
 mod audio;
+mod client;
 mod command;
 mod network;
 mod notify;
 mod state;
 
-use crate::network::ConnectionInfo;
-use crate::state::State;
-
 use futures::join;
 use ipc_channel::ipc::{self, IpcOneShotServer, IpcSender};
 use log::*;
-use mumble_protocol::control::ControlPacket;
-use mumble_protocol::crypt::ClientCryptState;
-use mumble_protocol::voice::Serverbound;
 use mumlib::command::{Command, CommandResponse};
 use mumlib::setup_logger;
 use std::fs;
-use std::sync::{Arc, Mutex};
-use tokio::sync::{mpsc, watch};
+use tokio::sync::mpsc;
 use tokio::task::spawn_blocking;
 
 #[tokio::main]
@@ -45,46 +39,17 @@ async fn main() {
         }
     }
 
-    // Oneshot channel for setting UDP CryptState from control task
-    // For simplicity we don't deal with re-syncing, real applications would have to.
-    let (crypt_state_sender, crypt_state_receiver) = mpsc::channel::<ClientCryptState>(1); // crypt state should always be consumed before sending a new one
-    let (packet_sender, packet_receiver) = mpsc::unbounded_channel::<ControlPacket<Serverbound>>();
     let (command_sender, command_receiver) = mpsc::unbounded_channel::<(
         Command,
         IpcSender<mumlib::error::Result<Option<CommandResponse>>>,
     )>();
-    let (connection_info_sender, connection_info_receiver) =
-        watch::channel::<Option<ConnectionInfo>>(None);
-    let (response_sender, response_receiver) = mpsc::unbounded_channel();
-    let (ping_request_sender, ping_request_receiver) = mpsc::unbounded_channel();
-
-    let state = State::new(packet_sender, connection_info_sender);
-    let state = Arc::new(Mutex::new(state));
 
-    let (_, _, _, e, _) = join!(
-        network::tcp::handle(
-            Arc::clone(&state),
-            connection_info_receiver.clone(),
-            crypt_state_sender,
-            packet_receiver,
-            response_receiver,
-        ),
-        network::udp::handle(
-            Arc::clone(&state),
-            connection_info_receiver.clone(),
-            crypt_state_receiver,
-        ),
-        command::handle(
-            state,
-            command_receiver,
-            response_sender,
-            ping_request_sender,
-        ),
+    let (_, e) = join!(
+        client::handle(command_receiver),
         spawn_blocking(move || {
             // IpcSender is blocking
             receive_oneshot_commands(command_sender);
         }),
-        network::udp::handle_pings(ping_request_receiver),
     );
     e.unwrap();
 }