FFI Destruct

![crates badge] ![docs badge] ![build badge]

Generates destructors for structures that contain raw pointers in the FFI.

About

The Destruct derive macro will implement Drop trait and free(drop) memory for structures containing raw pointers. It may be a common procedure for FFI resource management.

Safety

All the raw pointer dropping operations are unsafe and almost unchecked. Should only drop resources managed by Rust side.

Supported types

Both *const and *mut are acceptable. But currently, only single-level pointers are supported.

| type | handler | note | | ---------- | --------------------------------- | ------------------------------------------------------------------------------------------------ | | * c_char | ::std::ffi::CString::from_raw() | C-style string. Likely type path:
std::ffi::c_char libc::c_char std::os::raw::c_char | | * <T> | ::std::boxed::Box::from_raw() | Anything heap-allocated by Rust. Something likely from:
Box::into_raw(Box::new(<T>)) |

Example

Provides a structure with several raw pointers that need to be dropped manually. ```rust use ffidestruct::{externc_destructor, Destruct}; use std::ffi::*;

[derive(Destruct)]

pub struct MyStruct { field: *mut std::ffi::c_char, }

pub struct AnyOther(u32, u32);

// Struct definition here, with deriving Destruct and nullable attributes.

[derive(Destruct)]

pub struct Structure { // Default is non-null. cstring: *const cchar, #[nullable] cstringnullable: *mut c_char,

other: *mut MyStruct,
#[nullable]
other_nullable: *mut MyStruct,

// Do not drop this field.
#[no_drop]
not_dropped: *const AnyOther,

// Raw pointer for any other things
any: *mut AnyOther,

// Non-pointer types are still available, and will not be added to drop().
pub normal_int: u32,
pub normal_string: String,

}

// (Optional) The macro here generates the destructor: destructstructure() externc_destructor!(Structure);

fn main() { // Some resources manually managed let tmp = AnyOther(1, 1); let tmpptr = Box::intoraw(Box::new(tmp));

let my_struct = Structure {
    c_string: CString::new("Hello").unwrap().into_raw(),
    c_string_nullable: std::ptr::null_mut(),
    other: Box::into_raw(Box::new(MyStruct {
        field: CString::new("Hello").unwrap().into_raw(),
    })),
    other_nullable: std::ptr::null_mut(),
    not_dropped: tmp_ptr,
    any: Box::into_raw(Box::new(AnyOther(1, 1))),
    normal_int: 114514,
    normal_string: "Hello".to_string(),
};

let my_struct_ptr = Box::into_raw(Box::new(my_struct));
// FFI calling
unsafe {
    destruct_structure(my_struct_ptr);
}

// Drop the manually managed resources
unsafe {
    let _ = Box::from_raw(tmp_ptr);
}

} ```

After expanding the macros: ```rust

[macro_use]

![feature(prelude_import)]

![allow(dead_code)]

[prelude_import]

use std::prelude::rust_2021::*;

[macro_use]

extern crate std; use ffidestruct::{externcdestructor, Destruct}; use std::ffi::*; pub struct MyStruct { field: *mut std::ffi::cchar, } impl ::std::ops::Drop for MyStruct { fn drop(&mut self) { unsafe { let _ = ::std::ffi::CString::fromraw(self.field as *mut ::std::ffi::cchar); } } } pub struct AnyOther(u32, u32); pub struct Structure { cstring: *const cchar, #[nullable] cstringnullable: *mut cchar, other: *mut MyStruct, #[nullable] othernullable: *mut MyStruct, #[nodrop] notdropped: *const AnyOther, any: *mut AnyOther, pub normalint: u32, pub normalstring: String, } impl ::std::ops::Drop for Structure { fn drop(&mut self) { unsafe { let _ = ::std::ffi::CString::fromraw( self.cstring as *mut ::std::ffi::cchar, ); if !self.cstringnullable.isnull() { let _ = ::std::ffi::CString::fromraw( self.cstringnullable as *mut ::std::ffi::cchar, ); } let _ = ::std::boxed::Box::fromraw(self.other as *mut MyStruct); if !self.othernullable.isnull() { let _ = ::std::boxed::Box::fromraw( self.othernullable as *mut MyStruct, ); } let _ = ::std::boxed::Box::fromraw(self.any as *mut AnyOther); } } }

[no_mangle]

pub unsafe extern "C" fn destructstructure(ptr: *mut Structure) { if ptr.isnull() { return; } let _ = ::std::boxed::Box::fromraw(ptr); } fn main() { let tmp = AnyOther(1, 1); let tmpptr = Box::intoraw(Box::new(tmp)); let mystruct = Structure { cstring: CString::new("Hello").unwrap().intoraw(), cstringnullable: std::ptr::nullmut(), other: Box::intoraw( Box::new(MyStruct { field: CString::new("Hello").unwrap().intoraw(), }), ), othernullable: std::ptr::nullmut(), notdropped: tmpptr, any: Box::intoraw(Box::new(AnyOther(1, 1))), normalint: 114514, normalstring: "Hello".tostring(), }; let mystructptr = Box::intoraw(Box::new(mystruct)); unsafe { destructstructure(mystructptr); } unsafe { let _ = Box::fromraw(tmpptr); } } ```