reoxide 0.7.0

Rust-bindings for the ReOxide decompiler extension framework
Documentation 
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use crate::cpp::StdVector;
pub use crate::manual_bindings::ReOxideInterface;
use crate::manual_bindings::ghidra_throw;
use std::{ffi::c_char, panic::PanicHookInfo};

#[repr(C)]
pub struct Context {
    pub arch: *mut Architecture,
    pub stackspace: *mut AddrSpace,
    pub reoxide: *mut ReOxideInterface,
}

#[repr(C)]
pub struct ExtraArgs {
    pub group_name: *const c_char,
    pub extra_arg: u64,
}

opaque!(OpaquePlugin);
opaque!(OpaqueAction);
opaque!(OpaqueRule);

#[repr(C)]
pub struct ActionDefinition {
    pub name: *const c_char,
    pub constructor: extern "C-unwind" fn(
        *const Context,
        *mut OpaquePlugin,
        *const ExtraArgs,
    ) -> *mut OpaqueAction,
    pub destructor: extern "C-unwind" fn(*mut OpaqueAction),
    pub apply: extern "C-unwind" fn(*mut OpaqueAction, *mut Funcdata) -> i32,
}

#[repr(C)]
pub struct RuleDefinition {
    pub name: *const c_char,
    pub constructor: extern "C-unwind" fn(
        *const Context,
        *mut OpaquePlugin,
        *const ExtraArgs,
    ) -> *mut OpaqueRule,
    pub destructor: extern "C-unwind" fn(*mut OpaqueRule),
    pub oplist: extern "C-unwind" fn(*const OpaqueRule, *mut StdVector<OpCode>),
    pub apply: extern "C-unwind" fn(*mut OpaqueRule, *mut PcodeOp, *mut Funcdata) -> i32,
}

#[repr(C)]
pub struct DefinitionTable<T: ?Sized> {
    pub table: T,
}

unsafe impl<T: ?Sized> Sync for DefinitionTable<T> {}

pub struct CreationContext<'context, 'name, T> {
    pub arch: &'context mut Architecture,
    pub stack_space: &'context mut AddrSpace,
    pub reoxide: &'context mut ReOxideInterface,
    pub plugin: &'context mut T,
    pub group_name: &'name str,
    pub extra_args: u64,
}

#[repr(i32)]
pub enum ApplyResult {
    Applied = 1,
    NotApplied = 0,
}

pub trait Rule<'a> {
    type PluginContext;

    fn new(context: CreationContext<'a, '_, Self::PluginContext>) -> Self;

    fn op_list(&self) -> Vec<OpCode>;

    fn apply(&mut self, op: &mut PcodeOp, data: &mut Funcdata) -> ApplyResult;
}

pub trait Action<'a> {
    type PluginContext;

    fn new(context: CreationContext<'a, '_, Self::PluginContext>) -> Self;

    fn apply(&mut self, data: &mut Funcdata) -> ApplyResult;
}

/// Our drop in panic hook for plugins throws a RustError on the C++
/// side. Because we therefore (kind of) panic while using the
/// panic_hook, we can only do this *once*. On the next panic, Rust
/// will simply abort.
pub fn panic_hook(info: &PanicHookInfo) {
    let mut msg = String::new();

    // Add panic message if there is one
    if let Some(s) = info.payload().downcast_ref::<&str>() {
        msg.push_str(s);
    } else if let Some(s) = info.payload().downcast_ref::<String>() {
        msg.push_str(s);
    }
    msg.push('\n');

    if let Some(l) = info.location() {
        msg.push_str(&format!("In file {}, line {}\n", l.file(), l.line()));
    }

    let bt = std::backtrace::Backtrace::force_capture();
    msg.push_str(&format!("Backtrace:\n\n{}", bt));
    ghidra_throw(&msg);
}

pub use crate::generated::*;
pub use reoxide_proc::{action, plugin, rule};