Dereference FFI pointer in Python to get underlying array

Question

I have a C FFI written in Rust, called `src/lib.rs` that looks like the following: ``` // compile with $ cargo build extern crate libc; use self::libc::{size_t, int32_t}; use std::cmp::min; use std::slice; #[no_mangle] pub extern "C" fn rle_new(values_data: *const int32_t, values_length: size_t) -> *mut Rle { let values = unsafe { slice::from_raw_parts(values_data, values_length as usize).to_vec() }; return Box::into_raw(Box::new(Rle::new(values))); } #[no_mangle] pub extern "C" fn rle_free(ptr: *mut Rle) { if ptr.is_null() { return; } unsafe { Box::from_raw(ptr); } } #[no_mangle] pub extern "C" fn rle_values_size(rle: *mut Rle) -> int32_t { unsafe { (*rle).values.len() as i32 } } #[no_mangle] pub extern "C" fn rle_values(rle: *mut Rle) -> *mut int32_t { unsafe { &mut (*rle).values[0] } } #[derive(Debug, PartialEq)] pub struct Rle { pub values: Vec, } impl Rle { pub fn new(values: Vec) -> Self { return Rle { values: values }; } } ``` This is my Cargo.toml in the project base…

Accepted Answer

The `cast` should be the first warning sign. Why do you have to cast from the type to what should be the same type? This is because there are simple typos:

```
lib.rle_values.restype = POINTER(c_int32)    
lib.rle_values_size.restype = c_int32
```

Note that it's supposed to be `restype`, not `restypes`.

```
def __str__(self):
    values_size = lib.rle_values_size(self.obj)
    print(values_size, "values_size")

values_pointer = lib.rle_values(self.obj)
    print("values_pointer:", values_pointer)

thing = values_pointer[:values_size]
    return str(thing)
```

It's also better to use `as_mut_ptr`:

```
#[no_mangle]
pub extern "C" fn rle_values(rle: *mut Rle) -> *mut int32_t {
    let mut rle = unsafe { &mut *rle };
    rle.values.as_mut_ptr()
}
```

Running the program appears to work:

```
$ LD_LIBRARY_PATH=$PWD/target/debug/ python3 main.py
new
30 values_size
values_pointer: <__main__.LP_c_int object at 0x10f124048>
[1, 1, 2, 1, 1, 2, 1, 1, 2, 1, 1, 2, 1, 1, 2, 1, 1, 2, 1, 1, 2, 1, 1, 2, 1, 1, 2, 1, 1, 2]
```

I'd also recommend:

- the default ctypes return value is a `cint`. Not specifying a return type for `free` is probably not a good idea, as it should be `void`.

- return an unsigned number for the length of the data; what would -53 items mean?

- reduce the scope of the `unsafe` blocks to just the part that is unsafe and the code that ensures it is actually safe.

speaking of which, you could check for `NULL` pointers in each function.

```
#[no_mangle]
pub extern "C" fn rle_values_size(rle: *mut Rle) -> int32_t {
    match unsafe { rle.as_ref() } {
        Some(rle) => rle.values.len() as i32,
        None => 0,
    }
}

#[no_mangle]
pub extern "C" fn rle_values(rle: *mut Rle) -> *mut int32_t {
    match unsafe { rle.as_mut() } {
        Some(mut rle) => rle.values.as_mut_ptr(),
        None => ptr::null_mut(),
    }
}
```

Dereference FFI pointer in Python to get underlying array

Solution

Problem

Related problems