rust/ffi: use Packet wrapper in flow callback signatures

Author: jasonish

doc/userguide/devguide/extending/flow-lifecycle-callbacks.rst

@@ -104,15 +104,17 @@ The Rust wrappers register closures or function items and return
 
 .. code-block:: rust
 
-   use suricata_ffi::flow::{self, Flow, Packet, ThreadVars};
+   use suricata_ffi::flow;
+   use suricata_ffi::packet::Packet;
    use suricata_ffi::SCLogNotice;
+   use suricata_sys::sys::{Flow, ThreadVars};
 
-   fn flow_init(_tv: *mut ThreadVars, f: *mut Flow, _p: *const Packet) {
+   fn flow_init(_tv: *mut ThreadVars, f: *mut Flow, _p: Option<Packet<'_>>) {
        SCLogNotice!("flow initialized: {:p}", f);
    }
 
-   fn flow_update(_tv: *mut ThreadVars, f: *mut Flow, p: *mut Packet) {
-       SCLogNotice!("flow updated: {:p} packet: {:p}", f, p);
+   fn flow_update(_tv: *mut ThreadVars, f: *mut Flow, p: Option<Packet<'_>>) {
+       SCLogNotice!("flow updated: {:p} has_packet: {}", f, p.is_some());
    }
 
    fn flow_finish(_tv: *mut ThreadVars, f: *mut Flow) {

examples/plugins/rust/src/mod.rs

@@ -68,15 +68,19 @@ fn log_eve_wrapped(
     Ok(())
 }
 
-fn log_flow_init(_tv: *mut ThreadVars, _f: *mut Flow, _p: *const RawPacket) {
-    SCLogNotice!("rust example flow init callback: flow={:p}", _f);
+fn log_flow_init(_tv: *mut ThreadVars, _f: *mut Flow, _p: Option<Packet<'_>>) {
+    SCLogNotice!(
+        "rust example flow init callback: flow={:p}, has_packet={}",
+        _f,
+        _p.is_some()
+    );
 }
 
-fn log_flow_update(_tv: *mut ThreadVars, _f: *mut Flow, _p: *mut RawPacket) {
+fn log_flow_update(_tv: *mut ThreadVars, _f: *mut Flow, _p: Option<Packet<'_>>) {
     SCLogNotice!(
-        "rust example flow update callback: flow={:p}, packet={:p}",
+        "rust example flow update callback: flow={:p}, has_packet={}",
         _f,
-        _p
+        _p.is_some()
     );
 }
 

rust/ffi/src/flow.rs

@@ -17,7 +17,7 @@
 
 use std::os::raw::c_void;
 
-use suricata_sys::sys::{Flow, Packet, ThreadVars};
+use suricata_sys::sys::{Flow, Packet as RawPacket, ThreadVars};
 use suricata_sys::sys::{
     SCFlowRegisterFinishCallback, SCFlowRegisterInitCallback, SCFlowRegisterUpdateCallback,
 };
@@ -37,7 +37,10 @@ use suricata_sys::sys::{
 /// The callback must not panic.
 pub fn register_init_callback<F>(callback: F) -> Result<(), &'static str>
 where
-    F: Fn(*mut ThreadVars, *mut Flow, *const Packet) + Send + Sync + 'static,
+    F: for<'a> Fn(*mut ThreadVars, *mut Flow, Option<crate::packet::Packet<'a>>)
+        + Send
+        + Sync
+        + 'static,
 {
     let user = Box::into_raw(Box::new(callback)) as *mut c_void;
     if unsafe { SCFlowRegisterInitCallback(Some(init_callback_wrapper::<F>), user) } {
@@ -66,7 +69,10 @@ where
 /// The callback must not panic.
 pub fn register_update_callback<F>(callback: F) -> Result<(), &'static str>
 where
-    F: Fn(*mut ThreadVars, *mut Flow, *mut Packet) + Send + Sync + 'static,
+    F: for<'a> Fn(*mut ThreadVars, *mut Flow, Option<crate::packet::Packet<'a>>)
+        + Send
+        + Sync
+        + 'static,
 {
     let user = Box::into_raw(Box::new(callback)) as *mut c_void;
     if unsafe { SCFlowRegisterUpdateCallback(Some(update_callback_wrapper::<F>), user) } {
@@ -107,21 +113,37 @@ where
 }
 
 unsafe extern "C" fn init_callback_wrapper<F>(
-    tv: *mut ThreadVars, f: *mut Flow, p: *const Packet, user: *mut c_void,
+    tv: *mut ThreadVars, f: *mut Flow, p: *const RawPacket, user: *mut c_void,
 ) where
-    F: Fn(*mut ThreadVars, *mut Flow, *const Packet) + Send + Sync + 'static,
+    F: for<'a> Fn(*mut ThreadVars, *mut Flow, Option<crate::packet::Packet<'a>>)
+        + Send
+        + Sync
+        + 'static,
 {
     let callback = &*(user as *const F);
-    callback(tv, f, p);
+    let packet = if p.is_null() {
+        None
+    } else {
+        Some(crate::packet::Packet::from_ptr(p))
+    };
+    callback(tv, f, packet);
 }
 
 unsafe extern "C" fn update_callback_wrapper<F>(
-    tv: *mut ThreadVars, f: *mut Flow, p: *mut Packet, user: *mut c_void,
+    tv: *mut ThreadVars, f: *mut Flow, p: *mut RawPacket, user: *mut c_void,
 ) where
-    F: Fn(*mut ThreadVars, *mut Flow, *mut Packet) + Send + Sync + 'static,
+    F: for<'a> Fn(*mut ThreadVars, *mut Flow, Option<crate::packet::Packet<'a>>)
+        + Send
+        + Sync
+        + 'static,
 {
     let callback = &*(user as *const F);
-    callback(tv, f, p);
+    let packet = if p.is_null() {
+        None
+    } else {
+        Some(crate::packet::Packet::from_ptr(p))
+    };
+    callback(tv, f, packet);
 }
 
 unsafe extern "C" fn finish_callback_wrapper<F>(