#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structmember.h"

#include <ffi.h>

#ifdef MS_WIN32

#include <windows.h>

#include <malloc.h>

#ifndef IS_INTRESOURCE

#define IS_INTRESOURCE(x) (((size_t)(x) >> 16) == 0)

# ifdef _WIN32_WCE

# undef GetProcAddress

# define GetProcAddress GetProcAddressA

#include "ctypes_dlfcn.h"

#include "ctypes.h"

PyObject *PyExc_ArgError;

PyObject *_ctypes_ptrtype_cache;

static PyTypeObject Simple_Type;

static PyObject *_unpickle;

char *_ctypes_conversion_encoding = NULL;

char *_ctypes_conversion_errors = NULL;

#if (PY_VERSION_HEX < 0x02040000)

static PyObject *

PyTuple_Pack(int n, ...)

{

int i;

PyObject *o;

PyObject *result;

PyObject **items;

va_list vargs;

va_start(vargs, n);

result = PyTuple_New(n);

if (result == NULL)

return NULL;

items = ((PyTupleObject *)result)->ob_item;

for (i = 0; i < n; i++) {

o = va_arg(vargs, PyObject *);

Py_INCREF(o);

items[i] = o;

}

va_end(vargs);

return result;

}

typedef struct {

PyObject_HEAD

PyObject *key;

PyObject *dict;

} DictRemoverObject;

static void

_DictRemover_dealloc(PyObject *_self)

{

DictRemoverObject *self = (DictRemoverObject *)_self;

Py_XDECREF(self->key);

Py_XDECREF(self->dict);

Py_TYPE(self)->tp_free(_self);

}

static PyObject *

_DictRemover_call(PyObject *_self, PyObject *args, PyObject *kw)

{

DictRemoverObject *self = (DictRemoverObject *)_self;

if (self->key && self->dict) {

if (-1 == PyDict_DelItem(self->dict, self->key))

/* XXX Error context */

PyErr_WriteUnraisable(Py_None);

Py_DECREF(self->key);

self->key = NULL;

Py_DECREF(self->dict);

self->dict = NULL;

}

Py_INCREF(Py_None);

return Py_None;

}

static PyTypeObject DictRemover_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"_ctypes.DictRemover", /* tp_name */

sizeof(DictRemoverObject), /* tp_basicsize */

0, /* tp_itemsize */

_DictRemover_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

_DictRemover_call, /* tp_call */

0, /* tp_str */

0, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT, /* tp_flags */

"deletes a key from a dictionary", /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

0, /* tp_new */

0, /* tp_free */

};

PyDict_SetItemProxy(PyObject *dict, PyObject *key, PyObject *item)

{

PyObject *obj;

DictRemoverObject *remover;

PyObject *proxy;

int result;

obj = PyObject_CallObject((PyObject *)&DictRemover_Type, NULL);

if (obj == NULL)

return -1;

remover = (DictRemoverObject *)obj;

assert(remover->key == NULL);

assert(remover->dict == NULL);

Py_INCREF(key);

remover->key = key;

Py_INCREF(dict);

remover->dict = dict;

proxy = PyWeakref_NewProxy(item, obj);

Py_DECREF(obj);

if (proxy == NULL)

return -1;

result = PyDict_SetItem(dict, key, proxy);

Py_DECREF(proxy);

return result;

}

PyObject *

PyDict_GetItemProxy(PyObject *dict, PyObject *key)

{

PyObject *result;

PyObject *item = PyDict_GetItem(dict, key);

if (item == NULL)

return NULL;

if (!PyWeakref_CheckProxy(item))

return item;

result = PyWeakref_GET_OBJECT(item);

if (result == Py_None)

return NULL;

return result;

}

char *

_ctypes_alloc_format_string(const char *prefix, const char *suffix)

{

size_t len;

char *result;

if (suffix == NULL) {

assert(PyErr_Occurred());

return NULL;

}

len = strlen(suffix);

if (prefix)

len += strlen(prefix);

result = PyMem_Malloc(len + 1);

if (result == NULL)

return NULL;

if (prefix)

strcpy(result, prefix);

else

result[0] = '\0';

strcat(result, suffix);

return result;

}

static PyCArgObject *

StructUnionType_paramfunc(CDataObject *self)

