#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#include "Python.h"

#include <stdbool.h>

#ifdef MS_WIN32

#include <windows.h>

#include <tchar.h>

#include <dlfcn.h>

#ifdef __APPLE__

#include <mach-o/dyld.h>

#ifdef MS_WIN32

#include <malloc.h>

#include <ffi.h>

#include "ctypes.h"

#ifdef HAVE_ALLOCA_H

#include <alloca.h>

#ifdef _Py_MEMORY_SANITIZER

#include <sanitizer/msan_interface.h>

#if defined(_DEBUG) || defined(__MINGW32__)

#define DONT_USE_SEH

#include "pycore_runtime.h" // _PyRuntime

#include "pycore_global_objects.h"// _Py_ID()

#include "pycore_traceback.h" // _PyTraceback_Add()

#include "clinic/callproc.c.h"

#define CTYPES_CAPSULE_NAME_PYMEM "_ctypes pymem"

static void pymem_destructor(PyObject *ptr)

{

void *p = PyCapsule_GetPointer(ptr, CTYPES_CAPSULE_NAME_PYMEM);

if (p) {

PyMem_Free(p);

}

}

PyObject *

_ctypes_get_errobj(int **pspace)

{

PyObject *dict = PyThreadState_GetDict();

PyObject *errobj;

static PyObject *error_object_name;

if (dict == NULL) {

PyErr_SetString(PyExc_RuntimeError,

"cannot get thread state");

return NULL;

}

if (error_object_name == NULL) {

error_object_name = PyUnicode_InternFromString("ctypes.error_object");

if (error_object_name == NULL)

return NULL;

}

errobj = PyDict_GetItemWithError(dict, error_object_name);

if (errobj) {

if (!PyCapsule_IsValid(errobj, CTYPES_CAPSULE_NAME_PYMEM)) {

PyErr_SetString(PyExc_RuntimeError,

"ctypes.error_object is an invalid capsule");

return NULL;

}

Py_INCREF(errobj);

}

else if (!PyErr_Occurred()) {

void *space = PyMem_Calloc(2, sizeof(int));

if (space == NULL)

return NULL;

errobj = PyCapsule_New(space, CTYPES_CAPSULE_NAME_PYMEM, pymem_destructor);

if (errobj == NULL) {

PyMem_Free(space);

return NULL;

}

if (-1 == PyDict_SetItem(dict, error_object_name,

errobj)) {

Py_DECREF(errobj);

return NULL;

}

}

else {

return NULL;

}

*pspace = (int *)PyCapsule_GetPointer(errobj, CTYPES_CAPSULE_NAME_PYMEM);

return errobj;

}

static PyObject *

get_error_internal(PyObject *self, PyObject *args, int index)

{

int *space;

PyObject *errobj = _ctypes_get_errobj(&space);

PyObject *result;

if (errobj == NULL)

return NULL;

result = PyLong_FromLong(space[index]);

Py_DECREF(errobj);

return result;

}

static PyObject *

set_error_internal(PyObject *self, PyObject *args, int index)

{

int new_errno, old_errno;

PyObject *errobj;

int *space;

if (!PyArg_ParseTuple(args, "i", &new_errno)) {

return NULL;

}

errobj = _ctypes_get_errobj(&space);

if (errobj == NULL)

return NULL;

old_errno = space[index];

space[index] = new_errno;

Py_DECREF(errobj);

return PyLong_FromLong(old_errno);

}

static PyObject *

get_errno(PyObject *self, PyObject *args)

{

if (PySys_Audit("ctypes.get_errno", NULL) < 0) {

return NULL;

}

return get_error_internal(self, args, 0);

}

static PyObject *

set_errno(PyObject *self, PyObject *args)

{

if (PySys_Audit("ctypes.set_errno", "O", args) < 0) {

return NULL;

}

return set_error_internal(self, args, 0);

}

#ifdef MS_WIN32

static PyObject *

get_last_error(PyObject *self, PyObject *args)

{

if (PySys_Audit("ctypes.get_last_error", NULL) < 0) {

return NULL;

}

return get_error_internal(self, args, 1);

}

static PyObject *

set_last_error(PyObject *self, PyObject *args)

{

if (PySys_Audit("ctypes.set_last_error", "O", args) < 0) {

return NULL;

}

return set_error_internal(self, args, 1);

}

static WCHAR *FormatError(DWORD code)

