fix: ⚡ messages go to right channels

fix: ⚡ ice candidate transfer

fix: ⚡ deadlock in server

server/src/signal.rs

@@ -1,14 +1,15 @@
-use std::{collections::VecDeque, sync::LazyLock};
+use std::{collections::VecDeque, sync::LazyLock, time::Duration};
 
 use axum::{Router, http::StatusCode, response::IntoResponse, routing::get};
 use fastwebsockets::{
-    FragmentCollectorRead, OpCode, WebSocketError,
+    Frame, OpCode, WebSocketError,
     upgrade::{IncomingUpgrade, UpgradeFut},
 };
 use protocol::{Signal, SignalType};
 use tokio::{
     net::TcpListener,
     sync::{RwLock, broadcast},
+    time::sleep,
 };
 use tower_http::cors::CorsLayer;
 
@@ -17,6 +18,7 @@ const SERVER_ADDRESS: &str = "192.168.1.3:4546";
 static USER_MESSAGES: LazyLock<RwLock<VecDeque<UserMessages>>> =
     LazyLock::new(|| VecDeque::new().into());
 
+#[derive(Debug)]
 struct UserMessages {
     user: String,
     message_receiver: broadcast::Receiver<Signal>,
@@ -50,7 +52,7 @@ async fn websocket_handler(websocket: UpgradeFut) {
     websocket.set_writev(false);
     websocket.set_auto_close(true);
 
-    let (mut websocket_receiver, websocker_sender) = websocket.split(tokio::io::split);
+    let (mut websocket_receiver, mut websocker_sender) = websocket.split(tokio::io::split);
     let mut user = String::default();
     let (message_sender, message_receiver) = broadcast::channel(100);
 
@@ -72,7 +74,50 @@ async fn websocket_handler(websocket: UpgradeFut) {
             } else {
                 return;
             }
-            println!("{:#?}", signal);
+        }
+    }
+
+    tokio::spawn(async move {
+        while USER_MESSAGES.read().await.len() < 2 {
+            sleep(Duration::from_secs(1)).await;
+        }
+        loop {
+            let mut user_messages = USER_MESSAGES.write().await;
+            for user_message in user_messages.iter_mut() {
+                if user_message.user != user && user_message.message_receiver.len() > 0 {
+                    while let Ok(message) = user_message.message_receiver.recv().await {
+                        if let Err(err_val) = websocker_sender
+                            .write_frame(Frame::text(fastwebsockets::Payload::Owned(
+                                serde_json::to_vec(&message).unwrap(),
+                            )))
+                            .await
+                        {
+                            eprintln!("Error: WebSocket Send | {}", err_val);
+                        }
+                        if user_message.message_receiver.len() < 1 {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    });
+
+    while let Ok(received_frame) = websocket_receiver
+        .read_frame::<_, WebSocketError>(&mut move |_| async { unreachable!() })
+        .await
+    {
+        if let OpCode::Text = received_frame.opcode {
+            let signal =
+                serde_json::from_slice::<Signal>(&received_frame.payload.to_vec()).unwrap();
+
+            if signal.get_signal_type() != SignalType::Auth {
+                if let Err(err_val) = message_sender.send(signal) {
+                    eprintln!("Error: WebSocket Channel Send | {}", err_val);
+                }
+            } else {
+                return;
+            }
         }
     }
 }