{

PyCArgObject *parg;

StgDictObject *stgdict;

parg = PyCArgObject_new();

if (parg == NULL)

return NULL;

parg->tag = 'V';

stgdict = PyObject_stgdict((PyObject *)self);

assert(stgdict); /* Cannot be NULL for structure/union instances */

parg->pffi_type = &stgdict->ffi_type_pointer;

/* For structure parameters (by value), parg->value doesn't contain the structure

parg->value.p = self->b_ptr;

parg->size = self->b_size;

Py_INCREF(self);

parg->obj = (PyObject *)self;

return parg;

}

static PyObject *

StructUnionType_new(PyTypeObject *type, PyObject *args, PyObject *kwds, int isStruct)

{

PyTypeObject *result;

PyObject *fields;

StgDictObject *dict;

/* create the new instance (which is a class,

result = (PyTypeObject *)PyType_Type.tp_new(type, args, kwds);

if (!result)

return NULL;

/* keep this for bw compatibility */

if (PyDict_GetItemString(result->tp_dict, "_abstract_"))

return (PyObject *)result;

dict = (StgDictObject *)PyObject_CallObject((PyObject *)&PyCStgDict_Type, NULL);

if (!dict) {

Py_DECREF(result);

return NULL;

}

/* replace the class dict by our updated stgdict, which holds info

if (-1 == PyDict_Update((PyObject *)dict, result->tp_dict)) {

Py_DECREF(result);

Py_DECREF((PyObject *)dict);

return NULL;

}

Py_DECREF(result->tp_dict);

result->tp_dict = (PyObject *)dict;

dict->format = _ctypes_alloc_format_string(NULL, "B");

if (dict->format == NULL) {

Py_DECREF(result);

return NULL;

}

dict->paramfunc = StructUnionType_paramfunc;

fields = PyDict_GetItemString((PyObject *)dict, "_fields_");

if (!fields) {

StgDictObject *basedict = PyType_stgdict((PyObject *)result->tp_base);

if (basedict == NULL)

return (PyObject *)result;

/* copy base dict */

if (-1 == PyCStgDict_clone(dict, basedict)) {

Py_DECREF(result);

return NULL;

}

dict->flags &= ~DICTFLAG_FINAL; /* clear the 'final' flag in the subclass dict */

basedict->flags |= DICTFLAG_FINAL; /* set the 'final' flag in the baseclass dict */

return (PyObject *)result;

}

if (-1 == PyObject_SetAttrString((PyObject *)result, "_fields_", fields)) {

Py_DECREF(result);

return NULL;

}

return (PyObject *)result;

}

static PyObject *

PyCStructType_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

return StructUnionType_new(type, args, kwds, 1);

}

static PyObject *

UnionType_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

return StructUnionType_new(type, args, kwds, 0);

}

static char from_address_doc[] =

"C.from_address(integer) -> C instance\naccess a C instance at the specified address";

static PyObject *

CDataType_from_address(PyObject *type, PyObject *value)

{

void *buf;

if (!PyInt_Check(value) && !PyLong_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"integer expected");

return NULL;

}

buf = (void *)PyLong_AsVoidPtr(value);

if (PyErr_Occurred())

return NULL;

return PyCData_AtAddress(type, buf);

}

static char from_buffer_doc[] =

"C.from_buffer(object, offset=0) -> C instance\ncreate a C instance from a writeable buffer";

static int

KeepRef(CDataObject *target, Py_ssize_t index, PyObject *keep);

static PyObject *

CDataType_from_buffer(PyObject *type, PyObject *args)

{

void *buffer;

Py_ssize_t buffer_len;

Py_ssize_t offset = 0;

PyObject *obj, *result;

StgDictObject *dict = PyType_stgdict(type);

assert (dict);

if (!PyArg_ParseTuple(args,

#if (PY_VERSION_HEX < 0x02050000)

"O|i:from_buffer",

"O|n:from_buffer",

&obj, &offset))

return NULL;

if (-1 == PyObject_AsWriteBuffer(obj, &buffer, &buffer_len))

return NULL;

if (offset < 0) {

PyErr_SetString(PyExc_ValueError,

"offset cannot be negative");

return NULL;

}

if (dict->size > buffer_len - offset) {

PyErr_Format(PyExc_ValueError,

#if (PY_VERSION_HEX < 0x02050000)

"Buffer size too small (%d instead of at least %d bytes)",

"Buffer size too small (%zd instead of at least %zd bytes)",

buffer_len, dict->size + offset);

return NULL;

}

result = PyCData_AtAddress(type, (char *)buffer + offset);

if (result == NULL)

return NULL;

Py_INCREF(obj);

if (-1 == KeepRef((CDataObject *)result, -1, obj)) {

Py_DECREF(result);

return NULL;

}

return result;

}

