memflow-ffi 0.2.0

C bindings for the memflow physical memory introspection 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
114
115
116
117
118
119
120
121
122
123
124
125

use log::{Level, LevelFilter};
use memflow::cglue::IntError;
use memflow::error::Error;
use memflow::plugins::Inventory;
use std::num::NonZeroI32;

use std::ffi::CStr;
use std::os::raw::c_char;

/// Initialize logging with selected logging level.
#[no_mangle]
pub extern "C" fn log_init(level_filter: LevelFilter) {
    simplelog::TermLogger::init(
        level_filter,
        simplelog::Config::default(),
        simplelog::TerminalMode::Stdout,
        simplelog::ColorChoice::Auto,
    )
    .unwrap();
}

// TODO: add variadic functions when this is being stabilized, see https://github.com/rust-lang/rust/issues/44930

/// Logs a error message via log::error!
///
/// # Safety
///
/// The provided string must be a valid null-terminated char array.
#[no_mangle]
pub unsafe extern "C" fn log_error(s: *const c_char) {
    if !s.is_null() {
        let c_str = CStr::from_ptr(s);
        if let Ok(r_str) = c_str.to_str() {
            log::error!("{}", r_str);
        }
    }
}

/// Logs a warning message via log::warn!
///
/// # Safety
///
/// The provided string must be a valid null-terminated char array.
#[no_mangle]
pub unsafe extern "C" fn log_warn(s: *const c_char) {
    if !s.is_null() {
        let c_str = CStr::from_ptr(s);
        if let Ok(r_str) = c_str.to_str() {
            log::warn!("{}", r_str);
        }
    }
}

/// Logs a info message via log::info!
///
/// # Safety
///
/// The provided string must be a valid null-terminated char array.
#[no_mangle]
pub unsafe extern "C" fn log_info(s: *const c_char) {
    if !s.is_null() {
        let c_str = CStr::from_ptr(s);
        if let Ok(r_str) = c_str.to_str() {
            log::info!("{}", r_str);
        }
    }
}

/// Logs a debug message via log::debug!
///
/// # Safety
///
/// The provided string must be a valid null-terminated char array.
#[no_mangle]
pub unsafe extern "C" fn log_debug(s: *const c_char) {
    if !s.is_null() {
        let c_str = CStr::from_ptr(s);
        if let Ok(r_str) = c_str.to_str() {
            log::debug!("{}", r_str);
        }
    }
}

/// Logs a trace message via log::trace!
///
/// # Safety
///
/// The provided string must be a valid null-terminated char array.
#[no_mangle]
pub unsafe extern "C" fn log_trace(s: *const c_char) {
    if !s.is_null() {
        let c_str = CStr::from_ptr(s);
        if let Ok(r_str) = c_str.to_str() {
            log::trace!("{}", r_str);
        }
    }
}

/// Logs an error code with custom log level.
#[no_mangle]
pub extern "C" fn log_errorcode(level: Level, error: i32) {
    if let Some(error) = NonZeroI32::new(error) {
        log::log!(level, "{}", <Error as IntError>::from_int_err(error));
    }
}

/// Logs an error with debug log level.
#[no_mangle]
pub extern "C" fn log_debug_errorcode(error: i32) {
    log_errorcode(Level::Debug, error)
}

/// Sets new maximum log level.
///
/// If `inventory` is supplied, the log level is also updated within all plugin instances. However,
/// if it is not supplied, plugins will not have their log levels updated, potentially leading to
/// lower performance, or less logging than expected.
#[no_mangle]
pub extern "C" fn log_set_max_level(level_filter: LevelFilter, inventory: Option<&Inventory>) {
    if let Some(inventory) = inventory {
        inventory.set_max_log_level(level_filter);
    } else {
        log::set_max_level(level_filter);
    }
}