结构方法作为 FFI 回调

如何解决结构方法作为 FFI 回调

我正在为现有主机应用程序开发插件。该应用程序提供了一个本机 C SDK，我使用 bindgen 生成的 FFI 绑定从 Rust 连接到该 SDK。 SDK 严重依赖回调函数来通知我的插件状态变化和用户交互。

我在 Rust 方面的插件基本上是一个 struct 保存相关数据。所有功能都内置在此结构的方法中。

我的挑战是 SDK 需要的那些函数回调。

我可以轻松创建静态函数并将它们交给宿主应用程序：

// function to set callback function in FFI lib
fn set_callback(callback_fn: fn(usize)) {
    let ptr = callback_fn as *const ();
    unsafe {
        // transmute the fn ptr into a C-style fn
        std::mem::transmute::<*const (),Option<unsafe extern "C" fn(usize)>>(ptr);
        // this can now be handed over as the callback via FFI
        // ...
    }
}

// Rust function to be used as callback
fn my_callback(val: usize) {
    println!("{}",val);
}

set_callback(my_callback);

那些函数无法访问我的结构，因此无法访问存储在那里的数据和功能。所以我需要使用我的结构体的方法。

如果我将这些静态函数转换为结构体的方法，我就不能再将它们用作回调：

struct dummy {}

impl dummy {
    fn set_callback(&mut self,callback_fn: fn(usize)) {
        let ptr = callback_fn as *const ();
        unsafe {
            // transmute the fn ptr into a C-style fn
            std::mem::transmute::<*const (),Option<unsafe extern "C" fn(usize)>>(ptr);
            // this can now be handed over as the callback via FFI
            // ...
        }
    }
    fn my_callback(&self,val: usize) {
        // do something
    }

    fn init(&mut self) {
        self.set_callback(self.my_callback);
    }
}

let mut dummy_instance = dummy {};
dummy_instance.init();

error[E0615]: attempted to take value of method `my_callback` on type `&mut dummy`
   --> src/main.rs:18:36
    |
 18 |             self.set_callback(self.my_callback);
    |                                    ^^^^^^^^^^^ method,not a field
    |
help: use parentheses to call the method
    |
 18 |             self.set_callback(self.my_callback(_));
    |                                               ^^^

似乎我必须使用封装该函数调用的闭包。这给我带来了下一个障碍，因为我无法通过 FFI 轻松地将闭包移交给 C。我可以像这样包装它：

use std::ffi::c_void;

type Callback<T> = unsafe extern "C" fn(*mut c_void,x: T) -> T;

fn c_like_closure<F,T>(_: &mut F) -> Callback<T>
where
    F: FnMut(T) -> T,{
    unsafe extern "C" fn invoke<Q,S>(state: *mut c_void,x: S) -> S
    where
        Q: FnMut(S) -> S,{
        let func = &mut *(state as *mut Q);
        func(x)
    }

    invoke::<F,T>
}

struct Dummy {}

impl Dummy {
    fn my_callback(&self,val: usize) -> usize {
        val
    }
}

fn main() {

    let mut my_plugin = Dummy {};
    let mut cb = |val: usize| my_plugin.my_callback(val);

    let fn_ptr = c_like_closure(&mut cb);
    let g = unsafe { fn_ptr(&mut cb as *mut _ as *mut c_void,123) };
}

需要注意的是，我必须以某种方式交出上下文。而且我必须使用的 SDK 没有提供任何函数参数来让我顶部来回传递上下文。

我发现了 libffi 板条箱，它似乎能够包装一个封闭件并通过 FFI 将其移交。上面的例子可以修改如下：

use libffi::high::arity1::Closure1;
...
fn main() {

    let mut my_plugin = Dummy {};
    let mut cb = |val: usize| my_plugin.my_callback(val);

    let closure = Closure1::new(&cb);
    let fn_ptr = closure.code_ptr();
    unsafe {
        fn_ptr(123);
    }
}

不错！

直到我尝试在我的结构内部，在我的 init_plugin 方法中执行此操作。在那里我无法使用 self:

轻松创建闭包

struct Dummy {
    closure: Option<Box<Fn(usize) -> usize>>,}

impl Dummy {
    fn my_callback(&self,val: usize) -> usize {
        println!("{}",val);
        val
    }

    fn init_plugin(&mut self) {
        self.closure = Some(Box::new(|val: usize| self.my_callback(val)));
    }
}

error[E0759]: `self` has an anonymous lifetime `'_` but it needs to satisfy a `'static` lifetime requirement
  --> src/main.rs:64:38
   |
63 |     fn init_plugin(&mut self) {
   |                    --------- this data with an anonymous lifetime `'_`...
64 |         self.closure = Some(Box::new(|val: usize| self.my_callback(val)));
   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...is captured here,requiring it to live as long as `'static`

看起来我被闭包困在了我的道路上......我看到的唯一其他选择是一些静态中间函数，它们从某处获取对我的插件结构的引用，然后像这样调用它的方法：

let my_plugin = Dummy{};

Dummy::my_callback(my_plugin,123);

但这需要 my_plugin 成为一个全局变量，这对我来说听起来不太令人信服......

很明显，我不是唯一一个试图通过 FFI 处理回调的人。我想知道如何在不放弃 Rust 的原则和优势的情况下解决这个问题。

结构方法作为 FFI 回调

如何解决结构方法作为 FFI 回调

相关推荐