libinject/

drwrap.rs

use crate::ffi;
use crate::utils::Boolean;
use std::os::raw::{c_int, c_void};

/// Return value type for dr_wrap functions (e.g. `skip_call` and `set_retval`).
///
/// Not all functions return an `int`, this enum will be extended if/when new functions are wrapped
/// that do not return an `int` (e.g. "gethostbyaddr returns a pointer to the hostent structure" or
/// "accept returns a value of type SOCKET that is a descriptor for the new socket", quotes from
/// the winsock2 docs, https://learn.microsoft.com/en-us/windows/win32/api/winsock2).
#[derive(Debug, Clone)]
pub enum Retval {
    Int(i32),
}

impl Into<*mut c_void> for Retval {
    fn into(self) -> *mut c_void {
        match self {
            Retval::Int(int) => int as *mut c_void,
        }
    }
}

/// Sets the return value for a function that is being wrapped with the dynamorio drwrap extension.
/// May only be called from within a drwrap-pre or drwrap-post callback.
pub fn set_retval(wrapctx: *mut c_void, retval: Retval) -> bool {
    unsafe { ffi::drwrap_set_retval(wrapctx, retval.into()).as_bool() }
}

/// May only be called from a \p drwrap_wrap pre-function callback.
/// Skips execution of the original function and returns to the function's caller with a return value of \p retval.
///
/// The post-function callback will not be invoked; nor will any pre-function callbacks (if multiple were registered) that have not yet been called. If the original function uses the "stdcall" calling convention, the total size of its arguments must be supplied. The return value is set regardless of whether the original function officially returns a value or not. Further state changes may be made with drwrap_get_mcontext() and drwrap_set_mcontext() prior to calling this function.
///
/// Note: It is up to the client to ensure that the application behaves as desired when the original function is skipped.
///
/// Returns whether successful.
pub unsafe fn skip_call(wrapctx: *mut c_void, retval: Retval, stdcall_args_size: usize) -> bool {
    unsafe { ffi::drwrap_skip_call(wrapctx, retval.into(), stdcall_args_size).as_bool() }
}

pub fn get_arg(wrapctx: *mut c_void, idx: u8) -> *mut c_void {
    unsafe { ffi::drwrap_get_arg(wrapctx, idx as c_int) }
}