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