rns-hooks 0.2.1

Programmable hook system for the Reticulum Network Stack
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::builtin::BuiltinProgram;
#[cfg(feature = "native")]
use crate::native::NativeProgram;
#[cfg(feature = "wasm")]
use crate::runtime::StoreData;
#[cfg(feature = "wasm")]
use wasmtime::{Instance, Module, Store};

pub enum ProgramBackend {
    Builtin(BuiltinProgram),
    #[cfg(feature = "wasm")]
    Wasm(WasmProgram),
    #[cfg(feature = "native")]
    Native(NativeProgram),
}

#[cfg(feature = "wasm")]
pub struct WasmProgram {
    pub module: Module,
    pub export_name: String,
    /// Cached store and instance for cross-call state persistence.
    pub cached: Option<(Store<StoreData>, Instance)>,
}

/// A loaded hook program ready for execution.
pub struct LoadedProgram {
    pub name: String,
    pub priority: i32,
    pub consecutive_traps: u32,
    pub enabled: bool,
    pub max_consecutive_traps: u32,
    pub backend: ProgramBackend,
}

impl LoadedProgram {
    pub fn new_builtin(name: String, builtin: BuiltinProgram, priority: i32) -> Self {
        LoadedProgram {
            name,
            priority,
            consecutive_traps: 0,
            enabled: true,
            max_consecutive_traps: 10,
            backend: ProgramBackend::Builtin(builtin),
        }
    }

    #[cfg(feature = "wasm")]
    pub fn new(name: String, module: Module, priority: i32) -> Self {
        LoadedProgram {
            name,
            priority,
            consecutive_traps: 0,
            enabled: true,
            max_consecutive_traps: 10,
            backend: ProgramBackend::Wasm(WasmProgram {
                module,
                export_name: "on_hook".to_string(),
                cached: None,
            }),
        }
    }

    #[cfg(feature = "native")]
    pub fn new_native(name: String, native: NativeProgram, priority: i32) -> Self {
        LoadedProgram {
            name,
            priority,
            consecutive_traps: 0,
            enabled: true,
            max_consecutive_traps: 10,
            backend: ProgramBackend::Native(native),
        }
    }

    /// Reset the consecutive trap counter after a successful execution.
    pub fn record_success(&mut self) {
        self.consecutive_traps = 0;
    }

    /// Drop the cached store/instance (e.g. on reload).
    pub fn drop_cache(&mut self) {
        match &mut self.backend {
            ProgramBackend::Builtin(_) => {}
            #[cfg(feature = "wasm")]
            ProgramBackend::Wasm(wasm) => {
                wasm.cached = None;
            }
            #[cfg(feature = "native")]
            ProgramBackend::Native(_) => {}
        }
    }

    pub fn backend_name(&self) -> &'static str {
        match &self.backend {
            ProgramBackend::Builtin(_) => "builtin",
            #[cfg(feature = "wasm")]
            ProgramBackend::Wasm(_) => "wasm",
            #[cfg(feature = "native")]
            ProgramBackend::Native(_) => "native",
        }
    }

    /// Increment the trap counter. Returns `true` if the program was auto-disabled.
    pub fn record_trap(&mut self) -> bool {
        self.consecutive_traps += 1;
        if self.consecutive_traps >= self.max_consecutive_traps {
            self.enabled = false;
            true
        } else {
            false
        }
    }
}