Semi working multi client system

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)
     }

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!(
-    println!("From server 2: {:?}", con.read_bytes(1024).unwrap());
+        "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());
 }

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();
+                    client_recv.read_exact(&mut addr).unwrap();
-                clients.push(client_recv.try_clone().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
+                    if using_router {
-                        .write_all(&[&[1u8], &addr[..]].concat())
+                        std::thread::spawn(move || {
-                        .unwrap();
+                            while !route_tcp(&mut client_recv, &mut server_send).unwrap() {}
+                        });
 
-                    std::thread::spawn(move || {
+                        while !route_tcp(&mut server_recv, &mut client_send).unwrap() {}
-                        while !route_tcp2(&mut client_recv, &mut server_send).unwrap() {}
+                    } else {
-                    });
+                        server_send
+                            .write_all(&[&[1u8], &addr[..]].concat())
+                            .unwrap();
 
-                    while !route_tcp2(server_recv, &mut client_send).unwrap() {}
+                        std::thread::spawn(move || {
-                } else {
+                            while !route_tcp2(&mut client_recv, &mut server_send).unwrap() {}
-                    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 server_recv, &mut client_send).unwrap() {}
-                        while !route_tcp(&mut client_recv, &mut server_send).unwrap() {}
+                    }
-                    });
+                });
-
-                    while !route_tcp(&mut server_recv, &mut client_send).unwrap() {}
-                }
             }
             Err(_) => {}
         }