starting with multiplexing

SamarthJ2004 · SamarthJ2004 · commit bc5aa004e124 · 2025-09-15T20:31:39.000+05:30
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/muxer/Cargo.toml b/muxer/Cargo.toml
@@ -4,3 +4,5 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+tokio = { version = "1", features = ["full"] }
+common  = {path = "../common" }
diff --git a/muxer/src/lib.rs b/muxer/src/lib.rs
@@ -1,14 +1,104 @@
-pub fn add(left: u64, right: u64) -> u64 {
-    left + right
+use common::EncryptedStream;
+use std::collections::HashMap;
+use tokio::io::{AsyncBufReadExt, BufReader};
+
+pub async fn negotiate_multiplexing_protocol(
+    stream: &mut EncryptedStream,
+    is_initiator: bool,
+    supported_protocols: &HashMap<&'static str, Vec<&'static str>>,
+) {
+    if is_initiator {
+        println!("[negotiate_protocol] -> Sending /multistream/1.0.0");
+        let _ = stream.send(b"/multistream/1.0.0\n").await;
+    }
+
+    let response = stream.recv().await.unwrap();
+    let proto = String::from_utf8_lossy(&response);
+    println!(
+        "[negotiate_protocol] <- Received negotiation protocol: {}",
+        proto
+    );
+
+    if proto.trim() == "/multistream/1.0.0" {
+        if !is_initiator {
+            println!("[negotiate_protocol] -> Sending /multistream/1.0.0");
+            let _ = stream.send(b"/multistream/1.0.0\n").await;
+        }
+        println!("[negotiate_protocol] Entering subprotocol negotiation");
+        if let Some(transport) = negotiate(stream, is_initiator, &supported_protocols)
+            .await
+            .unwrap()
+        {
+            println!("[negotiate_protocol] ✅ Agreed on protocol: {transport}");
+        } else {
+            eprintln!("[negotiate_protocol] ❌ Unimplemented protocol");
+        }
+    } else {
+        eprintln!(
+            "[negotiate_protocol] Unsupported negotiation protocol: {other}",
+            other = proto
+        );
+        std::process::exit(1);
+    }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+async fn negotiate(
+    stream: &mut EncryptedStream,
+    is_initiator: bool,
+    supported_protocols: &HashMap<&'static str, Vec<&'static str>>,
+) -> tokio::io::Result<Option<String>> {
+    println!("[negotiate] Started negotiation, initiator={is_initiator}");
+
+    if is_initiator {
+        let mut input = String::new();
+        let mut stdin_reader = BufReader::new(tokio::io::stdin());
+        println!(
+            "[negotiate][initiator] Available protocols: {:?}",
+            supported_protocols.get("multiplexing")
+        );
+
+        stdin_reader.read_line(&mut input).await?;
+        let proto = input.trim();
+        println!("[negotiate][initiator] Proposing protocol: {proto}");
+
+        stream.send(format!("{proto}\n").as_bytes()).await?;
+
+        let response = stream.recv().await.unwrap();
+        let line = String::from_utf8_lossy(&response);
+        println!("[negotiate][initiator] <- Received response: {}", line);
+
+        if line.trim() == proto {
+            println!("[negotiate][initiator] ✅ Negotiated protocol: {proto}");
+            Ok(Some(proto.to_string()))
+        } else {
+            println!(
+                "[negotiate][initiator] ❌ Protocol rejected by responder: {}",
+                line.trim()
+            );
+            Ok(None)
+        }
+    } else {
+        println!("[negotiate][responder] Waiting for initiator proposal");
+        let response = stream.recv().await.unwrap();
+        let line = String::from_utf8_lossy(&response);
+        let proposal = line.trim();
+        println!("[negotiate][responder] <- Received proposal: {proposal}");
 
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
+        if let Some(p) = supported_protocols.get("multiplexing") {
+            if p.contains(&proposal) {
+                println!("[negotiate][responder] ✅ Accepting proposal: {proposal}");
+                stream.send(format!("{}\n", proposal).as_bytes()).await?;
+                Ok(Some(proposal.to_string()))
+            } else {
+                eprintln!(
+                    "[negotiate][responder] ❌ Unsupported proposal: {proposal}, replying 'na'"
+                );
+                stream.send(b"na\n").await?;
+                Ok(None)
+            }
+        } else {
+            eprintln!("[negotiate][responder] ⚠️ No protocols found in supported_protocols");
+            Ok(None)
+        }
     }
 }
diff --git a/transport/Cargo.toml b/transport/Cargo.toml
@@ -11,3 +11,4 @@ negotiation = { path = "../negotiation/" }
 security = { path = "../security" }
 snow = "0.10"
 common = { path = "../common"}
+muxer = { path = "../muxer" }
diff --git a/transport/src/main.rs b/transport/src/main.rs
@@ -1,4 +1,5 @@
 use common::EncryptedStream;
+use muxer::negotiate_multiplexing_protocol;
 use negotiation::negotiate_protocol;
 use security::negotiate_security_protocol;
 use std::{env, net::SocketAddr, sync::Arc};
@@ -75,6 +76,10 @@ async fn run_client(addr: &str) {
         writer: Mutex::new(writer),
     };
 
+    println!("[client] Starting multiplexing protocol negotiation...");
+    negotiate_multiplexing_protocol(&mut stream, true, &supported_protocols()).await;
+    println!("[client] Protocol negotiation complete");
+
     println!("[client] Starting protocol negotiation...");
     negotiate_protocol(&mut stream, true, &supported_protocols()).await;
     println!("[client] Protocol negotiation complete");
@@ -147,6 +152,10 @@ async fn handle_connection(socket: TcpStream, addr: SocketAddr) {
         writer: Mutex::new(writer),
     };
 
+    println!("[server] Starting multiplexing protocol negotiation...");
+    negotiate_multiplexing_protocol(&mut stream, false, &supported_protocols()).await;
+    println!("[server] Protocol negotiation complete");
+
     println!("[server] Starting protocol negotiation with {addr}");
     negotiate_protocol(&mut stream, false, &supported_protocols()).await;
     println!("[server] Protocol negotiation complete with {addr}");
@@ -182,5 +191,6 @@ fn supported_protocols() -> HashMap<&'static str, Vec<&'static str>> {
     HashMap::from([
         ("security", vec!["/noise/xx"]),
         ("protocol", vec!["/ping/1.0.0"]),
+        ("multiplexing", vec!["/yamux", "/mplex"]),
     ])
 }
