syscall-stream-rs/src/lib.rs

mod host;
mod syscall_exec;
#[allow(dead_code)]
mod syscall_intercept;

use syscall_lib::syscall_should_proxy;

use libc::exit;
use std::{
    cell::Cell,
    io::{BufWriter, Write},
    net::TcpStream,
    sync::Mutex,
};
use syscall_intercept::*;

use crate::host::Host;

static mut HOST: Option<Mutex<Host>> = None;

#[ctor::ctor]
fn start() {
    unsafe {
        HOST = Some({
            match Host::new() {
                Ok(host) => Mutex::new(host),
                Err(e) => {
                    eprintln!("Failed to connect to server: {}", e);
                    exit(1);
                }
            }
        });
    }

    unsafe { set_hook_fn(hook) };
}

// fn print_direct(str: &str)

thread_local! {
    /// A flag indicating whether the current thread is in an intercept context.
    static INTERCEPTED: Cell<bool> = Cell::new(false);
}

// lazy_static! {

// }

struct InterceptGuard;

impl InterceptGuard {
    fn try_lock() -> Option<Self> {
        INTERCEPTED.with(|x| {
            if x.get() {
                None
            } else {
                x.set(true);
                Some(InterceptGuard)
            }
        })
    }
}

impl Drop for InterceptGuard {
    fn drop(&mut self) {
        INTERCEPTED.with(|x| x.set(false));
    }
}

extern "C" fn hook(
    syscall_num: usize,
    arg0: usize,
    arg1: usize,
    arg2: usize,
    arg3: usize,
    arg4: usize,
    arg5: usize,
    result: &mut isize,
) -> InterceptResult {
    // detect and avoid recursive interception
    let _guard = match InterceptGuard::try_lock() {
        Some(g) => g,
        None => {
            println!("Disabled!");
            return InterceptResult::Forward;
        }
    };

    // if syscall_should_proxy(syscall_num) {
    //     return InterceptResult::Forward;
    // }

    unsafe {
        unset_hook_fn();
    }

    let args = [arg0, arg1, arg2, arg3, arg4, arg5];
    let syscall = syscall_lib::create_syscall(syscall_num, args);

    if !syscall_should_proxy(&syscall) {
        return InterceptResult::Forward;
    }

    // Return if is print
    // if syscall_num == libc::SYS_write as _ && arg0 == 1 {
    //     return InterceptResult::Forward;
    // }

    // if syscall_num == libc::SYS_close as _ && arg0 == 1 {
    //     return InterceptResult::Forward;
    // }

    // println!("{:?}", desc);

    unsafe {
        #[allow(static_mut_refs)]
        if let Some(host) = HOST.as_ref() {
            *result = host.lock().unwrap().execute(&syscall);
        }
    }

    unsafe {
        set_hook_fn(hook);
    }

    InterceptResult::Hook
}