udbg 0.3.1

cross-platform library for binary debugging and memory hacking
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

use crate::prelude::*;

use core::cell::Cell;
use std::sync::Arc;

pub mod udbg;

pub use libc::pid_t;

impl Symbol {
    pub fn undecorate(sym: &str, flags: UDbgFlags) -> Option<String> {
        use cpp_demangle::{DemangleOptions, Symbol};
        Symbol::new(sym).ok().and_then(|s| {
            let mut opts = DemangleOptions::new();
            if flags.contains(UDbgFlags::UNDEC_TYPE) {
                opts = opts.no_params();
            }
            if flags.contains(UDbgFlags::UNDEC_RETN) {
                opts = opts.no_return_type();
            }
            s.demangle(&opts).ok()
        })
    }
}

pub struct Module {
    pub data: ModuleData,
    pub syms: SymbolsData,
    pub loaded: Cell<bool>,
}

impl Module {
    // fn check_loaded(&self) {
    //     if self.loaded.get() { return; }
    //     let mut s = self.syms.write();
    //     self.loaded.set(true);
    //     match s.load(&self.data.path) {
    //         Ok(_) => {
    //         }
    //         Err(e) => {
    //             error!("{}", e);
    //         }
    //     }
    // }
}

impl GetProp for Module {
    fn get_prop(&self, key: &str) -> UDbgResult<serde_value::Value> {
        Ok(serde_value::Value::Unit)
    }
}

impl UDbgModule for Module {
    fn data(&self) -> &ModuleData {
        &self.data
    }

    fn symbol_status(&self) -> SymbolStatus {
        if self.syms.pdb.read().is_some() {
            SymbolStatus::Loaded
        } else {
            SymbolStatus::Unload
        }
    }
    fn add_symbol(&self, offset: usize, name: &str) -> UDbgResult<()> {
        self.syms.add_symbol(offset, name)
    }
    fn find_symbol(&self, offset: usize, max_offset: usize) -> Option<Symbol> {
        self.syms.find_symbol(offset, max_offset)
    }
    fn get_symbol(&self, name: &str) -> Option<Symbol> {
        self.syms.get_symbol(name)
    }
    fn symbol_file(&self) -> Option<Arc<dyn SymbolFile>> {
        self.syms.pdb.read().clone()
    }

    fn enum_symbol(&self, pat: Option<&str>) -> UDbgResult<Box<dyn Iterator<Item = Symbol>>> {
        Ok(Box::new(self.syms.enum_symbol(pat)?.into_iter()))
    }
    fn get_exports(&self) -> Option<Vec<Symbol>> {
        Some(self.syms.exports.iter().map(|i| i.1.clone()).collect())
    }

    // TODO: dwarf
    // fn load_symbol_file(&self, path: &str) -> UDbgResult<()> {
    //     // self.syms.write().load_from_pdb(path)?; Ok(())
    //     Ok(())
    // }
}