try to run denoising

.gitignore

@@ -1,3 +1,8 @@
 /target
 dist/
 server_hash.txt
+.aider*
+**.pem
+proxy/bundle
+config.toml
+proxy/config.toml

Cargo.toml

@@ -1,6 +1,6 @@
 [workspace]
 resolver = "2"
-members = [ "common","gui", "proxy"]
+members = ["common", "gui", "proxy"]
 
 [workspace.dependencies]
 serde = { version = "1.0.214", features = ["derive"] }
@@ -11,6 +11,16 @@ mumble-web2-common = { path = "common" }
 version = "0.5.0"
 package = "mumble-protocol-2x"
 default-features = false
-features = [
-  "asynchronous-codec",
-]
+features = ["asynchronous-codec"]
+
+[profile]
+
+[profile.wasm-dev]
+inherits = "dev"
+opt-level = 1
+
+[profile.server-dev]
+inherits = "dev"
+
+[profile.android-dev]
+inherits = "dev"

README.md

@@ -1,24 +1,23 @@
 # GUI Development
 
 ## Running Desktop
-1. `cargo install dioxus-cli --version 0.6.0-alpha.4`
-2. `dx build -p mumble-web2-gui --platform desktop`
 
-## Running Web
-1. `cargo install dioxus-cli --version 0.6.0-alpha.4`
-2. `cargo install cargo install wtransport --example gencert`
-3. in the proxy directory:
-   1. `cp config.toml.example config.toml`
-   2. run `gencert` and copy the certificate hash into config.toml
-   3. `cargo run -p mumble-web2-proxy` in the background
+1. `cargo install dioxus-cli --version 0.6.3`
+2. `dx run -p mumble-web2-gui --platform desktop --release`
 
-## with `dx serve`
-4. in the gui directory
-   1. `export 'MUMBLE_WEB2_GUI_CONFIG={"cert_hash": <CERTIFICATE HASH HERE>, "proxy_url": "https://localhost:4433"}'`
-   2. `dx serve -p mumble-web2-gui --platform web`
-5. connect to `localhost:8080` (most common)
 
-## with `mumble-web2-proxy` only
-4. in the gui directory:
-   1. `dx build -p mumble-web2-gui --platform web`
-5. connect to `localhost:4434` (most common)
+## Running Web (development)
+
+1. `cargo install dioxus-cli --version 0.6.3`
+3. `dx serve -p mumble-web2-gui --platform web`
+2. `cd docker && docker compose up`
+4. connect to `https://localhost:64444`
+5. fill in the proxy url as `https://127.0.0.1:4433/proxy` (this should autofill)
+
+## Running Web (with `proxy` only)
+
+1. `cargo install dioxus-cli --version 0.6.3`
+2. `dx build -p mumble-web2-gui --platform web --release`
+3. `cp config.toml.example config.toml`
+4. `cargo run -p mumble-web2-proxy` in the background
+5. connect to `localhost:8080`

common/src/lib.rs

@@ -1,9 +1,17 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Deserialize, Serialize, Default)]
-pub struct GuiConfig {
-    #[serde(default)]
-    pub force_proxy: bool,
+#[derive(Debug, Clone, Deserialize, Serialize, Default)]
+pub struct ClientConfig {
     pub proxy_url: Option<String>,
     pub cert_hash: Option<Vec<u8>>,
 }
+
+#[derive(Debug, Clone, Deserialize, Serialize, Default)]
+pub struct ServerStatus {
+    #[serde(default)]
+    pub success: bool,
+    pub version: Option<(u32, u32, u32)>,
+    pub users: Option<u32>,
+    pub max_users: Option<u32>,
+    pub bandwidth: Option<u32>,
+}

config.toml.example

@@ -0,0 +1,5 @@
+public_url = "https://127.0.0.1:4433"
+https_listen_address = "127.0.0.1:4433"
+http_listen_address = "127.0.0.1:8080"
+mumble_server_url = "[SERVER_URL_HERE]"
+gui_path = "target/dx/mumble-web2-gui/release/web/public"

docker/Caddyfile

@@ -0,0 +1,14 @@
+localhost:64444 {
+    tls internal
+
+    # Proxy /config path to mumble-web2-proxy
+    reverse_proxy /config http://127.0.0.1:4400
+
+    # Proxy /status path to mumble-web2-proxy
+    reverse_proxy /status http://127.0.0.1:4400
+
+
+    # Proxy root path to dx-serve
+    reverse_proxy http://127.0.0.1:8080
+
+}

docker/dioxus.Dockerfile

@@ -0,0 +1,22 @@
+FROM rust:1-bookworm AS base
+
+# Install cargo-binstall for faster CLI installation
+#RUN curl -L --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/cargo-bins/cargo-binstall/main/install-from-binstall-release.sh | bash
+
+RUN apt-get update && apt-get install -y screen
+
+# Install dioxus-cli version 0.6.3 specifically
+RUN cargo install dioxus-cli --version 0.6.3
+
+# Set working directory
+WORKDIR /app
+
+# Add wasm32 target for web development
+RUN rustup target add wasm32-unknown-unknown
+
+# Set environment variables
+ENV PATH="/root/.cargo/bin:$PATH"
+
+# Default command (can be overridden in docker-compose)
+CMD ["dx", "--help"]
+

docker/docker-compose.yaml

@@ -0,0 +1,60 @@
+services:
+  caddy:
+    image: caddy:latest
+    ports:
+      - "64444:64444/tcp"
+      - "64444:64444/udp"
+    volumes:
+      - ./Caddyfile:/etc/caddy/Caddyfile
+      #- caddy_data:/data
+      #- caddy_config:/config
+    depends_on:
+      #- dx-serve
+      - mumble-web2-proxy
+    network_mode: host
+
+  #dx-serve:
+  #  build:
+  #    dockerfile: ./dioxus.Dockerfile
+  #  working_dir: /app
+  #  volumes:
+  #    - ..:/app
+  #  environment:
+  #    - MUMBLE_WEB2_GUI_CONFIG_URL=https://localhost:64444/config
+  #  stdin_open: true
+  #  tty: true
+  #  command: >
+  #    bash -c "
+  #    screen -dmS serve bash -c 'dx serve -p mumble-web2-gui --platform web' &&
+  #    tail -f /dev/null
+  #    "
+  #  networks:
+  #    - app-network
+
+  mumble-web2-proxy:
+    image: rust:latest
+    working_dir: /app
+    volumes:
+      - ..:/app
+      - ./proxy-config.toml:/app/config.toml
+    ports:
+      - "4433:4433/tcp"
+      - "4433:4433/udp"
+    command: ["cargo", "run", "-p", "mumble-web2-proxy"]
+    network_mode: host
+
+  mumble-server:
+    image: mumblevoip/mumble-server:latest
+    ports:
+      - "64738:64738/tcp"
+      - "64738:64738/udp"
+    environment:
+      - MUMBLE_CONFIG_WELCOMETEXT=Welcome to the Mumble server
+    network_mode: host
+#volumes:
+#  caddy_data:
+#  caddy_config:
+#
+#networks:
+#  app-network:
+#    driver: bridge

docker/proxy-config.toml

@@ -0,0 +1,4 @@
+public_url = "https://127.0.0.1:4433"
+https_listen_address = "127.0.0.1:4433"
+http_listen_address = "127.0.0.1:4400"
+mumble_server_url = "127.0.0.1:64738"

gui/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2021"
 [dependencies]
 # Web Dependencies
 # ================
-dioxus-web = { version = "0.6.0-alpha.4", optional = true }
+dioxus-web = { version = "0.6.3", optional = true }
 wasm-bindgen = { version = "0.2.92", optional = true }
 wasm-bindgen-futures = { version = "0.4.42", optional = true }
 wasm-streams = { version = "0.4.0", optional = true }
@@ -53,20 +53,22 @@ web-sys = { version = "0.3.72", features = [
   "AudioDataCopyToOptions",
   "AudioSampleFormat",
   "Storage",
-], optional = true}
+], optional = true }
 gloo-timers = { version = "0.3.0", features = ["futures"], optional = true }
 tracing-web = { version = "0.1.3", optional = true }
 
 # Desktop Dependecies
 # ===================
-dioxus-desktop = { version = "0.6.0-alpha.4", optional = true}
+dioxus-desktop = { version = "0.6.3", optional = true }
 tokio = { version = "1.41.1", features = ["net", "rt"], optional = true }
 tokio-rustls = { version = "0.26.0", optional = true }
-
+opus = { version = "0.3.0", optional = true }
+cpal = { version = "0.15.3", optional = true }
+dasp_ring_buffer = { version = "0.11.0", optional = true }
 
 # Base Dependencies
 # ================
-dioxus = { version = "0.6.0-alpha.4" }
+dioxus = { version = "0.6.3" }
 once_cell = "1.19.0"
 asynchronous-codec = { workspace = true }
 futures = "0.3.30"
@@ -80,12 +82,26 @@ ordermap = "0.5.3"
 html-purifier = "0.3.0"
 markdown = "0.3.0"
 futures-channel = "0.3.30"
-sir = { git = "https://gitlab.com/samsartor/sir", features = ["dioxus"] } # dioxus 0.6
+sir = { git = "https://gitlab.com/samsartor/sir", features = [
+  "dioxus",
+] } # dioxus 0.6
 mumble-web2-common = { workspace = true }
 serde = { workspace = true }
 tracing-subscriber = { version = "0.3.18", features = ["ansi"] }
 tracing = "0.1.40"
 color-eyre = "0.6.3"
