如何访问 ctypes.LP_c_char 指针的值？

Question

I have defined a struct :

class FILE_HANDLE(Structure):
_fields_ = [
    ("handle_bytes", c_uint),
    ("handle_type", c_int),
    ("f_handle", POINTER(c_char))
]

The struct is initialised :

buf = create_string_buffer(f_handle.handle_bytes)
fh = FILE_HANDLE(c_uint(8), c_int(0), buf)

I am passing it by reference to a function that populates it.

ret = libc.name_to_handle_at(dirfd, pathname, byref(fh), byref(mount_id), flags)

I can check with strace that the call works, but I have not been able to figure out how to access the value of fh.f_handle

fh.f_handle type is <ctypes.LP_c_char object at 0x7f1a7ca17560>
fh.f_handle.contents type is <ctypes.LP_c_char object at 0x7f1a7ca17560> but I get a SIGSEGV if I try to access its value.
How could I get 8 bytes from f_handle into a string or array ?

Answer 1

Everything actually looks right for what you've shown, but without seeing the explicit C definition of the structure and function you are calling it is difficult to see the problem.

Here's an example that works with what you have shown. I inferred what the C definitions should be from what you have declared in Python, but most likely your definition is different if you get a segfault.

C Code (Windows)

struct FILE_HANDLE
{
    unsigned int handle_bytes;
    int handle_type;
    char* f_handle;
};

__declspec(dllexport) int name_to_handle_at(int dirfd, char* pathname, struct FILE_HANDLE* fh, int* mount_id, int flags)
{
    unsigned int i;
    printf("dirfd=%d pathname=%s fh->handle_bytes=%u fh->handle_type=%d flags=%d\n", dirfd, pathname, fh->handle_bytes, fh->handle_type, flags);
    for(i = 0; i < fh->handle_bytes; ++i)
        fh->f_handle[i] = 'A' + i;
    *mount_id = 123;
    return 1;
}

Python code (Works in Python 2 and 3):

from __future__ import print_function
from ctypes import *

class FILE_HANDLE(Structure):
    _fields_ = [("handle_bytes", c_uint),
                ("handle_type", c_int),
                ("f_handle", POINTER(c_char))]

buf = create_string_buffer(8);
fh = FILE_HANDLE(8,0,buf)
libc = CDLL('test.dll')
mount_id = c_int(0)
ret = libc.name_to_handle_at(1,b'abc',byref(fh),byref(mount_id),7)
print('mount_id =',mount_id.value)
print('fh.f_handle =',fh.f_handle[:fh.handle_bytes])

Output

dirfd=1 pathname=abc fh->handle_bytes=8 fh->handle_type=0 flags=7
mount_id = 123
fh.f_handle = b'ABCDEFGH'

Note that since the structure is declared as a pointer to a single character, printing fh.f_handle.contents would only print b'A' . Using slicing, I've instructed Python to index the pointer up to the length allocated.

If this doesn't work for you, provide a Minimal, Complete, and Verifiable example (as I have) to reproduce your error exactly.

Answer 2

fh.f_handle is shown as LP_c_char because you defined the struct that way.

buf = create_string_buffer(8)
print type(buf)
fh = FILE_HANDLE(c_uint(8), c_int(0), buf)
print type(fh.f_handle)

Will output

<class 'ctypes.c_char_Array_8'>
<class 'ctypes.LP_c_char'>

You have defined your struct to accept a pointer to a c_char. So when you try to access fh.f_handle it will expect the value to be a memory address containing the address to the actual single c_char.

But by trying to input a c_char * 8 from the string buffer it will convert the first part of your buffer to a pointer.

Python tries to dereference your char[0] which means that it will look for a memory address with the value of the character you have defined in char[0]. That memory address is not valid, so your interpreter will signal a SIGSEGV.

Now to create a class which properly handles a variable length buffer is quite difficult. An easier option is to pass the buffer as an opaque handle, to access it afterwards you need to cast it back to a char array.

Example:

class FILE_HANDLE(Structure):
    _fields_ = [
            ("handle_bytes", c_uint),
            ("handle_type", c_int),
            ("f_handle", c_void_p)
        ]

buf = create_string_buffer(8)
buf = cast(buf, c_void_p)
fh = FILE_HANDLE(c_uint(8), c_int(0), buf)
f_handle_value = (c_char * fh.handle_bytes).from_address(fh.f_handle)