mbox: malloc-based box
This crate provides structures that wrap pointers returned from malloc as a Box, and
automatically free them on drop. These types allow you to interact with pointers and
null-terminated strings and arrays in a Rusty style.
```rust extern crate libc; extern crate mbox;
use libc::{c_char, malloc, strcpy}; use mbox::MString;
// Assume we have a C function that returns a malloc'ed string. unsafe extern "C" fn createstr() -> *mut cchar { let ptr = malloc(12) as *mut cchar; strcpy(ptr, b"Hello world\0".asptr() as *const c_char); ptr }
fn main() { // we wrap the null-terminated string into an MString. let string = unsafe { MString::fromrawunchecked(create_str()) };
// check the content is expected.
assert_eq!(&*string, "Hello world");
// the string will be dropped by `free` after the code is done.
} ```
Add this to your Cargo.toml:
toml
[dependencies]
mbox = "0.1.0"
This crate provides three main types, all of which uses the system's malloc/free as the
allocator.
MBox<T> — Similar to Box<T>.MString — Similar to std::ffi::CString.MArray<T> — A null-terminated array, which can be used to represent e.g. array of C strings
terminated by a null pointer.You may compile mbox using the no-std feature to not link to std (it will still link to
core.
toml
[dependencies]
mbox = { version = "0.1.0", features = ["no-std"] }
When no-std is activated, you cannot convert an MString into a std::ffi::CStr, as the
type simply does not exist 🙂.
Note that MBox does not support custom allocator. If the type requires custom allocation,
MBox cannot serve you.
malloc_buf — MallocBuffer<T> is equivalent to
MBox<[T]>. Note however we will not check for null pointers.
cbox — When not using a custom DisposeRef, the
CSemiBox<'static, T> type is equivalent to MBox<T>, and CBox<T> is equivalent to
&'static T.
c_vec — When using free as the destructor, CVec<T> is
equivalent to MBox<[T]> and CSlice<T> as [T].