+crossbeam-queue = "0.3.11"
+lol_html = "2.2.0"
+rfd = "0.15.2"
+base64 = "0.22"
+mime_guess = "2.0.5"
+async_cell = "0.2.3"
+reqwest = { version = "0.12.22", features = ["json"] }
+
+# Denoising
+# =========
+deep_filter = { git = "https://github.com/Rikorose/DeepFilterNet.git", rev = "d375b2d8309e0935d165700c91da9de862a99c31" }
+crossbeam = "0.8.4"
 
 [features]
 web = [
@@ -100,4 +116,12 @@ web = [
   "gloo-timers",
   "tracing-web",
 ]
-desktop = ["dioxus/desktop", "tokio", "tokio-rustls", "tracing-subscriber/env-filter"]
+desktop = [
+  "dioxus/desktop",
+  "tokio",
+  "tokio-rustls",
+  "tracing-subscriber/env-filter",
+  "opus",
+  "cpal",
+  "dasp_ring_buffer",
+]

gui/Dioxus.toml

@@ -11,7 +11,6 @@ asset_dir = "public"
 [web.app]
 # HTML title tag content
 title = "Mumble Web 2"
-base_path = "gui"
 
 [web.watcher]
 # when watcher trigger, regenerate the `index.html`

gui/src/app.rs

@@ -1,11 +1,15 @@
 #![allow(non_snake_case)]
 
+use base64::{display::Base64Display, prelude::BASE64_URL_SAFE};
 use dioxus::prelude::*;
+use mime_guess::Mime;
+use mumble_web2_common::ClientConfig;
 use ordermap::OrderSet;
 use sir::{css, global_css};
 use std::collections::HashMap;
+use tracing::error;
 
-use crate::{imp, CONFIG};
+use crate::imp;
 
 pub type ChannelId = u32;
 pub type UserId = u32;
@@ -22,11 +26,18 @@ pub enum Command {
     Connect {
         address: String,
         username: String,
+        config: ClientConfig,
     },
     SendChat {
         markdown: String,
         channels: Vec<ChannelId>,
     },
+    SendFile {
+        bytes: Vec<u8>,
+        name: String,
+        mime: Option<Mime>,
+        channels: Vec<ChannelId>,
+    },
     SetMute {
         mute: bool,
     },
@@ -37,6 +48,9 @@ pub enum Command {
         channel: ChannelId,
         user: UserId,
     },
+    UpdateMicEffects {
+        denoise: bool,
+    },
     Disconnect,
 }
 
@@ -125,7 +139,7 @@ impl UserIcon {
 }
 
 #[component]
-pub fn UserPill(name: String, icon: UserIcon) -> Element {
+pub fn UserPill(name: String, icon: UserIcon, isself: bool) -> Element {
     let pill = css!(
         "
         border-radius: 100px;
@@ -139,16 +153,22 @@ pub fn UserPill(name: String, icon: UserIcon) -> Element {
     "
     );
 
+    let pill_self = css!(
+        "
+        font-weight: bolder;
+        "
+    );
+
     let color = match icon {
-        UserIcon::Normal => "var(--accent-a)",
-        UserIcon::Muted => "var(--accent-b)",
-        UserIcon::Deafened => "var(--accent-c)",
-        UserIcon::None => "var(--accent-a)",
+        UserIcon::Normal => "var(--accent-normal)",
+        UserIcon::Muted => "var(--accent-muted)",
+        UserIcon::Deafened => "var(--accent-deafened)",
+        UserIcon::None => "var(--accent-normal)",
     };
 
     rsx!(
         div {
-            class: "{pill}",
+            class: match isself { true => format!("{pill} {pill_self}"), false => format!("{pill}") },
             style: "background-color: {color}",
             { icon.url().map(|url| rsx!(img { src: url })) }
             "\u{00A0}{name}\u{00A0}"
@@ -163,10 +183,12 @@ pub fn User(id: UserId) -> Element {
         Some(state) => rsx!(UserPill {
             name: state.name.clone(),
             icon: state.icon(),
+            isself: server.session.unwrap() == id,
         }),
         None => rsx!(UserPill {
             name: format!("unknown user ({id})"),
             icon: UserIcon::None,
+            isself: false,
         }),
     }
 }
@@ -212,9 +234,9 @@ pub fn Channel(id: ChannelId) -> Element {
             summary {
                 span {
                     role: "button",
-                    prevent_default: "onclick",
                     ondoubleclick: move |evt| {
                         evt.stop_propagation();
+                        evt.prevent_default();
                         net.send(EnterChannel { channel: id, user })
                     },
                     "{state.name}"
@@ -235,12 +257,41 @@ pub fn Channel(id: ChannelId) -> Element {
     )
 }
 
+pub fn pick_and_send_file(net: &Coroutine<Command>) {
+    let channels = if let Some(user) = STATE.server.read().this_user() {
+        vec![user.channel]
+    } else {
+        return;
+    };
+    let dialog = rfd::AsyncFileDialog::new().pick_file();
+    let sender = net.tx();
+    spawn(async move {
+        let Some(handle) = dialog.await else { return };
+        let name = handle.file_name();
+        let bytes = handle.read().await;
+        let mime = mime_guess::from_path(&name).first();
+        let _ = sender.unbounded_send(SendFile {
+            bytes,
+            name,
+            mime,
+            channels,
+        });
+    });
+}
+
 #[component]
 pub fn ChatView() -> Element {
     let net: Coroutine<Command> = use_coroutine_handle();
     let server = STATE.server.read();
     let mut draft = use_signal(|| "".to_string());
 
+    let chat_panel = css!(
+        "
+        display: flex;
+        flex-direction: column;
+    "
+    );
+
     let chat_history = css!(
         "
         overflow-y: auto;
@@ -258,18 +309,44 @@ pub fn ChatView() -> Element {
     "
     );
 
+    let chat_box_wrapper = css!(
+        "
+        padding: 16px;
+        border-top: solid var(--line-color) var(--line-width);
+    "
+    );
+
     let chat_box = css!(
         "
         display: flex;
         flex-direction: row;
-        padding: 16px;
-        gap: 8px;
-        border-top: solid var(--line-color) var(--line-width);
+        gap: 16px;
+
+        background-color: var(--light-bg-color);
+
+        padding-top: 16px;
+        padding-bottom: 16px;
+
+        padding-left: 8px;
+        padding-right: 16px;
+
+        border-radius: 8px;
 
         input {
+            color: white;
+            background-color: var(--light-bg-color);
+
+            font-size: larger;
+
             flex-grow: 1;
-            padding: 8px;
+
+            border: none;
         }
+
+        input:focus {
+            outline: none;
+        }
+
     "
     );
 
@@ -284,44 +361,372 @@ pub fn ChatView() -> Element {
 
     rsx!(
         div {
-            class: "{chat_history}",
-            for chat in server.chat.iter() {
-                div {
-                    class: "{chat_message}",
-                    if let Some(sender) = chat.sender.and_then(|u| server.users.get(&u)) {
-                        UserPill {
-                            name: sender.name.clone(),
-                            icon: UserIcon::None,
+            class: "{chat_panel}",
+            div {
+                class: "{chat_history}",
+                for chat in server.chat.iter() {
+                    div {
+                        class: "{chat_message}",
+                        if let Some(sender) = chat.sender.and_then(|u| server.users.get(&u)) {
+                            UserPill {
+                                name: sender.name.clone(),
+                                icon: UserIcon::None,
+                                isself: false,
+                            }
+                        }
+                        span {
+                            dangerous_inner_html: "{chat.dangerous_html}",
                         }
                     }
-                    span {
-                        dangerous_inner_html: "{chat.dangerous_html}",
+                }
+            }
+            div {
+                class: "{chat_box_wrapper}",
+                div {
+                    class: "{chat_box}",
+                    input {
+                        placeholder: "say something",
+                        value: "{draft.read()}",
+                        oninput: move |evt| draft.set(evt.value().clone()),
+                        onkeypress: move |evt: Event<KeyboardData>| {
+                            if evt.code() == Code::Enter && evt.modifiers().is_empty() {
+                                do_send();
+                            }
+                        }
                     }
+                    div {
+                        span {
+                            onclick: move |_| pick_and_send_file(&net),
+                            class: "material-symbols-outlined",
+                            style: "color: rgba(255, 255, 255, 0.5); font-variation-settings: 'FILL' 1, 'wght' 700, 'GRAD' 0, 'opsz' 48; vertical-align: middle; font-size: 35px; user-select: none;",
+                            "attach_file",
+                        }
+                    }
+                    div {
+                        span {
+                            onclick: move |_| do_send(),
+                            class: "material-symbols-outlined",
+                            style: "color: rgba(255, 255, 255, 0.5); font-variation-settings: 'FILL' 1, 'wght' 700, 'GRAD' 0, 'opsz' 48; vertical-align: middle; font-size: 35px; user-select: none;",
+                            "send",
+                        }
+                    }
+                }
+                //button {
+                //    onclick: move |_| do_send(),
+                //    "Send"
+                //}
+            }
+        }
+    )
+}
+
+// true => rsx!(span { class: "material-symbols-outlined", style: "{button_style}", "mic_off"}),
+//Connecting => rsx! {
+//    div {
+//        class: "{connecting_status}",
+//        span {
+//            class: "material-symbols-outlined",
+//            style: "vertical-align: middle; font-size: 30px;",
+//            "signal_cellular_alt_2_bar"
+//        }
+//        span {
+//            style: "width: 5px; display: inline-block;"
+//        }
+//        span {
+//            style: "vertical-align: middle; font-size: 30px;",
+//            "Connecting"
+//        }
+//    }
+//},
+
+#[component]
+pub fn ControlView(config: Resource<ClientConfig>) -> Element {
+    let net: Coroutine<Command> = use_coroutine_handle();
+    let status = &STATE.status;
+    let server = STATE.server.read();
+    let Some(&UserState {
+        deaf,
+        self_deaf,
+        mute,
+        self_mute,
+        ref name,
+        channel,
+        ..
+    }) = server.this_user()
+    else {
+        return rsx!();
+    };
+
+    let current_channel_name = server.channels[&channel].name.clone();
+
+    let Some(proxy_url) = config
+        .read_unchecked()
+        .as_ref()
+        .and_then(|gui_config| gui_config.proxy_url.clone())
+    else {
+        return rsx!();
+    };
+
+    let button_row = css!(
+        r#"
+        display: flex;
+        gap: 10px;
+    "#
+    );
+
+    let spacer = css!(
+        r#"
+        flex-grow: 1;
+    "#
+    );
+
+    let toggle_button = css!(
+        r#"
+        padding: 8px;
+        height: 100%;
+        aspect-ratio: 1 / 1;
+
+        background-color: unset;
+
+        border: solid rgb(255 255 255 / 0.1) 3px;
+        border-radius: 10px;
+        color: rgb(255 255 255 / 50%);
+
+        transition: all 0.5s ease-in-out;
+        "#
+    );
+
+    let toggle_button_on = css!(
+        r#"
+        padding: 8px;
+        height: 100%;
+        aspect-ratio: 1 / 1;
+
+        background-color: oklch(0.5 0.1381 21.71 / 20.12%);
+
+        border: solid rgb(255 255 255 / 0) 3px;
+        border-radius: 10px;
+        color: oklch(0.53 0.1505 21.71 / 89.38%);
+
+        transition: all 0.25s ease-in-out;
+        "#
+    );
+
+    let button_style = r#"
+        font-variation-settings: 'FILL' 1, 'wght' 700, 'GRAD' 0, 'opsz' 48;
+        vertical-align: middle;
+        font-size: 35px;
+    "#;
+
+    let connecting_status = css!(
+        r#"
+            color: yellow;
+        "#
+    );
+
+    let connected_status = css!(
+        r#"
+            color: oklch(0.55 0.1184 141.35);
+        "#
+    );
+
+    let disconnected_status = css!(
+        r#"
+            color: gray;
+        "#
+    );
+
+    let failed_status = css!(
+        r#"
+            color: red;
+        "#
+    );
+
+    let connection_info = css!(
+        r#"
+            color: gray;
+        "#
+    );
+
+    let user_edit_button = css!(
+        r#"
+            background-color: oklch(0.53 0.1431 264.18);
+            border-radius: 50%;
+            aspect-ratio: 1 / 1;
+        "#
+    );
+
+    let connection_status = match &*status.read() {
+        Connecting => rsx! {
+            div {
+                class: "{connecting_status}",
+                span {
+                    class: "material-symbols-outlined",
+                    style: "vertical-align: middle; font-size: 30px;",
+                    "signal_cellular_alt_2_bar"
+                }
+                span {
+                    style: "width: 5px; display: inline-block;"
+                }
+                span {
+                    style: "vertical-align: middle; font-size: 30px;",
+                    "Connecting"
+                }
+            }
+        },
+        Connected => rsx! {
+            div {
+                div {
+                    class: "{connected_status}",
+                    span {
+                        class: "material-symbols-outlined",
+                        style: "vertical-align: middle; font-size: 30px;",
+                        "signal_cellular_alt"
+                    }
+                    span {
+                        style: "width: 5px; display: inline-block;"
+                    }
+                    span {
+                        style: "vertical-align: middle; font-size: 25px;",
+                        "Connected"
+                    }
+                }
+                div {
+                    class: "{connection_info}",
+                    span { style: "width: 3px; display: inline-block;"}
+                    span { "{current_channel_name}" }
+                    span { " — " }
+                    span { "{proxy_url}" }
+                }
+            }
+        },
+        Disconnected => rsx! {
+            div {
+                class: "{disconnected_status}",
+                span {
+                    class: "material-symbols-outlined",
+                    style: "vertical-align: middle;",
+                    "signal_disconnected"
+                }
+                span {
+                    style: "width: 5px; display: inline-block;"
+                }
+                span {
+                    style: "vertical-align: middle;",
+                    "Disconnected"
+                }
+            }
+        },
+        Failed(_) => rsx! {
+            div {
+                class: "{failed_status}",
+                span {
+                    class: "material-symbols-outlined",
+                    style: "vertical-align: middle;",
+                    "error"
+                }
+                span {
+                    style: "width: 5px; display: inline-block;"
+                }
+                span {
+                    style: "vertical-align: middle;",
+                    "Failed"
+                }
+            }
+        },
+    };
+
+    let denoise = use_signal(|| false);
+    rsx!(
+        // Server control
+        div {
+            class: "{button_row}",
+            div {
+                {connection_status}
+            }
+            span { class: "{spacer}" }
+            button {
+                class: "{toggle_button}",
+                onclick: move |_| net.send(Disconnect),
+                span {
+                    class: "material-symbols-outlined",
+                    style: "{button_style}",
+                    "signal_disconnected"
                 }
             }
         }
+        hr { style: "width: 100%;" }
+        // User control
         div {
-            class: "{chat_box}",
-            input {
-                placeholder: "say something",
-                value: "{draft.read()}",
-                oninput: move |evt| draft.set(evt.value().clone()),
-                onkeypress: move |evt: Event<KeyboardData>| {
-                    if evt.code() == Code::Enter && evt.modifiers().is_empty() {
-                        do_send();
-                    }
+            class: "{button_row}",
+            button {
+                class: "{user_edit_button}",
+                span {
+                    class: "material-symbols-outlined",
+                    style: "color: oklch(0.65 0.2245 28.06); font-size: 45px; font-variation-settings: 'FILL' 1, 'wght' 700, 'GRAD' 0, 'opsz' 48;",
+                    "person_edit"
+                }
+            }
+            div {
+                div {
+                    span { style: "font-size: 25px;", "{name}" }
+                }
+                div {
+                    span { style: "font-size: 20px; color: gray;", "some data" }
+                }
+            }
+            span { class: "{spacer}" }
+            button {
+                class: match denoise() {
+                    true => toggle_button_on,
+                    false => toggle_button,
+                },
+                role: "switch",
+                aria_checked: denoise(),
+                onclick: move |_| {
+                    let new_denoise = !denoise();
+                    *denoise.write_unchecked() = new_denoise;
+                    net.send(UpdateMicEffects { denoise: new_denoise })
+                },
+                match denoise() {
+                    true => rsx!(span { class: "material-symbols-outlined", style: "{button_style}", "cadence"}),
+                    false => rsx!(span { class: "material-symbols-outlined", style: "{button_style}", "graphic_eq"}),
                 }
             }
             button {
-                onclick: move |_| do_send(),
-                "Send"
+                class: match mute || self_mute {
+                    true => toggle_button_on,
+                    false => toggle_button,
+                },
+                role: "switch",
+                aria_checked: mute || self_mute,
+                disabled: mute,
+                onclick: move |_| net.send(SetMute { mute: !self_mute }),
+                match mute || self_mute {
+                    true => rsx!(span { class: "material-symbols-outlined", style: "{button_style}", "mic_off"}),
+                    false => rsx!(span { class: "material-symbols-outlined", style: "{button_style}", "mic"}),
+                }
+            }
+            button {
+                class: match deaf || self_deaf {
+                    true => toggle_button_on,
+                    false => toggle_button,
+                },
+                role: "switch",
+                aria_checked: deaf || self_deaf,
+                disabled: deaf,
+                onclick: move |_| net.send(SetDeaf { deaf: !self_deaf }),
+                match deaf || self_deaf {
+                    true => rsx!(span { class: "material-symbols-outlined", style: "{button_style}", "volume_off"}),
+                    false => rsx!(span { class: "material-symbols-outlined", style: "{button_style}", "volume_up"}),
+                }
             }
         }
     )
 }
 
 #[component]
-pub fn ServerView() -> Element {
+pub fn ServerView(config: Resource<ClientConfig>) -> Element {
     let net: Coroutine<Command> = use_coroutine_handle();
     let server = STATE.server.read();
     let Some(&UserState {
@@ -338,21 +743,21 @@ pub fn ServerView() -> Element {
     let grid = css!(
         r#"
         display: grid;
-        height: 100%;
+       height: 100%;
         background-color: var(--bg-color);
 
-        grid-template-rows: auto 1fr;
-        grid-template-columns: 1fr 1fr;
+        grid-template-rows: 1fr auto;
+        grid-template-columns: 1fr 2fr;
         grid-template-areas:
-            "bar bar"
-            "tree chat";
+            "tree chat"
+            "control chat";
 
         @media screen and (max-width: 720px) {
             grid-template-rows: auto 1fr 1fr;
             grid-template-columns: 1fr;
             grid-template-areas:
-                "bar"
                 "tree"
+                "control"
                 "chat";
         }
     "#
@@ -369,7 +774,7 @@ pub fn ServerView() -> Element {
     let chat_box = css!(
         "
         display: flex;
-        flex-direction: column;
+        flex-direction: row;
         grid-area: chat;
         border-left: solid var(--line-color) var(--line-width);
 
@@ -380,60 +785,24 @@ pub fn ServerView() -> Element {
     "
     );
 
-    let top_bar = css!(
+    let control_box = css!(
         "
         padding: 16px;
-        grid-area: bar;
-        background-color: var(--login-bg-color);
+        margin: 16px;
+        background-color: var(--light-bg-color);
+        border-radius: 10px;
+        overflow: hidden;
+        grid-area: control;
 
         display: flex;
-        flex-direction: row;
-        gap: 16px;
-        align-items: center;
-
-        button {
-            padding: 8px;
-
-            img {
-                height: 1em;
-                vertical-align: text-bottom;
-            }
-        }
+        gap: 10px;
+        flex-direction: column;
     "
     );
 
     rsx!(
         div {
             class: "{grid}",
-            div {
-                class: "{top_bar}",
-                button {
-                    onclick: move |_| net.send(Disconnect),
-                    "Disconnect"
-                }
-                button {
-                    role: "switch",
-                    aria_checked: mute || self_mute,
-                    disabled: mute,
-                    onclick: move |_| net.send(SetMute { mute: !self_mute }),
-                    match mute || self_mute {
-                        true => rsx!(img { src: asset!("assets/mic-off-svgrepo-com.svg") }),
-                        false => rsx!(img { src: asset!("assets/mic-svgrepo-com.svg") }),
-                    }
-                    "\u{00A0}Mute"
-                }
-                button {
-                    role: "switch",
-                    aria_checked: deaf || self_deaf,
-                    disabled: deaf,
-                    onclick: move |_| net.send(SetDeaf { deaf: !self_deaf }),
-                    match deaf || self_deaf {
-                        true => rsx!(img { src: asset!("assets/speaker-muted-svgrepo-com.svg") }),
-                        false => rsx!(img { src: asset!("assets/speaker-medium-svgrepo-com.svg") }),
-                    }
-                    "\u{00A0}Deafen"
-                }
-            }
             div {
                 class: "{channel_box}",
                 for (id, state) in server.channels.iter() {
@@ -446,15 +815,28 @@ pub fn ServerView() -> Element {
                 class: "{chat_box}",
                 ChatView {}
             }
+            div {
+                class: "{control_box}",
+                ControlView { config }
+            }
         }
     )
 }
 
 #[component]
-pub fn LoginView() -> Element {
+pub fn LoginView(config: Resource<ClientConfig>) -> Element {
     let net: Coroutine<Command> = use_coroutine_handle();
-    let default_address = CONFIG.proxy_url.as_deref().unwrap_or("");
-    let mut address = use_signal(|| default_address.to_string());
+
+    let mut address_input = use_signal(|| None::<String>);
+    let mut address = use_memo(move || {
+        if let Some(addr) = address_input() {
+            addr.clone()
+        } else {
+            config()
+                .and_then(|c| c.proxy_url.clone())
+                .unwrap_or_default()
+        }
+    });
 
     let previous_username = imp::load_username();
     let mut username = use_signal(|| previous_username.unwrap_or(String::new()));
@@ -508,6 +890,7 @@ pub fn LoginView() -> Element {
         net.send(Connect {
             address: address.read().clone(),
             username: username.read().clone(),
+            config: config.read().clone().unwrap_or_default(),
         })
     };
     let status = &STATE.status;
@@ -557,7 +940,7 @@ pub fn LoginView() -> Element {
                 placeholder: "server address",
                 value: "{address.read()}",
                 autofocus: "true",
-                oninput: move |evt| address.set(evt.value().clone()),
+                oninput: move |evt| address_input.set(Some(evt.value().clone())),
             }
             {bottom}
         }
@@ -566,17 +949,24 @@ pub fn LoginView() -> Element {
 
 pub fn app() -> Element {
     use_coroutine(|rx: UnboundedReceiver<Command>| super::network_entrypoint(rx));
+    let config = use_resource(|| async move {
+        match imp::load_config().await {
+            Ok(config) => config,
+            Err(_) => ClientConfig::default(),
+        }
+    });
 
     global_css!(
         "
     :root {
-        --txt-color: white;
-        --bg-color: #372f3a;
+        --txt-color: oklch(0.9 0 99);
+        --bg-color: oklch(0.15 0.01 338.64);
+        --light-bg-color: oklch(0.25 0.01 338.64);
         --login-bg-color: #5d7680;
         --primary-btn-color: #7bad9f;
-        --accent-a: #8eb29a;
-        --accent-b: #6a9395;
-        --accent-c: #464459;
+        --accent-normal: #7bad9f;
+        --accent-muted: #ff746c;
+        --accent-deafened: #464459;
         --line-width: 2px;
         --line-color: white;
     }
@@ -594,8 +984,10 @@ pub fn app() -> Element {
         overflow: auto;
         color: var(--txt-color);
 
-        font-family: sans-serif;
-        font-size: large;
+        font-family: Nunito;
+        font-size: 15pt;
+        font-weight: 600;
+
     }
 
     button {
@@ -617,25 +1009,28 @@ pub fn app() -> Element {
 
     input:focus,input:focus-visible {
         border: none;
-        outline: solid var(--line-width) var(--accent-a);
+        outline: solid var(--line-width) var(--accent-normal);
         outline-offset: -3px;
     }
 
     a:link {
-        color: var(--accent-a);
+        color: var(--accent-normal);
     }
 
     a:visited {
-        color: var(--accent-b);
+        color: var(--accent-muted);
     }
     "
     );
 
     rsx!(
+        document::Link{ rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=Nunito:ital,wght@0,200..1000;1,200..1000&display=swap" }
+        document::Link{ rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:opsz,wght,FILL,GRAD@20..48,100..700,0..1,-50..200" }
+
         sir::AppStyle { }
         match *STATE.status.read() {
-            Connected => rsx!(ServerView {}),
-            _ => rsx!(LoginView {}),
+            Connected => rsx!(ServerView { config }),
+            _ => rsx!(LoginView { config }),
         }
     )
 }

gui/src/effects.rs

@@ -0,0 +1,28 @@
+use crossbeam::atomic::AtomicCell;
+use std::sync::Arc;
+
+#[derive(Default)]
+pub struct AudioProcessor {
+    df: Option<::df::DFState>,
+}
+
+impl AudioProcessor {
+    pub fn new_denoising() -> Self {
+        let df = ::df::DFState::default();
+        AudioProcessor { df: Some(df) }
+    }
+}
+
+impl AudioProcessor {
+    pub fn process(&mut self, audio: &[f32]) -> Box<[f32]> {
+        let mut output: Box<[f32]> = vec![0f32; audio.len()].into();
+        if let Some(df) = &mut self.df {
+            df.process_frame(audio, &mut output);
+        } else {
+            output.copy_from_slice(audio);
+        }
+        output
+    }
+}
+
+pub type AudioProcessorSender = Arc<AtomicCell<Option<AudioProcessor>>>;

gui/src/imp/desktop.rs

@@ -1,20 +1,24 @@
 use crate::app::Command;
-use color_eyre::eyre::Error;
+use crate::effects::AudioProcessor;
+use color_eyre::eyre::{eyre, Error};
+use cpal::traits::{DeviceTrait, HostTrait};
 use dioxus::hooks::{UnboundedReceiver, UnboundedSender};
 use futures::io::{AsyncRead, AsyncWrite};
 use mumble_protocol::control::{ClientControlCodec, ControlPacket};
 use mumble_protocol::Serverbound;
-use mumble_web2_common::GuiConfig;
+use mumble_web2_common::ClientConfig;
 use std::net::ToSocketAddrs;
+use std::sync::Mutex;
 use std::{fmt, io, sync::Arc};
 use tokio::net::TcpStream;
 use tokio_rustls::rustls;
 use tokio_rustls::rustls::client::danger::{HandshakeSignatureValid, ServerCertVerifier};
 use tokio_rustls::rustls::pki_types::{CertificateDer, ServerName, UnixTime};
-use tokio_rustls::rustls::ClientConfig;
+use tokio_rustls::rustls::ClientConfig as RlsClientConfig;
 use tokio_rustls::rustls::DigitallySignedStruct;
 use tokio_rustls::TlsConnector;
 use tokio_util::compat::{TokioAsyncReadCompatExt as _, TokioAsyncWriteCompatExt as _};
+use tracing::{error, info, instrument, warn};
 
 pub use tokio::task::spawn;
 pub use tokio::time::sleep;
@@ -25,25 +29,110 @@ impl<T: AsyncRead + Unpin + Send + 'static> ImpRead for T {}
 pub trait ImpWrite: AsyncWrite + Unpin + Send + 'static {}
 impl<T: AsyncWrite + Unpin + Send + 'static> ImpWrite for T {}
 
-pub struct AudioSystem();
+pub struct AudioSystem {
+    output: cpal::Device,
+    input: cpal::Device,
+}
+
+type Buffer = Arc<Mutex<dasp_ring_buffer::Bounded<Vec<i16>>>>;
 
 impl AudioSystem {
-    pub fn new(sender: UnboundedSender<ControlPacket<Serverbound>>) -> Result<Self, Error> {
+    pub fn new() -> Result<Self, Error> {
         // TODO
-        Ok(AudioSystem())
+        let host = cpal::default_host();
+        let name = host.id();
+        Ok(AudioSystem {
+            output: host
+                .default_output_device()
+                .ok_or(eyre!("no output devices from {name:?}"))?,
+            input: host
+                .default_input_device()
+                .ok_or(eyre!("no input devices from {name:?}"))?,
+        })
+    }
+
+    pub fn set_processor(&self, processor: AudioProcessor) {
+        // TODO
+    }
+
+    pub fn start_recording(&mut self, each: impl FnMut(Vec<u8>) + 'static) -> Result<(), Error> {
+        // TODO
+        Ok(())
     }
 
     pub fn create_player(&mut self) -> Result<AudioPlayer, Error> {
-        // TODO
-        Ok(AudioPlayer())
+        let buffer = Arc::new(Mutex::new(dasp_ring_buffer::Bounded::from_raw_parts(
+            0,
+            0,
+            vec![
+            0;
+            2400 // 50ms of buffer
+        ],
+        )));
+        let decoder = opus::Decoder::new(48_000, opus::Channels::Mono)?;
+        let stream = {
+            let buffer = buffer.clone();
+            self.output.build_output_stream(
+                &cpal::StreamConfig {
+                    channels: 1,
+                    sample_rate: cpal::SampleRate(48_000),
+                    buffer_size: cpal::BufferSize::Fixed(480), // 10ms playback delay
+                },
+                move |frame, info| {
+                    let mut buffer = buffer.lock().unwrap();
+                    for x in frame.iter_mut() {
+                        match buffer.pop() {
+                            Some(y) => {
+                                *x = y;
+                            }
+                            None => {
+                                *x = 0;
+                            }
+                        }
+                    }
+                },
+                move |err| error!("could not create output stream {err:?}"),
+                None,
+            )?
+        };
+        Ok(AudioPlayer {
+            decoder,
+            stream,
+            buffer,
+            tmp: vec![0; 2400],
+        })
     }
 }
 
-pub struct AudioPlayer();
+pub struct AudioPlayer {
+    decoder: opus::Decoder,
+    stream: cpal::Stream,
+    buffer: Buffer,
+    tmp: Vec<i16>,
+}
 
 impl AudioPlayer {
     pub fn play_opus(&mut self, payload: &[u8]) {
-        // TODO
+        let len = loop {
+            match self.decoder.decode(payload, &mut self.tmp, false) {
+                Ok(l) => break l,
+                Err(e) => {
+                    error!("opus decode error {e:?}");
+                    return;
+                }
+            }
+        };
+
+        let mut buffer = self.buffer.lock().unwrap();
+        let mut overrun = 0;
+        for x in &self.tmp[..len] {
+            if let Some(_) = buffer.push(*x) {
+                overrun += 1;
+            }
+        }
+        if overrun > 0 {
+            warn!("playback overrun by {overrun} samples");
+        }
     }
 }
 
@@ -99,12 +188,16 @@ impl ServerCertVerifier for NoCertificateVerification {
     }
 }
 
+#[instrument]
 pub async fn network_connect(
     address: String,
     username: String,
     event_rx: &mut UnboundedReceiver<Command>,
+    gui_config: &ClientConfig,
 ) -> Result<(), Error> {
-    let config = ClientConfig::builder()
+    info!("connecting");
+
+    let config = RlsClientConfig::builder()
         .dangerous()
         .with_custom_certificate_verifier(Arc::new(NoCertificateVerification))
         .with_no_client_auth();
@@ -140,8 +233,10 @@ pub fn load_username() -> Option<String> {
     return None;
 }
 
-pub fn load_config() -> Option<GuiConfig> {
-    None
+pub async fn load_config() -> color_eyre::Result<ClientConfig> {
+    color_eyre::eyre::bail!(
+        "there is no config on desktop because desktops cannot be configured as they are tables"
+    )
 }
 
 pub fn init_logging() {

gui/src/imp/web.rs

@@ -1,15 +1,15 @@
 use crate::app::Command;
-use crate::CONFIG;
+use crate::effects::{AudioProcessor, AudioProcessorSender};
 use color_eyre::eyre::{bail, eyre, Error};
 use dioxus::prelude::*;
 use futures::{AsyncRead, AsyncWrite};
-use futures_channel::mpsc::UnboundedSender;
 use gloo_timers::future::TimeoutFuture;
-use mumble_protocol::control::{ClientControlCodec, ControlPacket};
-use mumble_protocol::voice::{VoicePacket, VoicePacketPayload};
-use mumble_protocol::Serverbound;
-use mumble_web2_common::GuiConfig;
+use js_sys::Float32Array;
+use mumble_protocol::control::ClientControlCodec;
+use mumble_web2_common::ClientConfig;
+use reqwest::Url;
 use std::time::Duration;
+use tracing::level_filters::LevelFilter;
 use tracing::{debug, error, info, instrument};
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::JsFuture;
@@ -71,28 +71,41 @@ impl<T> ResultExt<T> for Result<T, JsError> {
         self.map_err(|e| JsValue::from(e)).ey()
     }
 }
-pub struct AudioSystem(AudioContext);
+
+pub struct AudioSystem {
+    webctx: AudioContext,
+    processors: AudioProcessorSender,
+}
 
 impl AudioSystem {
-    pub fn new(sender: UnboundedSender<ControlPacket<Serverbound>>) -> Result<Self, Error> {
+    pub fn new() -> Result<Self, Error> {
         // Create MediaStreams to playback decoded audio
         // The audio context is used to reproduce audio.
-        let audio_context = configure_audio_context();
+        let webctx = configure_audio_context();
+        let processor = AudioProcessorSender::default();
+        Ok(AudioSystem {
+            webctx,
+            processors: processor,
+        })
+    }
 
-        let audio_context_worklet = audio_context.clone();
+    pub fn set_processor(&self, processor: AudioProcessor) {
+        self.processors.store(Some(processor))
+    }
+
+    pub fn start_recording(&mut self, each: impl FnMut(Vec<u8>) + 'static) -> Result<(), Error> {
+        let audio_context_worklet = self.webctx.clone();
+        let processors = self.processors.clone();
         spawn(async move {
-            match create_encoder_worklet(&audio_context_worklet, sender).await {
+            match run_encoder_worklet(&audio_context_worklet, each, processors).await {
                 Ok(node) => info!("created encoder worklet: {:?}", &node),
                 Err(err) => error!("could not create encoder worklet: {err}"),
             }
         });
-
-        Ok(AudioSystem(audio_context))
+        Ok(())
     }
 
     pub fn create_player(&mut self) -> Result<AudioPlayer, Error> {
-        let audio_context = &self.0;
-
         let audio_stream_generator =
             MediaStreamTrackGenerator::new(&MediaStreamTrackGeneratorInit::new("audio")).ey()?;
 
@@ -102,12 +115,10 @@ impl AudioSystem {
         let media_stream = MediaStream::new_with_tracks(&js_tracks).ey()?;
 
         // Create MediaStreamAudioSourceNode
-        let audio_source = audio_context
-            .create_media_stream_source(&media_stream)
-            .ey()?;
+        let audio_source = self.webctx.create_media_stream_source(&media_stream).ey()?;
         // Connect output of audio_source to audio_context (browser audio)
         audio_source
-            .connect_with_audio_node(&audio_context.destination())
+            .connect_with_audio_node(&self.webctx.destination())
             .ey()?;
 
         // Create callback functions for AudioDecoder
@@ -175,8 +186,8 @@ impl AudioPlayer {
 // Borrowed from
 // https://github.com/security-union/videocall-rs/blob/main/videocall-client/src/decode/config.rs#L6
 fn configure_audio_context() -> AudioContext {
-    let mut audio_context_options = AudioContextOptions::new();
-    audio_context_options.sample_rate(48000 as f32);
+    let audio_context_options = AudioContextOptions::new();
+    audio_context_options.set_sample_rate(48000 as f32);
     let audio_context = AudioContext::new_with_context_options(&audio_context_options).unwrap();
     audio_context
 }
@@ -191,16 +202,31 @@ impl PromiseExt for Promise {
     }
 }
 
-async fn create_encoder_worklet(
+fn process_audio(frame: &JsValue, processor: &mut AudioProcessor) {
+    let Ok(samples) = Reflect::get(&frame, &"data".into()) else {
+        return;
+    };
+    let Ok(samples) = samples.dyn_into::<Float32Array>() else {
+        return;
+    };
+    let input = samples.to_vec();
+    let output = processor.process(&input);
+    samples.copy_from(&output);
+}
+
+async fn run_encoder_worklet(
     audio_context: &AudioContext,
-    packets: UnboundedSender<ControlPacket<mumble_protocol::Serverbound>>,
+    mut each: impl FnMut(Vec<u8>) + 'static,
+    processors: AudioProcessorSender,
 ) -> Result<AudioWorkletNode, Error> {
+    let constraints = MediaStreamConstraints::new();
+    constraints.set_audio(&JsValue::TRUE);
     let stream = window()
         .unwrap()
         .navigator()
         .media_devices()
         .ey()?
-        .get_user_media_with_constraints(MediaStreamConstraints::new().audio(&JsValue::TRUE))
+        .get_user_media_with_constraints(&constraints)
         .ey()?
         .into_future()
         .await
@@ -234,35 +260,12 @@ async fn create_encoder_worklet(
     let encoder_error: Closure<dyn FnMut(JsValue)> =
         Closure::new(|e| error!("error encoding audio {:?}", e));
 
-    let download_buffer = std::cell::RefCell::new(Vec::new());
-
     // This knows what MediaStreamTrackGenerator to use as it closes around it
-    let mut sequence_num = 0;
     let output: Closure<dyn FnMut(EncodedAudioChunk)> =
         Closure::new(move |audio_data: EncodedAudioChunk| {
             let mut array = vec![0u8; audio_data.byte_length() as usize];
             audio_data.copy_to_with_u8_slice(&mut array);
-
-            download_buffer.borrow_mut().push(array.clone());
-            if download_buffer.borrow().len() > 200 {
-                //download_data(download_buffer.borrow().to_vec(), "download_buffer.opus");
-                //download_data(
-                //    ass::encode(download_buffer.borrow().to_vec(), 960, 0),
-                //    "download_buffer.opus",
-                //);
-                download_buffer.borrow_mut().clear();
-            }
-
-            let _ =
-                packets.unbounded_send(ControlPacket::UDPTunnel(Box::new(VoicePacket::Audio {
-                    _dst: std::marker::PhantomData,
-                    target: 0,
-                    session_id: (),
-                    seq_num: sequence_num,
-                    payload: VoicePacketPayload::Opus(array.into(), false),
-                    position_info: None,
-                })));
-            sequence_num = sequence_num.wrapping_add(2);
+            each(array);
         });
 
     let audio_encoder = AudioEncoder::new(&AudioEncoderInit::new(
@@ -282,23 +285,18 @@ async fn create_encoder_worklet(
     audio_encoder.configure(&encoder_config);
     info!("created audio encoder");
 
-    let download_buffer = std::cell::RefCell::new(Vec::new());
-
+    let mut current_processor = AudioProcessor::default();
     let onmessage: Closure<dyn FnMut(MessageEvent)> = Closure::new(move |event: MessageEvent| {
-        match AudioData::new(event.data().unchecked_ref()) {
-            Ok(data) => {
-                let x = web_sys::AudioDataCopyToOptions::new(0);
-                x.set_format(web_sys::AudioSampleFormat::F32);
-                let mut sub_buffer = vec![0; data.allocation_size(&x).unwrap() as usize];
-                data.copy_to_with_u8_slice(&mut sub_buffer, &x);
-                download_buffer.borrow_mut().append(&mut sub_buffer);
-                if download_buffer.borrow().len() > 48000 * 10 * 4 {
-                    //pub fn download_data(data: Vec<u8>, filename: &str) -> Result<(), JsValue> {
-                    //download_data(download_buffer.borrow().to_vec(), "download_buffer.pcm32");
-                    download_buffer.borrow_mut().clear();
-                }
+        if let Some(new_processor) = processors.take() {
+            current_processor = new_processor;
+        }
 
-                audio_encoder.encode(&data);
+        let frame = event.data();
+        process_audio(&frame, &mut current_processor);
+
+        match AudioData::new(frame.unchecked_ref()) {
+            Ok(data) => {
+                let _ = audio_encoder.encode(&data);
             }
             Err(err) => {
                 error!(
@@ -329,8 +327,9 @@ pub async fn network_connect(
     address: String,
     username: String,
     event_rx: &mut UnboundedReceiver<Command>,
+    gui_config: &ClientConfig,
 ) -> Result<(), Error> {
-    info!("Rust via WASM!");
+    info!("connecting");
 
     let object = web_sys::js_sys::Object::new();
 
@@ -341,7 +340,7 @@ pub async fn network_connect(
     )
     .ey()?;
 
-    if let Some(server_hash) = &CONFIG.cert_hash {
+    if let Some(server_hash) = &gui_config.cert_hash {
         let hash = web_sys::js_sys::Uint8Array::from(server_hash.as_slice());
         web_sys::js_sys::Reflect::set(&object, &"value".into(), &hash).ey()?;
     }
@@ -407,16 +406,23 @@ pub fn load_username() -> Option<String> {
         .ok()?
 }
 
-fn load_config_from_window() -> Option<GuiConfig> {
-    serde_wasm_bindgen::from_value(Reflect::get(window()?.as_ref(), &"config".into()).ok()?).ok()
-}
+pub async fn load_config() -> color_eyre::Result<ClientConfig> {
+    let config_url = match option_env!("MUMBLE_WEB2_GUI_CONFIG_URL") {
+        Some(url) => Url::parse(url)?,
+        None => {
+            let window: web_sys::Window = web_sys::window().expect("no global `window` exists");
+            let location = window.location();
+            Url::parse(&location.href().ey()?)?.join("config")?
+        }
+    };
+    info!("loading config from {}", config_url);
 
-fn load_config_from_env() -> Option<GuiConfig> {
-    serde_json::from_str(option_env!("MUMBLE_WEB2_GUI_CONFIG")?).ok()?
-}
+    let config = reqwest::get(config_url)
+        .await?
+        .json::<ClientConfig>()
+        .await?;
 
-pub fn load_config() -> Option<GuiConfig> {
-    load_config_from_window().or_else(load_config_from_env)
+    Ok(config)
 }
 
 pub fn init_logging() {
@@ -429,11 +435,14 @@ pub fn init_logging() {
     let fmt_layer = tracing_subscriber::fmt::layer()
         .with_ansi(false) // Only partially supported across browsers
         .without_time() // std::time is not available in browsers
-        .with_writer(MakeWebConsoleWriter::new()); // write events to the console
+        .with_writer(MakeWebConsoleWriter::new()) // write events to the console
+        .with_filter(LevelFilter::DEBUG);
     let perf_layer = performance_layer().with_details_from_fields(Pretty::default());
 
     tracing_subscriber::registry()
         .with(fmt_layer)
         .with(perf_layer)
         .init();
+
+    info!("logging initiated");
 }

gui/src/lib.rs

@@ -12,13 +12,15 @@ use futures::SinkExt as _;
 use futures::StreamExt as _;
 use futures_channel::mpsc::UnboundedSender;
 pub use imp::spawn;
+use msghtml::process_message_html;
 use mumble_protocol::control::msgs;
 use mumble_protocol::control::ControlCodec;
 use mumble_protocol::control::ControlPacket;
+use mumble_protocol::voice::VoicePacket;
 use mumble_protocol::voice::VoicePacketPayload;
 use mumble_protocol::Clientbound;
 use mumble_protocol::Serverbound;
-use mumble_web2_common::GuiConfig;
+use mumble_web2_common::ClientConfig;
 use once_cell::sync::Lazy;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
@@ -27,20 +29,28 @@ use tracing::debug;
 use tracing::error;
 use tracing::info;
 
-pub mod app;
-pub mod imp;
+use crate::effects::AudioProcessor;
+use crate::imp::AudioSystem;
 
-pub static CONFIG: Lazy<GuiConfig> = Lazy::new(|| imp::load_config().unwrap_or_default());
+pub mod app;
+mod effects;
+pub mod imp;
+mod msghtml;
 
 pub async fn network_entrypoint(mut event_rx: UnboundedReceiver<Command>) {
     loop {
-        let Some(Command::Connect { address, username }) = event_rx.next().await else {
+        let Some(Command::Connect {
+            address,
+            username,
+            config,
+        }) = event_rx.next().await
+        else {
             panic!("did not receive connect command")
         };
 
         *STATE.server.write() = Default::default();
         *STATE.status.write() = ConnectionState::Connecting;
-        if let Err(error) = imp::network_connect(address, username, &mut event_rx).await {
+        if let Err(error) = imp::network_connect(address, username, &mut event_rx, &config).await {
             error!("could not connect {:?}", error);
             *STATE.status.write() = ConnectionState::Failed(error.to_string());
         } else {
@@ -103,7 +113,23 @@ pub async fn network_loop<R: imp::ImpRead, W: imp::ImpWrite>(
         });
     }
 
-    let mut audio = imp::AudioSystem::new(send_chan.clone())?;
+    let mut audio = imp::AudioSystem::new()?;
+    {
+        let send_chan = send_chan.clone();
+        let mut sequence_num = 0;
+        audio.start_recording(move |opus_frame| {
+            let _ =
+                send_chan.unbounded_send(ControlPacket::UDPTunnel(Box::new(VoicePacket::Audio {
+                    _dst: std::marker::PhantomData,
+                    target: 0,
+                    session_id: (),
+                    seq_num: sequence_num,
+                    payload: VoicePacketPayload::Opus(opus_frame.into(), false),
+                    position_info: None,
+                })));
+            sequence_num = sequence_num.wrapping_add(2);
+        });
+    }
 
     // Create map of session_id -> AudioDecoder
     let mut decoder_map = HashMap::new();
@@ -139,7 +165,7 @@ pub async fn network_loop<R: imp::ImpRead, W: imp::ImpWrite>(
                 match command {
                     Some(Command::Disconnect) => break,
                     Some(command) => {
-                        let res = accept_command(command, &mut send_chan);
+                        let res = accept_command(command, &mut send_chan, &mut audio);
                         if let Err(err) = res {
                             info!("error accepting command {:?}", err)
                         }
@@ -157,6 +183,7 @@ pub async fn network_loop<R: imp::ImpRead, W: imp::ImpWrite>(
 fn accept_command(
     command: Command,
     send_chan: &mut UnboundedSender<ControlPacket<mumble_protocol::Serverbound>>,
+    audio: &mut AudioSystem,
 ) -> Result<(), Error> {
     use Command::*;
     let Some(session) = STATE.server.read().session else {
@@ -198,6 +225,47 @@ fn accept_command(
             u.set_channel_id(channels);
             let _ = send_chan.unbounded_send(u.into());
         }
+        SendFile {
+            ref bytes,
+            name,
+            mime,
+            channels,
+        } => {
+            use base64::{display::Base64Display, prelude::BASE64_STANDARD};
+            let html = match mime {
+                Some(mime) if mime.type_() == "image" => format!(
+                    "<img src=\"data:{};base64,{}\" />",
+                    mime,
+                    Base64Display::new(bytes, &BASE64_STANDARD)
+                ),
+                Some(mime) => format!(
+                    "<a href=\"data:{};base64,{}\" download>{name}</a>",
+                    mime,
+                    Base64Display::new(bytes, &BASE64_STANDARD)
+                ),
+                None => format!(
+                    "<a href=\"data:application/octet-stream;base64,{}\" download>{name}</a>",
+                    Base64Display::new(bytes, &BASE64_STANDARD)
+                ),
+            };
+
+            {
+                let mut server = STATE.server.write();
+                let Some(me) = server.session else {
+                    bail!("not signed in with a session id")
+                };
+                server.chat.push(Chat {
+                    raw: "".to_string(),
+                    dangerous_html: html.clone(),
+                    sender: Some(me),
+                })
+            }
+
+            let mut u = msgs::TextMessage::new();
+            u.set_message(html);
+            u.set_channel_id(channels);
+            let _ = send_chan.unbounded_send(u.into());
+        }
         SetMute { mute } => {
             let mut u = msgs::UserState::new();
             u.set_session(session);
@@ -217,6 +285,13 @@ fn accept_command(
             let _ = send_chan.unbounded_send(u.into());
         }
         Connect { .. } | Disconnect => (),
+        UpdateMicEffects { denoise } => {
+            if denoise {
+                audio.set_processor(AudioProcessor::new_denoising());
+            } else {
+                audio.set_processor(AudioProcessor::default());
+            }
+        }
     }
 
     Ok(())
@@ -358,7 +433,7 @@ fn accept_packet(
                     } else {
                         None
                     },
-                    dangerous_html: html_purifier::purifier(&text, Default::default()),
+                    dangerous_html: process_message_html(&text),
                     raw: text,
                 });
             }
@@ -370,7 +445,7 @@ fn accept_packet(
                 let text = u.get_welcome_text().to_string();
                 server.chat.push(Chat {
                     sender: None,
-                    dangerous_html: html_purifier::purifier(&text, Default::default()),
+                    dangerous_html: process_message_html(&text),
                     raw: text,
                 });
             }

gui/src/msghtml.rs

@@ -0,0 +1,110 @@
+// This is a fork of https://github.com/mehmetcansahin/html-purifier
+
+use lol_html::html_content::{Comment, Element};
+use lol_html::{comments, element, rewrite_str, RewriteStrSettings};
+
+pub struct AllowedElement {
+    pub name: &'static str,
+    pub attributes: &'static [&'static str],
+}
+
+const ALLOWED: &'static [AllowedElement] = &[
+    AllowedElement {
+        name: "div",
+        attributes: &[],
+    },
+    AllowedElement {
+        name: "b",
+        attributes: &[],
+    },
+    AllowedElement {
+        name: "strong",
+        attributes: &[],
+    },
+    AllowedElement {
+        name: "i",
+        attributes: &[],
+    },
+    AllowedElement {
+        name: "em",
+        attributes: &[],
+    },
+    AllowedElement {
+        name: "u",
+        attributes: &[],
+    },
+    AllowedElement {
+        name: "a",
+        attributes: &["href", "title"],
+    },
+    AllowedElement {
+        name: "ul",
+        attributes: &[],
+    },
+    AllowedElement {
+        name: "ol",
+        attributes: &[],
+    },
+    AllowedElement {
+        name: "li",
+        attributes: &[],
+    },
+    AllowedElement {
+        name: "p",
+        attributes: &["style"],
+    },
+    AllowedElement {
+        name: "br",
+        attributes: &[],
+    },
+    AllowedElement {
+        name: "span",
+        attributes: &["style"],
+    },
+    AllowedElement {
+        name: "img",
+        attributes: &["width", "height", "alt", "src"],
+    },
+];
+
+pub fn process_message_html(input: &str) -> String {
+    let element_handler = |el: &mut Element| {
+        let find = ALLOWED.iter().find(|e| e.name.eq(&el.tag_name()));
+        match find {
+            Some(find) => {
+                let remove_attributes = el
+                    .attributes()
+                    .iter()
+                    .filter(|e| find.attributes.iter().any(|a| a.eq(&e.name())) == false)
+                    .map(|m| m.name())
+                    .collect::<Vec<String>>();
+                for attr in remove_attributes {
+                    el.remove_attribute(&attr);
+                }
+            }
+            None => {
+                el.remove_and_keep_content();
+            }
+        }
+        if el.tag_name() == "a" {
+            el.set_attribute("target", "_blank");
+        }
+        Ok(())
+    };
+    let comment_handler = |c: &mut Comment| {
+        c.remove();
+        Ok(())
+    };
+    let output = rewrite_str(
+        input,
+        RewriteStrSettings {
+            element_content_handlers: vec![
+                element!("*", element_handler),
+                comments!("*", comment_handler),
+            ],
+            ..RewriteStrSettings::default()
+        },
+    )
+    .unwrap();
+    return output;
+}

proxy/.gitignore

@@ -1,4 +0,0 @@
-cert.pem
-key.pem
-bundle
-config.toml

proxy/Cargo.toml

@@ -4,15 +4,28 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-color-eyre = "0.6.3"
-serde = { version = "1.0.214", features = ["derive"] }
-serde_json = "1.0.132"
-tokio = { version = "1.37.0", features = ["full"] }
-tokio-rustls = "^0.26"
-toml = "0.8.19"
-tracing = { version = "0.1.40", features = ["async-await"] }
-tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
+color-eyre = "^0.6"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio = { version = "^1.37", features = ["full"] }
+tokio-rustls = "0.26"
+toml = "0.8"
+tracing = { version = "^0.1.40", features = ["async-await"] }
+tracing-subscriber = { version = "^0.3.18", features = ["env-filter"] }
 mumble-web2-common = { workspace = true }
-salvo = { version = "0.74.2", features = ["quinn", "eyre", "rustls", "serve-static", "logging"] }
-once_cell = "1.20.2"
+salvo = { version = "^0.74.2", features = [
+  "quinn",
+  "eyre",
+  "rustls",
+  "serve-static",
+  "logging",
+  "craft",
+  "cors",
+] }
+once_cell = "^1.20"
 rustls = { version = "^0.23", features = ["aws_lc_rs"] }
+rcgen = "^0.13.2"
+hmac-sha256 = "^1.1.8"
+time = "0.3"
+url = { version = "2", features = ["serde"] }
+rand = "0.9.2"

proxy/config.toml.example

@@ -1,11 +0,0 @@
-https_listen_address = "127.0.0.1:4433"
-http_listen_address = "127.0.0.1:8080"
-cert_path = "./cert.pem"
-key_path = "./key.pem"
-mumble_server_url = "voip.ohea.xyz:64738"
-gui_path = "../target/dx/mumble-web2-gui/release/web/public"
-
-[gui]
-force_proxy = true
-proxy_url = "https://127.0.0.1:4433/proxy"
-# cert_hash = [...]

proxy/src/main.rs

@@ -1,21 +1,26 @@
-use color_eyre::eyre::{anyhow, Context, Error, Result};
-use mumble_web2_common::GuiConfig;
+use color_eyre::eyre::{anyhow, bail, Context, Result};
+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;
 use salvo::prelude::*;
 use salvo::proto::quic::BidiStream;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::path::PathBuf;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use tokio::fs;
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 use tokio::net::TcpStream;
 use tokio::pin;
 use tokio_rustls::rustls::client::danger::{HandshakeSignatureValid, ServerCertVerifier};
 use tokio_rustls::rustls::pki_types::{CertificateDer, ServerName, UnixTime};
-use tokio_rustls::rustls::{ClientConfig, DigitallySignedStruct};
+use tokio_rustls::rustls::{ClientConfig as RlsClientConfig, DigitallySignedStruct};
 use tokio_rustls::{rustls, TlsConnector};
 use tracing::info;
 use tracing::info_span;
@@ -23,57 +28,31 @@ use tracing::Instrument;
 use tracing::{error, instrument};
 use tracing_subscriber::filter::LevelFilter;
 use tracing_subscriber::EnvFilter;
+use url::Url;
 
-#[derive(Deserialize)]
+mod ping;
+
+fn default_cert_alt_names() -> Vec<String> {
+    vec!["localhost".into()]
+}
+
+#[derive(Debug, Deserialize, Serialize)]
 struct Config {
+    public_url: Url,
     https_listen_address: SocketAddr,
     http_listen_address: Option<SocketAddr>,
-    cert_path: PathBuf,
-    key_path: PathBuf,
+    cert_path: Option<PathBuf>,
+    key_path: Option<PathBuf>,
+    #[serde(default = "default_cert_alt_names")]
+    cert_alt_names: Vec<String>,
     mumble_server_url: String,
     mumble_server_address: Option<SocketAddr>,
-    gui_path: PathBuf,
-    gui: Mutex<GuiConfig>,
+    gui_path: Option<PathBuf>,
 }
 
-static CONFIG: OnceCell<Config> = OnceCell::new();
-
-#[handler]
-#[instrument]
-async fn serve_gui_index_html(req: &Request, res: &mut Response) {
-    let config = CONFIG.get().unwrap();
-
-    // Load the HTML file
-    let path = config.gui_path.join("index.html");
-    let html = match fs::read_to_string(&path).await {
-        Ok(content) => content,
-        Err(err) => {
-            error!("could not load {}: {:?}", path.display(), err);
-            res.status_code(StatusCode::INTERNAL_SERVER_ERROR);
-            return;
-        }
-    };
-
-    // Insert the script tag with configuration
-    let modified_html = html.replace(
-        "</head>",
-        &format!(
-            "<script>window.config = {}</script>\n</head>",
-            serde_json::to_string(&config.gui).unwrap(),
-        ),
-    );
-    res.render(Text::Html(modified_html));
-}
-
-#[handler]
-async fn redirect_to_gui(res: &mut Response) {
-    res.render(Redirect::permanent("/gui"));
-}
-
-async fn init_config() -> Result<()> {
+fn init_config() -> Result<Config> {
     let mut config: Config = toml::from_str(
-        &fs::read_to_string("./config.toml")
-            .await
+        &std::fs::read_to_string("./config.toml")
             .context("reading config.toml (try making a copy of config.toml.example)")?,
     )?;
     let mumble_server_addr = config
@@ -89,123 +68,244 @@ async fn init_config() -> Result<()> {
             config.mumble_server_url
         ))?;
     config.mumble_server_address = Some(mumble_server_addr);
-    CONFIG
-        .set(config)
-        .map_err(|_| anyhow!("config already initialized"))?;
-    Ok(())
+    Ok(config)
 }
 
 #[tokio::main]
 async fn main() -> Result<()> {
     init_logging();
-    init_config().await?;
-    let config = CONFIG.get().unwrap();
+    let server_config = Arc::new(init_config()?);
+    info!("config:\n{}", toml::to_string_pretty(&*server_config)?);
 
-    // Server routing
-    let router = Router::new()
-        .get(redirect_to_gui)
-        .push(Router::with_path("/proxy").goal(connect_proxy))
-        .push(Router::with_path("/gui").get(serve_gui_index_html))
-        .push(Router::with_path("/gui/<*+rest>").get(StaticDir::new(config.gui_path.clone())))
-        // right now dioxus assets don't properly handle base_url, so we are stuck with this
-        .push(
-            Router::with_path("/assets/<*+rest>")
-                .get(StaticDir::new(config.gui_path.join("assets"))),
-        )
-        .hoop(Logger::new());
-
-    // Read server certs
     rustls::crypto::aws_lc_rs::default_provider()
         .install_default()
         .map_err(|e| anyhow!("could not install crypto provider {e:?}"))?;
-    let cert = fs::read(&config.cert_path)
-        .await
-        .context(format!("reading cert {}", config.cert_path.display()))?;
-    let key = fs::read(&config.key_path)
-        .await
-        .context(format!("reading key {}", config.key_path.display()))?;
+
+    let mut client_config = ClientConfig::default();
+    client_config.proxy_url = Some(server_config.public_url.join("proxy")?.to_string());
+    let (cert, key) = match (&server_config.cert_path, &server_config.key_path) {
+        (None, None) => {
+            info!("generating self-signed cert");
+
+            // FIXME: redo every <14 days
+            let mut dname = rcgen::DistinguishedName::new();
+            dname.push(rcgen::DnType::CommonName, "mumble-web self-signed");
+            let key_pair = rcgen::KeyPair::generate_for(&rcgen::PKCS_ECDSA_P256_SHA256)?;
+            let mut cert_params =
+                rcgen::CertificateParams::new(server_config.cert_alt_names.clone())?;
+            cert_params.distinguished_name = dname;
+            cert_params.not_before = time::OffsetDateTime::now_utc();
+            cert_params.not_after = cert_params.not_before + time::Duration::days(12);
+            let cert = cert_params.self_signed(&key_pair)?;
+
+            let hash = hmac_sha256::Hash::hash(cert.der().as_ref());
+            client_config.cert_hash = Some(hash.into());
+
+            (cert.pem().into(), key_pair.serialize_pem().into())
+        }
+        (Some(cert_path), Some(key_path)) => {
+            // Read server certs
+            let cert = fs::read(cert_path)
+                .await
+                .context(format!("reading cert {}", cert_path.display()))?;
+            let key = fs::read(key_path)
+                .await
+                .context(format!("reading key {}", key_path.display()))?;
+            (cert, key)
+        }
+        _ => {
+            bail!("please supply both cert_path and key_path (or neither to generate a self-signed cert)")
+        }
+    };
     let rustls_config = RustlsConfig::new(Keycert::new().cert(cert.as_slice()).key(key.as_slice()));
 
+    info!(
+        "client config:\n{}",
+        toml::to_string_pretty(&client_config)?
+    );
+
+    let config_craft = ConfigCraft {
+        server_config: server_config.clone(),
+        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 =
+            router.push(Router::with_path("/").get(StaticFile::new(gui_path.join("index.html"))));
+        router = router.push(Router::with_path("/<*+rest>").get(StaticDir::new(gui_path)));
+    }
+
+    let cors = Cors::new().allow_origin(AllowOrigin::any()).into_handler();
+
+    let service = Service::new(router).hoop(cors);
+
     // Create http listeners
-    let http_listener = config.http_listen_address.map(TcpListener::new);
+    let http_listener = server_config.http_listen_address.map(TcpListener::new);
     let https_listener =
-        TcpListener::new(config.https_listen_address).rustls(rustls_config.clone());
-    let http3_listener = QuinnListener::new(rustls_config, config.https_listen_address);
+        TcpListener::new(server_config.https_listen_address).rustls(rustls_config.clone());
+    let http3_listener = QuinnListener::new(rustls_config, server_config.https_listen_address);
 
     // Start server
     match (http_listener, https_listener, http3_listener) {
         (Some(a), b, c) => {
             let accepter = a.join(b).join(c).bind().await;
-            Server::new(accepter).serve(router).await;
+            Server::new(accepter).serve(service).await;
         }
         (None, b, c) => {
             let accepter = b.join(c).bind().await;
-            Server::new(accepter).serve(router).await;
+            Server::new(accepter).serve(service).await;
         }
     }
 
     Ok(())
 }
 
-#[handler]
-#[instrument]
-async fn connect_proxy(req: &mut Request, res: &mut Response) {
-    info!("received proxy request");
-    let mumble_server_address = CONFIG.get().unwrap().mumble_server_address.unwrap();
+#[derive(Clone)]
+pub struct StatusCraft {
+    mumble_server_address: SocketAddr,
+}
 
-    let wt = match req.web_transport_mut().await {
-        Ok(wt) => wt,
-        Err(err) => {
-            res.status_code(StatusCode::BAD_REQUEST);
-            res.render(format!("error with webtransport: {err:?}"));
-            return;
-        }
-    };
-    info!("got webtransport for connection");
+#[craft]
+impl StatusCraft {
+    #[craft(handler)]
+    async fn get_status(&self) -> Json<ServerStatus> {
+        let mut server_status = ServerStatus::default();
 
-    use salvo::webtransport::server::AcceptedBi;
-    let (id, bi) = match wt.accept_bi().await {
-        Ok(Some(AcceptedBi::BidiStream(id, bi))) => (id, bi),
-        Ok(Some(AcceptedBi::Request(req, _))) => {
-            res.status_code(StatusCode::BAD_REQUEST);
-            res.render(format!(
-                "expected webtransport stream but got request {req:?}"
-            ));
-            return;
-        }
-        Ok(None) => {
-            res.status_code(StatusCode::BAD_REQUEST);
-            res.render(format!("no bidirectional connection requested"));
-            return;
-        }
-        Err(err) => {
-            res.status_code(StatusCode::INTERNAL_SERVER_ERROR);
-            res.render(format!("error with bidirectional connection: {err:?}"));
-            return;
-        }
-    };
+        let ping_packet = ping::PingPacket {
+            id: rand::rng().random(),
+        };
 
-    /*
-    let id = wt.session_id();
-    let bi = match wt.open_bi(id).await {
-        Ok(bi) => bi,
-        Err(err) => {
-            res.status_code(StatusCode::BAD_REQUEST);
-            res.render(format!("could not open bidirectional stream: {err:?}"));
-            return;
-        }
-    };
-    */
+        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);
+            }
+        };
 
-    let (outgoing, incoming) = bi.split();
-    let res = tokio::spawn(async move {
-        if let Err(error) = connect_proxy_impl(mumble_server_address, incoming, outgoing).await {
-            error!("error connecting proxy {error:?}")
+        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>,
+    client_config: ClientConfig,
+}
+
+#[craft]
+impl ConfigCraft {
+    #[craft(handler)]
+    async fn get_config(&self) -> Json<ClientConfig> {
+        Json(self.client_config.clone())
+    }
+
+    #[craft(handler)]
+    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) => {
+                res.status_code(StatusCode::BAD_REQUEST);
+                res.render(format!("error with webtransport: {err:?}"));
+                return;
+            }
+        };
+        info!("got webtransport for connection");
+
+        use salvo::webtransport::server::AcceptedBi;
+        let (id, bi) = match wt.accept_bi().await {
+            Ok(Some(AcceptedBi::BidiStream(id, bi))) => (id, bi),
+            Ok(Some(AcceptedBi::Request(req, _))) => {
+                res.status_code(StatusCode::BAD_REQUEST);
+                res.render(format!(
+                    "expected webtransport stream but got request {req:?}"
+                ));
+                return;
+            }
+            Ok(None) => {
+                res.status_code(StatusCode::BAD_REQUEST);
+                res.render(format!("no bidirectional connection requested"));
+                return;
+            }
+            Err(err) => {
+                res.status_code(StatusCode::INTERNAL_SERVER_ERROR);
+                res.render(format!("error with bidirectional connection: {err:?}"));
+                return;
+            }
+        };
+
+        let (outgoing, incoming) = bi.split();
+        let res = tokio::spawn(async move {
+            if let Err(error) = connect_proxy_impl(mumble_server_address, incoming, outgoing).await
+            {
+                error!("error connecting proxy {error:?}")
+            }
+        })
+        .await;
+        if let Err(err) = res {
+            error!("crash in connected proxy {err:?}");
         }
-    })
-    .await;
-    if let Err(err) = res {
-        error!("crash in connected proxy {err:?}");
     }
 }
 
@@ -217,7 +317,7 @@ async fn connect_proxy_impl(
 ) -> Result<()> {
     info!("connecting to Mumble server...");
 
-    let config = ClientConfig::builder()
+    let config = RlsClientConfig::builder()
         .dangerous()
         .with_custom_certificate_verifier(Arc::new(NoCertificateVerification))
         .with_no_client_auth();

proxy/src/ping.rs

@@ -0,0 +1,141 @@
+// This code was taken from mumble-protocol-2x (https://github.com/dblsaiko/rust-mumble-protocol)
+// and originally from mumble-protocol (https://github.com/Johni0702/rust-mumble-protocol)
+// These projects are licensed under MIT and Apache 2.0.
+
+//! Ping messages and codec
+//!
+//! A Mumble client can send periodic UDP [PingPacket]s to servers
+//! in order to query their current state and measure latency.
+//! A server will usually respond with a corresponding [PongPacket] containing
+//! the requested details.
+//!
+//! Both packets are of fixed size and can be converted to/from `u8` arrays/slices via
+//! the respective `From`/`TryFrom` impls.
+
+/// A ping packet sent to the server.
+#[derive(Clone, Debug, PartialEq)]
+pub struct PingPacket {
+    /// Opaque, client-generated id.
+    ///
+    /// Will be returned by the server unmodified and can be used to correlate
+    /// pong replies to ping requests to e.g. calculate latency.
+    pub id: u64,
+}
+
+/// A pong packet sent to the client in reply to a previously received [PingPacket].
+#[derive(Clone, Debug, PartialEq)]
+pub struct PongPacket {
+    /// Opaque, client-generated id.
+    ///
+    /// Should match the value in the corresponding [PingPacket].
+    pub id: u64,
+
+    /// Server version. E.g. `0x010300` for `1.3.0`.
+    pub version: u32,
+
+    /// Current amount of users connected to the server.
+    pub users: u32,
+
+    /// Configured limit on the amount of users which can be connected to the server.
+    pub max_users: u32,
+
+    /// Maximum bandwidth for server-bound speech per client in bits per second
+    pub bandwidth: u32,
+}
+
+/// Error during parsing of a [PingPacket].
+#[derive(Clone, Debug, PartialEq)]
+pub enum ParsePingError {
+    /// Ping packets must always be 12 bytes in size.
+    InvalidSize,
+    /// Ping packets must have an all zero header of 4 bytes.
+    InvalidHeader,
+}
+
+impl TryFrom<&[u8]> for PingPacket {
+    type Error = ParsePingError;
+    fn try_from(buf: &[u8]) -> Result<Self, Self::Error> {
+        match <[u8; 12]>::try_from(buf) {
+            Ok(array) => {
+                if array[0..4] != [0, 0, 0, 0] {
+                    Err(ParsePingError::InvalidHeader)
+                } else {
+                    Ok(Self {
+                        id: u64::from_be_bytes(array[4..12].try_into().unwrap()),
+                    })
+                }
+            }
+            Err(_) => Err(ParsePingError::InvalidSize),
+        }
+    }
+}
+
+impl From<PingPacket> for [u8; 12] {
+    fn from(packet: PingPacket) -> Self {
+        let id = packet.id.to_be_bytes();
+        // Is there no nicer way to do this?
+        [
+            0, 0, 0, 0, id[0], id[1], id[2], id[3], id[4], id[5], id[6], id[7],
+        ]
+    }
+}
+
+/// Error during parsing of a [PongPacket].
+#[derive(Clone, Debug, PartialEq)]
+pub enum ParsePongError {
+    /// Pong packets must always be 24 bytes in size.
+    InvalidSize,
+}
+
+impl TryFrom<&[u8]> for PongPacket {
+    type Error = ParsePongError;
+    fn try_from(buf: &[u8]) -> Result<Self, Self::Error> {
+        match <[u8; 24]>::try_from(buf) {
+            Ok(array) => Ok(Self {
+                version: u32::from_be_bytes(array[0..4].try_into().unwrap()),
+                id: u64::from_be_bytes(array[4..12].try_into().unwrap()),
+                users: u32::from_be_bytes(array[12..16].try_into().unwrap()),
+                max_users: u32::from_be_bytes(array[16..20].try_into().unwrap()),
+                bandwidth: u32::from_be_bytes(array[20..24].try_into().unwrap()),
+            }),
+            Err(_) => Err(ParsePongError::InvalidSize),
+        }
+    }
+}
+
+impl From<PongPacket> for [u8; 24] {
+    fn from(packet: PongPacket) -> Self {
+        let version = packet.version.to_be_bytes();
+        let id = packet.id.to_be_bytes();
+        let users = packet.users.to_be_bytes();
+        let max_users = packet.max_users.to_be_bytes();
+        let bandwidth = packet.bandwidth.to_be_bytes();
+        // Is there no nicer way to do this?
+        [
+            version[0],
+            version[1],
+            version[2],
+            version[3],
+            id[0],
+            id[1],
+            id[2],
+            id[3],
+            id[4],
+            id[5],
+            id[6],
+            id[7],
+            users[0],
+            users[1],
+            users[2],
+            users[3],
+            max_users[0],
+            max_users[1],
+            max_users[2],
+            max_users[3],
+            bandwidth[0],
+            bandwidth[1],
+            bandwidth[2],
+            bandwidth[3],
+        ]
+    }
+}