How to expose a Rust ` Vec < T >` to FFI?

In Rust, Vec<T> is a convenient container for storing and managing data in collections. However, when interacting with the Foreign Function Interface (FFI), directly exposing Vec<T> can cause issues because languages like C or C++ do not natively support Rust's data structures and memory safety guarantees. Therefore, we need to expose Vec<T> in a way that other languages can understand. The following are the relevant steps and considerations:

Step 1: Using Raw Pointers and Length

The simplest approach is to convert Vec<T> into a raw pointer and a length representing the number of elements. This method is typically suitable for simple data types (e.g., i32, f64, etc.), and you must ensure the target language correctly handles this data.

rust
extern "C" {
    fn use_data_from_rust(data: *const i32, len: usize);
}

fn send_data_to_c() {
    let vec = vec![1, 2, 3, 4, 5];
    let len = vec.len();
    let data_ptr = vec.as_ptr();
    unsafe {
        use_data_from_rust(data_ptr, len);
    }
    // Note: Ensure `vec` is not dropped before the data is fully used by C.
}

Step 2: Considering Ownership and Memory Management

When passing Vec<T> through FFI, careful attention to memory management is essential. Rust handles memory allocation and deallocation, while languages like C or C++ might attempt to free or reallocate this memory during usage, leading to undefined behavior. Therefore, we may need to provide functions that allow external code to safely free or transfer ownership.

rust
// Define a memory-freeing function in Rust
#[no_mangle]
pub extern "C" fn free_vec(data: *mut i32, len: usize) {
    unsafe {
        let _ = Vec::from_raw_parts(data, len, len);
    }
}

fn send_data_take_ownership_to_c() {
    let mut vec = vec![1, 2, 3, 4, 5];
    let len = vec.len();
    let data_ptr = vec.as_mut_ptr();
    std::mem::forget(vec); // Prevent Rust from automatically freeing memory
    unsafe {
        use_data_from_rust(data_ptr, len);
        free_vec(data_ptr, len); // Free memory after C has finished processing
    }
}

Step 3: Handling Complex Data Types

For more complex data types, such as custom structs or Vec<T> containing non-Copy types, meticulous handling is required. Typically, you must ensure these types meet C's memory layout requirements at the FFI boundary (e.g., using #[repr(C)]).

Best Practices

• Maintain a simple interface: Keep the FFI interface straightforward and avoid passing complex data structures to minimize error likelihood.
• Clarify memory ownership: Explicitly document ownership transfer in interface specifications to prevent memory leaks or double frees.
• Use native tools: Consider tools like bindgen that automatically generate bindings between Rust and C, reducing manual coding errors.

By following these steps and considerations, we can effectively expose Vec<T> from Rust to FFI while ensuring the stability and security of the program.