How to allocate LinkedList comes from C binding in Rust? - memory

Question

I'm trying to understand Rust' memory mechanism, especially how it works when you need it to interoperate with C code.
Here I have small C code represents a linked list and a function prints its attr to stdout:
// this is wrapper.h
typedef struct elem {
int attr;
struct elem *next;
} elem;
typedef struct wrapper {
char name[16];
struct elem *first_elem;
} wrapper;
void print_all_attrs(wrapper *w);
// -----
// and this is how wrapper.c looks like:
#include <stdio.h>
#include "wrapper.h"
void print_all_attrs(wrapper *w) {
printf("NAME = %s\n", w->name);
elem *elem = w->first_elem;
while(elem != NULL) {
printf("ATTR = %d\n", elem->attr);
elem = elem->next;
}
}
We all know how to prepare a wrapper that can hold a linkedlist of elem which is created dynamically: we need to create a wrapper variable, then a logic allocates an area in heap for every elem, assigns the first one into wrapper->first_elem and then others to previous' next pointer. here the code does exactly same thing:
void main() {
wrapper w = {
.name = "ABCD",
};
elem *prev = NULL;
for(int i=0; i<10; i++) {
elem *new = malloc(sizeof(elem));
new->attr = i;
if(w.first_elem == NULL) {
w.first_elem = new;
prev = new;
continue;
}
prev->next = new;
prev = prev->next;
}
print_all_attrs(&w);
// CLEARING HEAP STUFF HERE...
}
So, in Rust, I'm trying to use those definitions by generating code bindgen and cc libraries, I'm skipping these details right now.
If I want to allocate something into heap, I know I can use Box but it doesn't work at all because it drops when it goes out scope. take a look below code that exits with segmentation fault:
unsafe {
let mut prev: *mut xxx::elem = w.first_elem;
for n in 0..10 {
let mut elem = Box::new(xxx::elem {
attr: n,
next: ptr::null_mut(),
});
if w.first_elem.is_null() {
w.first_elem = &mut *elem;
prev = &mut *elem;
continue;
}
(*prev).next = &mut *elem;
prev = (*prev).next;
}
xxx::print_all_attrs(&mut w);
}
I managed to use Layout and alloc, but these guys bring a cost that I need to dealloc the things after use:
unsafe {
use std::alloc::{Layout, alloc};
let mut prev: *mut xxx::elem = w.first_elem;
for n in 0..10 {
let layout = Layout::new::<xxx::elem>();
let mut p = alloc(layout) as *mut xxx::elem;
(*p).attr = n;
(*p).next = ptr::null_mut();
if w.first_elem.is_null() {
w.first_elem = p;
prev = p;
continue;
}
(*prev).next = p;
prev = (*prev).next;
}
xxx::print_all_attrs(&mut w);
// dealloc stuff here.
}
I wonder that if there is another possible way to do that without using Layout and its friends? I see this is one of the proper way to make it but it makes me feel this is not the expected "Rust-way".