syscall-stream-rs/client/src/main.rs

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