From ecfb279fcdfb2d3cfe72baca50d9099807be58d5 Mon Sep 17 00:00:00 2001
From: Kleo Dev <klesti.selimay@icloud.com>
Date: Wed, 13 Aug 2025 21:30:52 +0200
Subject: [PATCH] Semi working multi client system

---
 src/lib.rs    |  2 +-
 src/main.rs   |  8 +++++--
 src/router.rs | 59 +++++++++++++++++++++++++++++++--------------------
 3 files changed, 43 insertions(+), 26 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 6e55960..d96e15f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -32,7 +32,7 @@ impl GhostClient {
 
     pub fn read_bytes(&mut self, size: usize) -> std::io::Result<Vec<u8>> {
         let mut buf = vec![0u8; size];
-        let n = self.0.read(&mut buf)?;
+        let n = self.read(&mut buf)?;
         buf.truncate(n);
         Ok(buf)
     }
diff --git a/src/main.rs b/src/main.rs
index 9e5e49e..be81aa0 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,6 +5,10 @@ fn main() {
     let mut con = GhostClient::connect("0.0.0.0:443", (0, 0, 0, 0), 7525).unwrap();
     con.send("Hello from client!".as_bytes()).unwrap();
     let response = con.read_bytes(1024).unwrap();
-    println!("From server: {}", String::from_utf8(response).unwrap());
-    println!("From server 2: {:?}", con.read_bytes(1024).unwrap());
+    println!(
+        "From server: {} ({response:?})",
+        String::from_utf8(response.clone()).unwrap(),
+    );
+    // println!("From server 2: {:?}", con.read_bytes(1024).unwrap());
+    // println!("From server 3: {:?}", con.read_bytes(1024).unwrap());
 }
diff --git a/src/router.rs b/src/router.rs
index 735e3a8..284eafa 100644
--- a/src/router.rs
+++ b/src/router.rs
@@ -1,48 +1,61 @@
 use std::{
     io::{Read, Write},
     net::{TcpListener, TcpStream},
+    sync::{Arc, Mutex},
 };
 
 use crate::{format_ip_bytes, route_tcp, route_tcp2};
 
 pub fn router() {
     let server = TcpListener::bind("0.0.0.0:443").unwrap();
-    let mut clients: Vec<TcpStream> = Vec::new();
+    let clients: Arc<Mutex<Vec<TcpStream>>> = Arc::new(Mutex::new(Vec::new()));
 
     for stream in server.incoming() {
         match stream {
             Ok(mut client_recv) => {
-                let mut addr = [0; 6];
+                let clients = clients.clone();
+                std::thread::spawn(move || {
+                    let mut addr = [0; 6];
 
-                client_recv.read_exact(&mut addr).unwrap();
-                clients.push(client_recv.try_clone().unwrap());
+                    client_recv.read_exact(&mut addr).unwrap();
+                    clients
+                        .lock()
+                        .unwrap()
+                        .push(client_recv.try_clone().unwrap());
 
-                let i = clients.len().wrapping_sub(2);
+                    let i = clients.lock().unwrap().len().wrapping_sub(2);
+
+                    let mut using_router = false;
+
+                    let mut server_recv = if let Some(server_recv) = clients.lock().unwrap().get(i)
+                    {
+                        server_recv.try_clone().unwrap()
+                    } else {
+                        using_router = true;
+                        TcpStream::connect(format_ip_bytes(addr)).unwrap()
+                    };
 
-                if let Some(server_recv) = clients.get_mut(i) {
                     let mut server_send = server_recv.try_clone().unwrap();
                     let mut client_send = client_recv.try_clone().unwrap();
 
-                    server_send
-                        .write_all(&[&[1u8], &addr[..]].concat())
-                        .unwrap();
+                    if using_router {
+                        std::thread::spawn(move || {
+                            while !route_tcp(&mut client_recv, &mut server_send).unwrap() {}
+                        });
 
-                    std::thread::spawn(move || {
-                        while !route_tcp2(&mut client_recv, &mut server_send).unwrap() {}
-                    });
+                        while !route_tcp(&mut server_recv, &mut client_send).unwrap() {}
+                    } else {
+                        server_send
+                            .write_all(&[&[1u8], &addr[..]].concat())
+                            .unwrap();
 
-                    while !route_tcp2(server_recv, &mut client_send).unwrap() {}
-                } else {
-                    let mut server_recv = TcpStream::connect(format_ip_bytes(addr)).unwrap();
-                    let mut server_send = server_recv.try_clone().unwrap();
-                    let mut client_send = client_recv.try_clone().unwrap();
+                        std::thread::spawn(move || {
+                            while !route_tcp2(&mut client_recv, &mut server_send).unwrap() {}
+                        });
 
-                    std::thread::spawn(move || {
-                        while !route_tcp(&mut client_recv, &mut server_send).unwrap() {}
-                    });
-
-                    while !route_tcp(&mut server_recv, &mut client_send).unwrap() {}
-                }
+                        while !route_tcp2(&mut server_recv, &mut client_send).unwrap() {}
+                    }
+                });
             }
             Err(_) => {}
         }