static void
on_udp_read(uv_udp_t* handle, int nread, uv_buf_t buf, struct sockaddr* addr, unsigned flags)
{
PyGILState_STATE gstate = PyGILState_Ensure();
char ip[INET6_ADDRSTRLEN];
struct sockaddr_in addr4;
struct sockaddr_in6 addr6;
uv_err_t err;
UDP *self;
PyObject *result, *address_tuple, *data, *py_errorno;
ASSERT(handle);
ASSERT(flags == 0);
self = (UDP *)handle->data;
ASSERT(self);
/* Object could go out of scope in the callback, increase refcount to avoid it */
Py_INCREF(self);
if (nread == 0) {
goto done;
}
if (nread > 0) {
ASSERT(addr);
if (addr->sa_family == AF_INET) {
addr4 = *(struct sockaddr_in*)addr;
uv_ip4_name(&addr4, ip, INET_ADDRSTRLEN);
address_tuple = Py_BuildValue("(si)", ip, ntohs(addr4.sin_port));
} else {
addr6 = *(struct sockaddr_in6*)addr;
uv_ip6_name(&addr6, ip, INET6_ADDRSTRLEN);
address_tuple = Py_BuildValue("(si)", ip, ntohs(addr6.sin6_port));
}
data = PyBytes_FromStringAndSize(buf.base, nread);
py_errorno = Py_None;
Py_INCREF(Py_None);
} else if (nread < 0) {
address_tuple = Py_None;
Py_INCREF(Py_None);
data = Py_None;
Py_INCREF(Py_None);
err = uv_last_error(UV_HANDLE_LOOP(self));
py_errorno = PyInt_FromLong((long)err.code);
}
result = PyObject_CallFunctionObjArgs(self->on_read_cb, self, address_tuple, data, py_errorno, NULL);
if (result == NULL) {
handle_uncaught_exception(((Handle *)self)->loop);
}
Py_XDECREF(result);
Py_DECREF(address_tuple);
Py_DECREF(data);
Py_DECREF(py_errorno);
done:
/* In case of error libuv may not call alloc_cb */
if (buf.base != NULL) {
PyMem_Free(buf.base);
}
Py_DECREF(self);
PyGILState_Release(gstate);
}
/* Retrieves the file size
* Returns 1 if successful or -1 on error
*/
int pysmraw_file_object_io_handle_get_size(
pysmraw_file_object_io_handle_t *file_object_io_handle,
size64_t *size,
libcerror_error_t **error )
{
PyObject *method_name = NULL;
static char *function = "pysmraw_file_object_io_handle_get_size";
PyGILState_STATE gil_state = 0;
off64_t current_offset = 0;
int result = 0;
if( file_object_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file object IO handle.",
function );
return( -1 );
}
if( file_object_io_handle->file_object == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid file object IO handle - missing file object.",
function );
return( -1 );
}
gil_state = PyGILState_Ensure();
#if PY_MAJOR_VERSION >= 3
method_name = PyUnicode_FromString(
"get_size" );
#else
method_name = PyString_FromString(
"get_size" );
#endif
PyErr_Clear();
/* Determine if the file object has the get_size method
*/
result = PyObject_HasAttr(
file_object_io_handle->file_object,
method_name );
if( result != 0 )
{
if( pysmraw_file_object_get_size(
file_object_io_handle->file_object,
size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve size of file object.",
function );
goto on_error;
}
}
else
{
if( pysmraw_file_object_get_offset(
file_object_io_handle->file_object,
¤t_offset,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve current offset in file object.",
function );
goto on_error;
}
if( pysmraw_file_object_seek_offset(
file_object_io_handle->file_object,
0,
SEEK_END,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek end of file object.",
function );
goto on_error;
}
if( pysmraw_file_object_get_offset(
file_object_io_handle->file_object,
(off64_t *) size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve end offset in file object.",
function );
pysmraw_file_object_seek_offset(
file_object_io_handle->file_object,
current_offset,
SEEK_SET,
NULL );
goto on_error;
}
if( pysmraw_file_object_seek_offset(
file_object_io_handle->file_object,
current_offset,
SEEK_SET,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek current offset in file object.",
function );
goto on_error;
}
}
Py_DecRef(
method_name );
PyGILState_Release(
gil_state );
return( 1 );
on_error:
if( method_name != NULL )
{
Py_DecRef(
method_name );
}
PyGILState_Release(
gil_state );
return( 1 );
}
/*
* External interface
*/
static void
DoPy3Command(exarg_T *eap, const char *cmd)
{
#if defined(MACOS) && !defined(MACOS_X_UNIX)
GrafPtr oldPort;
#endif
#if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
char *saved_locale;
#endif
PyObject *cmdstr;
PyObject *cmdbytes;
#if defined(MACOS) && !defined(MACOS_X_UNIX)
GetPort(&oldPort);
/* Check if the Python library is available */
if ((Ptr)PyMac_Initialize == (Ptr)kUnresolvedCFragSymbolAddress)
goto theend;
#endif
if (Python3_Init())
goto theend;
RangeStart = eap->line1;
RangeEnd = eap->line2;
Python_Release_Vim(); /* leave vim */
#if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
/* Python only works properly when the LC_NUMERIC locale is "C". */
saved_locale = setlocale(LC_NUMERIC, NULL);
if (saved_locale == NULL || STRCMP(saved_locale, "C") == 0)
saved_locale = NULL;
else
{
/* Need to make a copy, value may change when setting new locale. */
saved_locale = (char *)vim_strsave((char_u *)saved_locale);
(void)setlocale(LC_NUMERIC, "C");
}
#endif
pygilstate = PyGILState_Ensure();
/* PyRun_SimpleString expects a UTF-8 string. Wrong encoding may cause
* SyntaxError (unicode error). */
cmdstr = PyUnicode_Decode(cmd, strlen(cmd),
(char *)ENC_OPT, CODEC_ERROR_HANDLER);
cmdbytes = PyUnicode_AsEncodedString(cmdstr, "utf-8", CODEC_ERROR_HANDLER);
Py_XDECREF(cmdstr);
PyRun_SimpleString(PyBytes_AsString(cmdbytes));
Py_XDECREF(cmdbytes);
PyGILState_Release(pygilstate);
#if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
if (saved_locale != NULL)
{
(void)setlocale(LC_NUMERIC, saved_locale);
vim_free(saved_locale);
}
#endif
Python_Lock_Vim(); /* enter vim */
PythonIO_Flush();
#if defined(MACOS) && !defined(MACOS_X_UNIX)
SetPort(oldPort);
#endif
theend:
return; /* keeps lint happy */
}
/******************************************************************************
*
* Call the python object with all arguments
*
*/
static void _CallPythonObject(void *mem,
ffi_type *restype,
SETFUNC setfunc,
PyObject *callable,
PyObject *converters,
void **pArgs)
{
int i;
PyObject *result;
PyObject *arglist = NULL;
int nArgs;
#ifdef WITH_THREAD
PyGILState_STATE state = PyGILState_Ensure();
#endif
nArgs = PySequence_Length(converters);
/* Hm. What to return in case of error?
For COM, 0xFFFFFFFF seems better than 0.
*/
if (nArgs < 0) {
PrintError("BUG: PySequence_Length");
goto Done;
}
arglist = PyTuple_New(nArgs);
if (!arglist) {
PrintError("PyTuple_New()");
goto Done;
}
for (i = 0; i < nArgs; ++i) {
/* Note: new reference! */
PyObject *cnv = PySequence_GetItem(converters, i);
StgDictObject *dict;
if (cnv)
dict = PyType_stgdict(cnv);
else {
PrintError("Getting argument converter %d\n", i);
goto Done;
}
if (dict && dict->getfunc && !IsSimpleSubType(cnv)) {
PyObject *v = dict->getfunc(*pArgs, dict->size);
if (!v) {
PrintError("create argument %d:\n", i);
Py_DECREF(cnv);
goto Done;
}
PyTuple_SET_ITEM(arglist, i, v);
/* XXX XXX XX
We have the problem that c_byte or c_short have dict->size of
1 resp. 4, but these parameters are pushed as sizeof(int) bytes.
BTW, the same problem occurrs when they are pushed as parameters
*/
} else if (dict) {
/* Hm, shouldn't we use CData_AtAddress() or something like that instead? */
CDataObject *obj = (CDataObject *)PyObject_CallFunctionObjArgs(cnv, NULL);
if (!obj) {
PrintError("create argument %d:\n", i);
Py_DECREF(cnv);
goto Done;
}
if (!CDataObject_Check(obj)) {
Py_DECREF(obj);
Py_DECREF(cnv);
PrintError("unexpected result of create argument %d:\n", i);
goto Done;
}
memcpy(obj->b_ptr, *pArgs, dict->size);
PyTuple_SET_ITEM(arglist, i, (PyObject *)obj);
#ifdef MS_WIN32
TryAddRef(dict, obj);
#endif
} else {
PyErr_SetString(PyExc_TypeError,
"cannot build parameter");
PrintError("Parsing argument %d\n", i);
Py_DECREF(cnv);
goto Done;
}
Py_DECREF(cnv);
/* XXX error handling! */
pArgs++;
}
#define CHECK(what, x) \
if (x == NULL) _AddTraceback(what, __FILE__, __LINE__ - 1), PyErr_Print()
result = PyObject_CallObject(callable, arglist);
CHECK("'calling callback function'", result);
if ((restype != &ffi_type_void) && result) {
PyObject *keep;
assert(setfunc);
#ifdef WORDS_BIGENDIAN
/* See the corresponding code in callproc.c, around line 961 */
if (restype->type != FFI_TYPE_FLOAT && restype->size < sizeof(ffi_arg))
mem = (char *)mem + sizeof(ffi_arg) - restype->size;
#endif
keep = setfunc(mem, result, 0);
CHECK("'converting callback result'", keep);
/* keep is an object we have to keep alive so that the result
stays valid. If there is no such object, the setfunc will
have returned Py_None.
If there is such an object, we have no choice than to keep
it alive forever - but a refcount and/or memory leak will
be the result. EXCEPT when restype is py_object - Python
itself knows how to manage the refcount of these objects.
*/
if (keep == NULL) /* Could not convert callback result. */
PyErr_WriteUnraisable(callable);
else if (keep == Py_None) /* Nothing to keep */
Py_DECREF(keep);
else if (setfunc != getentry("O")->setfunc) {
if (-1 == PyErr_Warn(PyExc_RuntimeWarning,
"memory leak in callback function."))
PyErr_WriteUnraisable(callable);
}
}
Py_XDECREF(result);
Done:
Py_XDECREF(arglist);
#ifdef WITH_THREAD
PyGILState_Release(state);
#endif
}
static void gil_gevent_get() {
pthread_setspecific(up.upt_gil_key, (void *) PyGILState_Ensure());
}
PyScopedGIL() {
gstate = PyGILState_Ensure();
}
int pythonmod_init(struct module_env* env, int id)
{
/* Initialize module */
FILE* script_py = NULL;
PyObject* py_cfg, *res;
PyGILState_STATE gil;
struct pythonmod_env* pe = (struct pythonmod_env*)calloc(1, sizeof(struct pythonmod_env));
if (!pe)
{
log_err("pythonmod: malloc failure");
return 0;
}
env->modinfo[id] = (void*) pe;
/* Initialize module */
pe->fname = env->cfg->python_script;
if(pe->fname==NULL || pe->fname[0]==0) {
log_err("pythonmod: no script given.");
return 0;
}
/* Initialize Python libraries */
if (!Py_IsInitialized())
{
Py_SetProgramName("unbound");
Py_NoSiteFlag = 1;
Py_Initialize();
PyEval_InitThreads();
SWIG_init();
pe->mainthr = PyEval_SaveThread();
}
gil = PyGILState_Ensure();
/* Initialize Python */
PyRun_SimpleString("import sys \n");
PyRun_SimpleString("sys.path.append('.') \n");
if(env->cfg->directory && env->cfg->directory[0]) {
char wdir[1524];
snprintf(wdir, sizeof(wdir), "sys.path.append('%s') \n",
env->cfg->directory);
PyRun_SimpleString(wdir);
}
PyRun_SimpleString("sys.path.append('"RUN_DIR"') \n");
PyRun_SimpleString("sys.path.append('"SHARE_DIR"') \n");
PyRun_SimpleString("import distutils.sysconfig \n");
PyRun_SimpleString("sys.path.append(distutils.sysconfig.get_python_lib(1,0)) \n");
if (PyRun_SimpleString("from unboundmodule import *\n") < 0)
{
log_err("pythonmod: cannot initialize core module: unboundmodule.py");
PyGILState_Release(gil);
return 0;
}
/* Check Python file load */
if ((script_py = fopen(pe->fname, "r")) == NULL)
{
log_err("pythonmod: can't open file %s for reading", pe->fname);
PyGILState_Release(gil);
return 0;
}
/* Load file */
pe->module = PyImport_AddModule("__main__");
pe->dict = PyModule_GetDict(pe->module);
pe->data = Py_None;
Py_INCREF(pe->data);
PyModule_AddObject(pe->module, "mod_env", pe->data);
/* TODO: deallocation of pe->... if an error occurs */
if (PyRun_SimpleFile(script_py, pe->fname) < 0)
{
log_err("pythonmod: can't parse Python script %s", pe->fname);
PyGILState_Release(gil);
return 0;
}
fclose(script_py);
if ((pe->func_init = PyDict_GetItemString(pe->dict, "init")) == NULL)
{
log_err("pythonmod: function init is missing in %s", pe->fname);
PyGILState_Release(gil);
return 0;
}
if ((pe->func_deinit = PyDict_GetItemString(pe->dict, "deinit")) == NULL)
{
log_err("pythonmod: function deinit is missing in %s", pe->fname);
PyGILState_Release(gil);
return 0;
}
if ((pe->func_operate = PyDict_GetItemString(pe->dict, "operate")) == NULL)
{
log_err("pythonmod: function operate is missing in %s", pe->fname);
PyGILState_Release(gil);
return 0;
}
if ((pe->func_inform = PyDict_GetItemString(pe->dict, "inform_super")) == NULL)
{
log_err("pythonmod: function inform_super is missing in %s", pe->fname);
PyGILState_Release(gil);
return 0;
}
py_cfg = SWIG_NewPointerObj((void*) env->cfg, SWIGTYPE_p_config_file, 0);
res = PyObject_CallFunction(pe->func_init, "iO", id, py_cfg);
if (PyErr_Occurred())
{
log_err("pythonmod: Exception occurred in function init");
PyErr_Print();
}
Py_XDECREF(res);
Py_XDECREF(py_cfg);
PyGILState_Release(gil);
return 1;
}
static void
nameinfo_cb(void *arg, int status, int timeouts, char *node, char *service)
{
PyGILState_STATE gstate = PyGILState_Ensure();
ares_cb_data_t *data;
DNSResolver *self;
PyObject *callback, *errorno, *dns_node, *dns_service, *dns_result, *result;
ASSERT(arg);
data = (ares_cb_data_t*)arg;
self = data->resolver;
callback = data->cb;
ASSERT(self);
/* Object could go out of scope in the callback, increase refcount to avoid it */
Py_INCREF(self);
if (status != ARES_SUCCESS) {
errorno = PyInt_FromLong((long)status);
dns_result = Py_None;
Py_INCREF(Py_None);
goto callback;
}
dns_result = PyTuple_New(2);
if (!dns_result) {
PyErr_NoMemory();
PyErr_WriteUnraisable(Py_None);
errorno = PyInt_FromLong((long)ARES_ENOMEM);
dns_result = Py_None;
Py_INCREF(Py_None);
goto callback;
}
dns_node = PyString_FromString(node);
if (service) {
dns_service = PyString_FromString(service);
} else {
dns_service = Py_None;
Py_INCREF(Py_None);
}
PyTuple_SET_ITEM(dns_result, 0, dns_node);
PyTuple_SET_ITEM(dns_result, 1, dns_service);
errorno = Py_None;
Py_INCREF(Py_None);
callback:
result = PyObject_CallFunctionObjArgs(callback, self, dns_result, errorno, NULL);
if (result == NULL) {
PyErr_WriteUnraisable(callback);
}
Py_XDECREF(result);
Py_DECREF(callback);
PyMem_Free(data);
Py_DECREF(self);
PyGILState_Release(gstate);
}
static void
host_cb(void *arg, int status, int timeouts, struct hostent *hostent)
{
PyGILState_STATE gstate = PyGILState_Ensure();
char ip[INET6_ADDRSTRLEN];
char **ptr;
ares_cb_data_t *data;
DNSResolver *self;
PyObject *callback, *dns_name, *errorno, *dns_aliases, *dns_addrlist, *dns_result, *tmp, *result;
ASSERT(arg);
data = (ares_cb_data_t*)arg;
self = data->resolver;
callback = data->cb;
ASSERT(self);
/* Object could go out of scope in the callback, increase refcount to avoid it */
Py_INCREF(self);
if (status != ARES_SUCCESS) {
errorno = PyInt_FromLong((long)status);
dns_result = Py_None;
Py_INCREF(Py_None);
goto callback;
}
dns_aliases = PyList_New(0);
dns_addrlist = PyList_New(0);
dns_result = PyTuple_New(3);
if (!(dns_aliases && dns_addrlist && dns_result)) {
PyErr_NoMemory();
PyErr_WriteUnraisable(Py_None);
Py_XDECREF(dns_aliases);
Py_XDECREF(dns_addrlist);
Py_XDECREF(dns_result);
errorno = PyInt_FromLong((long)ARES_ENOMEM);
dns_result = Py_None;
Py_INCREF(Py_None);
goto callback;
}
for (ptr = hostent->h_aliases; *ptr != NULL; ptr++) {
if (*ptr != hostent->h_name && strcmp(*ptr, hostent->h_name)) {
tmp = PyString_FromString(*ptr);
if (tmp == NULL) {
break;
}
PyList_Append(dns_aliases, tmp);
Py_DECREF(tmp);
}
}
for (ptr = hostent->h_addr_list; *ptr != NULL; ptr++) {
if (hostent->h_addrtype == AF_INET) {
uv_inet_ntop(AF_INET, *ptr, ip, INET_ADDRSTRLEN);
tmp = PyString_FromString(ip);
} else if (hostent->h_addrtype == AF_INET6) {
uv_inet_ntop(AF_INET6, *ptr, ip, INET6_ADDRSTRLEN);
tmp = PyString_FromString(ip);
} else {
continue;
}
if (tmp == NULL) {
break;
}
PyList_Append(dns_addrlist, tmp);
Py_DECREF(tmp);
}
dns_name = PyString_FromString(hostent->h_name);
PyTuple_SET_ITEM(dns_result, 0, dns_name);
PyTuple_SET_ITEM(dns_result, 1, dns_aliases);
PyTuple_SET_ITEM(dns_result, 2, dns_addrlist);
errorno = Py_None;
Py_INCREF(Py_None);
callback:
result = PyObject_CallFunctionObjArgs(callback, self, dns_result, errorno, NULL);
if (result == NULL) {
PyErr_WriteUnraisable(callback);
}
Py_XDECREF(result);
Py_DECREF(callback);
PyMem_Free(data);
Py_DECREF(self);
PyGILState_Release(gstate);
}
static void kbdint_response_callback(const char* name, int name_len,
const char* instruction, int instruction_len,
int num_prompts,
const LIBSSH2_USERAUTH_KBDINT_PROMPT* prompts,
LIBSSH2_USERAUTH_KBDINT_RESPONSE* responses,
void **abstract)
{
PyGILState_STATE gstate = PyGILState_Ensure();
PyObject *callback = ((SSH2_SessionObj*) *abstract)->cb_kbdint_response;
PyObject *lprompts = PyList_New(num_prompts);
PyObject *rv = NULL;
PyObject *it = NULL;
int i;
for (i = 0; i < num_prompts; i++) {
PyList_SET_ITEM(lprompts, i, Py_BuildValue("(s#O)", prompts[i].text,
prompts[i].length,
prompts[i].echo ? Py_True : Py_False));
}
rv = PyObject_CallFunction(callback, "s#s#O", name, name_len, instruction, instruction_len, lprompts);
Py_DECREF(lprompts);
if (rv == NULL)
goto failure;
it = PyObject_GetIter(rv);
Py_DECREF(rv);
if (it == NULL)
goto failure;
for (i = 0; i < num_prompts; i++) {
PyObject *item = PyIter_Next(it);
char *s;
Py_ssize_t length;
int ret;
if (item == NULL) {
Py_DECREF(it);
if (!PyErr_Occurred()) {
PyErr_Format(PyExc_ValueError, "callback returned %i reponse(s), "
"but %i prompt(s) were given", i, num_prompts);
}
goto failure;
}
#if PY_MAJOR_VERSION < 3
ret = PyString_AsStringAndSize(item, &s, &length);
#else
{
PyObject *enc;
if ((enc = PyUnicode_AsEncodedString(item, NULL, "strict")) == NULL) {
Py_DECREF(item);
Py_DECREF(it);
goto failure;
}
ret = PyBytes_AsStringAndSize(enc, &s, &length);
Py_DECREF(enc);
}
#endif
Py_DECREF(item);
if (ret == -1) {
Py_DECREF(it);
goto failure;
}
responses[i].text = strndup(s, length);
responses[i].length = length;
}
Py_DECREF(it);
goto exit;
failure:
PyErr_WriteUnraisable(callback);
exit:
PyGILState_Release(gstate);
}
PyGILState_STATE TAKE_GIL(void)
{
PyGILState_STATE state = PyGILState_Ensure();
takes ++;
return state;
}
//-------------------------------------------------------------------------
P_GIL::P_GIL() {
if (!Py_IsInitialized()) {
OutputDebugString("Grabbing GIL from uninitilized Python?!");
}
this->state = PyGILState_Ensure();
}
gil_guard_t()
: gstate(PyGILState_Ensure())
, is_released(false)
{
}
void
_pygi_closure_handle (ffi_cif *cif,
void *result,
void **args,
void *data)
{
PyGILState_STATE state;
PyGICClosure *closure = data;
gint n_args, i;
GIArgInfo *arg_info;
GIDirection arg_direction;
GITypeInfo *arg_type;
GITransfer arg_transfer;
GITypeTag arg_tag;
GITypeTag return_tag;
GITransfer return_transfer;
GITypeInfo *return_type;
PyObject *retval;
PyObject *py_args;
PyObject *pyarg;
gint n_in_args, n_out_args;
/* Lock the GIL as we are coming into this code without the lock and we
may be executing python code */
state = PyGILState_Ensure();
return_type = g_callable_info_get_return_type(closure->info);
return_tag = g_type_info_get_tag(return_type);
return_transfer = g_callable_info_get_caller_owns(closure->info);
n_args = g_callable_info_get_n_args (closure->info);
py_args = PyTuple_New(n_args);
if (py_args == NULL) {
PyErr_Clear();
goto end;
}
n_in_args = 0;
for (i = 0; i < n_args; i++) {
arg_info = g_callable_info_get_arg (closure->info, i);
arg_type = g_arg_info_get_type (arg_info);
arg_transfer = g_arg_info_get_ownership_transfer(arg_info);
arg_tag = g_type_info_get_tag(arg_type);
arg_direction = g_arg_info_get_direction(arg_info);
switch (arg_tag) {
case GI_TYPE_TAG_VOID:
{
if (g_type_info_is_pointer(arg_type)) {
if (PyTuple_SetItem(py_args, n_in_args, closure->user_data) != 0) {
PyErr_Clear();
goto end;
}
n_in_args++;
continue;
}
}
case GI_TYPE_TAG_ERROR:
{
continue;
}
default:
{
pyarg = _pygi_argument_to_object (args[i],
arg_type,
arg_transfer);
if(PyTuple_SetItem(py_args, n_in_args, pyarg) != 0) {
PyErr_Clear();
goto end;
}
n_in_args++;
g_base_info_unref((GIBaseInfo*)arg_info);
g_base_info_unref((GIBaseInfo*)arg_type);
}
}
}
if(_PyTuple_Resize (&py_args, n_in_args) != 0) {
PyErr_Clear();
goto end;
}
retval = PyObject_CallObject((PyObject *)closure->function, py_args);
Py_DECREF(py_args);
if (retval == NULL) {
goto end;
}
*(GArgument*)result = _pygi_argument_from_object(retval, return_type, return_transfer);
end:
g_base_info_unref((GIBaseInfo*)return_type);
PyGILState_Release(state);
if (closure->user_data)
Py_XDECREF(closure->user_data);
/* Now that the closure has finished we can make a decision about how
to free it. Scope call gets free'd now, scope notified will be freed
when the notify is called and we can free async anytime we want
once we return from this function */
switch (closure->scope) {
case GI_SCOPE_TYPE_CALL:
_pygi_invoke_closure_free(closure);
break;
case GI_SCOPE_TYPE_NOTIFIED:
break;
case GI_SCOPE_TYPE_ASYNC:
/* Append this PyGICClosure to a list of closure that we will free
after we're done with this function invokation */
async_free_list = g_slist_prepend(async_free_list, closure);
break;
default:
g_assert_not_reached();
}
}
// get spectrum messages and delay them
static gboolean on_message(GstBus *bus, GstMessage *message, gpointer data)
{
base *base_object = data;
GstElement *spectrum = GST_ELEMENT(base_object->spectrum_element->obj);
gst_object_ref(spectrum);
GstElement *message_element = GST_ELEMENT(GST_MESSAGE_SRC(message));
gst_object_ref(message_element);
if (message_element == spectrum)
{
GstClockTime waittime = GST_CLOCK_TIME_NONE;
const GstStructure *message_structure = gst_message_get_structure(message);
// determine waittime
GstClockTime timestamp, duration;
if (
gst_structure_get_clock_time(message_structure, "running-time", ×tamp)
&& gst_structure_get_clock_time(message_structure, "duration", &duration)
)
{
/* wait for middle of buffer */
waittime = timestamp + duration/2;
}
else if (gst_structure_get_clock_time(message_structure, "endtime", ×tamp))
{
waittime = timestamp;
}
// delay message
if (GST_CLOCK_TIME_IS_VALID(waittime))
{
GstClockTime basetime = gst_element_get_base_time(spectrum);
GstClockID clock_id = gst_clock_new_single_shot_id(base_object->sync_clock, basetime+waittime);
spectrum_message *mess = g_malloc(sizeof(spectrum_message));
// set bands and threshold
g_object_get(message_element, "bands", &(mess->bands), "threshold", &(mess->threshold), NULL);
// set start and duration
GstClockTime streamtime, duration;
gst_structure_get_clock_time(message_structure, "stream-time", &streamtime);
gst_structure_get_clock_time(message_structure, "duration", &duration);
mess->start = (gfloat)streamtime / GST_SECOND;
mess->duration = (gfloat)duration / GST_SECOND;
// set rate
GstPad *sink = gst_element_get_static_pad(GST_ELEMENT(base_object->spectrum_element->obj), "sink");
GstCaps *caps = gst_pad_get_negotiated_caps(sink);
gst_object_unref(sink);
GstStructure *caps_structure = gst_caps_get_structure(caps, 0);
gst_structure_get_int(caps_structure, "rate", &(mess->rate));
gst_caps_unref(caps);
// set magnitudes
const GValue *list = gst_structure_get_value(message_structure, "magnitude");
PyGILState_STATE gstate = PyGILState_Ensure();
int i;
mess->magnitudes = PyList_New(mess->bands);
for (i=0; i < (mess->bands); i++)
{
const GValue *value = gst_value_list_get_value(list, i);
gfloat f = g_value_get_float(value);
PyList_SetItem(mess->magnitudes, i, Py_BuildValue("f", f));
}
PyGILState_Release(gstate);
// set gobj
GObject *gobj = (base_object->gobj).obj;
g_assert(gobj != NULL);
g_object_ref(gobj);
mess->gobj = gobj;
// delay message
gst_clock_id_wait_async(clock_id, delayed_spectrum_update, mess);
gst_clock_id_unref(clock_id);
}
}
gst_object_unref(spectrum);
gst_object_unref(message_element);
return TRUE;
}
static void
getaddrinfo_cb(uv_getaddrinfo_t* handle, int status, struct addrinfo* res)
{
PyGILState_STATE gstate = PyGILState_Ensure();
struct addrinfo *ptr;
ares_cb_data_t *data;
uv_err_t err;
DNSResolver *self;
PyObject *callback, *addr, *item, *errorno, *dns_result, *result;
ASSERT(handle);
data = (ares_cb_data_t*)(handle->data);
self = data->resolver;
callback = data->cb;
ASSERT(self);
/* Object could go out of scope in the callback, increase refcount to avoid it */
Py_INCREF(self);
if (status != UV_OK) {
err = uv_last_error(UV_LOOP(self));
errorno = PyInt_FromLong((long)err.code);
dns_result = Py_None;
Py_INCREF(Py_None);
goto callback;
}
dns_result = PyList_New(0);
if (!dns_result) {
PyErr_NoMemory();
PyErr_WriteUnraisable(Py_None);
errorno = PyInt_FromLong((long)UV_ENOMEM);
dns_result = Py_None;
Py_INCREF(Py_None);
goto callback;
}
for (ptr = res; ptr; ptr = ptr->ai_next) {
addr = makesockaddr(ptr->ai_addr, ptr->ai_addrlen);
if (!addr) {
PyErr_NoMemory();
PyErr_WriteUnraisable(callback);
break;
}
item = Py_BuildValue("iiisO", ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol, ptr->ai_canonname ? ptr->ai_canonname : "", addr);
Py_DECREF(addr);
if (!item) {
PyErr_NoMemory();
PyErr_WriteUnraisable(callback);
break;
}
PyList_Append(dns_result, item);
Py_DECREF(item);
}
errorno = Py_None;
Py_INCREF(Py_None);
callback:
result = PyObject_CallFunctionObjArgs(callback, self, dns_result, errorno, NULL);
if (result == NULL) {
PyErr_WriteUnraisable(callback);
}
Py_XDECREF(result);
Py_DECREF(callback);
uv_freeaddrinfo(res);
PyMem_Free(handle);
PyMem_Free(data);
Py_DECREF(self);
PyGILState_Release(gstate);
}
static tree
handle_python_attribute(tree *node, tree name, tree args,
int flags, bool *no_add_attrs)
{
PyObject *callable;
/* Debug code: */
if (0) {
printf("handle_python_attribute called\n");
fprintf(stderr, "node: ");
debug_tree(*node); /* the site of the attribute e.g. a var_decl */
fprintf(stderr, "name: ");
debug_tree(name); /* an identifier_node e.g. "custom_attribute_without_args" */
fprintf(stderr, "args: ");
debug_tree(args); /* if present, a tree_list, e.g. of constants */
fprintf(stderr, "flags: %i\n", flags);
fprintf(stderr, "and here!\n");
}
/*
How do we get to the attribute?
This code:
const struct attribute_spec *spec = lookup_attribute_spec (name);
suggests that attributes must have unique names, so keep a dict mapping
strings to callables
*/
assert(IDENTIFIER_NODE == TREE_CODE(name));
callable = PyDict_GetItemString(attribute_dict, IDENTIFIER_POINTER(name));
assert(callable);
{
PyGILState_STATE gstate;
PyObject *py_args = NULL;
PyObject *result = NULL;
gstate = PyGILState_Ensure();
/*
The args to the function call will be the node, plus the args of the
attribute:
*/
py_args = make_args_for_attribute_callback(*node, args);
if (!py_args) {
goto cleanup;
}
result = PyObject_Call(callable, py_args, NULL);
if (!result) {
/* Treat an unhandled Python error as a compilation error: */
error("Unhandled Python exception raised within %s attribute handler",
IDENTIFIER_POINTER(name));
PyErr_PrintEx(1);
}
/* (the result is ignored) */
cleanup:
Py_XDECREF(py_args);
Py_XDECREF(result);
PyGILState_Release(gstate);
}
return NULL; // FIXME
}
static void
query_ns_cb(void *arg, int status,int timeouts, unsigned char *answer_buf, int answer_len)
{
PyGILState_STATE gstate = PyGILState_Ensure();
int parse_status;
char **ptr;
struct hostent *hostent;
ares_cb_data_t *data;
DNSResolver *self;
PyObject *dns_result, *errorno, *tmp, *result, *callback;
ASSERT(arg);
data = (ares_cb_data_t*)arg;
self = data->resolver;
callback = data->cb;
ASSERT(self);
/* Object could go out of scope in the callback, increase refcount to avoid it */
Py_INCREF(self);
if (status != ARES_SUCCESS) {
errorno = PyInt_FromLong((long)status);
dns_result = Py_None;
Py_INCREF(Py_None);
goto callback;
}
parse_status = ares_parse_ns_reply(answer_buf, answer_len, &hostent);
if (parse_status != ARES_SUCCESS) {
errorno = PyInt_FromLong((long)parse_status);
dns_result = Py_None;
Py_INCREF(Py_None);
goto callback;
}
dns_result = PyList_New(0);
if (!dns_result) {
PyErr_NoMemory();
PyErr_WriteUnraisable(Py_None);
errorno = PyInt_FromLong((long)ARES_ENOMEM);
dns_result = Py_None;
Py_INCREF(Py_None);
goto callback;
}
for (ptr = hostent->h_aliases; *ptr != NULL; ptr++) {
tmp = PyString_FromString(*ptr);
if (tmp == NULL) {
break;
}
PyList_Append(dns_result, tmp);
Py_DECREF(tmp);
}
ares_free_hostent(hostent);
errorno = Py_None;
Py_INCREF(Py_None);
callback:
result = PyObject_CallFunctionObjArgs(callback, self, dns_result, errorno, NULL);
if (result == NULL) {
PyErr_WriteUnraisable(callback);
}
Py_XDECREF(result);
Py_DECREF(callback);
PyMem_Free(data);
Py_DECREF(self);
PyGILState_Release(gstate);
}
int embed_sim_init(gpi_sim_info_t *info)
{
FENTER
int i;
int ret = 0;
/* Check that we are not already initialised */
if (pEventFn)
return ret;
// Find the simulation root
const char *dut = getenv("TOPLEVEL");
if (dut != NULL) {
if (!strcmp("", dut)) {
/* Empty string passed in, treat as NULL */
dut = NULL;
} else {
// Skip any library component of the toplevel
char *dot = strchr(dut, '.');
if (dot != NULL) {
dut += (dot - dut + 1);
}
}
}
PyObject *cocotb_module, *cocotb_init, *cocotb_args, *cocotb_retval;
PyObject *simlog_obj, *simlog_func;
PyObject *argv_list, *argc, *arg_dict, *arg_value;
cocotb_module = NULL;
arg_dict = NULL;
//Ensure that the current thread is ready to callthe Python C API
PyGILState_STATE gstate = PyGILState_Ensure();
to_python();
if (get_module_ref(COCOTB_MODULE, &cocotb_module))
goto cleanup;
// Obtain the loggpi logger object
simlog_obj = PyObject_GetAttrString(cocotb_module, "loggpi");
if (simlog_obj == NULL) {
PyErr_Print();
fprintf(stderr, "Failed to to get simlog object\n");
}
simlog_func = PyObject_GetAttrString(simlog_obj, "_printRecord");
if (simlog_func == NULL) {
PyErr_Print();
fprintf(stderr, "Failed to get the _printRecord method");
goto cleanup;
}
if (!PyCallable_Check(simlog_func)) {
PyErr_Print();
fprintf(stderr, "_printRecord is not callable");
goto cleanup;
}
set_log_handler(simlog_func);
Py_DECREF(simlog_func);
simlog_func = PyObject_GetAttrString(simlog_obj, "_willLog");
if (simlog_func == NULL) {
PyErr_Print();
fprintf(stderr, "Failed to get the _willLog method");
goto cleanup;
}
if (!PyCallable_Check(simlog_func)) {
PyErr_Print();
fprintf(stderr, "_willLog is not callable");
goto cleanup;
}
set_log_filter(simlog_func);
argv_list = PyList_New(0);
for (i = 0; i < info->argc; i++) {
arg_value = PyString_FromString(info->argv[i]);
PyList_Append(argv_list, arg_value);
}
arg_dict = PyModule_GetDict(cocotb_module);
PyDict_SetItemString(arg_dict, "argv", argv_list);
argc = PyInt_FromLong(info->argc);
PyDict_SetItemString(arg_dict, "argc", argc);
if (!PyCallable_Check(simlog_func)) {
PyErr_Print();
fprintf(stderr, "_printRecord is not callable");
goto cleanup;
}
LOG_INFO("Running on %s version %s", info->product, info->version);
LOG_INFO("Python interpreter initialised and cocotb loaded!");
// Now that logging has been set up ok we initialise the testbench
if (-1 == PyObject_SetAttrString(cocotb_module, "SIM_NAME", PyString_FromString(info->product))) {
PyErr_Print();
fprintf(stderr, "Unable to set SIM_NAME");
goto cleanup;
}
// Set language in use as an attribute to cocotb module, or None if not provided
const char *lang = getenv("TOPLEVEL_LANG");
PyObject* PyLang;
if (lang)
PyLang = PyString_FromString(lang);
else
PyLang = Py_None;
if (-1 == PyObject_SetAttrString(cocotb_module, "LANGUAGE", PyLang)) {
fprintf(stderr, "Unable to set LANGUAGE");
goto cleanup;
}
// Hold onto a reference to our _fail_test function
pEventFn = PyObject_GetAttrString(cocotb_module, "_sim_event");
if (!PyCallable_Check(pEventFn)) {
PyErr_Print();
fprintf(stderr, "cocotb._sim_event is not callable");
goto cleanup;
}
Py_INCREF(pEventFn);
cocotb_init = PyObject_GetAttrString(cocotb_module, "_initialise_testbench"); // New reference
if (cocotb_init == NULL || !PyCallable_Check(cocotb_init)) {
if (PyErr_Occurred())
PyErr_Print();
fprintf(stderr, "Cannot find function \"%s\"\n", "_initialise_testbench");
goto cleanup;
}
cocotb_args = PyTuple_New(1);
if (dut == NULL)
PyTuple_SetItem(cocotb_args, 0, Py_BuildValue("")); // Note: This function “steals” a reference to o.
else
PyTuple_SetItem(cocotb_args, 0, PyString_FromString(dut)); // Note: This function “steals” a reference to o.
cocotb_retval = PyObject_CallObject(cocotb_init, cocotb_args);
if (cocotb_retval != NULL) {
LOG_DEBUG("_initialise_testbench successful");
Py_DECREF(cocotb_retval);
} else {
PyErr_Print();
fprintf(stderr,"Cocotb initialisation failed - exiting\n");
goto cleanup;
}
FEXIT
goto ok;
cleanup:
ret = -1;
ok:
if (cocotb_module) {
Py_DECREF(cocotb_module);
}
if (arg_dict) {
Py_DECREF(arg_dict);
}
PyGILState_Release(gstate);
to_simulator();
return ret;
}
static void
query_srv_cb(void *arg, int status,int timeouts, unsigned char *answer_buf, int answer_len)
{
PyGILState_STATE gstate = PyGILState_Ensure();
int parse_status;
struct ares_srv_reply *srv_reply, *srv_ptr;
ares_cb_data_t *data;
DNSResolver *self;
PyObject *dns_result, *errorno, *tmp, *result, *callback;
ASSERT(arg);
data = (ares_cb_data_t*)arg;
self = data->resolver;
callback = data->cb;
ASSERT(self);
/* Object could go out of scope in the callback, increase refcount to avoid it */
Py_INCREF(self);
if (status != ARES_SUCCESS) {
errorno = PyInt_FromLong((long)status);
dns_result = Py_None;
Py_INCREF(Py_None);
goto callback;
}
parse_status = ares_parse_srv_reply(answer_buf, answer_len, &srv_reply);
if (parse_status != ARES_SUCCESS) {
errorno = PyInt_FromLong((long)parse_status);
dns_result = Py_None;
Py_INCREF(Py_None);
goto callback;
}
dns_result = PyList_New(0);
if (!dns_result) {
PyErr_NoMemory();
PyErr_WriteUnraisable(Py_None);
errorno = PyInt_FromLong((long)ARES_ENOMEM);
dns_result = Py_None;
Py_INCREF(Py_None);
goto callback;
}
for (srv_ptr = srv_reply; srv_ptr != NULL; srv_ptr = srv_ptr->next) {
tmp = PyTuple_New(4);
if (tmp == NULL) {
break;
}
PyTuple_SET_ITEM(tmp, 0, PyString_FromString(srv_ptr->host));
PyTuple_SET_ITEM(tmp, 1, PyInt_FromLong((long)srv_ptr->port));
PyTuple_SET_ITEM(tmp, 2, PyInt_FromLong((long)srv_ptr->priority));
PyTuple_SET_ITEM(tmp, 3, PyInt_FromLong((long)srv_ptr->weight));
PyList_Append(dns_result, tmp);
Py_DECREF(tmp);
}
ares_free_data(srv_reply);
errorno = Py_None;
Py_INCREF(Py_None);
callback:
result = PyObject_CallFunctionObjArgs(callback, self, dns_result, errorno, NULL);
if (result == NULL) {
PyErr_WriteUnraisable(callback);
}
Py_XDECREF(result);
Py_DECREF(callback);
PyMem_Free(data);
Py_DECREF(self);
PyGILState_Release(gstate);
}
PythonWrapper::GILLocker::GILLocker()
{
state_ = PyGILState_Ensure();
}
/**
*******************************************************************************************************
* Callback for as_info_foreach().
*
* @param err The as_error to be populated by the function
* with the encountered error if any.
* @param node The current as_node object for which the
* callback is fired by c client.
* @param req The info request string.
* @param res The info response string for current node.
* @pram udata The callback udata containing the host_lookup
* array and the return zval to be populated with
* an entry for current node's info response with
* the node's ID as the key.
*
* Returns true if callback is successful, Otherwise false.
*******************************************************************************************************
*/
static bool AerospikeClient_Info_each(as_error * err, const as_node * node, const char * req, char * res, void * udata)
{
PyObject * py_err = NULL;
PyObject * py_ustr = NULL;
PyObject * py_out = NULL;
foreach_callback_info_udata* udata_ptr = (foreach_callback_info_udata *) udata;
as_address* addr = NULL;
// Need to make sure we have the GIL since we're back in python land now
PyGILState_STATE gil_state = PyGILState_Ensure();
if (err && err->code != AEROSPIKE_OK) {
as_error_update(err, err->code, NULL);
goto CLEANUP;
}
else if (res) {
char * out = strchr(res,'\t');
if (out) {
out++;
py_out = PyString_FromString(out);
}
else {
py_out = PyString_FromString(res);
}
}
if (!py_err) {
Py_INCREF(Py_None);
py_err = Py_None;
}
if (!py_out) {
Py_INCREF(Py_None);
py_out = Py_None;
}
PyObject * py_res = PyTuple_New(2);
PyTuple_SetItem(py_res, 0, py_err);
PyTuple_SetItem(py_res, 1, py_out);
if (udata_ptr->host_lookup_p) {
PyObject * py_hosts = (PyObject *)udata_ptr->host_lookup_p;
if (py_hosts && PyList_Check(py_hosts)) {
addr = as_node_get_address((as_node *)node);
int size = (int) PyList_Size(py_hosts);
for (int i = 0; i < size; i++) {
char * host_addr = NULL;
int port = -1;
PyObject * py_host = PyList_GetItem(py_hosts, i);
if (PyTuple_Check(py_host) && PyTuple_Size(py_host) == 2) {
PyObject * py_addr = PyTuple_GetItem(py_host,0);
PyObject * py_port = PyTuple_GetItem(py_host,1);
if (PyUnicode_Check(py_addr)) {
py_ustr = PyUnicode_AsUTF8String(py_addr);
host_addr = PyBytes_AsString(py_ustr);
} else if (PyString_Check(py_addr)) {
host_addr = PyString_AsString(py_addr);
} else {
as_error_update(&udata_ptr->error, AEROSPIKE_ERR_PARAM, "Host address is of type incorrect");
if (py_res) {
Py_DECREF(py_res);
}
PyGILState_Release(gil_state);
return false;
}
if (PyInt_Check(py_port)) {
port = (uint16_t) PyInt_AsLong(py_port);
}
else if (PyLong_Check(py_port)) {
port = (uint16_t) PyLong_AsLong(py_port);
} else {
break;
}
char ip_port[IP_PORT_MAX_LEN];
// If the address is longer than the max length of an ipv6 address, raise an error and exit
if (strnlen(host_addr, INET6_ADDRSTRLEN) >= INET6_ADDRSTRLEN) {
as_error_update(&udata_ptr->error, AEROSPIKE_ERR_PARAM, "Host address is too long");
if (py_res) {
Py_DECREF(py_res);
}
goto CLEANUP;
}
sprintf(ip_port, "%s:%d", host_addr, port);
if ( !strcmp(ip_port, addr->name) ) {
PyObject * py_nodes = (PyObject *) udata_ptr->udata_p;
PyDict_SetItemString(py_nodes, node->name, py_res);
} else {
sprintf(ip_port, "[%s]:%d", host_addr, port);
if ( !strcmp(ip_port, addr->name) ) {
PyObject * py_nodes = (PyObject *) udata_ptr->udata_p;
PyDict_SetItemString(py_nodes, node->name, py_res);
}
}
}
if (py_ustr) {
Py_DECREF(py_ustr);
py_ustr = NULL;
}
}
} else if (!PyList_Check(py_hosts)) {
as_error_update(&udata_ptr->error, AEROSPIKE_ERR_PARAM, "Hosts should be specified in a list.");
goto CLEANUP;
}
} else {
PyObject * py_nodes = (PyObject *) udata_ptr->udata_p;
PyDict_SetItemString(py_nodes, node->name, py_res);
}
Py_DECREF(py_res);
CLEANUP:
if (py_ustr) {
Py_DECREF(py_ustr);
}
if (udata_ptr->error.code != AEROSPIKE_OK) {
PyObject * py_err = NULL;
error_to_pyobject( &udata_ptr->error, &py_err);
PyObject *exception_type = raise_exception(&udata_ptr->error);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
PyGILState_Release(gil_state);
return NULL;
}
if (err->code != AEROSPIKE_OK) {
PyObject * py_err = NULL;
error_to_pyobject(err, &py_err);
PyObject *exception_type = raise_exception(err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
PyGILState_Release(gil_state);
return NULL;
}
PyGILState_Release(gil_state);
return true;
}
PyEnsureGIL() :
_state(PyGILState_Ensure()) {
}
void end_python()
{
//...
PyGILState_Ensure();
Py_Finalize();
}
/* Seeks a certain offset within the file object IO handle
* Returns the offset if the seek is successful or -1 on error
*/
off64_t pysmraw_file_object_io_handle_seek_offset(
pysmraw_file_object_io_handle_t *file_object_io_handle,
off64_t offset,
int whence,
libcerror_error_t **error )
{
static char *function = "pysmraw_file_object_io_handle_seek_offset";
PyGILState_STATE gil_state = 0;
if( file_object_io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file object IO handle.",
function );
return( -1 );
}
gil_state = PyGILState_Ensure();
if( pysmraw_file_object_seek_offset(
file_object_io_handle->file_object,
offset,
whence,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek in file object.",
function );
goto on_error;
}
if( pysmraw_file_object_get_offset(
file_object_io_handle->file_object,
&offset,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to retrieve current offset in file object.",
function );
goto on_error;
}
PyGILState_Release(
gil_state );
return( offset );
on_error:
PyGILState_Release(
gil_state );
return( -1 );
}
static int node_dynamic_parse(struct bNode *node)
{
#ifndef WITH_PYTHON
return -1;
#else
PyObject *dict= NULL;
PyObject *pynode_data= NULL;
PyObject *pynode= NULL;
PyObject *args= NULL;
NodeScriptDict *nsd = NULL;
PyObject *pyresult = NULL;
char *buf = NULL;
int is_valid_script = 0;
PyGILState_STATE gilstate;
if (!node->id || !node->storage)
return 0;
/* READY, no need to be here */
if (BTST(node->custom1, NODE_DYNAMIC_READY))
return 0;
/* for threading */
gilstate = PyGILState_Ensure();
nsd = (NodeScriptDict *)node->storage;
dict = (PyObject *)(nsd->dict);
buf = txt_to_buf((Text *)node->id);
pyresult = PyRun_String(buf, Py_file_input, dict, dict);
MEM_freeN(buf);
if (!pyresult) {
if (BTST(node->custom1, NODE_DYNAMIC_LOADED)) {
node_dynamic_disable(node);
} else {
node_dynamic_disable_all_by_id(node->id);
}
node_dynamic_pyerror_print(node);
PyGILState_Release(gilstate);
return -1;
}
Py_DECREF(pyresult);
pynode_data = node_dynamic_get_pynode(dict);
if (pynode_data) {
BPy_NodeSocketLists *socklists = Node_CreateSocketLists(node);
args = Py_BuildValue("(O)", socklists);
/* init it to get the input and output sockets */
pynode = PyObject_Call(pynode_data, args, NULL);
Py_DECREF(pynode_data);
Py_DECREF(socklists);
Py_DECREF(args);
if (!PyErr_Occurred() && pynode && pytype_is_pynode(pynode)) {
InitNode((BPy_Node *)(pynode), node);
nsd->node = pynode;
node->typeinfo->execfunc = node_dynamic_exec_cb;
is_valid_script = 1;
/* for NEW, LOADED, REPARSE */
if (BNTST(node->custom1, NODE_DYNAMIC_ADDEXIST)) {
node->typeinfo->pydict = dict;
node->typeinfo->pynode = pynode;
node->typeinfo->id = node->id;
if (BNTST(node->custom1, NODE_DYNAMIC_LOADED))
nodeAddSockets(node, node->typeinfo);
if (BNTST(node->custom1, NODE_DYNAMIC_REPARSE))
node_dynamic_register_type(node);
}
node->custom1 = 0;
node->custom1 = BSET(node->custom1, NODE_DYNAMIC_READY);
}
}
PyGILState_Release(gilstate);
if (!is_valid_script) { /* not a valid pynode script */
node_dynamic_disable_all_by_id(node->id);
node_dynamic_pyerror_print(node);
return -1;
}
return 0;
#endif
}
/*
* External interface
*/
static void
DoPyCommand(const char *cmd, rangeinitializer init_range, runner run, void *arg)
{
#ifndef PY_CAN_RECURSE
static int recursive = 0;
#endif
#if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
char *saved_locale;
#endif
#ifdef PY_CAN_RECURSE
PyGILState_STATE pygilstate;
#endif
#ifndef PY_CAN_RECURSE
if (recursive)
{
EMSG(_("E659: Cannot invoke Python recursively"));
return;
}
++recursive;
#endif
if (python_end_called)
return;
if (Python_Init())
goto theend;
init_range(arg);
Python_Release_Vim(); /* leave vim */
#if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
/* Python only works properly when the LC_NUMERIC locale is "C". */
saved_locale = setlocale(LC_NUMERIC, NULL);
if (saved_locale == NULL || STRCMP(saved_locale, "C") == 0)
saved_locale = NULL;
else
{
/* Need to make a copy, value may change when setting new locale. */
saved_locale = (char *) PY_STRSAVE(saved_locale);
(void)setlocale(LC_NUMERIC, "C");
}
#endif
#ifdef PY_CAN_RECURSE
pygilstate = PyGILState_Ensure();
#else
Python_RestoreThread(); /* enter python */
#endif
run((char *) cmd, arg
#ifdef PY_CAN_RECURSE
, &pygilstate
#endif
);
#ifdef PY_CAN_RECURSE
PyGILState_Release(pygilstate);
#else
Python_SaveThread(); /* leave python */
#endif
#if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
if (saved_locale != NULL)
{
(void)setlocale(LC_NUMERIC, saved_locale);
PyMem_Free(saved_locale);
}
#endif
Python_Lock_Vim(); /* enter vim */
PythonIO_Flush();
theend:
#ifndef PY_CAN_RECURSE
--recursive;
#endif
return;
}
/* node_dynamic_setup: prepare for execution (state: NODE_DYNAMIC_READY)
* pynodes already linked to a script (node->id != NULL). */
static void node_dynamic_setup(bNode *node)
{
#ifdef WITH_PYTHON
NodeScriptDict *nsd = NULL;
bNodeTree *nodetree = NULL;
bNodeType *ntype = NULL;
PyGILState_STATE gilstate;
/* Possible cases:
* NEW
* ADDEXIST
* LOADED
* REPARSE
* ERROR
* READY
*/
/* NEW, but not linked to a script: link default (empty) typeinfo */
if (!node->id) {
node->typeinfo = node_dynamic_find_typeinfo(&node_all_shaders,
NULL);
return;
}
/* READY, no need to be here */
if (BTST(node->custom1, NODE_DYNAMIC_READY))
return;
gilstate = PyGILState_Ensure();
/* ERROR, reset to (empty) defaults */
if (BCLR(node->custom1, NODE_DYNAMIC_ERROR) == 0) {
node_dynamic_reset(node, 0);
PyGILState_Release(gilstate);
return;
}
/* User asked to update this pynode, prepare it for reparsing */
if (BTST(node->custom1, NODE_DYNAMIC_REPARSE)) {
int needs_parsing = 1;
node->custom1 = BSET(node->custom1, NODE_DYNAMIC_NEW);
if (BTST(node->custom1, NODE_DYNAMIC_ERROR)) {
node->custom1 = BCLR(node->custom1, NODE_DYNAMIC_REPARSE);
ntype = node_dynamic_find_typeinfo(&node_all_shaders, node->id);
if (ntype) {
node->typeinfo = ntype;
node->custom1 = BSET(node->custom1, NODE_DYNAMIC_ADDEXIST);
node->custom1 = BCLR(node->custom1, NODE_DYNAMIC_ERROR);
needs_parsing = 0;
}
else { nodeMakeDynamicType(node); }
} else {
node_dynamic_rem_all_links(node->typeinfo);
node_dynamic_free_typeinfo_sockets(node->typeinfo);
node_dynamic_update_socket_links(node, NULL);
node_dynamic_free_storage_cb(node);
}
if (needs_parsing) {
nsd = MEM_callocN(sizeof(NodeScriptDict), "node script dictionary");
nsd->dict = init_dynamicdict();
node->storage = nsd;
/* prepared, now reparse: */
node_dynamic_parse(node);
PyGILState_Release(gilstate);
return;
}
}
else if (BTST(node->custom1, NODE_DYNAMIC_LOADED)) {
/* when loading from a .blend we don't have G.main yet, so we
* quickly abuse node->storage in ntreeInitTypes (node.c) to have
* our nodetree ptr (needed if a pynode script that worked before
* saving the .blend for some reason fails upon loading): */
nodetree = (bNodeTree *)node->storage;
node->storage = NULL;
}
if (node->storage)
fprintf(stderr, "\nDEBUG: PYNODES ERROR: non NULL node->storage in node_dynamic_setup()\n");
nsd = MEM_callocN(sizeof(NodeScriptDict), "node script dictionary");
node->storage = nsd;
/* NEW, LOADED or REPARSE */
if (BNTST(node->custom1, NODE_DYNAMIC_ADDEXIST)) {
/* check if there's already a bNodeType linked to this script */
/* (XXX hardcoded for shader nodes for now) */
ntype = node_dynamic_find_typeinfo(&node_all_shaders, node->id);
if (ntype) { /* if so, reuse it */
node->typeinfo = ntype;
/* so this is actually an ADDEXIST type */
node->custom1 = BSET(node->custom1, NODE_DYNAMIC_ADDEXIST);
}
else { /* create bNodeType for this pynode */
nodeMakeDynamicType(node);
nsd->dict = init_dynamicdict();
if ((node_dynamic_parse(node) == -1) && nodetree) {
node_dynamic_reset_loaded(node);
}
PyGILState_Release(gilstate);
return;
}
}
/* ADDEXIST: new pynode linked to an already registered dynamic type,
* we just reuse existing py dict and pynode */
nsd->dict = node->typeinfo->pydict;
nsd->node = node->typeinfo->pynode;
Py_INCREF((PyObject *)(nsd->dict));
Py_INCREF((PyObject *)(nsd->node));
if (BTST(node->custom1, NODE_DYNAMIC_NEW)) {
nodeAddSockets(node, node->typeinfo);
node->custom1 = BCLR(node->custom1, NODE_DYNAMIC_NEW);
}
node->custom1 = BCLR(node->custom1, NODE_DYNAMIC_ADDEXIST);
node->custom1 = BSET(node->custom1, NODE_DYNAMIC_READY);
PyGILState_Release(gilstate);
#endif /* WITH_PYTHON */
return;
}
bool PythonEngine::runScript(const QString &script, const QString &fileName, bool useProfiler)
{
m_isScriptRunning = true;
PyGILState_STATE gstate = PyGILState_Ensure();
emit startedScript();
bool successfulRun = false;
QSettings settings;
// enable user module deleter
if (settings.value("PythonEngine/UserModuleDeleter", true).toBool())
deleteUserModules();
runPythonHeader();
PyObject *output = NULL;
if (QFile::exists(fileName))
{
QString str = QString("from os import chdir; chdir(u'" + QFileInfo(fileName).absolutePath() + "')");
#pragma omp critical(import)
{
PyObject *import = PyRun_String(str.toLatin1().data(), Py_single_input, m_dict, m_dict);
Py_XDECREF(import);
}
}
// compile
PyObject *code = Py_CompileString(script.toLatin1().data(), fileName.toLatin1().data(), Py_file_input);
// run
if (useProfiler)
{
setProfilerFileName(fileName);
startProfiler();
}
if (code) output = PyEval_EvalCode((PyCodeObject *) code, m_dict, m_dict);
if (useProfiler)
finishProfiler();
if (output)
{
successfulRun = true;
Py_XDECREF(output);
}
else
{
// error traceback
Py_XDECREF(errorType);
Py_XDECREF(errorValue);
Py_XDECREF(errorTraceback);
PyErr_Fetch(&errorType, &errorValue, &errorTraceback);
if (errorTraceback)
successfulRun = false;
}
Py_XDECREF(code);
m_isScriptRunning = false;
// release the thread, no Python API allowed beyond this point
PyGILState_Release(gstate);
emit executedScript();
return successfulRun;
}
void PythonTransform::transform(const QByteArray &input, QByteArray &output)
{
if (input.isEmpty())
return;
PyGILState_STATE lgstate;
lgstate = PyGILState_Ensure();
if (loadModule()) {
PyObject * pyInbound = Py_False; // need reference count management
if (twoWays)
pyInbound = (wayValue == INBOUND ? Py_True : Py_False );
Py_INCREF(pyInbound);
if (PyModule_AddObject(pModule, INBOUND_ATTR_NAME, pyInbound) == -1) { // steal reference
pythonmgm->checkPyError();
logError(tr("T_T Could not set the direction value properly:\n%1").arg(pythonmgm->getLastError()),id);
Py_XDECREF(pyInbound);
}
// setting parameters in the python environment
if (!parameters.isEmpty()) {
PyObject *paramsdict = PyDict_New();
if (!pythonmgm->checkPyError()) {
logError(tr("T_T Error while creating the Python parameter dict:\n%1").arg(pythonmgm->getLastError()), id);
Py_XDECREF(paramsdict);
PyGILState_Release(lgstate);
return;
}
// adding parameters to the python list
QHashIterator<QByteArray, QByteArray> i(parameters);
while (i.hasNext()) {
i.next();
PyObject* paramKey = PyUnicode_FromStringAndSize(i.key(),i.key().size());
if (!pythonmgm->checkPyError()) {
logError(tr("T_T Error while creating Python parameter key:\n%1").arg(pythonmgm->getLastError()), id);
Py_XDECREF(paramsdict);
PyGILState_Release(lgstate);
return;
}
PyObject* paramValue = PyUnicode_FromStringAndSize(i.value(),i.value().size());
if (!pythonmgm->checkPyError()) {
logError(tr("T_T Error while creating Python parameter value:\n%1").arg(pythonmgm->getLastError()), id);
Py_XDECREF(paramsdict);
Py_XDECREF(paramKey);
PyGILState_Release(lgstate);
return;
}
if (PyDict_SetItem(paramsdict,paramKey,paramValue) == -1) { // stealing reference
pythonmgm->checkPyError(); // we already know there was an error
logError(tr("T_T Error while setting Python parameter pair:\n%1").arg(pythonmgm->getLastError()), id);
Py_XDECREF(paramsdict);
Py_XDECREF(paramKey);
Py_XDECREF(paramValue);
PyGILState_Release(lgstate);
return;
}
// Cleaning the values (references not stolen)
Py_XDECREF(paramKey);
Py_XDECREF(paramValue);
}
if (PyModule_AddObject(pModule,PARAMS_ATTR_NAME , paramsdict) == -1) { // stolen paramsdict reference
pythonmgm->checkPyError();
logError(tr("T_T Could not set the Pip3line_params value properly:\n%1").arg(pythonmgm->getLastError()),id);
}
} else {
Py_INCREF(Py_None);
if (PyModule_AddObject(pModule,PARAMS_ATTR_NAME , Py_None) == -1) { // stealing reference
pythonmgm->checkPyError();
logError(tr("T_T Could not set the Pip3line_params None value properly:\n%1").arg(pythonmgm->getLastError()),id);
Py_DECREF(Py_None);
}
}
PyObject * pFunc = PyObject_GetAttrString(pModule, MAIN_FUNCTION_NAME);
if (pythonmgm->checkPyError() && PyCallable_Check(pFunc)) {
PyObject* pArgs = PyTuple_New(1);
if (!pythonmgm->checkPyError()) {
Q_EMIT error(tr("T_T Error while creating the Python argument tuple:\n%1").arg(pythonmgm->getLastError()), id);
Py_XDECREF(pFunc);
Py_XDECREF(pArgs);
PyGILState_Release(lgstate);
return;
}
PyObject* inputPy = PyByteArray_FromStringAndSize(input.data(),input.size());
if (!pythonmgm->checkPyError()) {
Q_EMIT error(tr("T_T Error while creating the Python byte array:\n%1").arg(pythonmgm->getLastError()), id);
Py_XDECREF(pFunc);
Py_XDECREF(pArgs);
Py_XDECREF(inputPy);
PyGILState_Release(lgstate);
return;
}
if (PyTuple_SetItem(pArgs, 0, inputPy) != 0) {// stealing the reference of inputPy
pythonmgm->checkPyError();
Q_EMIT error(tr("T_T Error while creating the Python byte array:\n%1").arg(pythonmgm->getLastError()), id);
Py_XDECREF(inputPy);
Py_XDECREF(pFunc);
Py_XDECREF(pArgs);
PyGILState_Release(lgstate);
return;
}
PyObject* returnValue = PyObject_CallObject(pFunc, pArgs); // new ref or NULL
if (!pythonmgm->checkPyError()) {
Q_EMIT error(tr("T_T Python error while executing the function:\n %1").arg(pythonmgm->getLastError()), id);
} else {
if (PyByteArray_Check(returnValue)) {
Py_ssize_t templength = PyByteArray_Size(returnValue);
if (templength > BLOCK_MAX_SIZE) {
templength = BLOCK_MAX_SIZE;
Q_EMIT warning(tr("Data block returned is too large, truncating."),id);
}
char * buffer = PyByteArray_AsString(returnValue); // never to be deleted
output.append(QByteArray(buffer,templength));
} else {
Q_EMIT error(tr("The Python object returned is not a bytearray"), id);
}
}
Py_XDECREF(returnValue);
Py_XDECREF(pArgs);
// Py_DECREF(inputPy); // stolen reference, don't touch that
Py_XDECREF(pFunc);
} else {
Q_EMIT error(tr("Python error while calling the function %1():\n%2").arg(MAIN_FUNCTION_NAME).arg(pythonmgm->getLastError()), id);
}
} else {
qDebug() << "[Python transform] could not load the module";
}
PyGILState_Release(lgstate);
}
