rust/ffi: add thread lifecycle callback wrappers

Ticket: OISF#8605

Author: jasonish

examples/plugins/rust/src/mod.rs

@@ -4,7 +4,7 @@ use suricata_ffi::eve::{self, SCJsonBuilder};
 use suricata_ffi::flow::{self, Flow, FlowStorage};
 use suricata_ffi::jsonbuilder::JsonBuilder;
 use suricata_ffi::packet::Packet;
-use suricata_ffi::threadvars::ThreadVars;
+use suricata_ffi::threadvars::{self, ThreadVars};
 use suricata_ffi::{SCLogError, SCLogNotice};
 use suricata_sys::sys::{
     Flow as RawFlow, Packet as RawPacket, SCEveRegisterCallback, SCPlugin,
@@ -23,6 +23,7 @@ unsafe extern "C" fn init() {
 pub fn register() -> Result<(), &'static str> {
     register_eve_callbacks()?;
     register_flow_callbacks()?;
+    register_thread_callbacks()?;
     Ok(())
 }
 
@@ -33,6 +34,10 @@ pub fn register_eve_callbacks() -> Result<(), &'static str> {
     eve::register_callback(log_eve_wrapped)
 }
 
+pub fn register_thread_callbacks() -> Result<(), &'static str> {
+    threadvars::register_init_callback(on_thread_init)
+}
+
 #[derive(Default)]
 struct ExampleFlowState {
     packets: u64,
@@ -74,6 +79,13 @@ fn log_eve_wrapped(
     Ok(())
 }
 
+fn on_thread_init(tv: ThreadVars<'_>) {
+    SCLogNotice!(
+        "rust example thread init callback: thread={:p}",
+        tv.as_ptr()
+    );
+}
+
 fn log_flow_init(
     _tv: ThreadVars<'_>,
     mut f: Flow<'_>,

rust/ffi/src/threadvars.rs

@@ -16,8 +16,10 @@
  */
 
 use std::marker::PhantomData;
+use std::os::raw::c_void;
 
 use suricata_sys::sys;
+use suricata_sys::sys::{SCThreadRegisterInitCallback, ThreadVars as RawThreadVars};
 
 pub struct ThreadVars<'a> {
     ptr: *const sys::ThreadVars,
@@ -36,3 +38,38 @@ impl<'a> ThreadVars<'a> {
         self.ptr
     }
 }
+
+/// Register a thread initialization callback.
+///
+/// The callback is invoked for every thread being initialized during Suricata
+/// startup. It receives the `ThreadVars` for the thread that has just been
+/// initialized.
+///
+/// # Safety
+///
+/// The callback receives raw pointers from Suricata. These pointers are only
+/// valid for the duration of the callback invocation and must not be stored.
+///
+/// The callback must not panic.
+pub fn register_init_callback<F>(callback: F) -> Result<(), &'static str>
+where
+    F: for<'a> Fn(ThreadVars<'a>) + Send + Sync + 'static,
+{
+    let user = Box::into_raw(Box::new(callback)) as *mut c_void;
+    if unsafe { SCThreadRegisterInitCallback(Some(init_callback_wrapper::<F>), user) } {
+        Ok(())
+    } else {
+        unsafe {
+            drop(Box::from_raw(user as *mut F));
+        }
+        Err("Failed to register thread init callback")
+    }
+}
+
+unsafe extern "C" fn init_callback_wrapper<F>(tv: *mut RawThreadVars, user: *mut c_void)
+where
+    F: for<'a> Fn(ThreadVars<'a>) + Send + Sync + 'static,
+{
+    let callback = &*(user as *const F);
+    callback(ThreadVars::from_ptr(tv));
+}

rust/sys/src/sys.rs

@@ -1878,6 +1878,20 @@ extern "C" {
         Free: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
     ) -> SCFlowStorageId;
 }
+#[doc = " \\brief Function type for thread intialization callbacks.\n\n Once registered by SCThreadRegisterInitCallback, this function will\n be called for every thread being initialized during Suricata\n startup.\n\n \\param tv The ThreadVars struct that has just been initialized.\n \\param user The user data provided when registering the callback."]
+pub type SCThreadInitCallbackFn = ::std::option::Option<
+    unsafe extern "C" fn(tv: *mut ThreadVars, user: *mut ::std::os::raw::c_void),
+>;
+extern "C" {
+    #[doc = " \\brief Register a thread init callback.\n\n Register a user provided function to be called every time a thread is\n initialized for use.\n\n \\param fn Pointer to function to be called\n \\param user Additional user data to be passed to callback\n\n \\returns true if callback was registered, otherwise false if the\n     callback could not be registered due to memory allocation error."]
+    pub fn SCThreadRegisterInitCallback(
+        fn_: SCThreadInitCallbackFn, user: *mut ::std::os::raw::c_void,
+    ) -> bool;
+}
+extern "C" {
+    #[doc = " \\internal\n\n Run all registered flow init callbacks."]
+    pub fn SCThreadRunInitCallbacks(tv: *mut ThreadVars);
+}
 extern "C" {
     pub fn SCSRepCatGetByShortname(shortname: *const ::std::os::raw::c_char) -> u8;
 }

src/bindgen.h

@@ -65,6 +65,8 @@
 #include "flow-callbacks.h"
 #include "flow-storage.h"
 
+#include "thread-callbacks.h"
+
 #include "reputation.h"
 #include "feature.h"
 #include "datasets.h"

src/thread-callbacks.h

@@ -18,8 +18,9 @@
 #ifndef SURICATA_THREAD_CALLBACKS_H
 #define SURICATA_THREAD_CALLBACKS_H
 
-#include "suricata-common.h"
+#ifndef SURICATA_BINDGEN_H
 #include "threadvars.h"
+#endif
 
 /** \brief Function type for thread intialization callbacks.
  *