Move mumble UDP ping into common crate (#33)

The desktop GUI doesn't go through the proxy to reach the Mumble server,
so its login screen needs to ping directly. Rather than duplicate the
ping logic, move it into the common crate behind an optional
`networking` feature (so common stays lightweight when the feature
isn't requested).

- common: add `ping_server(address, port)` behind `networking` feature
- proxy: replace the inline UdpSocket ping + ping.rs codec with a call
  to common::ping_server; drop the rand dep
- client: PlatformInterface::get_status now takes an address; desktop
  and mobile call common::ping_server directly, web still uses the
  proxy's /status endpoint
- gui: thread the address from the login input through get_status, so
  it re-pings when the user edits the address

Assisted-by: claude-opus-4-7
Reviewed-on: #33
Reviewed-by: restitux <restitux@ohea.xyz>
Co-authored-by: Sam Sartor <me@samsartor.com>
Co-committed-by: Sam Sartor <me@samsartor.com>

proxy/src/main.rs

@@ -1,6 +1,5 @@
 use color_eyre::eyre::{anyhow, bail, Context, Result};
-use mumble_web2_common::{ProxyOverrides, ServerStatus};
-use rand::Rng;
+use mumble_web2_common::{ping_server, ProxyOverrides, ServerStatus};
 use salvo::conn::rustls::{Keycert, RustlsConfig};
 use salvo::cors::{AllowOrigin, Cors};
 use salvo::logging::Logger;
@@ -26,8 +25,6 @@ use tracing_subscriber::filter::LevelFilter;
 use tracing_subscriber::EnvFilter;
 use url::Url;
 
-mod ping;
-
 fn default_cert_alt_names() -> Vec<String> {
     vec!["localhost".into()]
 }
@@ -179,70 +176,14 @@ pub struct StatusCraft {
 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,
+        let addr = self.mumble_server_address;
+        match ping_server(&addr.ip().to_string(), addr.port()).await {
+            Ok(status) => Json(status),
             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);
+                error!("ping failed: {e:#}");
+                Json(ServerStatus::default())
             }
         }
-
-        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)
     }
 }