chore: bump tokio-tungstenite to 0.28

Signed-off-by: Xin Liu <[email protected]>

Author: apepkuss

Cargo.lock

@@ -27,7 +27,7 @@ thiserror = "1.0"
 tokio = { version = "1", features = ["full"] }
 
 # WebSocket
-tokio-tungstenite = "0.24"
+tokio-tungstenite = { version = "0.28", features = ["rustls-tls-webpki-roots"] }
 
 # Utilities
 tower = "0.5"

Cargo.toml

@@ -1,6 +1,6 @@
 use axum::{
     body::Bytes,
-    extract::{Path, State},
+    extract::{Path, RawQuery, State},
     http::{Method, StatusCode},
     response::{IntoResponse, Response},
 };
@@ -14,6 +14,7 @@ use crate::{db, proxy::HttpProxy};
 pub async fn http_proxy_handler(
     State(state): State<Arc<AppState>>,
     Path((session_id, path)): Path<(String, String)>,
+    RawQuery(query): RawQuery,
     method: Method,
     headers: axum::http::HeaderMap,
     body: Bytes,
@@ -36,7 +37,7 @@ pub async fn http_proxy_handler(
         return Err(StatusCode::SERVICE_UNAVAILABLE);
     }
 
-    // 3. Construct full path
+    // 3. Construct full path with query string
     let full_path = if path.is_empty() {
         "/".to_string()
     } else if path.starts_with('/') {
@@ -45,12 +46,19 @@ pub async fn http_proxy_handler(
         format!("/{}", path)
     };
 
+    // Append query string if present
+    let full_path_with_query = if let Some(q) = query {
+        format!("{}?{}", full_path, q)
+    } else {
+        full_path
+    };
+
     // 4. Forward request
     match state
         .http_proxy
         .forward_request(
             &session.downstream_server_url,
-            &full_path,
+            &full_path_with_query,
             method,
             headers,
             body,

src/handlers/http.rs

@@ -66,6 +66,9 @@ fn convert_to_ws_url(http_url: &str) -> String {
         http_url.replace("https://", "wss://")
     } else if http_url.starts_with("http://") {
         http_url.replace("http://", "ws://")
+    } else if http_url.starts_with("wss://") || http_url.starts_with("ws://") {
+        // Already a WebSocket URL, return as-is
+        http_url.to_string()
     } else {
         // If no protocol prefix, default to ws://
         format!("ws://{}", http_url)
@@ -87,5 +90,15 @@ mod tests {
             "wss://example.com"
         );
         assert_eq!(convert_to_ws_url("localhost:8080"), "ws://localhost:8080");
+
+        // Test WebSocket URLs are returned as-is
+        assert_eq!(
+            convert_to_ws_url("ws://localhost:8080"),
+            "ws://localhost:8080"
+        );
+        assert_eq!(
+            convert_to_ws_url("wss://echo.websocket.org"),
+            "wss://echo.websocket.org"
+        );
     }
 }

src/handlers/websocket.rs

@@ -38,7 +38,7 @@ impl WsProxy {
                             buffer.len()
                         );
                         if let Err(e) = downstream_write
-                            .send(TungsteniteMessage::Text(buffer.to_string()))
+                            .send(TungsteniteMessage::Text(buffer.to_string().into()))
                             .await
                         {
                             error!("Failed to forward text message to downstream: {}", e);
@@ -51,7 +51,7 @@ impl WsProxy {
                             data.len()
                         );
                         if let Err(e) = downstream_write
-                            .send(TungsteniteMessage::Binary(data.into()))
+                            .send(TungsteniteMessage::Binary(data))
                             .await
                         {
                             error!("Failed to forward binary message to downstream: {}", e);
@@ -60,19 +60,15 @@ impl WsProxy {
                     }
                     Ok(Message::Ping(data)) => {
                         info!("Client -> Downstream: Ping");
-                        if let Err(e) = downstream_write
-                            .send(TungsteniteMessage::Ping(data.into()))
-                            .await
+                        if let Err(e) = downstream_write.send(TungsteniteMessage::Ping(data)).await
                         {
                             error!("Failed to forward Ping to downstream: {}", e);
                             break;
                         }
                     }
                     Ok(Message::Pong(data)) => {
                         info!("Client -> Downstream: Pong");
-                        if let Err(e) = downstream_write
-                            .send(TungsteniteMessage::Pong(data.into()))
-                            .await
+                        if let Err(e) = downstream_write.send(TungsteniteMessage::Pong(data)).await
                         {
                             error!("Failed to forward Pong to downstream: {}", e);
                             break;
@@ -97,7 +93,10 @@ impl WsProxy {
                 match msg {
                     Ok(TungsteniteMessage::Text(text)) => {
                         info!("Downstream -> Client: Text message ({} bytes)", text.len());
-                        if let Err(e) = client_write.send(Message::Text(text.into())).await {
+                        if let Err(e) = client_write
+                            .send(Message::Text(text.to_string().into()))
+                            .await
+                        {
                             error!("Failed to forward text message to client: {}", e);
                             break;
                         }
@@ -107,21 +106,21 @@ impl WsProxy {
                             "Downstream -> Client: Binary message ({} bytes)",
                             data.len()
                         );
-                        if let Err(e) = client_write.send(Message::Binary(data.into())).await {
+                        if let Err(e) = client_write.send(Message::Binary(data)).await {
                             error!("Failed to forward binary message to client: {}", e);
                             break;
                         }
                     }
                     Ok(TungsteniteMessage::Ping(data)) => {
                         info!("Downstream -> Client: Ping");
-                        if let Err(e) = client_write.send(Message::Ping(data.into())).await {
+                        if let Err(e) = client_write.send(Message::Ping(data)).await {
                             error!("Failed to forward Ping to client: {}", e);
                             break;
                         }
                     }
                     Ok(TungsteniteMessage::Pong(data)) => {
                         info!("Downstream -> Client: Pong");
-                        if let Err(e) = client_write.send(Message::Pong(data.into())).await {
+                        if let Err(e) = client_write.send(Message::Pong(data)).await {
                             error!("Failed to forward Pong to client: {}", e);
                             break;
                         }