Question

I’m using a 3rd party C library that defines an opaque type:

    foo_t

And uses pointers to this type in its functions:

    void foo_init(foo_t *foo);

Typical usage would be allocating a foo_t on the stack and passing a reference:

  {
    foo_t foo;

    foo_init(&foo);
    ...
  }

How do I call foo_init() with ctypes without knowing what constitutes a foo_t?

I think if I knew sizeof(foo_t) I could create a buffer of that size and cast, but is it possible to get the size with ctypes?

I could write a one-liner C program:

    printf("sizeof(foo_t) = %zu\n", sizeof(foo_t));

and hard-code that value into my python, but that would get ugly in a hurry: I’d have to touch my python source with every upgrade to the library.

A slightly cleaner way would be to write a python c-ext to export the size value, but that too would require a recompile with every library upgrade.

Does anyone have a recipe for using ctypes with such opaque types?

Answer 1

I think this is the simplest solution…

Create a C file, say, foosizes.c:

    size_t SIZEOF_FOO = sizeof(foo_t);

And compile it into a shared object, foosizes.so. Then in a python script:

    from ctypes import *
    foosizeslib = CDLL('foosizes.so')
    sizeof_foo = c_ulong.in_dll(foosizeslib, 'SIZEOF_FOO')

I can then create a buffer of the appropriate size and pass it to functions, by reference, as a pointer to the opaque type. So far, so good.