Kinda get network working

client/src/main.rs

@@ -0,0 +1,85 @@
+mod syscall_exec;
+
+use std::{
+    io::{Read, Write},
+    net::{TcpListener, TcpStream},
+    thread,
+};
+
+use syscall_lib::{Message, ProgramMemory, Syscall};
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:1234").unwrap();
+
+    for stream in listener.incoming() {
+        let mut stream = stream.unwrap();
+
+        thread::spawn(move || {
+            let _ = handle_connection(&mut stream);
+            println!("Connection from {} closed", stream.peer_addr().unwrap());
+        });
+    }
+}
+
+fn handle_connection(stream: &mut TcpStream) -> Result<(), std::io::Error> {
+    println!("Got connection from {}", stream.peer_addr()?);
+
+    // let mut memory = ProgramMemory::default();
+
+    loop {
+        let mut size_buf = [0u8; 4];
+        stream.read_exact(&mut size_buf)?;
+        let size = u32::from_be_bytes(size_buf);
+
+        let mut buf = vec![0u8; size as usize];
+
+        stream.read_exact(&mut buf)?;
+
+        let decoded = Syscall::decode(&buf).unwrap();
+
+        println!("{:?} -> ", decoded);
+
+        // let result = match decoded {
+        //     Syscall::Write(..) => 0,
+        //     _ => syscall_exec::execute_syscall(decoded),
+        // };
+        let result = syscall_exec::execute_syscall(decoded);
+
+        println!("{:?}", result);
+
+        let bytes: [u8; 8] = result.to_be_bytes();
+        stream.write_all(&bytes)?;
+        stream.flush()?;
+
+        // let response = bincode::serialize(&result).unwrap();
+        // stream.write_all(&response).unwrap();
+
+        // match decoded {
+        //     Message::RequestMemory(addr) => {
+        //         let mem_map = memory.lock().unwrap();
+        //         let data = mem_map.get(&addr);
+        //         let response = bincode::serialize(&data).unwrap();
+        //         stream.write_all(&response).unwrap();
+        //     }
+        //     Message::UpdateMemory(addr, data) => {
+        //         let mut mem_map = memory.lock().unwrap();
+        //         mem_map.insert(addr, data);
+        //         println!("Memory at {} updated.", addr);
+        //     }
+        //     Message::Syscall(_, _) => {
+        //         // The host doesn't execute the syscall.
+        //         // It just waits for the result.
+        //     }
+        //     Message::SyscallReturn(ret, new_mem) => {
+        //         println!("Syscall returned with value: {}", ret);
+        //         if let Some((addr, data)) = new_mem {
+        //             let mut mem_map = memory.lock().unwrap();
+        //             mem_map.insert(addr, data);
+        //             println!("New memory object created at {}.", addr);
+        //         }
+        //     }
+        // }
+
+        // println!("{:?}", decoded);
+    }
+}