compiler crash………

3 files changed, 75 insertions, 21 deletions

diff --git a/server/src/main.rs b/server/src/main.rs
index ff34ad0..b4121b9 100644
--- a/server/src/main.rs
+++ b/server/src/main.rs
@@ -1,5 +1,3 @@
-#![feature(async_closure)]
-
 pub mod protocol;
 pub mod room;
 
@@ -11,6 +9,7 @@ use room::Room;
 use std::convert::Infallible;
 use std::sync::Arc;
 use warp::hyper::Server;
+use warp::ws::WebSocket;
 use warp::{Filter, Rejection, Reply};
 
 type Rooms = Arc<CHashMap<String, Room>>;
@@ -73,7 +72,7 @@ async fn handle_rejection(err: Rejection) -> Result<impl Reply, Infallible> {
 }
 
 fn signaling_connect(rname: String, rooms: Rooms, ws: warp::ws::Ws) -> impl Reply {
-    ws.on_upgrade(async move |sock| {
+    async fn inner(sock: WebSocket, rname: String, rooms: Rooms) {
         let room = match rooms.get(&rname) {
             Some(r) => r,
             None => {
@@ -85,5 +84,6 @@ fn signaling_connect(rname: String, rooms: Rooms, ws: warp::ws::Ws) -> impl Repl
         if room.should_remove().await {
             rooms.remove(&rname);
         }
-    })
+    }
+    ws.on_upgrade(move |sock| inner(sock, rname, rooms))
 }
diff --git a/server/src/protocol.rs b/server/src/protocol.rs
index d7e94d0..780ae4a 100644
--- a/server/src/protocol.rs
+++ b/server/src/protocol.rs
@@ -1,16 +1,43 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
-pub enum ClientboundPacket {}
+pub enum ClientboundPacket {
+    Init {
+        your_id: usize,
+        version: String,
+    },
+    ClientJoin {
+        id: usize,
+        name: String,
+    },
+    ClientLeave {
+        id: usize,
+    },
+    Message {
+        sender: usize,
+        message: RelayMessage,
+    },
+}
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ServerboundPacket {
-    Answer { receiver: usize },
+    Relay {
+        recipient: Option<usize>,
+        message: RelayMessage,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum RelayMessage {
+    Offer(RTCSessionDescriptionInit),
+    Answer(RTCSessionDescriptionInit),
+    IceCandidate(RTCIceCandidateInit),
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum RTCSdpType {
     Answer,
@@ -18,13 +45,15 @@ pub enum RTCSdpType {
     PRAnswer,
     Rollback,
 }
-#[derive(Debug, Serialize, Deserialize)]
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct RTCSessionDescriptionInit {
     sdp: String,
     #[serde(rename = "type")]
     ty: RTCSdpType,
 }
-#[derive(Debug, Serialize, Deserialize)]
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct RTCIceCandidateInit {
     candidate: Option<String>,
     #[serde(rename = "sdpMLineIndex")]
diff --git a/server/src/room.rs b/server/src/room.rs
index 14ff9b6..43cfa90 100644
--- a/server/src/room.rs
+++ b/server/src/room.rs
@@ -7,12 +7,13 @@ use warp::ws::{Message, WebSocket};
 
 #[derive(Debug)]
 pub struct Client {
-    out: mpsc::UnboundedSender<ClientboundPacket>,
+    pub name: String,
+    pub out: mpsc::UnboundedSender<ClientboundPacket>,
 }
 
 #[derive(Debug, Default)]
 pub struct Room {
-    clients: RwLock<HashMap<usize, Client>>,
+    pub clients: RwLock<HashMap<usize, Client>>,
 }
 
 impl Room {
@@ -32,12 +33,20 @@ impl Room {
             }
         });
 
-        let id = {
-            let mut g = self.clients.write().await;
-            let id = g.len();
-            g.insert(id, Client { out: tx });
-            id
-        };
+        let mut g = self.clients.write().await;
+        let id = g.len();
+        let name = format!("user no. {id}");
+        g.insert(
+            id,
+            Client {
+                out: tx,
+                name: name.clone(),
+            },
+        );
+        drop(g);
+
+        self.broadcast(id, ClientboundPacket::ClientJoin { id, name })
+            .await;
 
         while let Some(result) = user_ws_rx.next().await {
             let msg = match result {
@@ -62,10 +71,26 @@ impl Room {
         self.clients.write().await.remove(&id);
     }
 
-    pub async fn client_message(&self, sender: usize, packet: ServerboundPacket) {
+    pub async fn broadcast(&self, sender: usize, packet: ClientboundPacket) {
         for (&id, tx) in self.clients.read().await.iter() {
             if sender != id {
-                let _ = tx.out.send(todo!());
+                let _ = tx.out.send(packet.clone());
+            }
+        }
+    }
+    pub async fn send_to_client(&self, recipient: usize, packet: ClientboundPacket) {
+        if let Some(c) = self.clients.read().await.get(&recipient) {
+            let _ = c.out.send(packet);
+        }
+    }
+
+    pub async fn client_message(&self, sender: usize, packet: ServerboundPacket) {
+        match packet {
+            ServerboundPacket::Relay { recipient, message } => {
+                if let Some(recipient) = recipient {
+                    self.send_to_client(recipient, ClientboundPacket::Message { sender, message })
+                        .await;
+                }
             }
         }
     }