brickworks 0.0.1

Brick Rigs mod loader
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use std::collections::HashMap;
use std::vec::Vec;
use min_hook_rs::*;
use core::ffi::c_void;

use crate::BrickRust_print;
use crate::br_print;

#[derive(Clone)]
struct Hook
{
    f: *const (),
    subhooks: Vec<*const ()>,
}

static mut HOOKS: Option<HashMap<*const (), Hook>> = None;


pub(crate) unsafe fn init()
{
    HOOKS = Some(HashMap::new());
    let _ = min_hook_rs::initialize();

}
/**
 * Creates and enables hooking for a function.
 * Returns hooked pointer to the function.
 * */
pub unsafe fn hook( f: *const (), new_fn: *const() ) -> *const ()
{
    let hooks = HOOKS.as_mut().unwrap();
    let r = hooks.get(&f);
    if r.is_some() { 
        return r.unwrap().f;
    }

    let mut h: Hook = Hook { 
        f: core::ptr::null(), 
        subhooks: Vec::new(),
    };

    let r = create_hook( f as *mut c_void, new_fn as *mut c_void );
    if r.is_err() { return core::ptr::null(); }
    h.f = core::mem::transmute(r.unwrap());

    let r = enable_hook(f as *mut c_void);
    if r.is_err() { return core::ptr::null(); }

    hooks.insert(f, h.clone());
    h.f
}

pub unsafe fn add_subhook( f: *const (), sub: *const () )
{
    let hooks = HOOKS.as_mut().unwrap();
    let r = hooks.get_mut(&f);
    if r.is_none() { panic!("function not found: {:p}", f) }
    let h: &mut Hook = r.unwrap();
    h.subhooks.push(sub);

}
pub unsafe fn get_subhooks( f: *const () ) -> (*const *const (), usize)
{
    let hooks = HOOKS.as_mut().unwrap();
    let r = hooks.get(&f);
    if r.is_none() { panic!("function not found: {:p}", f) }
    let h: &Hook = r.unwrap();
    return (h.subhooks.as_ptr(), h.subhooks.len());
}