static char from_buffer_copy_doc[] =

"C.from_buffer_copy(object, offset=0) -> C instance\ncreate a C instance from a readable buffer";

static PyObject *

GenericPyCData_new(PyTypeObject *type, PyObject *args, PyObject *kwds);

static PyObject *

CDataType_from_buffer_copy(PyObject *type, PyObject *args)

{

const void *buffer;

Py_ssize_t buffer_len;

Py_ssize_t offset = 0;

PyObject *obj, *result;

StgDictObject *dict = PyType_stgdict(type);

assert (dict);

if (!PyArg_ParseTuple(args,

#if (PY_VERSION_HEX < 0x02050000)

"O|i:from_buffer",

"O|n:from_buffer",

&obj, &offset))

return NULL;

if (-1 == PyObject_AsReadBuffer(obj, &buffer, &buffer_len))

return NULL;

if (offset < 0) {

PyErr_SetString(PyExc_ValueError,

"offset cannot be negative");

return NULL;

}

if (dict->size > buffer_len - offset) {

PyErr_Format(PyExc_ValueError,

#if (PY_VERSION_HEX < 0x02050000)

"Buffer size too small (%d instead of at least %d bytes)",

"Buffer size too small (%zd instead of at least %zd bytes)",

buffer_len, dict->size + offset);

return NULL;

}

result = GenericPyCData_new((PyTypeObject *)type, NULL, NULL);

if (result == NULL)

return NULL;

memcpy(((CDataObject *)result)->b_ptr,

(char *)buffer+offset, dict->size);

return result;

}

static char in_dll_doc[] =

"C.in_dll(dll, name) -> C instance\naccess a C instance in a dll";

static PyObject *

CDataType_in_dll(PyObject *type, PyObject *args)

{

PyObject *dll;

char *name;

PyObject *obj;

void *handle;

void *address;

if (!PyArg_ParseTuple(args, "Os:in_dll", &dll, &name))

return NULL;

obj = PyObject_GetAttrString(dll, "_handle");

if (!obj)

return NULL;

if (!PyInt_Check(obj) && !PyLong_Check(obj)) {

PyErr_SetString(PyExc_TypeError,

"the _handle attribute of the second argument must be an integer");

Py_DECREF(obj);

return NULL;

}

handle = (void *)PyLong_AsVoidPtr(obj);

Py_DECREF(obj);

if (PyErr_Occurred()) {

PyErr_SetString(PyExc_ValueError,

"could not convert the _handle attribute to a pointer");

return NULL;

}

#ifdef MS_WIN32

address = (void *)GetProcAddress(handle, name);

if (!address) {

PyErr_Format(PyExc_ValueError,

"symbol '%s' not found",

name);

return NULL;

}

address = (void *)ctypes_dlsym(handle, name);

if (!address) {

#ifdef __CYGWIN__

PyErr_Format(PyExc_ValueError,

"symbol '%s' not found (%s) ",

name);

PyErr_SetString(PyExc_ValueError, ctypes_dlerror());

return NULL;

}

return PyCData_AtAddress(type, address);

}

static char from_param_doc[] =

"Convert a Python object into a function call parameter.";

static PyObject *

CDataType_from_param(PyObject *type, PyObject *value)