{

WCHAR *lpMsgBuf;

DWORD n;

n = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM |

FORMAT_MESSAGE_IGNORE_INSERTS,

NULL,

code,

MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */

(LPWSTR) &lpMsgBuf,

0,

NULL);

if (n) {

while (iswspace(lpMsgBuf[n-1]))

--n;

lpMsgBuf[n] = L'\0'; /* rstrip() */

}

return lpMsgBuf;

}

#ifndef DONT_USE_SEH

static void SetException(DWORD code, EXCEPTION_RECORD *pr)

{

if (PySys_Audit("ctypes.set_exception", "I", code) < 0) {

/* An exception was set by the audit hook */

return;

}

/* The 'code' is a normal win32 error code so it could be handled by

switch (code) {

case EXCEPTION_ACCESS_VIOLATION:

/* The thread attempted to read from or write

if (pr->ExceptionInformation[0] == 0)

PyErr_Format(PyExc_OSError,

"exception: access violation reading %p",

pr->ExceptionInformation[1]);

else

PyErr_Format(PyExc_OSError,

"exception: access violation writing %p",

pr->ExceptionInformation[1]);

break;

case EXCEPTION_BREAKPOINT:

/* A breakpoint was encountered. */

PyErr_SetString(PyExc_OSError,

"exception: breakpoint encountered");

break;

case EXCEPTION_DATATYPE_MISALIGNMENT:

/* The thread attempted to read or write data that is

PyErr_SetString(PyExc_OSError,

"exception: datatype misalignment");

break;

case EXCEPTION_SINGLE_STEP:

/* A trace trap or other single-instruction mechanism

PyErr_SetString(PyExc_OSError,

"exception: single step");

break;

case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:

/* The thread attempted to access an array element

PyErr_SetString(PyExc_OSError,

"exception: array bounds exceeded");

break;

case EXCEPTION_FLT_DENORMAL_OPERAND:

/* One of the operands in a floating-point operation

PyErr_SetString(PyExc_OSError,

"exception: floating-point operand denormal");

break;

case EXCEPTION_FLT_DIVIDE_BY_ZERO:

/* The thread attempted to divide a floating-point

PyErr_SetString(PyExc_OSError,

"exception: float divide by zero");

break;

case EXCEPTION_FLT_INEXACT_RESULT:

/* The result of a floating-point operation cannot be

PyErr_SetString(PyExc_OSError,

"exception: float inexact");

break;

case EXCEPTION_FLT_INVALID_OPERATION:

/* This exception represents any floating-point

PyErr_SetString(PyExc_OSError,

"exception: float invalid operation");

break;

case EXCEPTION_FLT_OVERFLOW:

/* The exponent of a floating-point operation is

PyErr_SetString(PyExc_OSError,

"exception: float overflow");

break;

case EXCEPTION_FLT_STACK_CHECK:

/* The stack overflowed or underflowed as the result

PyErr_SetString(PyExc_OSError,

"exception: stack over/underflow");

break;

case EXCEPTION_STACK_OVERFLOW:

/* The stack overflowed or underflowed as the result

PyErr_SetString(PyExc_OSError,

"exception: stack overflow");

break;

case EXCEPTION_FLT_UNDERFLOW:

/* The exponent of a floating-point operation is less

PyErr_SetString(PyExc_OSError,

"exception: float underflow");

break;

case EXCEPTION_INT_DIVIDE_BY_ZERO:

/* The thread attempted to divide an integer value by

PyErr_SetString(PyExc_OSError,

"exception: integer divide by zero");

break;

case EXCEPTION_INT_OVERFLOW:

/* The result of an integer operation caused a carry

PyErr_SetString(PyExc_OSError,

"exception: integer overflow");

break;

case EXCEPTION_PRIV_INSTRUCTION:

/* The thread attempted to execute an instruction

PyErr_SetString(PyExc_OSError,

"exception: privileged instruction");

break;

case EXCEPTION_NONCONTINUABLE_EXCEPTION:

/* The thread attempted to continue execution after a

PyErr_SetString(PyExc_OSError,

"exception: nocontinuable");

break;

default:

PyErr_SetFromWindowsErr(code);

break;

}

}

static DWORD HandleException(EXCEPTION_POINTERS *ptrs,

DWORD *pdw, EXCEPTION_RECORD *record)

{

*pdw = ptrs->ExceptionRecord->ExceptionCode;

*record = *ptrs->ExceptionRecord;

/* We don't want to catch breakpoint exceptions, they are used to attach

if (*pdw == EXCEPTION_BREAKPOINT)

return EXCEPTION_CONTINUE_SEARCH;

return EXCEPTION_EXECUTE_HANDLER;

}

static PyObject *

check_hresult(PyObject *self, PyObject *args)

{

HRESULT hr;

if (!PyArg_ParseTuple(args, "i", &hr))

return NULL;

if (FAILED(hr))

return PyErr_SetFromWindowsErr(hr);

return PyLong_FromLong(hr);

}

PyCArgObject *

PyCArgObject_new(void)

{

PyCArgObject *p;

ctypes_state *st = GLOBAL_STATE();

p = PyObject_GC_New(PyCArgObject, st->PyCArg_Type);

if (p == NULL)

return NULL;

p->pffi_type = NULL;

p->tag = '\0';

p->obj = NULL;

memset(&p->value, 0, sizeof(p->value));

PyObject_GC_Track(p);

return p;

}

static int

PyCArg_traverse(PyCArgObject *self, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(self));

Py_VISIT(self->obj);

return 0;

}

static int

PyCArg_clear(PyCArgObject *self)

{

Py_CLEAR(self->obj);

return 0;

}

static void

PyCArg_dealloc(PyCArgObject *self)

{

PyTypeObject *tp = Py_TYPE(self);

PyObject_GC_UnTrack(self);

(void)PyCArg_clear(self);

tp->tp_free((PyObject *)self);

Py_DECREF(tp);

}

static int

is_literal_char(unsigned char c)

{

return c < 128 && _PyUnicode_IsPrintable(c) && c != '\\' && c != '\'';

}

static PyObject *

PyCArg_repr(PyCArgObject *self)

{

switch(self->tag) {

case 'b':

case 'B':

return PyUnicode_FromFormat("<cparam '%c' (%d)>",

self->tag, self->value.b);

case 'h':

case 'H':

return PyUnicode_FromFormat("<cparam '%c' (%d)>",

self->tag, self->value.h);

case 'i':

case 'I':

return PyUnicode_FromFormat("<cparam '%c' (%d)>",

self->tag, self->value.i);

case 'l':

case 'L':

return PyUnicode_FromFormat("<cparam '%c' (%ld)>",

self->tag, self->value.l);

case 'q':

case 'Q':

return PyUnicode_FromFormat("<cparam '%c' (%lld)>",

self->tag, self->value.q);

case 'd':

case 'f': {

PyObject *f = PyFloat_FromDouble((self->tag == 'f') ? self->value.f : self->value.d);

if (f == NULL) {

return NULL;

}

PyObject *result = PyUnicode_FromFormat("<cparam '%c' (%R)>", self->tag, f);

Py_DECREF(f);

return result;

}

case 'c':

if (is_literal_char((unsigned char)self->value.c)) {

return PyUnicode_FromFormat("<cparam '%c' ('%c')>",

self->tag, self->value.c);

}

else {

return PyUnicode_FromFormat("<cparam '%c' ('\\x%02x')>",

self->tag, (unsigned char)self->value.c);

}

case 'z':

case 'Z':

case 'P':

return PyUnicode_FromFormat("<cparam '%c' (%p)>",

self->tag, self->value.p);

break;

default:

if (is_literal_char((unsigned char)self->tag)) {

return PyUnicode_FromFormat("<cparam '%c' at %p>",

(unsigned char)self->tag, (void *)self);

}

else {

return PyUnicode_FromFormat("<cparam 0x%02x at %p>",

(unsigned char)self->tag, (void *)self);

}

}

}

static PyMemberDef PyCArgType_members[] = {

{ "_obj", _Py_T_OBJECT,

offsetof(PyCArgObject, obj), Py_READONLY,

"the wrapped object" },

{ NULL },

};

static PyType_Slot carg_slots[] = {

{Py_tp_dealloc, PyCArg_dealloc},

{Py_tp_traverse, PyCArg_traverse},

{Py_tp_clear, PyCArg_clear},

{Py_tp_repr, PyCArg_repr},

{Py_tp_members, PyCArgType_members},

{0, NULL},

};

PyType_Spec carg_spec = {

.name = "_ctypes.CArgObject",

.basicsize = sizeof(PyCArgObject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION),

.slots = carg_slots,

};

union result {

char c;

char b;

short h;

int i;

long l;

long long q;

long double D;

double d;

float f;

void *p;

};

struct argument {

};

static int ConvParam(PyObject *obj, Py_ssize_t index, struct argument *pa)

{

StgDictObject *dict;

pa->keep = NULL; /* so we cannot forget it later */

dict = PyObject_stgdict(obj);

if (dict) {

PyCArgObject *carg;

assert(dict->paramfunc);

/* If it has an stgdict, it is a CDataObject */

carg = dict->paramfunc((CDataObject *)obj);

if (carg == NULL)

return -1;

pa->ffi_type = carg->pffi_type;

memcpy(&pa->value, &carg->value, sizeof(pa->value));

pa->keep = (PyObject *)carg;

return 0;

}

ctypes_state *st = GLOBAL_STATE();

if (PyCArg_CheckExact(st, obj)) {

PyCArgObject *carg = (PyCArgObject *)obj;

pa->ffi_type = carg->pffi_type;

pa->keep = Py_NewRef(obj);

memcpy(&pa->value, &carg->value, sizeof(pa->value));

return 0;

}

/* check for None, integer, string or unicode and use directly if successful */

if (obj == Py_None) {

pa->ffi_type = &ffi_type_pointer;

pa->value.p = NULL;

return 0;

}

if (PyLong_Check(obj)) {

pa->ffi_type = &ffi_type_sint;

pa->value.i = (long)PyLong_AsUnsignedLong(obj);

if (pa->value.i == -1 && PyErr_Occurred()) {

PyErr_Clear();

pa->value.i = PyLong_AsLong(obj);

if (pa->value.i == -1 && PyErr_Occurred()) {

PyErr_SetString(PyExc_OverflowError,

"int too long to convert");

return -1;

}

}

return 0;

}

if (PyBytes_Check(obj)) {

pa->ffi_type = &ffi_type_pointer;

pa->value.p = PyBytes_AsString(obj);

pa->keep = Py_NewRef(obj);

return 0;

}

if (PyUnicode_Check(obj)) {

pa->ffi_type = &ffi_type_pointer;

pa->value.p = PyUnicode_AsWideCharString(obj, NULL);

if (pa->value.p == NULL)

return -1;

pa->keep = PyCapsule_New(pa->value.p, CTYPES_CAPSULE_NAME_PYMEM, pymem_destructor);

if (!pa->keep) {

PyMem_Free(pa->value.p);

return -1;

}

return 0;

}

{

PyObject *arg;

if (PyObject_GetOptionalAttr(obj, &_Py_ID(_as_parameter_), &arg) < 0) {

return -1;

}

/* Which types should we exactly allow here?

if (arg) {

int result;

result = ConvParam(arg, index, pa);

Py_DECREF(arg);

return result;

}

PyErr_Format(PyExc_TypeError,

"Don't know how to convert parameter %d",

Py_SAFE_DOWNCAST(index, Py_ssize_t, int));

return -1;

}

}

#if defined(MS_WIN32) && !defined(_WIN32_WCE)

int can_return_struct_as_int(size_t s)

{

return s == 1 || s == 2 || s == 4;

}

int can_return_struct_as_sint64(size_t s)

{

#ifdef _M_ARM

// 8 byte structs cannot be returned in a register on ARM32

return 0;

return s == 8;

}

ffi_type *_ctypes_get_ffi_type(PyObject *obj)

{

StgDictObject *dict;

if (obj == NULL)

return &ffi_type_sint;

dict = PyType_stgdict(obj);

if (dict == NULL)

return &ffi_type_sint;

#if defined(MS_WIN32) && !defined(_WIN32_WCE)

/* This little trick works correctly with MSVC.

if (dict->ffi_type_pointer.type == FFI_TYPE_STRUCT) {

if (can_return_struct_as_int(dict->ffi_type_pointer.size))

return &ffi_type_sint32;

else if (can_return_struct_as_sint64 (dict->ffi_type_pointer.size))

return &ffi_type_sint64;

}

return &dict->ffi_type_pointer;

}

static int _call_function_pointer(int flags,

int argtypecount)

{

PyThreadState *_save = NULL; /* For Py_BLOCK_THREADS and Py_UNBLOCK_THREADS */

PyObject *error_object = NULL;

int *space;

ffi_cif cif;

int cc;

#if defined(MS_WIN32) && !defined(DONT_USE_SEH)

DWORD dwExceptionCode = 0;

EXCEPTION_RECORD record;

/* XXX check before here */

if (restype == NULL) {

PyErr_SetString(PyExc_RuntimeError,

"No ffi_type for result");

return -1;

}

cc = FFI_DEFAULT_ABI;

#if defined(MS_WIN32) && !defined(MS_WIN64) && !defined(_WIN32_WCE) && !defined(_M_ARM)

if ((flags & FUNCFLAG_CDECL) == 0)

cc = FFI_STDCALL;

# ifdef USING_APPLE_OS_LIBFFI

# ifdef HAVE_BUILTIN_AVAILABLE

# define HAVE_FFI_PREP_CIF_VAR_RUNTIME __builtin_available(macos 10.15, ios 13, watchos 6, tvos 13, *)

# define HAVE_FFI_PREP_CIF_VAR_RUNTIME (ffi_prep_cif_var != NULL)

# elif HAVE_FFI_PREP_CIF_VAR

# define HAVE_FFI_PREP_CIF_VAR_RUNTIME true

# define HAVE_FFI_PREP_CIF_VAR_RUNTIME false

/* Even on Apple-arm64 the calling convention for variadic functions coincides

bool is_variadic = (argtypecount != 0 && argcount > argtypecount);

(void) is_variadic;

#if defined(__APPLE__) && defined(__arm64__)

if (is_variadic) {

if (HAVE_FFI_PREP_CIF_VAR_RUNTIME) {

} else {

PyErr_SetString(PyExc_NotImplementedError, "ffi_prep_cif_var() is missing");

return -1;

}

}

#if HAVE_FFI_PREP_CIF_VAR

if (is_variadic) {

if (HAVE_FFI_PREP_CIF_VAR_RUNTIME) {

if (FFI_OK != ffi_prep_cif_var(&cif,

cc,

argtypecount,

argcount,

restype,

atypes)) {

PyErr_SetString(PyExc_RuntimeError,

"ffi_prep_cif_var failed");

return -1;

}

} else {

if (FFI_OK != ffi_prep_cif(&cif,

cc,

argcount,

restype,

atypes)) {

PyErr_SetString(PyExc_RuntimeError,

"ffi_prep_cif failed");

return -1;

}

}

} else

{

if (FFI_OK != ffi_prep_cif(&cif,

cc,

argcount,

restype,

atypes)) {

PyErr_SetString(PyExc_RuntimeError,

"ffi_prep_cif failed");

return -1;

}

}

if (flags & (FUNCFLAG_USE_ERRNO | FUNCFLAG_USE_LASTERROR)) {

error_object = _ctypes_get_errobj(&space);

if (error_object == NULL)

return -1;

}

if ((flags & FUNCFLAG_PYTHONAPI) == 0)

Py_UNBLOCK_THREADS

if (flags & FUNCFLAG_USE_ERRNO) {

int temp = space[0];

space[0] = errno;

errno = temp;

}

#ifdef MS_WIN32

if (flags & FUNCFLAG_USE_LASTERROR) {

int temp = space[1];

space[1] = GetLastError();

SetLastError(temp);

}

#ifndef DONT_USE_SEH

__try {

ffi_call(&cif, (void *)pProc, resmem, avalues);

#ifdef MS_WIN32

#ifndef DONT_USE_SEH

}

__except (HandleException(GetExceptionInformation(),

&dwExceptionCode, &record)) {

;

}

if (flags & FUNCFLAG_USE_LASTERROR) {

int temp = space[1];

space[1] = GetLastError();

SetLastError(temp);

}

if (flags & FUNCFLAG_USE_ERRNO) {

int temp = space[0];

space[0] = errno;

errno = temp;

}

if ((flags & FUNCFLAG_PYTHONAPI) == 0)

Py_BLOCK_THREADS

Py_XDECREF(error_object);

#ifdef MS_WIN32

#ifndef DONT_USE_SEH

if (dwExceptionCode) {

SetException(dwExceptionCode, &record);

return -1;

}

if ((flags & FUNCFLAG_PYTHONAPI) && PyErr_Occurred())

return -1;

return 0;

}

static PyObject *GetResult(PyObject *restype, void *result, PyObject *checker)

{

StgDictObject *dict;

PyObject *retval, *v;

if (restype == NULL)

return PyLong_FromLong(*(int *)result);

if (restype == Py_None) {

Py_RETURN_NONE;

}

dict = PyType_stgdict(restype);

if (dict == NULL)

return PyObject_CallFunction(restype, "i", *(int *)result);