• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*****************************************************************
2   This file contains remnant Python 2.3 compatibility code that is no longer
3   strictly required.
4  *****************************************************************/
5 
6 
7 /*
8  * History: First version dated from 3/97, derived from my SCMLIB version
9  * for win16.
10  */
11 /*
12  * Related Work:
13  *      - calldll       http://www.nightmare.com/software.html
14  *      - libffi        http://sourceware.cygnus.com/libffi/
15  *      - ffcall        http://clisp.cons.org/~haible/packages-ffcall.html
16  *   and, of course, Don Beaudry's MESS package, but this is more ctypes
17  *   related.
18  */
19 
20 
21 /*
22   How are functions called, and how are parameters converted to C ?
23 
24   1. _ctypes.c::PyCFuncPtr_call receives an argument tuple 'inargs' and a
25   keyword dictionary 'kwds'.
26 
27   2. After several checks, _build_callargs() is called which returns another
28   tuple 'callargs'.  This may be the same tuple as 'inargs', a slice of
29   'inargs', or a completely fresh tuple, depending on several things (is it a
30   COM method?, are 'paramflags' available?).
31 
32   3. _build_callargs also calculates bitarrays containing indexes into
33   the callargs tuple, specifying how to build the return value(s) of
34   the function.
35 
36   4. _ctypes_callproc is then called with the 'callargs' tuple.  _ctypes_callproc first
37   allocates two arrays.  The first is an array of 'struct argument' items, the
38   second array has 'void *' entries.
39 
40   5. If 'converters' are present (converters is a sequence of argtypes'
41   from_param methods), for each item in 'callargs' converter is called and the
42   result passed to ConvParam.  If 'converters' are not present, each argument
43   is directly passed to ConvParm.
44 
45   6. For each arg, ConvParam stores the contained C data (or a pointer to it,
46   for structures) into the 'struct argument' array.
47 
48   7. Finally, a loop fills the 'void *' array so that each item points to the
49   data contained in or pointed to by the 'struct argument' array.
50 
51   8. The 'void *' argument array is what _call_function_pointer
52   expects. _call_function_pointer then has very little to do - only some
53   libffi specific stuff, then it calls ffi_call.
54 
55   So, there are 4 data structures holding processed arguments:
56   - the inargs tuple (in PyCFuncPtr_call)
57   - the callargs tuple (in PyCFuncPtr_call)
58   - the 'struct arguments' array
59   - the 'void *' array
60 
61  */
62 
63 #include "Python.h"
64 #include "structmember.h"
65 
66 #ifdef MS_WIN32
67 #include <windows.h>
68 #include <tchar.h>
69 #else
70 #include "ctypes_dlfcn.h"
71 #endif
72 
73 #ifdef MS_WIN32
74 #include <malloc.h>
75 #endif
76 
77 #include <ffi.h>
78 #include "ctypes.h"
79 #ifdef HAVE_ALLOCA_H
80 /* AIX needs alloca.h for alloca() */
81 #include <alloca.h>
82 #endif
83 
84 #if defined(_DEBUG) || defined(__MINGW32__)
85 /* Don't use structured exception handling on Windows if this is defined.
86    MingW, AFAIK, doesn't support it.
87 */
88 #define DONT_USE_SEH
89 #endif
90 
91 
92 #define CTYPES_CAPSULE_ERROROBJ "_ctypes/callproc.c error object"
93 CTYPES_CAPSULE_INSTANTIATE_DESTRUCTOR(CTYPES_CAPSULE_ERROROBJ)
94 
95 #if defined(CTYPES_UNICODE) && !defined(HAVE_USABLE_WCHAR_T)
96 #  define CTYPES_CAPSULE_WCHAR_T "_ctypes/callproc.c wchar_t buffer from unicode"
CTYPES_CAPSULE_INSTANTIATE_DESTRUCTOR(CTYPES_CAPSULE_WCHAR_T)97 CTYPES_CAPSULE_INSTANTIATE_DESTRUCTOR(CTYPES_CAPSULE_WCHAR_T)
98 #endif
99 
100 /*
101   ctypes maintains thread-local storage that has space for two error numbers:
102   private copies of the system 'errno' value and, on Windows, the system error code
103   accessed by the GetLastError() and SetLastError() api functions.
104 
105   Foreign functions created with CDLL(..., use_errno=True), when called, swap
106   the system 'errno' value with the private copy just before the actual
107   function call, and swapped again immediately afterwards.  The 'use_errno'
108   parameter defaults to False, in this case 'ctypes_errno' is not touched.
109 
110   On Windows, foreign functions created with CDLL(..., use_last_error=True) or
111   WinDLL(..., use_last_error=True) swap the system LastError value with the
112   ctypes private copy.
113 
114   The values are also swapped immeditately before and after ctypes callback
115   functions are called, if the callbacks are constructed using the new
116   optional use_errno parameter set to True: CFUNCTYPE(..., use_errno=TRUE) or
117   WINFUNCTYPE(..., use_errno=True).
118 
119   New ctypes functions are provided to access the ctypes private copies from
120   Python:
121 
122   - ctypes.set_errno(value) and ctypes.set_last_error(value) store 'value' in
123     the private copy and returns the previous value.
124 
125   - ctypes.get_errno() and ctypes.get_last_error() returns the current ctypes
126     private copies value.
127 */
128 
129 /*
130   This function creates and returns a thread-local Python object that has
131   space to store two integer error numbers; once created the Python object is
132   kept alive in the thread state dictionary as long as the thread itself.
133 */
134 PyObject *
135 _ctypes_get_errobj(int **pspace)
136 {
137     PyObject *dict = PyThreadState_GetDict();
138     PyObject *errobj;
139     static PyObject *error_object_name;
140     if (dict == 0) {
141         PyErr_SetString(PyExc_RuntimeError,
142                         "cannot get thread state");
143         return NULL;
144     }
145     if (error_object_name == NULL) {
146         error_object_name = PyString_InternFromString("ctypes.error_object");
147         if (error_object_name == NULL)
148             return NULL;
149     }
150     errobj = PyDict_GetItem(dict, error_object_name);
151     if (errobj) {
152 #ifdef CTYPES_USING_CAPSULE
153         if (!PyCapsule_IsValid(errobj, CTYPES_CAPSULE_ERROROBJ)) {
154             PyErr_SetString(PyExc_RuntimeError,
155                 "ctypes.error_object is an invalid capsule");
156             return NULL;
157         }
158 #endif /* CTYPES_USING_CAPSULE */
159         Py_INCREF(errobj);
160     }
161     else {
162         void *space = PyMem_Malloc(sizeof(int) * 2);
163         if (space == NULL)
164             return NULL;
165         memset(space, 0, sizeof(int) * 2);
166         errobj = CAPSULE_NEW(space, CTYPES_CAPSULE_ERROROBJ);
167         if (errobj == NULL) {
168             PyMem_Free(space);
169             return NULL;
170         }
171         if (-1 == PyDict_SetItem(dict, error_object_name,
172                                  errobj)) {
173             Py_DECREF(errobj);
174             return NULL;
175         }
176     }
177     *pspace = (int *)CAPSULE_DEREFERENCE(errobj, CTYPES_CAPSULE_ERROROBJ);
178     return errobj;
179 }
180 
181 static PyObject *
get_error_internal(PyObject * self,PyObject * args,int index)182 get_error_internal(PyObject *self, PyObject *args, int index)
183 {
184     int *space;
185     PyObject *errobj = _ctypes_get_errobj(&space);
186     PyObject *result;
187 
188     if (errobj == NULL)
189         return NULL;
190     result = PyInt_FromLong(space[index]);
191     Py_DECREF(errobj);
192     return result;
193 }
194 
195 static PyObject *
set_error_internal(PyObject * self,PyObject * args,int index)196 set_error_internal(PyObject *self, PyObject *args, int index)
197 {
198     int new_errno, old_errno;
199     PyObject *errobj;
200     int *space;
201 
202     if (!PyArg_ParseTuple(args, "i", &new_errno))
203         return NULL;
204     errobj = _ctypes_get_errobj(&space);
205     if (errobj == NULL)
206         return NULL;
207     old_errno = space[index];
208     space[index] = new_errno;
209     Py_DECREF(errobj);
210     return PyInt_FromLong(old_errno);
211 }
212 
213 static PyObject *
get_errno(PyObject * self,PyObject * args)214 get_errno(PyObject *self, PyObject *args)
215 {
216     return get_error_internal(self, args, 0);
217 }
218 
219 static PyObject *
set_errno(PyObject * self,PyObject * args)220 set_errno(PyObject *self, PyObject *args)
221 {
222     return set_error_internal(self, args, 0);
223 }
224 
225 #ifdef MS_WIN32
226 
227 static PyObject *
get_last_error(PyObject * self,PyObject * args)228 get_last_error(PyObject *self, PyObject *args)
229 {
230     return get_error_internal(self, args, 1);
231 }
232 
233 static PyObject *
set_last_error(PyObject * self,PyObject * args)234 set_last_error(PyObject *self, PyObject *args)
235 {
236     return set_error_internal(self, args, 1);
237 }
238 
239 PyObject *ComError;
240 
FormatError(DWORD code)241 static TCHAR *FormatError(DWORD code)
242 {
243     TCHAR *lpMsgBuf;
244     DWORD n;
245     n = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
246                       NULL,
247                       code,
248                       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */
249               (LPTSTR) &lpMsgBuf,
250               0,
251               NULL);
252     if (n) {
253         while (_istspace(lpMsgBuf[n-1]))
254             --n;
255         lpMsgBuf[n] = _T('\0'); /* rstrip() */
256     }
257     return lpMsgBuf;
258 }
259 
260 #ifndef DONT_USE_SEH
SetException(DWORD code,EXCEPTION_RECORD * pr)261 static void SetException(DWORD code, EXCEPTION_RECORD *pr)
262 {
263     /* The 'code' is a normal win32 error code so it could be handled by
264     PyErr_SetFromWindowsErr(). However, for some errors, we have additional
265     information not included in the error code. We handle those here and
266     delegate all others to the generic function. */
267     switch (code) {
268     case EXCEPTION_ACCESS_VIOLATION:
269         /* The thread attempted to read from or write
270            to a virtual address for which it does not
271            have the appropriate access. */
272         if (pr->ExceptionInformation[0] == 0)
273             PyErr_Format(PyExc_WindowsError,
274                          "exception: access violation reading %p",
275                          pr->ExceptionInformation[1]);
276         else
277             PyErr_Format(PyExc_WindowsError,
278                          "exception: access violation writing %p",
279                          pr->ExceptionInformation[1]);
280         break;
281 
282     case EXCEPTION_BREAKPOINT:
283         /* A breakpoint was encountered. */
284         PyErr_SetString(PyExc_WindowsError,
285                         "exception: breakpoint encountered");
286         break;
287 
288     case EXCEPTION_DATATYPE_MISALIGNMENT:
289         /* The thread attempted to read or write data that is
290            misaligned on hardware that does not provide
291            alignment. For example, 16-bit values must be
292            aligned on 2-byte boundaries, 32-bit values on
293            4-byte boundaries, and so on. */
294         PyErr_SetString(PyExc_WindowsError,
295                         "exception: datatype misalignment");
296         break;
297 
298     case EXCEPTION_SINGLE_STEP:
299         /* A trace trap or other single-instruction mechanism
300            signaled that one instruction has been executed. */
301         PyErr_SetString(PyExc_WindowsError,
302                         "exception: single step");
303         break;
304 
305     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
306         /* The thread attempted to access an array element
307            that is out of bounds, and the underlying hardware
308            supports bounds checking. */
309         PyErr_SetString(PyExc_WindowsError,
310                         "exception: array bounds exceeded");
311         break;
312 
313     case EXCEPTION_FLT_DENORMAL_OPERAND:
314         /* One of the operands in a floating-point operation
315            is denormal. A denormal value is one that is too
316            small to represent as a standard floating-point
317            value. */
318         PyErr_SetString(PyExc_WindowsError,
319                         "exception: floating-point operand denormal");
320         break;
321 
322     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
323         /* The thread attempted to divide a floating-point
324            value by a floating-point divisor of zero. */
325         PyErr_SetString(PyExc_WindowsError,
326                         "exception: float divide by zero");
327         break;
328 
329     case EXCEPTION_FLT_INEXACT_RESULT:
330         /* The result of a floating-point operation cannot be
331            represented exactly as a decimal fraction. */
332         PyErr_SetString(PyExc_WindowsError,
333                         "exception: float inexact");
334         break;
335 
336     case EXCEPTION_FLT_INVALID_OPERATION:
337         /* This exception represents any floating-point
338            exception not included in this list. */
339         PyErr_SetString(PyExc_WindowsError,
340                         "exception: float invalid operation");
341         break;
342 
343     case EXCEPTION_FLT_OVERFLOW:
344         /* The exponent of a floating-point operation is
345            greater than the magnitude allowed by the
346            corresponding type. */
347         PyErr_SetString(PyExc_WindowsError,
348                         "exception: float overflow");
349         break;
350 
351     case EXCEPTION_FLT_STACK_CHECK:
352         /* The stack overflowed or underflowed as the result
353            of a floating-point operation. */
354         PyErr_SetString(PyExc_WindowsError,
355                         "exception: stack over/underflow");
356         break;
357 
358     case EXCEPTION_STACK_OVERFLOW:
359         /* The stack overflowed or underflowed as the result
360            of a floating-point operation. */
361         PyErr_SetString(PyExc_WindowsError,
362                         "exception: stack overflow");
363         break;
364 
365     case EXCEPTION_FLT_UNDERFLOW:
366         /* The exponent of a floating-point operation is less
367            than the magnitude allowed by the corresponding
368            type. */
369         PyErr_SetString(PyExc_WindowsError,
370                         "exception: float underflow");
371         break;
372 
373     case EXCEPTION_INT_DIVIDE_BY_ZERO:
374         /* The thread attempted to divide an integer value by
375            an integer divisor of zero. */
376         PyErr_SetString(PyExc_WindowsError,
377                         "exception: integer divide by zero");
378         break;
379 
380     case EXCEPTION_INT_OVERFLOW:
381         /* The result of an integer operation caused a carry
382            out of the most significant bit of the result. */
383         PyErr_SetString(PyExc_WindowsError,
384                         "exception: integer overflow");
385         break;
386 
387     case EXCEPTION_PRIV_INSTRUCTION:
388         /* The thread attempted to execute an instruction
389            whose operation is not allowed in the current
390            machine mode. */
391         PyErr_SetString(PyExc_WindowsError,
392                         "exception: priviledged instruction");
393         break;
394 
395     case EXCEPTION_NONCONTINUABLE_EXCEPTION:
396         /* The thread attempted to continue execution after a
397            noncontinuable exception occurred. */
398         PyErr_SetString(PyExc_WindowsError,
399                         "exception: nocontinuable");
400         break;
401 
402     default:
403         PyErr_SetFromWindowsErr(code);
404         break;
405     }
406 }
407 
HandleException(EXCEPTION_POINTERS * ptrs,DWORD * pdw,EXCEPTION_RECORD * record)408 static DWORD HandleException(EXCEPTION_POINTERS *ptrs,
409                              DWORD *pdw, EXCEPTION_RECORD *record)
410 {
411     *pdw = ptrs->ExceptionRecord->ExceptionCode;
412     *record = *ptrs->ExceptionRecord;
413     /* We don't want to catch breakpoint exceptions, they are used to attach
414      * a debugger to the process.
415      */
416     if (*pdw == EXCEPTION_BREAKPOINT)
417         return EXCEPTION_CONTINUE_SEARCH;
418     return EXCEPTION_EXECUTE_HANDLER;
419 }
420 #endif
421 
422 static PyObject *
check_hresult(PyObject * self,PyObject * args)423 check_hresult(PyObject *self, PyObject *args)
424 {
425     HRESULT hr;
426     if (!PyArg_ParseTuple(args, "i", &hr))
427         return NULL;
428     if (FAILED(hr))
429         return PyErr_SetFromWindowsErr(hr);
430     return PyInt_FromLong(hr);
431 }
432 
433 #endif
434 
435 /**************************************************************/
436 
437 PyCArgObject *
PyCArgObject_new(void)438 PyCArgObject_new(void)
439 {
440     PyCArgObject *p;
441     p = PyObject_New(PyCArgObject, &PyCArg_Type);
442     if (p == NULL)
443         return NULL;
444     p->pffi_type = NULL;
445     p->tag = '\0';
446     p->obj = NULL;
447     memset(&p->value, 0, sizeof(p->value));
448     return p;
449 }
450 
451 static void
PyCArg_dealloc(PyCArgObject * self)452 PyCArg_dealloc(PyCArgObject *self)
453 {
454     Py_XDECREF(self->obj);
455     PyObject_Del(self);
456 }
457 
458 static PyObject *
PyCArg_repr(PyCArgObject * self)459 PyCArg_repr(PyCArgObject *self)
460 {
461     char buffer[256];
462     switch(self->tag) {
463     case 'b':
464     case 'B':
465         sprintf(buffer, "<cparam '%c' (%d)>",
466             self->tag, self->value.b);
467         break;
468     case 'h':
469     case 'H':
470         sprintf(buffer, "<cparam '%c' (%d)>",
471             self->tag, self->value.h);
472         break;
473     case 'i':
474     case 'I':
475         sprintf(buffer, "<cparam '%c' (%d)>",
476             self->tag, self->value.i);
477         break;
478     case 'l':
479     case 'L':
480         sprintf(buffer, "<cparam '%c' (%ld)>",
481             self->tag, self->value.l);
482         break;
483 
484 #ifdef HAVE_LONG_LONG
485     case 'q':
486     case 'Q':
487         sprintf(buffer,
488 #ifdef MS_WIN32
489             "<cparam '%c' (%I64d)>",
490 #else
491             "<cparam '%c' (%qd)>",
492 #endif
493             self->tag, self->value.q);
494         break;
495 #endif
496     case 'd':
497         sprintf(buffer, "<cparam '%c' (%f)>",
498             self->tag, self->value.d);
499         break;
500     case 'f':
501         sprintf(buffer, "<cparam '%c' (%f)>",
502             self->tag, self->value.f);
503         break;
504 
505     case 'c':
506         sprintf(buffer, "<cparam '%c' (%c)>",
507             self->tag, self->value.c);
508         break;
509 
510 /* Hm, are these 'z' and 'Z' codes useful at all?
511    Shouldn't they be replaced by the functionality of c_string
512    and c_wstring ?
513 */
514     case 'z':
515     case 'Z':
516     case 'P':
517         sprintf(buffer, "<cparam '%c' (%p)>",
518             self->tag, self->value.p);
519         break;
520 
521     default:
522         sprintf(buffer, "<cparam '%c' at %p>",
523             self->tag, self);
524         break;
525     }
526     return PyString_FromString(buffer);
527 }
528 
529 static PyMemberDef PyCArgType_members[] = {
530     { "_obj", T_OBJECT,
531       offsetof(PyCArgObject, obj), READONLY,
532       "the wrapped object" },
533     { NULL },
534 };
535 
536 PyTypeObject PyCArg_Type = {
537     PyVarObject_HEAD_INIT(NULL, 0)
538     "CArgObject",
539     sizeof(PyCArgObject),
540     0,
541     (destructor)PyCArg_dealloc,                 /* tp_dealloc */
542     0,                                          /* tp_print */
543     0,                                          /* tp_getattr */
544     0,                                          /* tp_setattr */
545     0,                                          /* tp_compare */
546     (reprfunc)PyCArg_repr,                      /* tp_repr */
547     0,                                          /* tp_as_number */
548     0,                                          /* tp_as_sequence */
549     0,                                          /* tp_as_mapping */
550     0,                                          /* tp_hash */
551     0,                                          /* tp_call */
552     0,                                          /* tp_str */
553     0,                                          /* tp_getattro */
554     0,                                          /* tp_setattro */
555     0,                                          /* tp_as_buffer */
556     Py_TPFLAGS_DEFAULT,                         /* tp_flags */
557     0,                                          /* tp_doc */
558     0,                                          /* tp_traverse */
559     0,                                          /* tp_clear */
560     0,                                          /* tp_richcompare */
561     0,                                          /* tp_weaklistoffset */
562     0,                                          /* tp_iter */
563     0,                                          /* tp_iternext */
564     0,                                          /* tp_methods */
565     PyCArgType_members,                         /* tp_members */
566 };
567 
568 /****************************************************************/
569 /*
570  * Convert a PyObject * into a parameter suitable to pass to an
571  * C function call.
572  *
573  * 1. Python integers are converted to C int and passed by value.
574  *    Py_None is converted to a C NULL pointer.
575  *
576  * 2. 3-tuples are expected to have a format character in the first
577  *    item, which must be 'i', 'f', 'd', 'q', or 'P'.
578  *    The second item will have to be an integer, float, double, long long
579  *    or integer (denoting an address void *), will be converted to the
580  *    corresponding C data type and passed by value.
581  *
582  * 3. Other Python objects are tested for an '_as_parameter_' attribute.
583  *    The value of this attribute must be an integer which will be passed
584  *    by value, or a 2-tuple or 3-tuple which will be used according
585  *    to point 2 above. The third item (if any), is ignored. It is normally
586  *    used to keep the object alive where this parameter refers to.
587  *    XXX This convention is dangerous - you can construct arbitrary tuples
588  *    in Python and pass them. Would it be safer to use a custom container
589  *    datatype instead of a tuple?
590  *
591  * 4. Other Python objects cannot be passed as parameters - an exception is raised.
592  *
593  * 5. ConvParam will store the converted result in a struct containing format
594  *    and value.
595  */
596 
597 union result {
598     char c;
599     char b;
600     short h;
601     int i;
602     long l;
603 #ifdef HAVE_LONG_LONG
604     PY_LONG_LONG q;
605 #endif
606     long double D;
607     double d;
608     float f;
609     void *p;
610 };
611 
612 struct argument {
613     ffi_type *ffi_type;
614     PyObject *keep;
615     union result value;
616 };
617 
618 /*
619  * Convert a single Python object into a PyCArgObject and return it.
620  */
ConvParam(PyObject * obj,Py_ssize_t index,struct argument * pa)621 static int ConvParam(PyObject *obj, Py_ssize_t index, struct argument *pa)
622 {
623     StgDictObject *dict;
624     pa->keep = NULL; /* so we cannot forget it later */
625 
626     dict = PyObject_stgdict(obj);
627     if (dict) {
628         PyCArgObject *carg;
629         assert(dict->paramfunc);
630         /* If it has an stgdict, it is a CDataObject */
631         carg = dict->paramfunc((CDataObject *)obj);
632         pa->ffi_type = carg->pffi_type;
633         memcpy(&pa->value, &carg->value, sizeof(pa->value));
634         pa->keep = (PyObject *)carg;
635         return 0;
636     }
637 
638     if (PyCArg_CheckExact(obj)) {
639         PyCArgObject *carg = (PyCArgObject *)obj;
640         pa->ffi_type = carg->pffi_type;
641         Py_INCREF(obj);
642         pa->keep = obj;
643         memcpy(&pa->value, &carg->value, sizeof(pa->value));
644         return 0;
645     }
646 
647     /* check for None, integer, string or unicode and use directly if successful */
648     if (obj == Py_None) {
649         pa->ffi_type = &ffi_type_pointer;
650         pa->value.p = NULL;
651         return 0;
652     }
653 
654     if (PyInt_Check(obj)) {
655         pa->ffi_type = &ffi_type_sint;
656         pa->value.i = PyInt_AS_LONG(obj);
657         return 0;
658     }
659 
660     if (PyLong_Check(obj)) {
661         pa->ffi_type = &ffi_type_sint;
662         pa->value.i = (long)PyLong_AsUnsignedLong(obj);
663         if (pa->value.i == -1 && PyErr_Occurred()) {
664             PyErr_Clear();
665             pa->value.i = PyLong_AsLong(obj);
666             if (pa->value.i == -1 && PyErr_Occurred()) {
667                 PyErr_SetString(PyExc_OverflowError,
668                                 "long int too long to convert");
669                 return -1;
670             }
671         }
672         return 0;
673     }
674 
675     if (PyString_Check(obj)) {
676         pa->ffi_type = &ffi_type_pointer;
677         pa->value.p = PyString_AS_STRING(obj);
678         Py_INCREF(obj);
679         pa->keep = obj;
680         return 0;
681     }
682 
683 #ifdef CTYPES_UNICODE
684     if (PyUnicode_Check(obj)) {
685 #ifdef HAVE_USABLE_WCHAR_T
686         pa->ffi_type = &ffi_type_pointer;
687         pa->value.p = PyUnicode_AS_UNICODE(obj);
688         Py_INCREF(obj);
689         pa->keep = obj;
690         return 0;
691 #else
692         int size = PyUnicode_GET_SIZE(obj);
693         pa->ffi_type = &ffi_type_pointer;
694         size += 1; /* terminating NUL */
695         size *= sizeof(wchar_t);
696         pa->value.p = PyMem_Malloc(size);
697         if (!pa->value.p) {
698             PyErr_NoMemory();
699             return -1;
700         }
701         memset(pa->value.p, 0, size);
702         pa->keep = CAPSULE_NEW(pa->value.p, CTYPES_CAPSULE_WCHAR_T);
703         if (!pa->keep) {
704             PyMem_Free(pa->value.p);
705             return -1;
706         }
707         if (-1 == PyUnicode_AsWideChar((PyUnicodeObject *)obj,
708                                        pa->value.p, PyUnicode_GET_SIZE(obj)))
709             return -1;
710         return 0;
711 #endif
712     }
713 #endif
714 
715     {
716         PyObject *arg;
717         arg = PyObject_GetAttrString(obj, "_as_parameter_");
718         /* Which types should we exactly allow here?
719            integers are required for using Python classes
720            as parameters (they have to expose the '_as_parameter_'
721            attribute)
722         */
723         if (arg) {
724             int result;
725             result = ConvParam(arg, index, pa);
726             Py_DECREF(arg);
727             return result;
728         }
729         PyErr_Format(PyExc_TypeError,
730                      "Don't know how to convert parameter %d",
731                      Py_SAFE_DOWNCAST(index, Py_ssize_t, int));
732         return -1;
733     }
734 }
735 
736 
_ctypes_get_ffi_type(PyObject * obj)737 ffi_type *_ctypes_get_ffi_type(PyObject *obj)
738 {
739     StgDictObject *dict;
740     if (obj == NULL)
741         return &ffi_type_sint;
742     dict = PyType_stgdict(obj);
743     if (dict == NULL)
744         return &ffi_type_sint;
745 #if defined(MS_WIN32) && !defined(_WIN32_WCE)
746     /* This little trick works correctly with MSVC.
747        It returns small structures in registers
748     */
749     if (dict->ffi_type_pointer.type == FFI_TYPE_STRUCT) {
750         if (dict->ffi_type_pointer.size <= 4)
751             return &ffi_type_sint32;
752         else if (dict->ffi_type_pointer.size <= 8)
753             return &ffi_type_sint64;
754     }
755 #endif
756     return &dict->ffi_type_pointer;
757 }
758 
759 
760 /*
761  * libffi uses:
762  *
763  * ffi_status ffi_prep_cif(ffi_cif *cif, ffi_abi abi,
764  *                         unsigned int nargs,
765  *                         ffi_type *rtype,
766  *                         ffi_type **atypes);
767  *
768  * and then
769  *
770  * void ffi_call(ffi_cif *cif, void *fn, void *rvalue, void **avalues);
771  */
_call_function_pointer(int flags,PPROC pProc,void ** avalues,ffi_type ** atypes,ffi_type * restype,void * resmem,int argcount)772 static int _call_function_pointer(int flags,
773                                   PPROC pProc,
774                                   void **avalues,
775                                   ffi_type **atypes,
776                                   ffi_type *restype,
777                                   void *resmem,
778                                   int argcount)
779 {
780 #ifdef WITH_THREAD
781     PyThreadState *_save = NULL; /* For Py_BLOCK_THREADS and Py_UNBLOCK_THREADS */
782 #endif
783     PyObject *error_object = NULL;
784     int *space;
785     ffi_cif cif;
786     int cc;
787 #ifdef MS_WIN32
788     int delta;
789 #ifndef DONT_USE_SEH
790     DWORD dwExceptionCode = 0;
791     EXCEPTION_RECORD record;
792 #endif
793 #endif
794     /* XXX check before here */
795     if (restype == NULL) {
796         PyErr_SetString(PyExc_RuntimeError,
797                         "No ffi_type for result");
798         return -1;
799     }
800 
801     cc = FFI_DEFAULT_ABI;
802 #if defined(MS_WIN32) && !defined(MS_WIN64) && !defined(_WIN32_WCE)
803     if ((flags & FUNCFLAG_CDECL) == 0)
804         cc = FFI_STDCALL;
805 #endif
806     if (FFI_OK != ffi_prep_cif(&cif,
807                                cc,
808                                argcount,
809                                restype,
810                                atypes)) {
811         PyErr_SetString(PyExc_RuntimeError,
812                         "ffi_prep_cif failed");
813         return -1;
814     }
815 
816     if (flags & (FUNCFLAG_USE_ERRNO | FUNCFLAG_USE_LASTERROR)) {
817         error_object = _ctypes_get_errobj(&space);
818         if (error_object == NULL)
819             return -1;
820     }
821 #ifdef WITH_THREAD
822     if ((flags & FUNCFLAG_PYTHONAPI) == 0)
823         Py_UNBLOCK_THREADS
824 #endif
825     if (flags & FUNCFLAG_USE_ERRNO) {
826         int temp = space[0];
827         space[0] = errno;
828         errno = temp;
829     }
830 #ifdef MS_WIN32
831     if (flags & FUNCFLAG_USE_LASTERROR) {
832         int temp = space[1];
833         space[1] = GetLastError();
834         SetLastError(temp);
835     }
836 #ifndef DONT_USE_SEH
837     __try {
838 #endif
839         delta =
840 #endif
841                 ffi_call(&cif, (void *)pProc, resmem, avalues);
842 #ifdef MS_WIN32
843 #ifndef DONT_USE_SEH
844     }
845     __except (HandleException(GetExceptionInformation(),
846                               &dwExceptionCode, &record)) {
847         ;
848     }
849 #endif
850     if (flags & FUNCFLAG_USE_LASTERROR) {
851         int temp = space[1];
852         space[1] = GetLastError();
853         SetLastError(temp);
854     }
855 #endif
856     if (flags & FUNCFLAG_USE_ERRNO) {
857         int temp = space[0];
858         space[0] = errno;
859         errno = temp;
860     }
861 #ifdef WITH_THREAD
862     if ((flags & FUNCFLAG_PYTHONAPI) == 0)
863         Py_BLOCK_THREADS
864 #endif
865     Py_XDECREF(error_object);
866 #ifdef MS_WIN32
867 #ifndef DONT_USE_SEH
868     if (dwExceptionCode) {
869         SetException(dwExceptionCode, &record);
870         return -1;
871     }
872 #endif
873 #ifdef MS_WIN64
874     if (delta != 0) {
875         PyErr_Format(PyExc_RuntimeError,
876                  "ffi_call failed with code %d",
877                  delta);
878         return -1;
879     }
880 #else
881     if (delta < 0) {
882         if (flags & FUNCFLAG_CDECL)
883             PyErr_Format(PyExc_ValueError,
884                      "Procedure called with not enough "
885                      "arguments (%d bytes missing) "
886                      "or wrong calling convention",
887                      -delta);
888         else
889             PyErr_Format(PyExc_ValueError,
890                      "Procedure probably called with not enough "
891                      "arguments (%d bytes missing)",
892                      -delta);
893         return -1;
894     } else if (delta > 0) {
895         PyErr_Format(PyExc_ValueError,
896                  "Procedure probably called with too many "
897                  "arguments (%d bytes in excess)",
898                  delta);
899         return -1;
900     }
901 #endif
902 #endif
903     if ((flags & FUNCFLAG_PYTHONAPI) && PyErr_Occurred())
904         return -1;
905     return 0;
906 }
907 
908 /*
909  * Convert the C value in result into a Python object, depending on restype.
910  *
911  * - If restype is NULL, return a Python integer.
912  * - If restype is None, return None.
913  * - If restype is a simple ctypes type (c_int, c_void_p), call the type's getfunc,
914  *   pass the result to checker and return the result.
915  * - If restype is another ctypes type, return an instance of that.
916  * - Otherwise, call restype and return the result.
917  */
GetResult(PyObject * restype,void * result,PyObject * checker)918 static PyObject *GetResult(PyObject *restype, void *result, PyObject *checker)
919 {
920     StgDictObject *dict;
921     PyObject *retval, *v;
922 
923     if (restype == NULL)
924         return PyInt_FromLong(*(int *)result);
925 
926     if (restype == Py_None) {
927         Py_INCREF(Py_None);
928         return Py_None;
929     }
930 
931     dict = PyType_stgdict(restype);
932     if (dict == NULL)
933         return PyObject_CallFunction(restype, "i", *(int *)result);
934 
935     if (dict->getfunc && !_ctypes_simple_instance(restype)) {
936         retval = dict->getfunc(result, dict->size);
937         /* If restype is py_object (detected by comparing getfunc with
938            O_get), we have to call Py_DECREF because O_get has already
939            called Py_INCREF.
940         */
941         if (dict->getfunc == _ctypes_get_fielddesc("O")->getfunc) {
942             Py_DECREF(retval);
943         }
944     } else
945         retval = PyCData_FromBaseObj(restype, NULL, 0, result);
946 
947     if (!checker || !retval)
948         return retval;
949 
950     v = PyObject_CallFunctionObjArgs(checker, retval, NULL);
951     if (v == NULL)
952         _ctypes_add_traceback("GetResult", "_ctypes/callproc.c", __LINE__-2);
953     Py_DECREF(retval);
954     return v;
955 }
956 
957 /*
958  * Raise a new exception 'exc_class', adding additional text to the original
959  * exception string.
960  */
_ctypes_extend_error(PyObject * exc_class,char * fmt,...)961 void _ctypes_extend_error(PyObject *exc_class, char *fmt, ...)
962 {
963     va_list vargs;
964     PyObject *tp, *v, *tb, *s, *cls_str, *msg_str;
965 
966     va_start(vargs, fmt);
967     s = PyString_FromFormatV(fmt, vargs);
968     va_end(vargs);
969     if (!s)
970         return;
971 
972     PyErr_Fetch(&tp, &v, &tb);
973     PyErr_NormalizeException(&tp, &v, &tb);
974     cls_str = PyObject_Str(tp);
975     if (cls_str) {
976         PyString_ConcatAndDel(&s, cls_str);
977         PyString_ConcatAndDel(&s, PyString_FromString(": "));
978         if (s == NULL)
979             goto error;
980     } else
981         PyErr_Clear();
982     msg_str = PyObject_Str(v);
983     if (msg_str)
984         PyString_ConcatAndDel(&s, msg_str);
985     else {
986         PyErr_Clear();
987         PyString_ConcatAndDel(&s, PyString_FromString("???"));
988         if (s == NULL)
989             goto error;
990     }
991     PyErr_SetObject(exc_class, s);
992 error:
993     Py_XDECREF(tp);
994     Py_XDECREF(v);
995     Py_XDECREF(tb);
996     Py_XDECREF(s);
997 }
998 
999 
1000 #ifdef MS_WIN32
1001 
1002 static PyObject *
GetComError(HRESULT errcode,GUID * riid,IUnknown * pIunk)1003 GetComError(HRESULT errcode, GUID *riid, IUnknown *pIunk)
1004 {
1005     HRESULT hr;
1006     ISupportErrorInfo *psei = NULL;
1007     IErrorInfo *pei = NULL;
1008     BSTR descr=NULL, helpfile=NULL, source=NULL;
1009     GUID guid;
1010     DWORD helpcontext=0;
1011     LPOLESTR progid;
1012     PyObject *obj;
1013     TCHAR *text;
1014 
1015     /* We absolutely have to release the GIL during COM method calls,
1016        otherwise we may get a deadlock!
1017     */
1018 #ifdef WITH_THREAD
1019     Py_BEGIN_ALLOW_THREADS
1020 #endif
1021 
1022     hr = pIunk->lpVtbl->QueryInterface(pIunk, &IID_ISupportErrorInfo, (void **)&psei);
1023     if (FAILED(hr))
1024         goto failed;
1025 
1026     hr = psei->lpVtbl->InterfaceSupportsErrorInfo(psei, riid);
1027     psei->lpVtbl->Release(psei);
1028     if (FAILED(hr))
1029         goto failed;
1030 
1031     hr = GetErrorInfo(0, &pei);
1032     if (hr != S_OK)
1033         goto failed;
1034 
1035     pei->lpVtbl->GetDescription(pei, &descr);
1036     pei->lpVtbl->GetGUID(pei, &guid);
1037     pei->lpVtbl->GetHelpContext(pei, &helpcontext);
1038     pei->lpVtbl->GetHelpFile(pei, &helpfile);
1039     pei->lpVtbl->GetSource(pei, &source);
1040 
1041     pei->lpVtbl->Release(pei);
1042 
1043   failed:
1044 #ifdef WITH_THREAD
1045     Py_END_ALLOW_THREADS
1046 #endif
1047 
1048     progid = NULL;
1049     ProgIDFromCLSID(&guid, &progid);
1050 
1051     text = FormatError(errcode);
1052     obj = Py_BuildValue(
1053 #ifdef _UNICODE
1054         "iu(uuuiu)",
1055 #else
1056         "is(uuuiu)",
1057 #endif
1058         errcode,
1059         text,
1060         descr, source, helpfile, helpcontext,
1061         progid);
1062     if (obj) {
1063         PyErr_SetObject(ComError, obj);
1064         Py_DECREF(obj);
1065     }
1066     LocalFree(text);
1067 
1068     if (descr)
1069         SysFreeString(descr);
1070     if (helpfile)
1071         SysFreeString(helpfile);
1072     if (source)
1073         SysFreeString(source);
1074 
1075     return NULL;
1076 }
1077 #endif
1078 
1079 /*
1080  * Requirements, must be ensured by the caller:
1081  * - argtuple is tuple of arguments
1082  * - argtypes is either NULL, or a tuple of the same size as argtuple
1083  *
1084  * - XXX various requirements for restype, not yet collected
1085  */
_ctypes_callproc(PPROC pProc,PyObject * argtuple,IUnknown * pIunk,GUID * iid,int flags,PyObject * argtypes,PyObject * restype,PyObject * checker)1086 PyObject *_ctypes_callproc(PPROC pProc,
1087                     PyObject *argtuple,
1088 #ifdef MS_WIN32
1089                     IUnknown *pIunk,
1090                     GUID *iid,
1091 #endif
1092                     int flags,
1093                     PyObject *argtypes, /* misleading name: This is a tuple of
1094                                            methods, not types: the .from_param
1095                                            class methods of the types */
1096             PyObject *restype,
1097             PyObject *checker)
1098 {
1099     Py_ssize_t i, n, argcount, argtype_count;
1100     void *resbuf;
1101     struct argument *args, *pa;
1102     ffi_type **atypes;
1103     ffi_type *rtype;
1104     void **avalues;
1105     PyObject *retval = NULL;
1106 
1107     n = argcount = PyTuple_GET_SIZE(argtuple);
1108 #ifdef MS_WIN32
1109     /* an optional COM object this pointer */
1110     if (pIunk)
1111         ++argcount;
1112 #endif
1113 
1114     args = (struct argument *)alloca(sizeof(struct argument) * argcount);
1115     if (!args) {
1116         PyErr_NoMemory();
1117         return NULL;
1118     }
1119     memset(args, 0, sizeof(struct argument) * argcount);
1120     argtype_count = argtypes ? PyTuple_GET_SIZE(argtypes) : 0;
1121 #ifdef MS_WIN32
1122     if (pIunk) {
1123         args[0].ffi_type = &ffi_type_pointer;
1124         args[0].value.p = pIunk;
1125         pa = &args[1];
1126     } else
1127 #endif
1128         pa = &args[0];
1129 
1130     /* Convert the arguments */
1131     for (i = 0; i < n; ++i, ++pa) {
1132         PyObject *converter;
1133         PyObject *arg;
1134         int err;
1135 
1136         arg = PyTuple_GET_ITEM(argtuple, i);            /* borrowed ref */
1137         /* For cdecl functions, we allow more actual arguments
1138            than the length of the argtypes tuple.
1139            This is checked in _ctypes::PyCFuncPtr_Call
1140         */
1141         if (argtypes && argtype_count > i) {
1142             PyObject *v;
1143             converter = PyTuple_GET_ITEM(argtypes, i);
1144             v = PyObject_CallFunctionObjArgs(converter,
1145                                                arg,
1146                                                NULL);
1147             if (v == NULL) {
1148                 _ctypes_extend_error(PyExc_ArgError, "argument %d: ", i+1);
1149                 goto cleanup;
1150             }
1151 
1152             err = ConvParam(v, i+1, pa);
1153             Py_DECREF(v);
1154             if (-1 == err) {
1155                 _ctypes_extend_error(PyExc_ArgError, "argument %d: ", i+1);
1156                 goto cleanup;
1157             }
1158         } else {
1159             err = ConvParam(arg, i+1, pa);
1160             if (-1 == err) {
1161                 _ctypes_extend_error(PyExc_ArgError, "argument %d: ", i+1);
1162                 goto cleanup; /* leaking ? */
1163             }
1164         }
1165     }
1166 
1167     rtype = _ctypes_get_ffi_type(restype);
1168     resbuf = alloca(max(rtype->size, sizeof(ffi_arg)));
1169 
1170     avalues = (void **)alloca(sizeof(void *) * argcount);
1171     atypes = (ffi_type **)alloca(sizeof(ffi_type *) * argcount);
1172     if (!resbuf || !avalues || !atypes) {
1173         PyErr_NoMemory();
1174         goto cleanup;
1175     }
1176     for (i = 0; i < argcount; ++i) {
1177         atypes[i] = args[i].ffi_type;
1178         if (atypes[i]->type == FFI_TYPE_STRUCT)
1179             avalues[i] = (void *)args[i].value.p;
1180         else
1181             avalues[i] = (void *)&args[i].value;
1182     }
1183 
1184     if (-1 == _call_function_pointer(flags, pProc, avalues, atypes,
1185                                      rtype, resbuf,
1186                                      Py_SAFE_DOWNCAST(argcount,
1187                                                       Py_ssize_t,
1188                                                       int)))
1189         goto cleanup;
1190 
1191 #ifdef WORDS_BIGENDIAN
1192     /* libffi returns the result in a buffer with sizeof(ffi_arg). This
1193        causes problems on big endian machines, since the result buffer
1194        address cannot simply be used as result pointer, instead we must
1195        adjust the pointer value:
1196      */
1197     /*
1198       XXX I should find out and clarify why this is needed at all,
1199       especially why adjusting for ffi_type_float must be avoided on
1200       64-bit platforms.
1201      */
1202     if (rtype->type != FFI_TYPE_FLOAT
1203         && rtype->type != FFI_TYPE_STRUCT
1204         && rtype->size < sizeof(ffi_arg))
1205         resbuf = (char *)resbuf + sizeof(ffi_arg) - rtype->size;
1206 #endif
1207 
1208 #ifdef MS_WIN32
1209     if (iid && pIunk) {
1210         if (*(int *)resbuf & 0x80000000)
1211             retval = GetComError(*(HRESULT *)resbuf, iid, pIunk);
1212         else
1213             retval = PyInt_FromLong(*(int *)resbuf);
1214     } else if (flags & FUNCFLAG_HRESULT) {
1215         if (*(int *)resbuf & 0x80000000)
1216             retval = PyErr_SetFromWindowsErr(*(int *)resbuf);
1217         else
1218             retval = PyInt_FromLong(*(int *)resbuf);
1219     } else
1220 #endif
1221         retval = GetResult(restype, resbuf, checker);
1222   cleanup:
1223     for (i = 0; i < argcount; ++i)
1224         Py_XDECREF(args[i].keep);
1225     return retval;
1226 }
1227 
1228 static int
_parse_voidp(PyObject * obj,void ** address)1229 _parse_voidp(PyObject *obj, void **address)
1230 {
1231     *address = PyLong_AsVoidPtr(obj);
1232     if (*address == NULL)
1233         return 0;
1234     return 1;
1235 }
1236 
1237 #ifdef MS_WIN32
1238 
1239 #ifdef _UNICODE
1240 #  define PYBUILD_TSTR "u"
1241 #else
1242 #  define PYBUILD_TSTR "s"
1243 #  ifndef _T
1244 #    define _T(text) text
1245 #  endif
1246 #endif
1247 
1248 static char format_error_doc[] =
1249 "FormatError([integer]) -> string\n\
1250 \n\
1251 Convert a win32 error code into a string. If the error code is not\n\
1252 given, the return value of a call to GetLastError() is used.\n";
format_error(PyObject * self,PyObject * args)1253 static PyObject *format_error(PyObject *self, PyObject *args)
1254 {
1255     PyObject *result;
1256     TCHAR *lpMsgBuf;
1257     DWORD code = 0;
1258     if (!PyArg_ParseTuple(args, "|i:FormatError", &code))
1259         return NULL;
1260     if (code == 0)
1261         code = GetLastError();
1262     lpMsgBuf = FormatError(code);
1263     if (lpMsgBuf) {
1264         result = Py_BuildValue(PYBUILD_TSTR, lpMsgBuf);
1265         LocalFree(lpMsgBuf);
1266     } else {
1267         result = Py_BuildValue("s", "<no description>");
1268     }
1269     return result;
1270 }
1271 
1272 static char load_library_doc[] =
1273 "LoadLibrary(name) -> handle\n\
1274 \n\
1275 Load an executable (usually a DLL), and return a handle to it.\n\
1276 The handle may be used to locate exported functions in this\n\
1277 module.\n";
load_library(PyObject * self,PyObject * args)1278 static PyObject *load_library(PyObject *self, PyObject *args)
1279 {
1280     TCHAR *name;
1281     PyObject *nameobj;
1282     PyObject *ignored;
1283     HMODULE hMod;
1284     if (!PyArg_ParseTuple(args, "S|O:LoadLibrary", &nameobj, &ignored))
1285         return NULL;
1286 #ifdef _UNICODE
1287     name = alloca((PyString_Size(nameobj) + 1) * sizeof(WCHAR));
1288     if (!name) {
1289         PyErr_NoMemory();
1290         return NULL;
1291     }
1292 
1293     {
1294         int r;
1295         char *aname = PyString_AsString(nameobj);
1296         if(!aname)
1297             return NULL;
1298         r = MultiByteToWideChar(CP_ACP, 0, aname, -1, name, PyString_Size(nameobj) + 1);
1299         name[r] = 0;
1300     }
1301 #else
1302     name = PyString_AsString(nameobj);
1303     if(!name)
1304         return NULL;
1305 #endif
1306 
1307     hMod = LoadLibrary(name);
1308     if (!hMod)
1309         return PyErr_SetFromWindowsErr(GetLastError());
1310 #ifdef _WIN64
1311     return PyLong_FromVoidPtr(hMod);
1312 #else
1313     return Py_BuildValue("i", hMod);
1314 #endif
1315 }
1316 
1317 static char free_library_doc[] =
1318 "FreeLibrary(handle) -> void\n\
1319 \n\
1320 Free the handle of an executable previously loaded by LoadLibrary.\n";
free_library(PyObject * self,PyObject * args)1321 static PyObject *free_library(PyObject *self, PyObject *args)
1322 {
1323     void *hMod;
1324     if (!PyArg_ParseTuple(args, "O&:FreeLibrary", &_parse_voidp, &hMod))
1325         return NULL;
1326     if (!FreeLibrary((HMODULE)hMod))
1327         return PyErr_SetFromWindowsErr(GetLastError());
1328     Py_INCREF(Py_None);
1329     return Py_None;
1330 }
1331 
1332 /* obsolete, should be removed */
1333 /* Only used by sample code (in samples\Windows\COM.py) */
1334 static PyObject *
call_commethod(PyObject * self,PyObject * args)1335 call_commethod(PyObject *self, PyObject *args)
1336 {
1337     IUnknown *pIunk;
1338     int index;
1339     PyObject *arguments;
1340     PPROC *lpVtbl;
1341     PyObject *result;
1342     CDataObject *pcom;
1343     PyObject *argtypes = NULL;
1344 
1345     if (!PyArg_ParseTuple(args,
1346                           "OiO!|O!",
1347                           &pcom, &index,
1348                           &PyTuple_Type, &arguments,
1349                           &PyTuple_Type, &argtypes))
1350         return NULL;
1351 
1352     if (argtypes && (PyTuple_GET_SIZE(arguments) != PyTuple_GET_SIZE(argtypes))) {
1353         PyErr_Format(PyExc_TypeError,
1354                      "Method takes %d arguments (%d given)",
1355                      PyTuple_GET_SIZE(argtypes), PyTuple_GET_SIZE(arguments));
1356         return NULL;
1357     }
1358 
1359     if (!CDataObject_Check(pcom) || (pcom->b_size != sizeof(void *))) {
1360         PyErr_Format(PyExc_TypeError,
1361                      "COM Pointer expected instead of %s instance",
1362                      Py_TYPE(pcom)->tp_name);
1363         return NULL;
1364     }
1365 
1366     if ((*(void **)(pcom->b_ptr)) == NULL) {
1367         PyErr_SetString(PyExc_ValueError,
1368                         "The COM 'this' pointer is NULL");
1369         return NULL;
1370     }
1371 
1372     pIunk = (IUnknown *)(*(void **)(pcom->b_ptr));
1373     lpVtbl = (PPROC *)(pIunk->lpVtbl);
1374 
1375     result =  _ctypes_callproc(lpVtbl[index],
1376                         arguments,
1377 #ifdef MS_WIN32
1378                         pIunk,
1379                         NULL,
1380 #endif
1381                         FUNCFLAG_HRESULT, /* flags */
1382                 argtypes, /* self->argtypes */
1383                 NULL, /* self->restype */
1384                 NULL); /* checker */
1385     return result;
1386 }
1387 
1388 static char copy_com_pointer_doc[] =
1389 "CopyComPointer(src, dst) -> HRESULT value\n";
1390 
1391 static PyObject *
copy_com_pointer(PyObject * self,PyObject * args)1392 copy_com_pointer(PyObject *self, PyObject *args)
1393 {
1394     PyObject *p1, *p2, *r = NULL;
1395     struct argument a, b;
1396     IUnknown *src, **pdst;
1397     if (!PyArg_ParseTuple(args, "OO:CopyComPointer", &p1, &p2))
1398         return NULL;
1399     a.keep = b.keep = NULL;
1400 
1401     if (-1 == ConvParam(p1, 0, &a) || -1 == ConvParam(p2, 1, &b))
1402         goto done;
1403     src = (IUnknown *)a.value.p;
1404     pdst = (IUnknown **)b.value.p;
1405 
1406     if (pdst == NULL)
1407         r = PyInt_FromLong(E_POINTER);
1408     else {
1409         if (src)
1410             src->lpVtbl->AddRef(src);
1411         *pdst = src;
1412         r = PyInt_FromLong(S_OK);
1413     }
1414   done:
1415     Py_XDECREF(a.keep);
1416     Py_XDECREF(b.keep);
1417     return r;
1418 }
1419 #else
1420 
py_dl_open(PyObject * self,PyObject * args)1421 static PyObject *py_dl_open(PyObject *self, PyObject *args)
1422 {
1423     char *name;
1424     void * handle;
1425 #ifdef RTLD_LOCAL
1426     int mode = RTLD_NOW | RTLD_LOCAL;
1427 #else
1428     /* cygwin doesn't define RTLD_LOCAL */
1429     int mode = RTLD_NOW;
1430 #endif
1431     if (!PyArg_ParseTuple(args, "z|i:dlopen", &name, &mode))
1432         return NULL;
1433     mode |= RTLD_NOW;
1434     handle = ctypes_dlopen(name, mode);
1435     if (!handle) {
1436         char *errmsg = ctypes_dlerror();
1437         if (!errmsg)
1438             errmsg = "dlopen() error";
1439         PyErr_SetString(PyExc_OSError,
1440                                errmsg);
1441         return NULL;
1442     }
1443     return PyLong_FromVoidPtr(handle);
1444 }
1445 
py_dl_close(PyObject * self,PyObject * args)1446 static PyObject *py_dl_close(PyObject *self, PyObject *args)
1447 {
1448     void *handle;
1449 
1450     if (!PyArg_ParseTuple(args, "O&:dlclose", &_parse_voidp, &handle))
1451         return NULL;
1452     if (dlclose(handle)) {
1453         PyErr_SetString(PyExc_OSError,
1454                                ctypes_dlerror());
1455         return NULL;
1456     }
1457     Py_INCREF(Py_None);
1458     return Py_None;
1459 }
1460 
py_dl_sym(PyObject * self,PyObject * args)1461 static PyObject *py_dl_sym(PyObject *self, PyObject *args)
1462 {
1463     char *name;
1464     void *handle;
1465     void *ptr;
1466 
1467     if (!PyArg_ParseTuple(args, "O&s:dlsym",
1468                           &_parse_voidp, &handle, &name))
1469         return NULL;
1470     ptr = ctypes_dlsym((void*)handle, name);
1471     if (!ptr) {
1472         PyErr_SetString(PyExc_OSError,
1473                                ctypes_dlerror());
1474         return NULL;
1475     }
1476     return PyLong_FromVoidPtr(ptr);
1477 }
1478 #endif
1479 
1480 /*
1481  * Only for debugging so far: So that we can call CFunction instances
1482  *
1483  * XXX Needs to accept more arguments: flags, argtypes, restype
1484  */
1485 static PyObject *
call_function(PyObject * self,PyObject * args)1486 call_function(PyObject *self, PyObject *args)
1487 {
1488     void *func;
1489     PyObject *arguments;
1490     PyObject *result;
1491 
1492     if (!PyArg_ParseTuple(args,
1493                           "O&O!",
1494                           &_parse_voidp, &func,
1495                           &PyTuple_Type, &arguments))
1496         return NULL;
1497 
1498     result =  _ctypes_callproc((PPROC)func,
1499                         arguments,
1500 #ifdef MS_WIN32
1501                         NULL,
1502                         NULL,
1503 #endif
1504                         0, /* flags */
1505                 NULL, /* self->argtypes */
1506                 NULL, /* self->restype */
1507                 NULL); /* checker */
1508     return result;
1509 }
1510 
1511 /*
1512  * Only for debugging so far: So that we can call CFunction instances
1513  *
1514  * XXX Needs to accept more arguments: flags, argtypes, restype
1515  */
1516 static PyObject *
call_cdeclfunction(PyObject * self,PyObject * args)1517 call_cdeclfunction(PyObject *self, PyObject *args)
1518 {
1519     void *func;
1520     PyObject *arguments;
1521     PyObject *result;
1522 
1523     if (!PyArg_ParseTuple(args,
1524                           "O&O!",
1525                           &_parse_voidp, &func,
1526                           &PyTuple_Type, &arguments))
1527         return NULL;
1528 
1529     result =  _ctypes_callproc((PPROC)func,
1530                         arguments,
1531 #ifdef MS_WIN32
1532                         NULL,
1533                         NULL,
1534 #endif
1535                         FUNCFLAG_CDECL, /* flags */
1536                 NULL, /* self->argtypes */
1537                 NULL, /* self->restype */
1538                 NULL); /* checker */
1539     return result;
1540 }
1541 
1542 /*****************************************************************
1543  * functions
1544  */
1545 static char sizeof_doc[] =
1546 "sizeof(C type) -> integer\n"
1547 "sizeof(C instance) -> integer\n"
1548 "Return the size in bytes of a C instance";
1549 
1550 static PyObject *
sizeof_func(PyObject * self,PyObject * obj)1551 sizeof_func(PyObject *self, PyObject *obj)
1552 {
1553     StgDictObject *dict;
1554 
1555     dict = PyType_stgdict(obj);
1556     if (dict)
1557         return PyInt_FromSsize_t(dict->size);
1558 
1559     if (CDataObject_Check(obj))
1560         return PyInt_FromSsize_t(((CDataObject *)obj)->b_size);
1561     PyErr_SetString(PyExc_TypeError,
1562                     "this type has no size");
1563     return NULL;
1564 }
1565 
1566 static char alignment_doc[] =
1567 "alignment(C type) -> integer\n"
1568 "alignment(C instance) -> integer\n"
1569 "Return the alignment requirements of a C instance";
1570 
1571 static PyObject *
align_func(PyObject * self,PyObject * obj)1572 align_func(PyObject *self, PyObject *obj)
1573 {
1574     StgDictObject *dict;
1575 
1576     dict = PyType_stgdict(obj);
1577     if (dict)
1578         return PyInt_FromSsize_t(dict->align);
1579 
1580     dict = PyObject_stgdict(obj);
1581     if (dict)
1582         return PyInt_FromSsize_t(dict->align);
1583 
1584     PyErr_SetString(PyExc_TypeError,
1585                     "no alignment info");
1586     return NULL;
1587 }
1588 
1589 static char byref_doc[] =
1590 "byref(C instance[, offset=0]) -> byref-object\n"
1591 "Return a pointer lookalike to a C instance, only usable\n"
1592 "as function argument";
1593 
1594 /*
1595  * We must return something which can be converted to a parameter,
1596  * but still has a reference to self.
1597  */
1598 static PyObject *
byref(PyObject * self,PyObject * args)1599 byref(PyObject *self, PyObject *args)
1600 {
1601     PyCArgObject *parg;
1602     PyObject *obj;
1603     PyObject *pyoffset = NULL;
1604     Py_ssize_t offset = 0;
1605 
1606     if (!PyArg_UnpackTuple(args, "byref", 1, 2,
1607                            &obj, &pyoffset))
1608         return NULL;
1609     if (pyoffset) {
1610         offset = PyNumber_AsSsize_t(pyoffset, NULL);
1611         if (offset == -1 && PyErr_Occurred())
1612             return NULL;
1613     }
1614     if (!CDataObject_Check(obj)) {
1615         PyErr_Format(PyExc_TypeError,
1616                      "byref() argument must be a ctypes instance, not '%s'",
1617                      Py_TYPE(obj)->tp_name);
1618         return NULL;
1619     }
1620 
1621     parg = PyCArgObject_new();
1622     if (parg == NULL)
1623         return NULL;
1624 
1625     parg->tag = 'P';
1626     parg->pffi_type = &ffi_type_pointer;
1627     Py_INCREF(obj);
1628     parg->obj = obj;
1629     parg->value.p = (char *)((CDataObject *)obj)->b_ptr + offset;
1630     return (PyObject *)parg;
1631 }
1632 
1633 static char addressof_doc[] =
1634 "addressof(C instance) -> integer\n"
1635 "Return the address of the C instance internal buffer";
1636 
1637 static PyObject *
addressof(PyObject * self,PyObject * obj)1638 addressof(PyObject *self, PyObject *obj)
1639 {
1640     if (CDataObject_Check(obj))
1641         return PyLong_FromVoidPtr(((CDataObject *)obj)->b_ptr);
1642     PyErr_SetString(PyExc_TypeError,
1643                     "invalid type");
1644     return NULL;
1645 }
1646 
1647 static int
converter(PyObject * obj,void ** address)1648 converter(PyObject *obj, void **address)
1649 {
1650     *address = PyLong_AsVoidPtr(obj);
1651     return *address != NULL;
1652 }
1653 
1654 static PyObject *
My_PyObj_FromPtr(PyObject * self,PyObject * args)1655 My_PyObj_FromPtr(PyObject *self, PyObject *args)
1656 {
1657     PyObject *ob;
1658     if (!PyArg_ParseTuple(args, "O&:PyObj_FromPtr", converter, &ob))
1659         return NULL;
1660     Py_INCREF(ob);
1661     return ob;
1662 }
1663 
1664 static PyObject *
My_Py_INCREF(PyObject * self,PyObject * arg)1665 My_Py_INCREF(PyObject *self, PyObject *arg)
1666 {
1667     Py_INCREF(arg); /* that's what this function is for */
1668     Py_INCREF(arg); /* that for returning it */
1669     return arg;
1670 }
1671 
1672 static PyObject *
My_Py_DECREF(PyObject * self,PyObject * arg)1673 My_Py_DECREF(PyObject *self, PyObject *arg)
1674 {
1675     Py_DECREF(arg); /* that's what this function is for */
1676     Py_INCREF(arg); /* that's for returning it */
1677     return arg;
1678 }
1679 
1680 #ifdef CTYPES_UNICODE
1681 
1682 static char set_conversion_mode_doc[] =
1683 "set_conversion_mode(encoding, errors) -> (previous-encoding, previous-errors)\n\
1684 \n\
1685 Set the encoding and error handling ctypes uses when converting\n\
1686 between unicode and strings.  Returns the previous values.\n";
1687 
1688 static PyObject *
set_conversion_mode(PyObject * self,PyObject * args)1689 set_conversion_mode(PyObject *self, PyObject *args)
1690 {
1691     char *coding, *mode, *errors, *encoding=NULL;
1692     PyObject *result;
1693 
1694     if (!PyArg_ParseTuple(args, "zs:set_conversion_mode", &coding, &mode))
1695         return NULL;
1696 
1697     result = Py_BuildValue("(zz)", _ctypes_conversion_encoding,
1698                            _ctypes_conversion_errors);
1699     if (!result) {
1700         return NULL;
1701     }
1702 
1703     if (coding) {
1704         encoding = PyMem_Malloc(strlen(coding) + 1);
1705         if (!encoding) {
1706             Py_DECREF(result);
1707             return PyErr_NoMemory();
1708         }
1709         strcpy(encoding, coding);
1710     }
1711 
1712     errors = PyMem_Malloc(strlen(mode) + 1);
1713     if (!errors) {
1714         Py_DECREF(result);
1715         PyMem_Free(encoding);
1716         return PyErr_NoMemory();
1717     }
1718     strcpy(errors, mode);
1719 
1720     PyMem_Free(_ctypes_conversion_encoding);
1721     _ctypes_conversion_encoding = encoding;
1722 
1723     PyMem_Free(_ctypes_conversion_errors);
1724     _ctypes_conversion_errors = errors;
1725 
1726     return result;
1727 }
1728 #endif
1729 
1730 static PyObject *
resize(PyObject * self,PyObject * args)1731 resize(PyObject *self, PyObject *args)
1732 {
1733     CDataObject *obj;
1734     StgDictObject *dict;
1735     Py_ssize_t size;
1736 
1737     if (!PyArg_ParseTuple(args,
1738 #if (PY_VERSION_HEX < 0x02050000)
1739                           "Oi:resize",
1740 #else
1741                           "On:resize",
1742 #endif
1743                           &obj, &size))
1744         return NULL;
1745 
1746     dict = PyObject_stgdict((PyObject *)obj);
1747     if (dict == NULL) {
1748         PyErr_SetString(PyExc_TypeError,
1749                         "excepted ctypes instance");
1750         return NULL;
1751     }
1752     if (size < dict->size) {
1753         PyErr_Format(PyExc_ValueError,
1754 #if PY_VERSION_HEX < 0x02050000
1755                      "minimum size is %d",
1756 #else
1757                      "minimum size is %zd",
1758 #endif
1759                      dict->size);
1760         return NULL;
1761     }
1762     if (obj->b_needsfree == 0) {
1763         PyErr_Format(PyExc_ValueError,
1764                      "Memory cannot be resized because this object doesn't own it");
1765         return NULL;
1766     }
1767     if (size <= sizeof(obj->b_value)) {
1768         /* internal default buffer is large enough */
1769         obj->b_size = size;
1770         goto done;
1771     }
1772     if (!_CDataObject_HasExternalBuffer(obj)) {
1773         /* We are currently using the objects default buffer, but it
1774            isn't large enough any more. */
1775         void *ptr = PyMem_Malloc(size);
1776         if (ptr == NULL)
1777             return PyErr_NoMemory();
1778         memset(ptr, 0, size);
1779         memmove(ptr, obj->b_ptr, obj->b_size);
1780         obj->b_ptr = ptr;
1781         obj->b_size = size;
1782     } else {
1783         void * ptr = PyMem_Realloc(obj->b_ptr, size);
1784         if (ptr == NULL)
1785             return PyErr_NoMemory();
1786         obj->b_ptr = ptr;
1787         obj->b_size = size;
1788     }
1789   done:
1790     Py_INCREF(Py_None);
1791     return Py_None;
1792 }
1793 
1794 static PyObject *
unpickle(PyObject * self,PyObject * args)1795 unpickle(PyObject *self, PyObject *args)
1796 {
1797     PyObject *typ;
1798     PyObject *state;
1799     PyObject *result;
1800     PyObject *tmp;
1801 
1802     if (!PyArg_ParseTuple(args, "OO", &typ, &state))
1803         return NULL;
1804     result = PyObject_CallMethod(typ, "__new__", "O", typ);
1805     if (result == NULL)
1806         return NULL;
1807     tmp = PyObject_CallMethod(result, "__setstate__", "O", state);
1808     if (tmp == NULL) {
1809         Py_DECREF(result);
1810         return NULL;
1811     }
1812     Py_DECREF(tmp);
1813     return result;
1814 }
1815 
1816 static PyObject *
POINTER(PyObject * self,PyObject * cls)1817 POINTER(PyObject *self, PyObject *cls)
1818 {
1819     PyObject *result;
1820     PyTypeObject *typ;
1821     PyObject *key;
1822     char *buf;
1823 
1824     result = PyDict_GetItem(_ctypes_ptrtype_cache, cls);
1825     if (result) {
1826         Py_INCREF(result);
1827         return result;
1828     }
1829     if (PyString_CheckExact(cls)) {
1830         buf = PyMem_Malloc(strlen(PyString_AS_STRING(cls)) + 3 + 1);
1831         if (buf == NULL)
1832             return PyErr_NoMemory();
1833         sprintf(buf, "LP_%s", PyString_AS_STRING(cls));
1834         result = PyObject_CallFunction((PyObject *)Py_TYPE(&PyCPointer_Type),
1835                                        "s(O){}",
1836                                        buf,
1837                                        &PyCPointer_Type);
1838         if (result == NULL)
1839             return result;
1840         key = PyLong_FromVoidPtr(result);
1841         if (key == NULL) {
1842             Py_DECREF(result);
1843             return NULL;
1844         }
1845     } else if (PyType_Check(cls)) {
1846         typ = (PyTypeObject *)cls;
1847         buf = PyMem_Malloc(strlen(typ->tp_name) + 3 + 1);
1848         if (buf == NULL)
1849             return PyErr_NoMemory();
1850         sprintf(buf, "LP_%s", typ->tp_name);
1851         result = PyObject_CallFunction((PyObject *)Py_TYPE(&PyCPointer_Type),
1852                                        "s(O){sO}",
1853                                        buf,
1854                                        &PyCPointer_Type,
1855                                        "_type_", cls);
1856         PyMem_Free(buf);
1857         if (result == NULL)
1858             return result;
1859         Py_INCREF(cls);
1860         key = cls;
1861     } else {
1862         PyErr_SetString(PyExc_TypeError, "must be a ctypes type");
1863         return NULL;
1864     }
1865     if (-1 == PyDict_SetItem(_ctypes_ptrtype_cache, key, result)) {
1866         Py_DECREF(result);
1867         Py_DECREF(key);
1868         return NULL;
1869     }
1870     Py_DECREF(key);
1871     return result;
1872 }
1873 
1874 static PyObject *
pointer(PyObject * self,PyObject * arg)1875 pointer(PyObject *self, PyObject *arg)
1876 {
1877     PyObject *result;
1878     PyObject *typ;
1879 
1880     typ = PyDict_GetItem(_ctypes_ptrtype_cache, (PyObject *)Py_TYPE(arg));
1881     if (typ)
1882         return PyObject_CallFunctionObjArgs(typ, arg, NULL);
1883     typ = POINTER(NULL, (PyObject *)Py_TYPE(arg));
1884     if (typ == NULL)
1885                     return NULL;
1886     result = PyObject_CallFunctionObjArgs(typ, arg, NULL);
1887     Py_DECREF(typ);
1888     return result;
1889 }
1890 
1891 static PyObject *
buffer_info(PyObject * self,PyObject * arg)1892 buffer_info(PyObject *self, PyObject *arg)
1893 {
1894     StgDictObject *dict = PyType_stgdict(arg);
1895     PyObject *shape;
1896     Py_ssize_t i;
1897 
1898     if (dict == NULL)
1899         dict = PyObject_stgdict(arg);
1900     if (dict == NULL) {
1901         PyErr_SetString(PyExc_TypeError,
1902                         "not a ctypes type or object");
1903         return NULL;
1904     }
1905     shape = PyTuple_New(dict->ndim);
1906     if (shape == NULL)
1907         return NULL;
1908     for (i = 0; i < (int)dict->ndim; ++i)
1909         PyTuple_SET_ITEM(shape, i, PyLong_FromSsize_t(dict->shape[i]));
1910 
1911     if (PyErr_Occurred()) {
1912         Py_DECREF(shape);
1913         return NULL;
1914     }
1915     return Py_BuildValue("siN", dict->format, dict->ndim, shape);
1916 }
1917 
1918 PyMethodDef _ctypes_module_methods[] = {
1919     {"get_errno", get_errno, METH_NOARGS},
1920     {"set_errno", set_errno, METH_VARARGS},
1921     {"POINTER", POINTER, METH_O },
1922     {"pointer", pointer, METH_O },
1923     {"_unpickle", unpickle, METH_VARARGS },
1924     {"_buffer_info", buffer_info, METH_O,
1925      "Return buffer interface information (for testing only)"},
1926     {"resize", resize, METH_VARARGS, "Resize the memory buffer of a ctypes instance"},
1927 #ifdef CTYPES_UNICODE
1928     {"set_conversion_mode", set_conversion_mode, METH_VARARGS, set_conversion_mode_doc},
1929 #endif
1930 #ifdef MS_WIN32
1931     {"get_last_error", get_last_error, METH_NOARGS},
1932     {"set_last_error", set_last_error, METH_VARARGS},
1933     {"CopyComPointer", copy_com_pointer, METH_VARARGS, copy_com_pointer_doc},
1934     {"FormatError", format_error, METH_VARARGS, format_error_doc},
1935     {"LoadLibrary", load_library, METH_VARARGS, load_library_doc},
1936     {"FreeLibrary", free_library, METH_VARARGS, free_library_doc},
1937     {"call_commethod", call_commethod, METH_VARARGS },
1938     {"_check_HRESULT", check_hresult, METH_VARARGS},
1939 #else
1940     {"dlopen", py_dl_open, METH_VARARGS,
1941      "dlopen(name, flag={RTLD_GLOBAL|RTLD_LOCAL}) open a shared library"},
1942     {"dlclose", py_dl_close, METH_VARARGS, "dlclose a library"},
1943     {"dlsym", py_dl_sym, METH_VARARGS, "find symbol in shared library"},
1944 #endif
1945     {"alignment", align_func, METH_O, alignment_doc},
1946     {"sizeof", sizeof_func, METH_O, sizeof_doc},
1947     {"byref", byref, METH_VARARGS, byref_doc},
1948     {"addressof", addressof, METH_O, addressof_doc},
1949     {"call_function", call_function, METH_VARARGS },
1950     {"call_cdeclfunction", call_cdeclfunction, METH_VARARGS },
1951     {"PyObj_FromPtr", My_PyObj_FromPtr, METH_VARARGS },
1952     {"Py_INCREF", My_Py_INCREF, METH_O },
1953     {"Py_DECREF", My_Py_DECREF, METH_O },
1954     {NULL,      NULL}        /* Sentinel */
1955 };
1956 
1957 /*
1958  Local Variables:
1959  compile-command: "cd .. && python setup.py -q build -g && python setup.py -q build install --home ~"
1960  End:
1961 */
1962