{

PyObject *as_parameter;

int res = PyObject_IsInstance(value, type);

if (res == -1)

return NULL;

if (res) {

Py_INCREF(value);

return value;

}

if (PyCArg_CheckExact(value)) {

PyCArgObject *p = (PyCArgObject *)value;

PyObject *ob = p->obj;

const char *ob_name;

StgDictObject *dict;

dict = PyType_stgdict(type);

/* If we got a PyCArgObject, we must check if the object packed in it

if(dict && ob) {

res = PyObject_IsInstance(ob, dict->proto);

if (res == -1)

return NULL;

if (res) {

Py_INCREF(value);

return value;

}

}

ob_name = (ob) ? Py_TYPE(ob)->tp_name : "???";

PyErr_Format(PyExc_TypeError,

"expected %s instance instead of pointer to %s",

((PyTypeObject *)type)->tp_name, ob_name);

return NULL;

}

as_parameter = PyObject_GetAttrString(value, "_as_parameter_");

if (as_parameter) {

value = CDataType_from_param(type, as_parameter);

Py_DECREF(as_parameter);

return value;

}

PyErr_Format(PyExc_TypeError,

"expected %s instance instead of %s",

((PyTypeObject *)type)->tp_name,

Py_TYPE(value)->tp_name);

return NULL;

}

static PyMethodDef CDataType_methods[] = {

{ "from_param", CDataType_from_param, METH_O, from_param_doc },

{ "from_address", CDataType_from_address, METH_O, from_address_doc },

{ "from_buffer", CDataType_from_buffer, METH_VARARGS, from_buffer_doc, },

{ "from_buffer_copy", CDataType_from_buffer_copy, METH_VARARGS, from_buffer_copy_doc, },

{ "in_dll", CDataType_in_dll, METH_VARARGS, in_dll_doc },

{ NULL, NULL },

};

static PyObject *

CDataType_repeat(PyObject *self, Py_ssize_t length)

{

if (length < 0)

return PyErr_Format(PyExc_ValueError,

#if (PY_VERSION_HEX < 0x02050000)

"Array length must be >= 0, not %d",

"Array length must be >= 0, not %zd",

length);

return PyCArrayType_from_ctype(self, length);

}

static PySequenceMethods CDataType_as_sequence = {

0, /* inquiry sq_length; */

0, /* binaryfunc sq_concat; */

CDataType_repeat, /* intargfunc sq_repeat; */

0, /* intargfunc sq_item; */

0, /* intintargfunc sq_slice; */

0, /* intobjargproc sq_ass_item; */

0, /* intintobjargproc sq_ass_slice; */

0, /* objobjproc sq_contains; */

0, /* binaryfunc sq_inplace_concat; */

0, /* intargfunc sq_inplace_repeat; */

};

static int

CDataType_clear(PyTypeObject *self)

{

StgDictObject *dict = PyType_stgdict((PyObject *)self);

if (dict)

Py_CLEAR(dict->proto);

return PyType_Type.tp_clear((PyObject *)self);

}

static int

CDataType_traverse(PyTypeObject *self, visitproc visit, void *arg)

{

StgDictObject *dict = PyType_stgdict((PyObject *)self);

if (dict)

Py_VISIT(dict->proto);

return PyType_Type.tp_traverse((PyObject *)self, visit, arg);

}

static int

PyCStructType_setattro(PyObject *self, PyObject *key, PyObject *value)

{

/* XXX Should we disallow deleting _fields_? */

if (-1 == PyType_Type.tp_setattro(self, key, value))

return -1;

if (value && PyString_Check(key) &&

0 == strcmp(PyString_AS_STRING(key), "_fields_"))

return PyCStructUnionType_update_stgdict(self, value, 1);

return 0;

}

static int

UnionType_setattro(PyObject *self, PyObject *key, PyObject *value)

{

/* XXX Should we disallow deleting _fields_? */

if (-1 == PyObject_GenericSetAttr(self, key, value))

return -1;

if (PyString_Check(key) &&

0 == strcmp(PyString_AS_STRING(key), "_fields_"))

return PyCStructUnionType_update_stgdict(self, value, 0);

return 0;

}

PyTypeObject PyCStructType_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"_ctypes.PyCStructType", /* tp_name */

0, /* tp_basicsize */

0, /* tp_itemsize */

0, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

0, /* tp_repr */

0, /* tp_as_number */

&CDataType_as_sequence, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

0, /* tp_getattro */

PyCStructType_setattro, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */

"metatype for the CData Objects", /* tp_doc */

(traverseproc)CDataType_traverse, /* tp_traverse */

(inquiry)CDataType_clear, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

CDataType_methods, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

PyCStructType_new, /* tp_new */

0, /* tp_free */

};

static PyTypeObject UnionType_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"_ctypes.UnionType", /* tp_name */

0, /* tp_basicsize */

0, /* tp_itemsize */

0, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

0, /* tp_repr */

0, /* tp_as_number */

