add /status endpoint to proxy

proxy/src/main.rs

@@ -1,5 +1,10 @@
 use color_eyre::eyre::{anyhow, bail, Context, Result};
-use mumble_web2_common::ClientConfig;
+use color_eyre::owo_colors::OwoColorize;
+use mumble_web2_common::{ClientConfig, ServerStatus};
+use once_cell::sync::OnceCell;
+use rand::Rng;
+use rcgen::date_time_ymd;
+use rustls::server;
 use salvo::conn::rustls::{Keycert, RustlsConfig};
 use salvo::cors::{AllowOrigin, Cors};
 use salvo::logging::Logger;
@@ -25,6 +30,8 @@ use tracing_subscriber::filter::LevelFilter;
 use tracing_subscriber::EnvFilter;
 use url::Url;
 
+mod ping;
+
 fn default_cert_alt_names() -> Vec<String> {
     vec!["localhost".into()]
 }
@@ -122,10 +129,15 @@ async fn main() -> Result<()> {
         client_config,
     };
 
+    let status_craft = StatusCraft {
+        mumble_server_address: server_config.mumble_server_address.unwrap().clone(),
+    };
+
     // Server routing
     let mut router = Router::new()
         .push(Router::with_path("/proxy").goal(config_craft.connect_proxy()))
         .push(Router::with_path("/config").get(config_craft.get_config()))
+        .push(Router::with_path("/status").get(status_craft.get_status()))
         .hoop(Logger::new());
     if let Some(gui_path) = server_config.gui_path.clone() {
         router =
@@ -158,6 +170,82 @@ async fn main() -> Result<()> {
     Ok(())
 }
 
+#[derive(Clone)]
+pub struct StatusCraft {
+    mumble_server_address: SocketAddr,
+}
+
+#[craft]
+impl StatusCraft {
+    #[craft(handler)]
+    async fn get_status(&self) -> Json<ServerStatus> {
+        let mut server_status = ServerStatus::default();
+
+        let ping_packet = ping::PingPacket {
+            id: rand::rng().random(),
+        };
+
+        let sock = match tokio::net::UdpSocket::bind("0.0.0.0:0").await {
+            Ok(s) => s,
+            Err(e) => {
+                error!("Could not bind udp socket: {}", e);
+                return Json(server_status);
+            }
+        };
+
+        match sock.connect(self.mumble_server_address).await {
+            Ok(_) => {}
+            Err(e) => {
+                error!("Could not send ping packet: {}", e);
+                return Json(server_status);
+            }
+        }
+
+        match sock.send(&<[u8; 12]>::from(ping_packet)).await {
+            Ok(_) => {}
+            Err(e) => {
+                error!("Could not send ping packet");
+                return Json(server_status);
+            }
+        }
+
+        let mut pong_buf: [u8; 24] = [0; 24];
+
+        match tokio::time::timeout(
+            tokio::time::Duration::from_secs(1),
+            sock.recv(&mut pong_buf),
+        )
+        .await
+        {
+            Ok(_) => {}
+            Err(e) => {
+                error!("Could not send ping packet");
+                return Json(server_status);
+            }
+        }
+
+        let pong_packet = match ping::PongPacket::try_from(pong_buf.as_slice()) {
+            Ok(p) => p,
+            Err(e) => {
+                error!("Could not parse pong packet: {:?}", e);
+                return Json(server_status);
+            }
+        };
+
+        server_status.success = true;
+        server_status.version = Some((
+            pong_packet.version & 0xFF,
+            (pong_packet.version >> 8) & 0xFF,
+            (pong_packet.version >> 16) & 0xFF,
+        ));
+        server_status.users = Some(pong_packet.users);
+        server_status.max_users = Some(pong_packet.max_users);
+        server_status.bandwidth = Some(pong_packet.bandwidth);
+
+        Json(server_status)
+    }
+}
+
 #[derive(Clone)]
 pub struct ConfigCraft {
     server_config: Arc<Config>,
@@ -175,7 +263,6 @@ impl ConfigCraft {
     async fn connect_proxy(&self, req: &mut Request, res: &mut Response) {
         info!("received proxy request");
         let mumble_server_address = self.server_config.mumble_server_address.unwrap();
-
         let wt = match req.web_transport_mut().await {
             Ok(wt) => wt,
             Err(err) => {