提供char *作为c_char_p的Python 2.7 ctypes接口DLL导致异常

Question

i got a Dll where i have exported following function:

extern "C" __declspec(dllexport) uint32_t  __stdcall init(Param* InitParameter);


 extern "C" __declspec(dllexport) uint32_t  __stdcall init(Param* InitParameter)
    {  

      std::cerr << "Output test! " << std::endl;   
      std::string xy(InitParameter->log_filename);
      std::cerr  << xy << std::endl;
    ...
    }

Param is a struct looking like this: (Variable names are modified)

typedef struct {
 int64_t a;
 int64_t b;
 int64_t c;
 int64_t d;
 uint32_t aa;
 uint32_t bb;
 uint32_t cc;
 uint16_t aaa;
 uint16_t bbb;
 uint8_t  aaaa;
 bool     Switch1
 bool     Switch2
 char*    LogFileName
}Param;

I use this dll within python by ctypes. I created a class to cover the Param structure.

class Param(ctypes.Structure):
    _fields_ = [            
            ("a",         ctypes.c_int64),
            ("b",         ctypes.c_int64),
            ("c",         ctypes.c_int64),
            ("d",         ctypes.c_int64),
            ("aa",        ctypes.c_uint32),
            ("bb",        ctypes.c_uint32),
            ("cc",        ctypes.c_uint32),
            ("aaa",       ctypes.c_uint16),
            ("bbb",       ctypes.c_uint16),                    
            ("aaaa",      ctypes.c_uint8),
            ("Switch1",   ctypes.c_bool),
            ("Switch2",   ctypes.c_bool),
            ("LogFileName", ctypes.c_char_p) 
            ]

Next i have created a class to cover the DLL and its function:

class MyDLL():   
    def __init__(self): #Constructor
        self.dll = ctypes.WinDLL('MyDll.dll')
        self.pf_init = self.dll['init']
        self.pf_init.restype = ctypes.c_uint32
        self.pf_init.argtypes = [ctypes.POINTER(Param)]

   def init(self, parameter_object):
        self.parameter = parameter_object
        try:
            self.pf_init(self.parameter)
            print "It works!"
        except WindowsError as e:
            print "Windows Error({0}): {1}".format(e.errno, e.message)

This is an example how I use the init function of the DLL. First a create an instance of Param, and put in some values. The problematic value - i will come later to that point - is the parameter LogFileName.

parameter = Param()
parameter.a = 0
parameter.b = 0
...
parameter.LogFileName = 'IAmGoingNuts'

Next i create an instance of the DLL and call the function.

mylittleDLL = MyDLL()
mylittleDLL.init(parameter)

The problem is, because of the LogFileName the function call is giving me an exception because of access violation. When i remove the logfile from the structure in C++ and Python, the problem is gone.

Here the exception:

Windows Error(None): exception: access violation reading 0xC54D7C00

If i modify python and c++ code and remove the LogFileName from both, it works fine.

Somehow it does not matter if i give the LogFilename by singlequotes or doublequotes or putting a 'b' in front of it like: b"SomeFileName"

I have experimented by providing the logfilename as ctypes.by_ref (which won't work for sure). I have tried ctypes.create_string_buffer(b"filename") in different variations. Recreated examples from stackoverflow and codeproject.com.. however.. i am stuck.

I am quite sure I am doing a very silly mistake, but i do not get the hang of it where it is. I just want to provide a filename from python to the dll.. that is actually all I want.

Any help is highly welcomed and appreciated!

Best regards, Tobias

UPDATE

With the help of eryksun, i have found different offsets of the location of LogFileName in the class in Python (52Bytes) and in the struct in C (51Bytes). I have also found some #pramga pack(push, 1) which sets the packaging to one byte. I have removed the pragma for testing purpose, but still the offsets are different (the same as before) and for sure the exception still happens.. I have checked once more for having the same structure in python class as well as in the c struct and also verified the datatypes.. All is fine. It might happen because of some compiler optimization.... at least i will give a try by disabling optimization.

2nd UPDATE

Even with disabled pragma pack directives and disabled optimization it comes to different offsets in python (52Bytes) and C++(51Bytes) in the Param structure. Well.. at least I could do some pointer arithmetic, but actually I want to avoid this... How can i ensure same offsets? In CTypes as well in C++ I am using std. data-types like uint32_t. I ordered the data by size in the struct (Except char* it is a 4Bytes type i quess). I will reorder the LogFileName poniter just to check for any differences and put the results here.. maybe this does the trick..

3rd UPDATE -> Solution!

The problem has been the location of the char* (Pointer 4Byte Type) in the structure! I have changed the structure as follows (here Python, but the same is done in C++):

class Param(ctypes.Structure):
    _fields_ = [            
            ("a",         ctypes.c_int64),
            ("b",         ctypes.c_int64),
            ("c",         ctypes.c_int64),
            ("d",         ctypes.c_int64),
            ("LogFileName", ctypes.c_char_p),
            ("aa",        ctypes.c_uint32),
            ("bb",        ctypes.c_uint32),
            ("cc",        ctypes.c_uint32),
            ("aaa",       ctypes.c_uint16),
            ("bbb",       ctypes.c_uint16),                    
            ("aaaa",      ctypes.c_uint8),
            ("Switch1",   ctypes.c_bool),
            ("Switch2",   ctypes.c_bool)
            ]

Thus i have put the 4Byte Type directly after the 8Byte Types int64_t . So the char* is directly on a 4Byte and 8Byte boarder (Byte allignment).

My wild guess: In the former struct/class, the char* LogFileName has been the last element and i suspect 1 byte padding for the uint8_t type of "aaaa" thus it has been 51Bytes in C++ and 52Bytes in Python.

Last update on this: I have found one more pragma pack(push,1) , this could also have caused the missing byte padding on the C++ side because of the order of the elements in the c struct Param.

After this change char* LogFileName has offset of 32Bytes both in C++ and Python.

Thank you soo much eryksun!!!

Answer 1

The problem has been the location of the char* (Pointer 4Byte Type) in the structure! I have changed the structure as follows (here Python, but the same is done in C++):

class Param(ctypes.Structure):
    _fields_ = [            
            ("a",         ctypes.c_int64),
            ("b",         ctypes.c_int64),
            ("c",         ctypes.c_int64),
            ("d",         ctypes.c_int64),
            ("LogFileName", ctypes.c_char_p),
            ("aa",        ctypes.c_uint32),
            ("bb",        ctypes.c_uint32),
            ("cc",        ctypes.c_uint32),
            ("aaa",       ctypes.c_uint16),
            ("bbb",       ctypes.c_uint16),                    
            ("aaaa",      ctypes.c_uint8),
            ("Switch1",   ctypes.c_bool),
            ("Switch2",   ctypes.c_bool)
            ]

Thus i have put the 4Byte Type directly after the 8Byte Types int64_t . So the char* is directly on a 4Byte and 8Byte boarder (Byte allignment).

My wild guess: In the former struct/class, the char* LogFileName has been the last element and i suspect 1 byte padding for the uint8_t type of "aaaa" thus it has been 51Bytes in C++ and 52Bytes in Python.

Last update on this: I have found one more pragma pack(push,1) , this could also have caused the missing byte padding on the C++ side because of the order of the elements in the c struct Param .

After this change char* LogFileName has offset of 32Bytes both in C++ and Python.

Thank you soo much eryksun!!!