&CDataType_as_sequence, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

0, /* tp_getattro */

UnionType_setattro, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */

"metatype for the CData Objects", /* tp_doc */

(traverseproc)CDataType_traverse, /* tp_traverse */

(inquiry)CDataType_clear, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

CDataType_methods, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

UnionType_new, /* tp_new */

0, /* tp_free */

};

static int

PyCPointerType_SetProto(StgDictObject *stgdict, PyObject *proto)

{

if (!proto || !PyType_Check(proto)) {

PyErr_SetString(PyExc_TypeError,

"_type_ must be a type");

return -1;

}

if (!PyType_stgdict(proto)) {

PyErr_SetString(PyExc_TypeError,

"_type_ must have storage info");

return -1;

}

Py_INCREF(proto);

Py_XDECREF(stgdict->proto);

stgdict->proto = proto;

return 0;

}

static PyCArgObject *

PyCPointerType_paramfunc(CDataObject *self)

{

PyCArgObject *parg;

parg = PyCArgObject_new();

if (parg == NULL)

return NULL;

parg->tag = 'P';

parg->pffi_type = &ffi_type_pointer;

Py_INCREF(self);

parg->obj = (PyObject *)self;

parg->value.p = *(void **)self->b_ptr;

return parg;

}

static PyObject *

PyCPointerType_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

PyTypeObject *result;

StgDictObject *stgdict;

PyObject *proto;

PyObject *typedict;

typedict = PyTuple_GetItem(args, 2);

if (!typedict)

return NULL;

stgdict = (StgDictObject *)PyObject_CallObject(

(PyObject *)&PyCStgDict_Type, NULL);

if (!stgdict)

return NULL;

stgdict->size = sizeof(void *);

stgdict->align = _ctypes_get_fielddesc("P")->pffi_type->alignment;

stgdict->length = 1;

stgdict->ffi_type_pointer = ffi_type_pointer;

stgdict->paramfunc = PyCPointerType_paramfunc;

stgdict->flags |= TYPEFLAG_ISPOINTER;

proto = PyDict_GetItemString(typedict, "_type_"); /* Borrowed ref */

if (proto && -1 == PyCPointerType_SetProto(stgdict, proto)) {

Py_DECREF((PyObject *)stgdict);

return NULL;

}

if (proto) {

StgDictObject *itemdict = PyType_stgdict(proto);

assert(itemdict);

/* If itemdict->format is NULL, then this is a pointer to an

stgdict->format = _ctypes_alloc_format_string("&",

itemdict->format ? itemdict->format : "B");

if (stgdict->format == NULL) {

Py_DECREF((PyObject *)stgdict);

return NULL;

}

}

/* create the new instance (which is a class,

result = (PyTypeObject *)PyType_Type.tp_new(type, args, kwds);

if (result == NULL) {

Py_DECREF((PyObject *)stgdict);

return NULL;

}

/* replace the class dict by our updated spam dict */

if (-1 == PyDict_Update((PyObject *)stgdict, result->tp_dict)) {

Py_DECREF(result);

Py_DECREF((PyObject *)stgdict);

return NULL;

}

Py_DECREF(result->tp_dict);

result->tp_dict = (PyObject *)stgdict;

return (PyObject *)result;

}

static PyObject *

PyCPointerType_set_type(PyTypeObject *self, PyObject *type)

{

StgDictObject *dict;

dict = PyType_stgdict((PyObject *)self);

assert(dict);

if (-1 == PyCPointerType_SetProto(dict, type))

return NULL;

if (-1 == PyDict_SetItemString((PyObject *)dict, "_type_", type))

return NULL;

Py_INCREF(Py_None);

return Py_None;

}

staticforward PyObject *_byref(PyObject *);

static PyObject *

PyCPointerType_from_param(PyObject *type, PyObject *value)

{

StgDictObject *typedict;

if (value == Py_None) {

/* ConvParam will convert to a NULL pointer later */

Py_INCREF(value);

return value;

}

typedict = PyType_stgdict(type);

assert(typedict); /* Cannot be NULL for pointer types */

/* If we expect POINTER(<type>), but receive a <type> instance, accept

switch (PyObject_IsInstance(value, typedict->proto)) {

case 1:

Py_INCREF(value); /* _byref steals a refcount */

return _byref(value);

case -1:

return NULL;

default: