rrplug 4.2.1

framework for R2Northstar plugins
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

//! the interface registry is here pog!

use once_cell::sync::Lazy;
use parking_lot::Mutex;
use std::{
    collections::HashMap,
    ffi::{c_char, c_void, CStr},
};

use crate::high::UnsafeHandle;

use super::interface::{AsInterface, Interface};

/// SAFETY: keys cannot be removed or else a memory leak will accure, this whole thing lives for the entire duration of a plugin
static REGISTERED_INTERFACES: Lazy<Mutex<HashMap<&'static str, UnsafeHandle<*const c_void>>>> =
    Lazy::new(|| Mutex::new(HashMap::new()));

#[export_name = "CreateInterface"]
unsafe extern "C" fn create_interface(
    interface_name: *const c_char,
    error: *mut i32,
) -> *const c_void {
    let interfaces = REGISTERED_INTERFACES.lock();

    unsafe { CStr::from_ptr(interface_name) }
        .to_str()
        .ok()
        .and_then(|name| interfaces.get(name))
        .map(|interface| interface.copy())
        .unwrap_or_else(|| {
            unsafe { *error = 1 };
            std::ptr::null()
        })
}

/// registers a interface and allows for it's fetching from the CreateInterface function which is exposed by rrplug
///
/// # Example
/// ```
/// # use crate::rrplug;
/// # use rrplug_proc::as_interface;
/// use rrplug::prelude::*;
///
/// #[repr(C)]
/// struct Exposedinterface {
///     what_is_2p2: i32,
/// }
///
/// #[as_interface]
/// impl Exposedinterface {
///     fn new() -> Self {
///         Self { what_is_2p2: 2+2 }
///     }
///
///     pub const fn twoplustwo(&self) -> i32 {
///         self.what_is_2p2
///     }
/// }
///
/// _ = unsafe{ register_interface("Exposedinterface001", Exposedinterface::new()) };
/// ```
///
/// # Safety
///
/// marked as unsafe for now since I don't know if the current Interface api safe enough and wouldn't be exploited from safe rust
///
/// interfaces must be sync and send have to deal with the Interface struct instead of there struct which all handled by the [`crate::as_interface`] macro
pub unsafe fn register_interface<T: Send + Sync + 'static + AsInterface>(
    name: &'static str,
    interface: Interface<T>,
) -> &'static T {
    let interface = Box::leak(Box::new(interface));
    REGISTERED_INTERFACES.lock().insert(
        name,
        UnsafeHandle::internal_new(interface as *const _ as *const c_void),
    );

    &interface.data
}