How to deal with variable length data struct in C/JNI

Question

I have another JNI related question. How do you handle variable length
data structures in Java and pointer to a pointer?
Basically, I have a backend in C which has records but we don't know
how many. The API looks like
typedef struct rec_list_s {
int rec_list_cnt;
rec_list_data_t rec_list_data[1];
} rec_list_t;
int rec_list_show(void handle, rec_list_t *list_ptr);
/* Code snippet for rec_list_show */
int rec_list_show(void handle, rec_list_t *list_ptr)
rec_list_t *ptr;
sz = sizeof (rec_list_t) +
((record_count - 1) * sizeof (rec_list_data_t));
ptr = malloc(sz);
/* fill the data */
*list_ptr = ptr;
return (0);
So I need to wrap rec_list_show() in JNI call so I can have Java call
it. How do i pass a pointer to a pointer from Java? I tried in the
native C code for JNI to return the pointer to pointer as a result
and store in a member in the Java class rec_list_t and then I pass
that to JNI call for rec_list_show. The C backend code was fine
since it got the pointer to pointer but Java become unhappy when
the object it was referencing changed memory location (I suspect
the garbage collection becomes unhappy).
So what would be a good way to deal with this kind of code?
Thanks,
Sunay
Edited by: st9 on Aug 30, 2010 5:47 PM

Answer 1

I did not imply that you don't know C but you are implying that I don't understand C. Perhaps
google Sunay Tripathi and click I am feeling lucky so that we don't get into teaching C
discussions :) On the other hand, I am definitely looking for someone to teach me Java
otherwise I wouldn't be asking.
Anyway, let me explain again. The sample function rec_list_show() runs on the backend. It
is a different process with a different VM space. It of course knows the size of the array
and what to fill in. As a caller to that API (which is a separate process), I don't know
what that size is but I need to get the size and corresponding data in one shot because
the backend locks the table when its providing me the info to make sure its synchronous.
Now I (the Java process) needs to get that count and data in one shot. Since the C library
underneath me (wrapped around my JNI interface) has private IPC mechanism to copy
the contiguous memory from the backend into my memory space, all I need is to provide
a pointer to a pointer which gets filled in by backend and is available to my process. So
my equivalent C frontend just passes a pointer to a pointer and casts the return value in
rec_list_t. The rec_list_cnt tells it how many members it got. The first member is part of
the struct itself but then following members are right after.
Another way to help you understand this is with this code snippet from front end C program
rec_list_t     *ptr, *save_ptr;
rec_list_data_t *data_ptr;
int          cnt;
save_ptr = ptr = malloc(sizeof(rec_list_t));
rec_list_show(handle, &ptr);
assert(save_ptr != ptr);
cnt = ptr->rec_list_cnt;
for (i = 0; i < cnt; i++) {
     data_ptr = &ptr->rec_list_data;
Notice the assert(). Also notice the for loop. How do I expect to walk more that one
member when rec_list_data is a fixed size array of one member?typedef struct rec_list_s {
     int               rec_list_cnt;
     rec_list_data_t          rec_list_data[1];
} rec_list_t;
Anyway, I do understand that Java will not allow me to get a reference to a long and
how Java memory management works. But the JNI native implementation is C
and I was wondering if people have managed to do some tricks there between C
and Java.