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

use std::marker::PhantomData;
use error::*;
use {Detour, Function, HookableWith, RawDetour};

/// A type-safe wrapper around [RawDetour](./struct.RawDetour.html).  
///
/// Therefore documentation related to `RawDetour` affects this interface as well.
///
/// Due to being generated by a macro, the `GenericDetour::call` method is not
/// exposed in the documentation.  
/// It accepts the same arguments as `T`, and shares its result type:
///
/// ```c
/// // Calls the original function regardless of whether it's hooked or not
/// fn call(&self, T::Arguments) -> T::Output
/// ```
///
/// # Example
///
/// ```rust
/// use detour::{Detour, GenericDetour};
///
/// fn add5(val: i32) -> i32 { val + 5 }
/// fn add10(val: i32) -> i32 { val + 10 }
///
/// let mut hook = unsafe {
///     GenericDetour::<fn(i32) -> i32>::new(add5, add10).unwrap()
/// };
///
/// assert_eq!(add5(5), 10);
/// assert_eq!(hook.call(5), 10);
///
/// unsafe { hook.enable().unwrap() };
///
/// assert_eq!(add5(5), 15);
/// assert_eq!(hook.call(5), 10);
///
/// unsafe { hook.disable().unwrap() };
///
/// assert_eq!(add5(5), 10);
/// ```
#[derive(Debug)]
pub struct GenericDetour<T: Function> {
    detour: RawDetour,
    target: PhantomData<T>,
}

impl<T: Function> GenericDetour<T> {
    /// Create a new hook given a target function and a compatible detour
    /// function.
    pub unsafe fn new<D>(target: T, detour: D) -> Result<Self>
            where T: HookableWith<D>,
                  D: Function {
        RawDetour::new(target.to_ptr(), detour.to_ptr()).map(|raw| GenericDetour {
            target: PhantomData,
            detour: raw,
        })
    }
}

unsafe impl <T: Function> Detour for GenericDetour<T> {
    unsafe fn toggle(&mut self, enabled: bool) -> Result<()> { self.detour.toggle(enabled) }
    fn is_enabled(&self) -> bool { self.detour.is_enabled() }
    fn trampoline(&self) -> &() { self.detour.trampoline() }
}

unsafe impl <T: Function> Send for GenericDetour<T> { }
unsafe impl <T: Function> Sync for GenericDetour<T> { }