How do I pass a closure through raw pointers as an argument to a C function?

by

First, some logical errors with the code:

  1. It is not correct to cast pointers to i32 on many platforms (like 64-bit). Pointers may use all of those bits. Truncating a pointer and then calling a function at the truncated address will lead to Really Bad Things. Generally you want to use a machine-sized integer (usize or isize).

  2. The sum value needs to be mutable.

The meat of the problem is that closures are concrete types that take up a size unknown to the programmer, but known to the compiler. The C function is limited to taking a machine-sized integer.

Because closures implement one of the Fn* traits, we can take a reference to the closure’s implementation of that trait to generate a trait object. Taking a reference a trait leads to a fat pointer that contains two pointer-sized values. In this case, it contains a pointer to the data that is closed-over and a pointer to a vtable, the concrete methods that implement the trait.

In general, any reference to or Box of a dynamically-sized type type is going to generate a fat pointer.

On a 64-bit machine, a fat pointer would be 128 bits in total, and casting that to a machine-sized pointer would again truncate the data, causing Really Bad Things to happen.

The solution, like everything else in computer science, is to add more layers of abstraction:

use std::os::raw::c_void;

fn enum_wnd_proc(some_value: i32, lparam: usize) {
    let trait_obj_ref: &mut &mut FnMut(i32) -> bool = unsafe {
        let closure_pointer_pointer = lparam as *mut c_void;
        &mut *(closure_pointer_pointer as *mut _)
    };
    println!(
        "predicate() executed and returned: {}",
        trait_obj_ref(some_value)
    );
}

fn main() {
    let mut sum = 0;
    let mut closure = |some_value: i32| -> bool {
        println!("I'm summing {} + {}", sum, some_value);
        sum += some_value;
        sum >= 100
    };

    let mut trait_obj: &mut FnMut(i32) -> bool = &mut closure;
    let trait_obj_ref = &mut trait_obj;

    let closure_pointer_pointer = trait_obj_ref as *mut _ as *mut c_void;
    let lparam = closure_pointer_pointer as usize;

    enum_wnd_proc(20, lparam);
}

We take a second reference to the fat pointer, which creates a thin pointer. This pointer is only one machine-integer in size.

Maybe a diagram will help (or hurt)?

Reference -> Trait object -> Concrete closure
 8 bytes       16 bytes         ?? bytes

Because we are using raw pointers, it is now the programmers responsibility to make sure that the closure outlives where it is used! If enum_wnd_proc stores the pointer somewhere, you must be very careful to not use it after the closure is dropped.

As a side note, using mem::transmute when casting the trait object:

use std::mem;
let closure_pointer_pointer: *mut c_void = unsafe { mem::transmute(trait_obj) };

Produces a better error message:

error[E0512]: transmute called with types of different sizes
  --> src/main.rs:26:57
   |
26 |     let closure_pointer_pointer: *mut c_void = unsafe { mem::transmute(trait_obj) };
   |                                                         ^^^^^^^^^^^^^^
   |
   = note: source type: &mut dyn std::ops::FnMut(i32) -> bool (128 bits)
   = note: target type: *mut std::ffi::c_void (64 bits)

Error E0512.

See also

More Related Contents:

  1. How do I convert a Rust closure to a C-style callback?
  2. Traits and Rust
  3. How to get a reference to a concrete type from a trait object?
  4. Why can impl trait not be used to return multiple / conditional types?
  5. How do I implement a trait I don’t own for a type I don’t own?
  6. When does a closure implement Fn, FnMut and FnOnce?
  7. Mutably borrow one struct field while borrowing another in a closure
  8. What makes something a “trait object”?
  9. Is it possible to use `impl Trait` as a function’s return type in a trait definition?
  10. How do I return an instance of a trait from a method?
  11. I implemented a trait for another trait but cannot call methods from both traits
  12. Why would I implement methods on a trait instead of as part of the trait?
  13. How does the mechanism behind the creation of boxed traits work?
  14. How to use struct self in member method closure
  15. Why is the `Sized` bound necessary in this trait?
  16. Can’t borrow mutably within two different closures in the same scope
  17. How can I implement Rust’s Copy trait?
  18. What is the right way to allocate data to pass to an FFI call?
  19. How can I modify self in a closure called from a member function?
  20. Is there any trait that specifies numeric functionality?
  21. Understanding Traits and Object Safety
  22. How do I create a Rust callback function to pass to a FFI function?
  23. Why does a mutable borrow of a closure through DerefMut not work?
  24. Can’t implement a trait I don’t own for all types that implement a trait I do own
  25. How do I specify that a struct field must implement a trait?
  26. Rust equivalent to Swift’s extension methods to a protocol?
  27. Cannot use moved BufReader after for loop with bufreader.lines()
  28. Can a struct containing a raw pointer implement Send and be FFI safe?
  29. How can I specify linker flags/arguments in a build script?
  30. Do I have to implement a trait twice when implementing it for both reference and non-reference types?

Leave a Comment