void INITMODULE (void) { PyObject *m, *d, *c; UNLESS (sort_str=PyString_FromString("sort")) return; UNLESS (reverse_str=PyString_FromString("reverse")) return; UNLESS (items_str=PyString_FromString("items")) return; UNLESS (__setstate___str=PyString_FromString("__setstate__")) return; UNLESS (PyExtensionClassCAPI=PyCObject_Import("ExtensionClass","CAPI")) return; #ifdef PERSISTENT if ((cPersistenceCAPI=PyCObject_Import("cPersistence","CAPI"))) { BucketType.methods.link=cPersistenceCAPI->methods; BucketType.tp_getattro=cPersistenceCAPI->getattro; BucketType.tp_setattro=cPersistenceCAPI->setattro; SetType.methods.link=cPersistenceCAPI->methods; SetType.tp_getattro=cPersistenceCAPI->getattro; SetType.tp_setattro=cPersistenceCAPI->setattro; BTreeType.methods.link=cPersistenceCAPI->methods; BTreeType.tp_getattro=cPersistenceCAPI->getattro; BTreeType.tp_setattro=cPersistenceCAPI->setattro; TreeSetType.methods.link=cPersistenceCAPI->methods; TreeSetType.tp_getattro=cPersistenceCAPI->getattro; TreeSetType.tp_setattro=cPersistenceCAPI->setattro; } else return; /* Grab the ConflictError class */ m = PyImport_ImportModule("ZODB.POSException"); if (m != NULL) { c = PyObject_GetAttrString(m, "BTreesConflictError"); if (c != NULL) ConflictError = c; Py_DECREF(m); } if (ConflictError == NULL) { Py_INCREF(PyExc_ValueError); ConflictError=PyExc_ValueError; } #else BTreeType.tp_getattro=PyExtensionClassCAPI->getattro; BucketType.tp_getattro=PyExtensionClassCAPI->getattro; SetType.tp_getattro=PyExtensionClassCAPI->getattro; TreeSetType.tp_getattro=PyExtensionClassCAPI->getattro; #endif BTreeItemsType.ob_type=&PyType_Type; #ifdef INTSET_H UNLESS(d = PyImport_ImportModule("intSet")) return; UNLESS(intSetType = PyObject_GetAttrString (d, "intSet")) return; Py_DECREF (d); #endif /* Create the module and add the functions */ m = Py_InitModule4("_" MOD_NAME_PREFIX "BTree", module_methods, BTree_module_documentation, (PyObject*)NULL,PYTHON_API_VERSION); /* Add some symbolic constants to the module */ d = PyModule_GetDict(m); PyExtensionClass_Export(d,MOD_NAME_PREFIX "Bucket", BucketType); PyExtensionClass_Export(d,MOD_NAME_PREFIX "BTree", BTreeType); PyExtensionClass_Export(d,MOD_NAME_PREFIX "Set", SetType); PyExtensionClass_Export(d,MOD_NAME_PREFIX "TreeSet", TreeSetType); }
PyObject *session_connect(PyObject *self, PyObject *args) { #ifdef DEBUG fprintf(stderr, "> entering session_connect\n"); #endif sp_session_config config; PyObject *client; sp_session *session; sp_error error; PyObject *uobj, *pobj; char *username, *password; if(!PyArg_ParseTuple(args, "O", &client)) return NULL; PyEval_InitThreads(); config.api_version = SPOTIFY_API_VERSION; config.userdata = (void *)client; config.callbacks = &g_callbacks; config.user_agent = "unset"; #ifdef DEBUG fprintf(stderr, "Config mark 1\n"); #endif PyObject *cache_location = PyObject_GetAttr(client, PyString_FromString("cache_location")); #ifdef DEBUG fprintf(stderr, "Cache location is '%s'\n", PyString_AsString(cache_location)); #endif if(cache_location == NULL) { PyErr_SetString(SpotifyError, "Client did not provide a cache_location"); return NULL; } #ifdef DEBUG fprintf(stderr, "Config mark 1.1\n"); #endif config.cache_location = copystring(cache_location); #ifdef DEBUG fprintf(stderr, "Config mark 2\n"); #endif PyObject *settings_location = PyObject_GetAttr(client, PyString_FromString("settings_location")); if(settings_location == NULL) { PyErr_SetString(SpotifyError, "Client did not provide a settings_location"); return NULL; } config.settings_location = copystring(settings_location); #ifdef DEBUG fprintf(stderr, "Config mark 3\n"); #endif PyObject *application_key = PyObject_GetAttr(client, PyString_FromString("application_key")); if(application_key == NULL) { PyErr_SetString(SpotifyError, "Client did not provide an application_key"); return NULL; } char *s_appkey; Py_ssize_t l_appkey; PyString_AsStringAndSize(application_key, &s_appkey, &l_appkey); config.application_key_size = l_appkey; config.application_key = PyMem_Malloc(l_appkey); memcpy(config.application_key, s_appkey, l_appkey); #ifdef DEBUG fprintf(stderr, "Config mark 4\n"); #endif PyObject *user_agent = PyObject_GetAttr(client, PyString_FromString("user_agent")); if(user_agent == NULL) { PyErr_SetString(SpotifyError, "Client did not provide a user_agent"); return NULL; } config.user_agent = copystring(user_agent); #ifdef DEBUG fprintf(stderr, "Config mark 5\n"); #endif uobj = PyObject_GetAttr(client, PyString_FromString("username")); if(uobj == NULL) { PyErr_SetString(SpotifyError, "Client did not provide a username"); return NULL; } username = copystring(uobj); pobj = PyObject_GetAttr(client, PyString_FromString("password")); if(pobj == NULL) { PyErr_SetString(SpotifyError, "Client did not provide a password"); return NULL; } password = copystring(pobj); Py_BEGIN_ALLOW_THREADS #ifdef DEBUG fprintf(stderr, "Calling sp_session_init\n"); #endif error = sp_session_init(&config, &session); #ifdef DEBUG fprintf(stderr, "Returned from sp_session_init\n"); #endif Py_END_ALLOW_THREADS session_constructed = 1; if(error != SP_ERROR_OK) { PyErr_SetString(SpotifyError, sp_error_message(error)); return NULL; } Py_BEGIN_ALLOW_THREADS error = sp_session_login(session, username, password); Py_END_ALLOW_THREADS if(error != SP_ERROR_OK) { PyErr_SetString(SpotifyError, sp_error_message(error)); return NULL; } Session *psession = (Session *)PyObject_CallObject((PyObject *)&SessionType, NULL); Py_INCREF(psession); psession->_session = session; return (PyObject *)psession; }
static PyObject* mod_connect(PyObject* self, PyObject* args, PyObject* kwargs) { UNUSED(self); Object pConnectString = 0; int fAutoCommit = 0; int fAnsi = 0; // force ansi int fUnicodeResults = 0; int fReadOnly = 0; long timeout = 0; Object attrs_before; // Optional connect attrs set before connecting Py_ssize_t size = args ? PyTuple_Size(args) : 0; if (size > 1) { PyErr_SetString(PyExc_TypeError, "function takes at most 1 non-keyword argument"); return 0; } if (size == 1) { if (!PyString_Check(PyTuple_GET_ITEM(args, 0)) && !PyUnicode_Check(PyTuple_GET_ITEM(args, 0))) return PyErr_Format(PyExc_TypeError, "argument 1 must be a string or unicode object"); pConnectString.Attach(PyUnicode_FromObject(PyTuple_GetItem(args, 0))); if (!pConnectString.IsValid()) return 0; } if (kwargs && PyDict_Size(kwargs) > 0) { Object partsdict(PyDict_New()); if (!partsdict.IsValid()) return 0; Py_ssize_t pos = 0; PyObject* key = 0; PyObject* value = 0; Object okey; // in case we need to allocate a new key while (PyDict_Next(kwargs, &pos, &key, &value)) { if (!Text_Check(key)) return PyErr_Format(PyExc_TypeError, "Dictionary keys passed to connect must be strings"); // // Note: key and value are *borrowed*. // // // Check for the two non-connection string keywords we accept. (If we get many more of these, create something // // table driven. Are we sure there isn't a Python function to parse keywords but leave those it doesn't know?) // const char* szKey = PyString_AsString(key); if (Text_EqualsI(key, "autocommit")) { fAutoCommit = PyObject_IsTrue(value); continue; } if (Text_EqualsI(key, "ansi")) { fAnsi = PyObject_IsTrue(value); continue; } #if PY_MAJOR_VERSION < 3 if (Text_EqualsI(key, "unicode_results")) { fUnicodeResults = PyObject_IsTrue(value); continue; } #endif if (Text_EqualsI(key, "timeout")) { timeout = PyInt_AsLong(value); if (PyErr_Occurred()) return 0; continue; } if (Text_EqualsI(key, "readonly")) { fReadOnly = PyObject_IsTrue(value); continue; } if (Text_EqualsI(key, "attrs_before")) { attrs_before = _CheckAttrsDict(value); if (PyErr_Occurred()) return 0; continue; } // Map DB API recommended names to ODBC names (e.g. user --> uid). for (size_t i = 0; i < _countof(keywordmaps); i++) { if (Text_EqualsI(key, keywordmaps[i].oldname)) { if (keywordmaps[i].newnameObject == 0) { keywordmaps[i].newnameObject = PyString_FromString(keywordmaps[i].newname); if (keywordmaps[i].newnameObject == 0) return 0; } key = keywordmaps[i].newnameObject; break; } } PyObject* str = PyObject_Str(value); // convert if necessary if (!str) return 0; if (PyDict_SetItem(partsdict.Get(), key, str) == -1) { Py_XDECREF(str); return 0; } Py_XDECREF(str); } if (PyDict_Size(partsdict.Get())) pConnectString.Attach(MakeConnectionString(pConnectString.Get(), partsdict)); } if (!pConnectString.IsValid()) return PyErr_Format(PyExc_TypeError, "no connection information was passed"); if (henv == SQL_NULL_HANDLE) { if (!AllocateEnv()) return 0; } return (PyObject*)Connection_New(pConnectString.Get(), fAutoCommit != 0, fAnsi != 0, fUnicodeResults != 0, timeout, fReadOnly != 0, attrs_before); }
JSTrapStatus doi_check_sc_hs(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval,void *closure) { JSOp opcode = 0; JSStackFrame * fp = NULL; jsval r_val = 0; size_t l_val = 0; const JSCodeSpec *cs; char *updatetype = "R"; opcode = (JSOp)*pc;//JS_GetTrapOpcode(cx, script, pc);//in 1.8.0, use this cs = &js_CodeSpec[opcode]; //fprintf(stderr, "DEBUG:now %s\n", cs->name); fp = NULL; JS_FrameIterator(cx,&fp); r_val = l_val = 0; switch(opcode) { case JSOP_SETNAME: case JSOP_SETPROP: { r_val = FETCH_OPND(-1); l_val = get_opcode_arg(cx,script,pc); updatetype = "R"; break; } case JSOP_SETGVAR: { r_val = FETCH_OPND(-1); l_val = (size_t)&(fp->vars[GET_VARNO(pc)]); // TODO: FIXIT this is not l_val, setgvar is more than that updatetype = "R"; break; } case JSOP_SETELEM: { r_val = FETCH_OPND(-1); l_val = FETCH_OPND(-3); updatetype = "A"; break; } case JSOP_SETVAR: { r_val = FETCH_OPND(-1); l_val = (size_t)&(fp->vars[GET_VARNO(pc)]); // TODO: FIXIT updatetype = "R"; break; } case JSOP_SETLOCALPOP: case JSOP_SETLOCAL: { r_val = FETCH_OPND(-1); l_val = (size_t)&(fp->spbase[GET_UINT16(pc)]); updatetype = "R"; break; } case JSOP_SETARG: { r_val = FETCH_OPND(-1); l_val = (size_t)&(fp->argv[GET_ARGNO(pc)]); // TODO: FIXIT updatetype = "R"; break; } case JSOP_SETCONST: { // Errr.... actually i don't know what's the meaning of setconst etc, // if you know, please email me :) fprintf(stderr, "DEBUG: found %s\n", cs->name); r_val = FETCH_OPND(-1); l_val = 0; updatetype = "R"; break; } case JSOP_ENUMELEM: case JSOP_ENUMCONSTELEM: { fprintf(stderr, "DEBUG: found %s\n", cs->name); r_val = FETCH_OPND(-3); l_val = FETCH_OPND(-2); updatetype = "A"; break; } case JSOP_SETXMLNAME: case JSOP_SETMETHOD: { l_val = FETCH_OPND(-2); r_val = FETCH_OPND(-1); updatetype = "R"; break; } default: if(0&&cs->format & JOF_SET){ fprintf(stderr, "DEBUG: %s interpreted but not checked\n", cs->name); } break; } if(r_val != 0 && JSVAL_IS_STRING(r_val)) { uint32_t length = 0; length = JS_GetStringLength(JSVAL_TO_STRING(r_val)) * sizeof(jschar); if(length < MIN_STR_LEN_TO_CHECK){ goto end; } int r = 0; unsigned char *bytes = NULL; jschar *jschars = NULL; jschars = JS_GetStringChars(JSVAL_TO_STRING(r_val)); bytes = (unsigned char *)jschars; if(length > 65535){ //Heapspray DETECTED! /* fprintf(stderr,"\nDEBUG: HEAPSPRAY DETECTED!\n"); */ heapspray_info hsinfo; hsinfo = check_heapspray(bytes,length); PyObject* alert = NULL; PyObject* param = NULL; Context* pycx = NULL; pycx = (Context*) JS_GetContextPrivate(cx); size_t uniqueid = (size_t)pycx + (size_t)l_val; PyObject *str = PyString_FromString("alert_by_uid"); PyObject *alert_by_uid = NULL; if (str == NULL) goto error; alert_by_uid = PyObject_GetAttr((PyObject *)HeapsprayAlertType,str); Py_DECREF(str); str = NULL; if (alert_by_uid == NULL) goto error; PyObject *pyuid = Py_BuildValue("i",uniqueid); if (PyDict_Contains(alert_by_uid,pyuid)){ alert = PyDict_GetItem(alert_by_uid,pyuid); if(alert == NULL) goto error; PyObject *raiseret = PyObject_CallMethod(alert, "reraise", "sdi{s:s#,s:i,s:s#,s:i}", "Previous", hsinfo.entropy, length, "sledge_char", &(hsinfo.most_char), 1, "sledge_cnt", hsinfo.most_char_cnt, "sec_char", &(hsinfo.sec_char), 1, "sec_char_cnt", hsinfo.sec_char_cnt); if(raiseret == NULL) goto error; Py_DECREF(raiseret); raiseret = NULL; }else{ param = Py_BuildValue("isdii{s:s#,s:i,s:s#,s:i}s", -1, "Heapspray Detected!", hsinfo.entropy, length, uniqueid, "sledge_char", &(hsinfo.most_char), 1, "sledge_cnt", hsinfo.most_char_cnt, "sec_char", &(hsinfo.sec_char), 1, "sec_char_cnt", hsinfo.sec_char_cnt, updatetype); if(param == NULL) goto error; alert = PyObject_CallObject((PyObject*)HeapsprayAlertType,param); Py_DECREF(param); param = NULL; if(alert == NULL) goto error; if(PyList_Append(pycx->alertlist,alert) != 0) { goto error; } Py_DECREF(alert); alert = NULL; } Py_DECREF(pyuid); pyuid = NULL; }else{ /* FILE *f; */ /* char path[100]; */ /* sprintf(path,"debug/%d.sc",l_val); */ /* f = fopen(path,"wb"); */ /* fwrite(bytes,length,1,f); */ /* fclose(f); */ r = check_buffer(bytes,length); if(r >= 0) { //Shellcode DETECTED! /* fprintf(stderr,"\nDEBUG: SHELLCODE DETECTED!\n"); */ PyObject* alert = NULL; PyObject* param = NULL; Context* pycx = NULL; param = Py_BuildValue("iss#i", -1, "Shellcode Detected!", bytes, length, r); if(param == NULL) goto error; alert = PyObject_CallObject((PyObject*)ShellcodeAlertType,param); Py_DECREF(param); param = NULL; if(alert == NULL) goto error; pycx = (Context*) JS_GetContextPrivate(cx); if(PyList_Append(pycx->alertlist,alert) != 0) { goto error; } Py_DECREF(alert); alert = NULL; //TODO: FIXME: is it necesary to DECREF alert? /* if rt.malvariables.has_key(l_val): */ /* alert = rt.malvariables[l_val] */ /* else: */ /* alert = Alert(0,l_val,"Shellcode Detected",{"hit":0}) */ /* rt.malvariables[l_val]=alert */ /* rt.alerts.append(alert) */ /* alert.misc["hit"]+=1 */ /* jschars = JS_GetStringChars(JSVAL_TO_STRING(r_val)) */ /* bytes = <char *>jschars */ /* length = JS_GetStringLength(JSVAL_TO_STRING(r_val)) */ /* s = PyString_FromStringAndSize(bytes, length*2)#sizeof(jschar)) */ /* alert.misc["contents"] = s */ /* alert.misc["offset"] = r */ /* #f = open("shellcodes/"+str(l_val)+".sc","w") */ /* #f.write(s) */ /* #f.close() */ /* #print "DEBUG: !!!SC DETECTED at "+str(l_val)+"="+str(r_val)+"size:"+str(length*2) */ } } } end: return JSTRAP_CONTINUE; error: return JSTRAP_ERROR; }
static PyObject *PyRRD_fetch( PyObject UNUSED(*self), PyObject * args) { PyObject *r; rrd_value_t *data, *datai; unsigned long step, ds_cnt; time_t start, end; int argc; char **argv, **ds_namv; if (create_args("fetch", args, &argc, &argv) < 0) return NULL; if (rrd_fetch(argc, argv, &start, &end, &step, &ds_cnt, &ds_namv, &data) == -1) { PyErr_SetString(ErrorObject, rrd_get_error()); rrd_clear_error(); r = NULL; } else { /* Return : ((start, end, step), (name1, name2, ...), [(data1, data2, ..), ...]) */ PyObject *range_tup, *dsnam_tup, *data_list, *t; unsigned long i, j, row; rrd_value_t dv; row = (end - start) / step; r = PyTuple_New(3); range_tup = PyTuple_New(3); dsnam_tup = PyTuple_New(ds_cnt); data_list = PyList_New(row); PyTuple_SET_ITEM(r, 0, range_tup); PyTuple_SET_ITEM(r, 1, dsnam_tup); PyTuple_SET_ITEM(r, 2, data_list); datai = data; PyTuple_SET_ITEM(range_tup, 0, PyInt_FromLong((long) start)); PyTuple_SET_ITEM(range_tup, 1, PyInt_FromLong((long) end)); PyTuple_SET_ITEM(range_tup, 2, PyInt_FromLong((long) step)); for (i = 0; i < ds_cnt; i++) PyTuple_SET_ITEM(dsnam_tup, i, PyString_FromString(ds_namv[i])); for (i = 0; i < row; i++) { t = PyTuple_New(ds_cnt); PyList_SET_ITEM(data_list, i, t); for (j = 0; j < ds_cnt; j++) { dv = *(datai++); if (isnan(dv)) { PyTuple_SET_ITEM(t, j, Py_None); Py_INCREF(Py_None); } else { PyTuple_SET_ITEM(t, j, PyFloat_FromDouble((double) dv)); } } } for (i = 0; i < ds_cnt; i++) rrd_freemem(ds_namv[i]); rrd_freemem(ds_namv); /* rrdtool don't use PyMem_Malloc :) */ rrd_freemem(data); } destroy_args(&argv); return r; }
static PyObject * meth_get__name__(PyCFunctionObject *m, void *closure) { return PyString_FromString(m->m_ml->ml_name); }
PyObject * MeshAttributes_str(PyObject *v) { MeshAttributesObject *obj = (MeshAttributesObject *)v; return PyString_FromString(PyMeshAttributes_ToString(obj->data,"").c_str()); }
// @doc - This file contains autoduck documentation // --------------------------------------------------- // PyObject *PyObject_FromNOTIFICATION(NOTIFICATION *n) { PyObject *ret = NULL; switch (n->ulEventType) { case fnevCriticalError: { ERROR_NOTIFICATION &err = n->info.err; ret = Py_BuildValue("k(s#iiN)", n->ulEventType, err.lpEntryID, err.cbEntryID, err.scode, err.ulFlags, PyObject_FromMAPIERROR(err.lpMAPIError, err.ulFlags&MAPI_UNICODE, FALSE)); break; } case fnevExtended: { EXTENDED_NOTIFICATION &ext = n->info.ext; ret = Py_BuildValue("k(ks#)", n->ulEventType, ext.ulEvent, ext.pbEventParameters, ext.cb); break; } case fnevNewMail: { NEWMAIL_NOTIFICATION &newmail = n->info.newmail; PyObject *msg_class = newmail.ulFlags&MAPI_UNICODE? PyWinObject_FromWCHAR((const WCHAR *)newmail.lpszMessageClass) : PyString_FromString((const char *)newmail.lpszMessageClass); if (!msg_class) return NULL; ret = Py_BuildValue("k(s#s#kNk)", n->ulEventType, newmail.lpEntryID, newmail.cbEntryID, newmail.lpParentID, newmail.cbParentID, newmail.ulFlags, msg_class, newmail.ulMessageFlags); break; } case fnevObjectCopied: case fnevObjectCreated: case fnevObjectDeleted: case fnevObjectModified: case fnevObjectMoved: case fnevSearchComplete: { OBJECT_NOTIFICATION &obj = n->info.obj; PyObject *obArray = PyMAPIObject_FromSPropTagArray(obj.lpPropTagArray); if (!obArray) return NULL; ret = Py_BuildValue("k(s#is#s#s#N)", n->ulEventType, obj.lpEntryID, obj.cbEntryID, obj.ulObjType, obj.lpParentID, obj.cbParentID, obj.lpOldID, obj.cbOldID, obj.lpOldParentID, obj.cbOldParentID, obArray); break; } case fnevTableModified: { TABLE_NOTIFICATION &tab = n->info.tab; ret = Py_BuildValue("k(kiNNN)", n->ulEventType, tab.ulTableEvent, tab.hResult, PyMAPIObject_FromSPropValue(&tab.propIndex), PyMAPIObject_FromSPropValue(&tab.propPrior), PyMAPIObject_FromSRow(&tab.row)); break; } case fnevStatusObjectModified: { STATUS_OBJECT_NOTIFICATION &statobj = n->info.statobj; ret = Py_BuildValue("k(s#N)", n->ulEventType, statobj.lpEntryID, statobj.cbEntryID, PyMAPIObject_FromSPropValueArray(statobj.lpPropVals, statobj.cValues)); break; } default: { PyCom_LoggerWarning(NULL, "unknown MAPI notification type %x", n->ulEventType); ret = Py_BuildValue("k(O)", n->ulEventType, Py_None); break; } } return ret; }
static void ev_io_on_read(struct ev_loop* mainloop, ev_io* watcher, const int events) { static char read_buf[READ_BUFFER_SIZE]; Request* request = REQUEST_FROM_WATCHER(watcher); read_state read_state; ssize_t read_bytes = read( request->client_fd, read_buf, READ_BUFFER_SIZE ); GIL_LOCK(0); if (read_bytes == 0) { /* Client disconnected */ read_state = aborted; DBG_REQ(request, "Client disconnected"); } else if (read_bytes < 0) { /* Would block or error */ if(errno == EAGAIN || errno == EWOULDBLOCK) { read_state = not_yet_done; } else { read_state = aborted; DBG_REQ(request, "Hit errno %d while read()ing", errno); } } else { /* OK, either expect more data or done reading */ Request_parse(request, read_buf, (size_t)read_bytes); if(request->state.error_code) { /* HTTP parse error */ read_state = done; DBG_REQ(request, "Parse error"); request->current_chunk = PyString_FromString( http_error_messages[request->state.error_code]); assert(request->iterator == NULL); } else if(request->state.parse_finished) { /* HTTP parse successful */ read_state = done; bool wsgi_ok = wsgi_call_application(request); if (!wsgi_ok) { /* Response is "HTTP 500 Internal Server Error" */ DBG_REQ(request, "WSGI app error"); assert(PyErr_Occurred()); PyErr_Print(); assert(!request->state.chunked_response); Py_XCLEAR(request->iterator); request->current_chunk = PyString_FromString( http_error_messages[HTTP_SERVER_ERROR]); } } else { /* Wait for more data */ read_state = not_yet_done; } } switch (read_state) { case not_yet_done: break; case done: DBG_REQ(request, "Stop read watcher, start write watcher"); ev_io_stop(mainloop, &request->ev_watcher); ev_io_init(&request->ev_watcher, &ev_io_on_write, request->client_fd, EV_WRITE); ev_io_start(mainloop, &request->ev_watcher); break; case aborted: close_connection(mainloop, request); break; } GIL_UNLOCK(0); }
static PyObject * PLy_trigger_build_args(FunctionCallInfo fcinfo, PLyProcedure *proc, HeapTuple *rv) { TriggerData *tdata = (TriggerData *) fcinfo->context; PyObject *pltname, *pltevent, *pltwhen, *pltlevel, *pltrelid, *plttablename, *plttableschema; PyObject *pltargs, *pytnew, *pytold; PyObject *volatile pltdata = NULL; char *stroid; PG_TRY(); { pltdata = PyDict_New(); if (!pltdata) PLy_elog(ERROR, "could not create new dictionary while building trigger arguments"); pltname = PyString_FromString(tdata->tg_trigger->tgname); PyDict_SetItemString(pltdata, "name", pltname); Py_DECREF(pltname); stroid = DatumGetCString(DirectFunctionCall1(oidout, ObjectIdGetDatum(tdata->tg_relation->rd_id))); pltrelid = PyString_FromString(stroid); PyDict_SetItemString(pltdata, "relid", pltrelid); Py_DECREF(pltrelid); pfree(stroid); stroid = SPI_getrelname(tdata->tg_relation); plttablename = PyString_FromString(stroid); PyDict_SetItemString(pltdata, "table_name", plttablename); Py_DECREF(plttablename); pfree(stroid); stroid = SPI_getnspname(tdata->tg_relation); plttableschema = PyString_FromString(stroid); PyDict_SetItemString(pltdata, "table_schema", plttableschema); Py_DECREF(plttableschema); pfree(stroid); if (TRIGGER_FIRED_BEFORE(tdata->tg_event)) pltwhen = PyString_FromString("BEFORE"); else if (TRIGGER_FIRED_AFTER(tdata->tg_event)) pltwhen = PyString_FromString("AFTER"); else if (TRIGGER_FIRED_INSTEAD(tdata->tg_event)) pltwhen = PyString_FromString("INSTEAD OF"); else { elog(ERROR, "unrecognized WHEN tg_event: %u", tdata->tg_event); pltwhen = NULL; /* keep compiler quiet */ } PyDict_SetItemString(pltdata, "when", pltwhen); Py_DECREF(pltwhen); if (TRIGGER_FIRED_FOR_ROW(tdata->tg_event)) { pltlevel = PyString_FromString("ROW"); PyDict_SetItemString(pltdata, "level", pltlevel); Py_DECREF(pltlevel); if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event)) { pltevent = PyString_FromString("INSERT"); PyDict_SetItemString(pltdata, "old", Py_None); pytnew = PLyDict_FromTuple(&(proc->result), tdata->tg_trigtuple, tdata->tg_relation->rd_att); PyDict_SetItemString(pltdata, "new", pytnew); Py_DECREF(pytnew); *rv = tdata->tg_trigtuple; } else if (TRIGGER_FIRED_BY_DELETE(tdata->tg_event)) { pltevent = PyString_FromString("DELETE"); PyDict_SetItemString(pltdata, "new", Py_None); pytold = PLyDict_FromTuple(&(proc->result), tdata->tg_trigtuple, tdata->tg_relation->rd_att); PyDict_SetItemString(pltdata, "old", pytold); Py_DECREF(pytold); *rv = tdata->tg_trigtuple; } else if (TRIGGER_FIRED_BY_UPDATE(tdata->tg_event)) { pltevent = PyString_FromString("UPDATE"); pytnew = PLyDict_FromTuple(&(proc->result), tdata->tg_newtuple, tdata->tg_relation->rd_att); PyDict_SetItemString(pltdata, "new", pytnew); Py_DECREF(pytnew); pytold = PLyDict_FromTuple(&(proc->result), tdata->tg_trigtuple, tdata->tg_relation->rd_att); PyDict_SetItemString(pltdata, "old", pytold); Py_DECREF(pytold); *rv = tdata->tg_newtuple; } else { elog(ERROR, "unrecognized OP tg_event: %u", tdata->tg_event); pltevent = NULL; /* keep compiler quiet */ } PyDict_SetItemString(pltdata, "event", pltevent); Py_DECREF(pltevent); } else if (TRIGGER_FIRED_FOR_STATEMENT(tdata->tg_event)) { pltlevel = PyString_FromString("STATEMENT"); PyDict_SetItemString(pltdata, "level", pltlevel); Py_DECREF(pltlevel); PyDict_SetItemString(pltdata, "old", Py_None); PyDict_SetItemString(pltdata, "new", Py_None); *rv = NULL; if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event)) pltevent = PyString_FromString("INSERT"); else if (TRIGGER_FIRED_BY_DELETE(tdata->tg_event)) pltevent = PyString_FromString("DELETE"); else if (TRIGGER_FIRED_BY_UPDATE(tdata->tg_event)) pltevent = PyString_FromString("UPDATE"); else if (TRIGGER_FIRED_BY_TRUNCATE(tdata->tg_event)) pltevent = PyString_FromString("TRUNCATE"); else { elog(ERROR, "unrecognized OP tg_event: %u", tdata->tg_event); pltevent = NULL; /* keep compiler quiet */ } PyDict_SetItemString(pltdata, "event", pltevent); Py_DECREF(pltevent); } else elog(ERROR, "unrecognized LEVEL tg_event: %u", tdata->tg_event); if (tdata->tg_trigger->tgnargs) { /* * all strings... */ int i; PyObject *pltarg; pltargs = PyList_New(tdata->tg_trigger->tgnargs); for (i = 0; i < tdata->tg_trigger->tgnargs; i++) { pltarg = PyString_FromString(tdata->tg_trigger->tgargs[i]); /* * stolen, don't Py_DECREF */ PyList_SetItem(pltargs, i, pltarg); } } else { Py_INCREF(Py_None); pltargs = Py_None; } PyDict_SetItemString(pltdata, "args", pltargs); Py_DECREF(pltargs); } PG_CATCH(); { Py_XDECREF(pltdata); PG_RE_THROW(); } PG_END_TRY(); return pltdata; }
PyObject * FontAttributes_str(PyObject *v) { FontAttributesObject *obj = (FontAttributesObject *)v; return PyString_FromString(PyFontAttributes_ToString(obj->data,"").c_str()); }
PyObject *_attachsql_get_library_version(PyObject *self, PyObject *unused) { return PyString_FromString(attachsql_get_library_version()); }
static PyObject * get_fork_state(PyObject *self) { (void)self; return PyString_FromString(fork_state_name[fork_state]); }
/* * This routine needs to emulate load_package in import.c in * python, but from a DataSectionPtr */ PyObject* PyResMgrImportLoader::load_package( const std::string& name, DataSectionPtr package ) { // We don't erase ourselves from the modules_ list, since whatever // we call to process our __init__ script will do it for us. std::string moduleName = name; std::string::size_type dotPos = name.rfind( "." ); if ( dotPos != std::string::npos ) { moduleName = name.substr( dotPos + 1 ); } PyObject *module = PyImport_AddModule( name.c_str() ); if ( module == NULL ) { // Propagate the PyErr up return NULL; } PyObject *moduleDict = PyModule_GetDict( module ); PyObject *file = PyString_FromString( ( path_ + "/" + moduleName).c_str() ); if ( file == NULL ) { return NULL; } PyObject *path = Py_BuildValue( "[O]", file ); if ( path == NULL ) { Py_DECREF( file ); return NULL; } int err = PyDict_SetItemString( moduleDict, "__file__", file ); Py_DECREF( file ); if ( err != 0 ) { Py_DECREF( path ); return NULL; } err = PyDict_SetItemString( moduleDict, "__path__", path ); Py_DECREF( path ); if ( err != 0 ) { return NULL; } err = PyDict_SetItemString( moduleDict, "__loader__", this ); if ( err != 0 ) { return NULL; } // This call was tested in find_module_file earlier. moduleCacheEntry packageInit = find_module_file( "__init__", package ); // TRACE_MSG( "PyResMgrImportLoader(%s)::load_package: processing %s\n", // path_.c_str(), name.c_str() ); switch( packageInit.first ) { case PY_OBJECT: return load_compiled_module( name, packageInit.second->asBinary() ); case PY_SOURCE: return load_source_module( name, packageInit.second->asBinary(), package ); case NOT_FOUND: case PKG_DIRECTORY: case C_EXTENSION: break; } Py_Return; }
static int pygvfinfo_setattr(PyGnomeVFSFileInfo *self, const gchar *attr, PyObject *value) { GnomeVFSFileInfo *finfo; if (!self->finfo) self->finfo = gnome_vfs_file_info_new(); finfo = self->finfo; if (!strcmp(attr, "__members__")) { PyErr_SetString(PyExc_TypeError, "readonly attribute"); return -1; } else if (!strcmp(attr, "name")) { if (!PyString_Check(value)) { PyErr_SetString(PyExc_TypeError, "'name' attribute must be a string"); return -1; } if (finfo->name) g_free(finfo->name); finfo->name = g_strdup(PyString_AsString(value)); return 0; } else if (!strcmp(attr, "valid_fields")) { if (!PyInt_Check(value)) { PyErr_SetString(PyExc_TypeError, "'valid_fields' attribute must be an int"); return -1; } finfo->valid_fields = PyInt_AsLong(value); return 0; } else if (!strcmp(attr, "type")) { if (!PyInt_Check(value)) { PyErr_SetString(PyExc_TypeError, "'type' attribute must be an int"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_TYPE; finfo->type = PyInt_AsLong(value); return 0; } else if (!strcmp(attr, "permissions")) { if (!PyInt_Check(value)) { PyErr_SetString(PyExc_TypeError, "'permissions' attribute must be an int"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS; finfo->permissions = PyInt_AsLong(value); return 0; } else if (!strcmp(attr, "access")) { if (!PyInt_Check(value)) { PyErr_SetString(PyExc_TypeError, "'access' attribute must be an int"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_ACCESS; finfo->permissions |= PyInt_AsLong(value); return 0; } else if (!strcmp(attr, "flags")) { if (!PyInt_Check(value)) { PyErr_SetString(PyExc_TypeError, "'flags' attribute must be an int"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_FLAGS; finfo->flags = PyInt_AsLong(value); return 0; } else if (!strcmp(attr, "device")) { if (!(PyInt_Check(value) || PyLong_Check(value))) { PyErr_SetString(PyExc_TypeError, "'device' attribute must be an int or long"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_DEVICE; if (PyInt_Check(value)) finfo->device = PyInt_AsLong(value); else finfo->device = PyLong_AsUnsignedLongLong(value); return 0; } else if (!strcmp(attr, "inode")) { if (!(PyInt_Check(value) || PyLong_Check(value))) { PyErr_SetString(PyExc_TypeError, "'inode' attribute must be an int or long"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_INODE; if (PyInt_Check(value)) finfo->inode = PyInt_AsLong(value); else finfo->inode = PyLong_AsUnsignedLongLong(value); return 0; } else if (!strcmp(attr, "link_count")) { if (!(PyInt_Check(value) || PyLong_Check(value))) { PyErr_SetString(PyExc_TypeError, "'link_count' attribute must be an int or long"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_LINK_COUNT; if (PyInt_Check(value)) finfo->link_count = PyInt_AsLong(value); else finfo->link_count = PyLong_AsUnsignedLongLong(value); return 0; } else if (!strcmp(attr, "uid")) { if (!(PyInt_Check(value) || PyLong_Check(value))) { PyErr_SetString(PyExc_TypeError, "'uid' attribute must be an int or long"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_IDS; if (PyInt_Check(value)) finfo->uid = PyInt_AsLong(value); else finfo->uid = PyLong_AsUnsignedLongLong(value); return 0; } else if (!strcmp(attr, "gid")) { if (!(PyInt_Check(value) || PyLong_Check(value))) { PyErr_SetString(PyExc_TypeError, "'gid' attribute must be an int or long"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_IDS; if (PyInt_Check(value)) finfo->gid = PyInt_AsLong(value); else finfo->gid = PyLong_AsUnsignedLongLong(value); return 0; } else if (!strcmp(attr, "size")) { if (!(PyInt_Check(value) || PyLong_Check(value))) { PyErr_SetString(PyExc_TypeError, "'size' attribute must be an int or long"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_SIZE; if (PyInt_Check(value)) finfo->size = PyInt_AsLong(value); else finfo->size = PyLong_AsUnsignedLongLong(value); return 0; } else if (!strcmp(attr, "block_count")) { if (!(PyInt_Check(value) || PyLong_Check(value))) { PyErr_SetString(PyExc_TypeError, "'block_count' attribute must be an int or long"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_BLOCK_COUNT; if (PyInt_Check(value)) finfo->block_count = PyInt_AsLong(value); else finfo->block_count = PyLong_AsUnsignedLongLong(value); return 0; } else if (!strcmp(attr, "io_block_size")) { if (!(PyInt_Check(value) || PyLong_Check(value))) { PyErr_SetString(PyExc_TypeError, "'io_block_size' attribute must be an int or long"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_IO_BLOCK_SIZE; if (PyInt_Check(value)) finfo->io_block_size = PyInt_AsLong(value); else finfo->io_block_size = PyLong_AsUnsignedLongLong(value); return 0; } else if (!strcmp(attr, "atime")) { if (!PyLong_Check(value)) { PyErr_SetString(PyExc_TypeError, "'atime' attribute must be a long"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_ATIME; finfo->atime = PyLong_AsUnsignedLongLong(value); return 0; } else if (!strcmp(attr, "mtime")) { if (!PyLong_Check(value)) { PyErr_SetString(PyExc_TypeError, "'mtime' attribute must be a long"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_MTIME; finfo->mtime = PyLong_AsUnsignedLongLong(value); return 0; } else if (!strcmp(attr, "ctime")) { if (!PyLong_Check(value)) { PyErr_SetString(PyExc_TypeError, "'ctime' attribute must be a long"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_CTIME; finfo->ctime = PyLong_AsUnsignedLongLong(value); return 0; } else if (!strcmp(attr, "symlink_name")) { if (!PyString_Check(value)) { PyErr_SetString(PyExc_TypeError, "'symlink_name' attribute must be a string"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_SYMLINK_NAME; if (finfo->symlink_name) g_free(finfo->symlink_name); finfo->symlink_name = g_strdup(PyString_AsString(value)); return 0; } else if (!strcmp(attr, "mime_type")) { if (!PyString_Check(value)) { PyErr_SetString(PyExc_TypeError, "'mime_type' attribute must be a string"); return -1; } finfo->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_MIME_TYPE; if (finfo->mime_type) g_free(finfo->mime_type); finfo->mime_type = g_strdup(PyString_AsString(value)); return 0; } else { PyObject *name = PyString_FromString(attr); int ret = PyObject_GenericSetAttr((PyObject *)self, name, value); Py_DECREF(name); return ret; } }
/* Helper function for typy_fields which converts a single field to a dictionary. Returns NULL on error. */ static PyObject * convert_field (struct type *type, int field) { PyObject *result = field_new (); PyObject *arg; if (!result) return NULL; if (!field_is_static (&TYPE_FIELD (type, field))) { arg = PyLong_FromLong (TYPE_FIELD_BITPOS (type, field)); if (!arg) goto fail; if (PyObject_SetAttrString (result, "bitpos", arg) < 0) goto failarg; } if (TYPE_FIELD_NAME (type, field)) arg = PyString_FromString (TYPE_FIELD_NAME (type, field)); else { arg = Py_None; Py_INCREF (arg); } if (!arg) goto fail; if (PyObject_SetAttrString (result, "name", arg) < 0) goto failarg; arg = TYPE_FIELD_ARTIFICIAL (type, field) ? Py_True : Py_False; Py_INCREF (arg); if (PyObject_SetAttrString (result, "artificial", arg) < 0) goto failarg; if (TYPE_CODE (type) == TYPE_CODE_CLASS) arg = field < TYPE_N_BASECLASSES (type) ? Py_True : Py_False; else arg = Py_False; Py_INCREF (arg); if (PyObject_SetAttrString (result, "is_base_class", arg) < 0) goto failarg; arg = PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field)); if (!arg) goto fail; if (PyObject_SetAttrString (result, "bitsize", arg) < 0) goto failarg; /* A field can have a NULL type in some situations. */ if (TYPE_FIELD_TYPE (type, field) == NULL) { arg = Py_None; Py_INCREF (arg); } else arg = type_to_type_object (TYPE_FIELD_TYPE (type, field)); if (!arg) goto fail; if (PyObject_SetAttrString (result, "type", arg) < 0) goto failarg; return result; failarg: Py_DECREF (arg); fail: Py_DECREF (result); return NULL; }
static PyObject * pygvfinfo_getattr(PyGnomeVFSFileInfo *self, const gchar *attr) { GnomeVFSFileInfo *finfo; finfo = self->finfo; if (!strcmp(attr, "__members__")) { return Py_BuildValue("[ssssssssssssssssss]", "atime", "block_count", "ctime", "device", "flags", "gid", "inode", "io_block_size", "link_count", "mime_type", "mtime", "name", "permissions", "access", "size", "symlink_name", "type", "uid", "valid_fields"); } else if (!strcmp(attr, "name")) { if (finfo->name) return PyString_FromString(finfo->name); Py_INCREF(Py_None); return Py_None; } else if (!strcmp(attr, "valid_fields")) { return PyInt_FromLong(finfo->valid_fields); } else if (!strcmp(attr, "type")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_TYPE)) { PyErr_SetString(PyExc_ValueError, "type field has no valid value"); return NULL; } return PyInt_FromLong(finfo->type); } else if (!strcmp(attr, "permissions")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_PERMISSIONS)) { PyErr_SetString(PyExc_ValueError, "permissions field has no valid value"); return NULL; } return PyInt_FromLong(finfo->permissions & (~PYGNOME_VFS_ACCESS_BITS)); } else if (!strcmp(attr, "access")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_ACCESS)) { PyErr_SetString(PyExc_ValueError, "access field has no valid value"); return NULL; } return PyInt_FromLong(finfo->permissions & PYGNOME_VFS_ACCESS_BITS); } else if (!strcmp(attr, "flags")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_FLAGS)) { PyErr_SetString(PyExc_ValueError,"flags field has no valid value"); return NULL; } return PyInt_FromLong(finfo->flags); } else if (!strcmp(attr, "device")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_DEVICE)) { PyErr_SetString(PyExc_ValueError, "device field has no valid value"); return NULL; } if (finfo->device <= G_MAXLONG) return PyInt_FromLong(finfo->device); else return PyLong_FromUnsignedLongLong(finfo->device); } else if (!strcmp(attr, "inode")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_INODE)) { PyErr_SetString(PyExc_ValueError,"inode field has no valid value"); return NULL; } if (finfo->inode <= G_MAXLONG) return PyInt_FromLong(finfo->inode); else return PyLong_FromUnsignedLongLong(finfo->inode); } else if (!strcmp(attr, "link_count")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_LINK_COUNT)) { PyErr_SetString(PyExc_ValueError, "link_count field has no valid value"); return NULL; } if (finfo->link_count < G_MAXLONG) return PyInt_FromLong(finfo->link_count); else return PyLong_FromUnsignedLong(finfo->link_count); } else if (!strcmp(attr, "uid")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_IDS)) { PyErr_SetString(PyExc_ValueError, "uid field has no valid value"); return NULL; } if (finfo->uid < G_MAXLONG) return PyInt_FromLong(finfo->uid); else return PyLong_FromUnsignedLong(finfo->uid); } else if (!strcmp(attr, "gid")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_IDS)) { PyErr_SetString(PyExc_ValueError, "gid field has no valid value"); return NULL; } if (finfo->gid < G_MAXLONG) return PyInt_FromLong(finfo->gid); else return PyLong_FromUnsignedLong(finfo->gid); } else if (!strcmp(attr, "size")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SIZE)) { PyErr_SetString(PyExc_ValueError, "size field has no valid value"); return NULL; } if (finfo->size <= G_MAXLONG) return PyInt_FromLong(finfo->size); else return PyLong_FromUnsignedLongLong(finfo->size); } else if (!strcmp(attr, "block_count")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_BLOCK_COUNT)) { PyErr_SetString(PyExc_ValueError, "block_count field has no valid value"); return NULL; } if (finfo->block_count <= G_MAXLONG) return PyInt_FromLong(finfo->block_count); else return PyLong_FromUnsignedLongLong(finfo->block_count); } else if (!strcmp(attr, "io_block_size")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_IO_BLOCK_SIZE)){ PyErr_SetString(PyExc_ValueError, "io_block_size field has no valid value"); return NULL; } if (finfo->io_block_size < G_MAXLONG) return PyInt_FromLong(finfo->io_block_size); else return PyLong_FromUnsignedLong(finfo->io_block_size); } else if (!strcmp(attr, "atime")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_ATIME)) { PyErr_SetString(PyExc_ValueError,"atime field has no valid value"); return NULL; } return PyLong_FromLongLong(finfo->atime); } else if (!strcmp(attr, "mtime")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_MTIME)) { PyErr_SetString(PyExc_ValueError,"mtime field has no valid value"); return NULL; } return PyLong_FromLongLong(finfo->mtime); } else if (!strcmp(attr, "ctime")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_CTIME)) { PyErr_SetString(PyExc_ValueError,"ctime field has no valid value"); return NULL; } return PyLong_FromLongLong(finfo->ctime); } else if (!strcmp(attr, "symlink_name")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SYMLINK_NAME)) { PyErr_SetString(PyExc_ValueError, "link_name field has no valid value"); return NULL; } if (finfo->symlink_name) return PyString_FromString(finfo->symlink_name); Py_INCREF(Py_None); return Py_None; } else if (!strcmp(attr, "mime_type")) { if (!(finfo->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_MIME_TYPE)) { PyErr_SetString(PyExc_ValueError, "mime_type field has no valid value"); return NULL; } if (finfo->mime_type) return PyString_FromString(finfo->mime_type); Py_INCREF(Py_None); return Py_None; } else { PyObject *name = PyString_FromString(attr); PyObject *ret = PyObject_GenericGetAttr((PyObject *)self, name); Py_DECREF(name); return ret; } }
static PyObject * get_line_buffer(PyObject *self, PyObject *noarg) { return PyString_FromString(rl_line_buffer); }
static PlumaPlugin * pluma_plugin_loader_iface_load (PlumaPluginLoader *loader, PlumaPluginInfo *info, const gchar *path) { PlumaPluginLoaderPython *pyloader = PLUMA_PLUGIN_LOADER_PYTHON (loader); PyObject *main_module, *main_locals, *pytype; PyObject *pymodule, *fromlist; gchar *module_name; PlumaPlugin *result; if (pyloader->priv->init_failed) { g_warning ("Cannot load python plugin Python '%s' since pluma was" "not able to initialize the Python interpreter.", pluma_plugin_info_get_name (info)); return NULL; } /* see if py definition for the plugin is already loaded */ result = new_plugin_from_info (pyloader, info); if (result != NULL) return result; main_module = PyImport_AddModule ("pluma.plugins"); if (main_module == NULL) { g_warning ("Could not get pluma.plugins."); return NULL; } /* If we have a special path, we register it */ if (path != NULL) { PyObject *sys_path = PySys_GetObject ("path"); PyObject *pypath = PyString_FromString (path); if (PySequence_Contains (sys_path, pypath) == 0) PyList_Insert (sys_path, 0, pypath); Py_DECREF (pypath); } main_locals = PyModule_GetDict (main_module); /* we need a fromlist to be able to import modules with a '.' in the name. */ fromlist = PyTuple_New(0); module_name = g_strdup (pluma_plugin_info_get_module_name (info)); pymodule = PyImport_ImportModuleEx (module_name, main_locals, main_locals, fromlist); Py_DECREF(fromlist); if (!pymodule) { g_free (module_name); PyErr_Print (); return NULL; } PyDict_SetItemString (main_locals, module_name, pymodule); g_free (module_name); pytype = find_python_plugin_type (info, pymodule); if (pytype) return add_python_info (pyloader, info, pymodule, path, pytype); return NULL; }
char* sendAndRecieve(const char* url) { Py_Initialize(); PyObject *pArgs, *pValue, *pFunc; PyObject *pGlobal = PyDict_New(); PyObject *pLocal; PyRun_SimpleString("import types,sys"); //create the new module in python PyRun_SimpleString("mymod = types.ModuleType(\"mymod\")"); //add it to the sys modules so that it can be imported by other modules PyRun_SimpleString("sys.modules[\"mymod\"] = mymod"); //import sys so that path will be available in mymod so that other/newly created modules can be imported PyRun_SimpleString("exec 'import sys' in mymod.__dict__"); //import it to the current python interpreter PyObject *pNewMod = PyImport_Import(PyString_FromString("mymod")); //Get the dictionary object from my module so I can pass this to PyRun_String pLocal = PyModule_GetDict(pNewMod); //import urllib2 to global namespace PyMapping_SetItemString(pGlobal, "urllib2", PyImport_ImportModule("urllib2")); //Define my function in the newly created module pValue = PyRun_String("def get(url):\n\treturn urllib2.urlopen(url).read()\n", Py_file_input, pGlobal, pLocal); Py_DECREF(pValue); //Get a pointer to the function I just defined pFunc = PyObject_GetAttrString(pNewMod, "get"); if (pFunc == NULL) { #ifdef DEBUG PyErr_Print(); #endif return NULL; } //Build a tuple to hold my arguments (just the number 4 in this case) pArgs = PyTuple_New(1); pValue = PyString_FromString(url); PyTuple_SetItem(pArgs, 0, pValue); //Call my function, passing it the number four pValue = PyObject_CallObject(pFunc, pArgs); if (pValue == NULL) { #ifdef DEBUG PyErr_Print(); #endif return NULL; } Py_DECREF(pArgs); char* result = PyString_AsString(pValue); if (result == NULL) { #ifdef DEBUG PyErr_Print(); #endif return NULL; } Py_DECREF(pValue); Py_XDECREF(pFunc); Py_DECREF(pNewMod); Py_Finalize(); return result; }
PyObject *eterm_to_py(ETERM * obj) { int i; int count; ETERM *obj2; PyObject *eobj = NULL; if (obj == NULL) { Py_INCREF(Py_None); return Py_None; } switch (ERL_TYPE(obj)) { case ERL_CONS: case ERL_NIL: count = erl_length(obj); eobj = PyList_New(0); for (i = 0; i < count; i++) { obj2 = erl_hd(obj); PyList_Append(eobj, eterm_to_py(obj2)); obj = erl_tl(obj); } break; case ERL_TUPLE: eobj = PyTuple_New(erl_size(obj)); for (i = 1; i <= erl_size(obj); i++) { obj2 = erl_element(i, obj); PyTuple_SetItem(eobj, i - 1, eterm_to_py(obj2)); } break; case ERL_ATOM: eobj = PyString_FromStringAndSize(ERL_ATOM_PTR(obj), ERL_ATOM_SIZE(obj)); break; case ERL_INTEGER: eobj = PyInt_FromLong(ERL_INT_VALUE(obj)); break; case ERL_BINARY: fprintf(stderr, "FOUND A BINARY %.*s\n", ERL_BIN_SIZE(obj), ERL_BIN_PTR(obj)); break; case ERL_PID: eobj = PyDict_New(); if (PyDict_SetItemString(eobj, "node", PyString_FromString(ERL_PID_NODE(obj)))) { PyErr_Print(); break; } if (PyDict_SetItemString(eobj, "number", PyInt_FromLong(ERL_PID_NUMBER(obj)))) { PyErr_Print(); break; } if (PyDict_SetItemString(eobj, "serial", PyInt_FromLong(ERL_PID_SERIAL(obj)))) { PyErr_Print(); break; } if (PyDict_SetItemString(eobj, "creation", PyInt_FromLong(ERL_PID_CREATION(obj)))) { PyErr_Print(); break; } default: fprintf(stderr, "UNMANAGED ETERM TYPE: %d\n", ERL_TYPE(obj)); break; } if (eobj == NULL) { Py_INCREF(Py_None); return Py_None; } return eobj; }
PyObject * LDAP_get_option(LDAPObject *self, int option) { int res; int intval; struct timeval *tv; LDAPAPIInfo apiinfo; LDAPControl **lcs; LDAPControl *lc; char *strval; PyObject *extensions, *v, *tup; Py_ssize_t i, num_extensions, num_controls; LDAP *ld; ld = self ? self->ldap : NULL; switch(option) { case LDAP_OPT_API_INFO: apiinfo.ldapai_info_version = LDAP_API_INFO_VERSION; if (self) LDAP_BEGIN_ALLOW_THREADS(self); res = ldap_get_option( ld, option, &apiinfo ); if (self) LDAP_END_ALLOW_THREADS(self); if (res != LDAP_OPT_SUCCESS) return option_error(res, "ldap_get_option"); /* put the extensions into tuple form */ num_extensions = 0; while (apiinfo.ldapai_extensions[num_extensions]) num_extensions++; extensions = PyTuple_New(num_extensions); for (i = 0; i < num_extensions; i++) PyTuple_SET_ITEM(extensions, i, PyString_FromString(apiinfo.ldapai_extensions[i])); /* return api info as a dictionary */ v = Py_BuildValue("{s:i, s:i, s:i, s:s, s:i, s:O}", "info_version", apiinfo.ldapai_info_version, "api_version", apiinfo.ldapai_api_version, "protocol_version", apiinfo.ldapai_protocol_version, "vendor_name", apiinfo.ldapai_vendor_name, "vendor_version", apiinfo.ldapai_vendor_version, "extensions", extensions); if (apiinfo.ldapai_vendor_name) ldap_memfree(apiinfo.ldapai_vendor_name); for (i = 0; i < num_extensions; i++) ldap_memfree(apiinfo.ldapai_extensions[i]); ldap_memfree(apiinfo.ldapai_extensions); Py_DECREF(extensions); return v; #ifdef HAVE_SASL case LDAP_OPT_X_SASL_SSF: #endif case LDAP_OPT_REFERRALS: case LDAP_OPT_RESTART: case LDAP_OPT_DEREF: case LDAP_OPT_SIZELIMIT: case LDAP_OPT_TIMELIMIT: case LDAP_OPT_PROTOCOL_VERSION: case LDAP_OPT_ERROR_NUMBER: case LDAP_OPT_DEBUG_LEVEL: #ifdef HAVE_TLS case LDAP_OPT_X_TLS: case LDAP_OPT_X_TLS_REQUIRE_CERT: #ifdef LDAP_OPT_X_TLS_CRLCHECK case LDAP_OPT_X_TLS_CRLCHECK: #endif #ifdef LDAP_OPT_X_TLS_PROTOCOL_MIN case LDAP_OPT_X_TLS_PROTOCOL_MIN: #endif #endif #ifdef HAVE_SASL case LDAP_OPT_X_SASL_SSF_MIN: case LDAP_OPT_X_SASL_SSF_MAX: #endif #ifdef LDAP_OPT_X_SASL_NOCANON case LDAP_OPT_X_SASL_NOCANON: #endif #ifdef LDAP_OPT_CONNECT_ASYNC case LDAP_OPT_CONNECT_ASYNC: #endif #ifdef LDAP_OPT_X_KEEPALIVE_IDLE case LDAP_OPT_X_KEEPALIVE_IDLE: #endif #ifdef LDAP_OPT_X_KEEPALIVE_PROBES case LDAP_OPT_X_KEEPALIVE_PROBES: #endif #ifdef LDAP_OPT_X_KEEPALIVE_INTERVAL case LDAP_OPT_X_KEEPALIVE_INTERVAL: #endif /* Integer-valued options */ if (self) LDAP_BEGIN_ALLOW_THREADS(self); res = ldap_get_option(ld, option, &intval); if (self) LDAP_END_ALLOW_THREADS(self); if (res != LDAP_OPT_SUCCESS) return option_error(res, "ldap_get_option"); return PyInt_FromLong(intval); case LDAP_OPT_HOST_NAME: case LDAP_OPT_URI: #ifdef LDAP_OPT_DEFBASE case LDAP_OPT_DEFBASE: #endif case LDAP_OPT_ERROR_STRING: case LDAP_OPT_MATCHED_DN: #ifdef HAVE_TLS case LDAP_OPT_X_TLS_CACERTFILE: case LDAP_OPT_X_TLS_CACERTDIR: case LDAP_OPT_X_TLS_CERTFILE: case LDAP_OPT_X_TLS_KEYFILE: case LDAP_OPT_X_TLS_CIPHER_SUITE: case LDAP_OPT_X_TLS_RANDOM_FILE: case LDAP_OPT_X_TLS_DHFILE: #ifdef LDAP_OPT_X_TLS_CRLFILE case LDAP_OPT_X_TLS_CRLFILE: #endif #ifdef LDAP_OPT_X_TLS_PACKAGE case LDAP_OPT_X_TLS_PACKAGE: #endif #endif #ifdef HAVE_SASL case LDAP_OPT_X_SASL_SECPROPS: case LDAP_OPT_X_SASL_MECH: case LDAP_OPT_X_SASL_REALM: case LDAP_OPT_X_SASL_AUTHCID: case LDAP_OPT_X_SASL_AUTHZID: #ifdef LDAP_OPT_X_SASL_USERNAME case LDAP_OPT_X_SASL_USERNAME: #endif #endif /* String-valued options */ if (self) LDAP_BEGIN_ALLOW_THREADS(self); res = ldap_get_option(ld, option, &strval); if (self) LDAP_END_ALLOW_THREADS(self); if (res != LDAP_OPT_SUCCESS) return option_error(res, "ldap_get_option"); if (strval == NULL) { Py_INCREF(Py_None); return Py_None; } v = PyString_FromString(strval); ldap_memfree(strval); return v; case LDAP_OPT_TIMEOUT: case LDAP_OPT_NETWORK_TIMEOUT: /* Double-valued timeval options */ if (self) LDAP_BEGIN_ALLOW_THREADS(self); res = ldap_get_option(ld, option, &tv); if (self) LDAP_END_ALLOW_THREADS(self); if (res != LDAP_OPT_SUCCESS) return option_error(res, "ldap_get_option"); if (tv == NULL) { Py_INCREF(Py_None); return Py_None; } v = PyFloat_FromDouble( (double) tv->tv_sec + ( (double) tv->tv_usec / 1000000.0 ) ); ldap_memfree(tv); return v; case LDAP_OPT_SERVER_CONTROLS: case LDAP_OPT_CLIENT_CONTROLS: if (self) LDAP_BEGIN_ALLOW_THREADS(self); res = ldap_get_option(ld, option, &lcs); if (self) LDAP_END_ALLOW_THREADS(self); if (res != LDAP_OPT_SUCCESS) return option_error(res, "ldap_get_option"); if (lcs == NULL) return PyList_New(0); /* Get the number of controls */ num_controls = 0; while (lcs[num_controls]) num_controls++; /* We'll build a list of controls, with each control a tuple */ v = PyList_New(num_controls); for (i = 0; i < num_controls; i++) { lc = lcs[i]; tup = Py_BuildValue("(sbs)", lc->ldctl_oid, lc->ldctl_iscritical, lc->ldctl_value.bv_val); PyList_SET_ITEM(v, i, tup); } ldap_controls_free(lcs); return v; default: PyErr_Format(PyExc_ValueError, "unknown option %d", option); return NULL; } }
// copy current artcle for back compatible use only // for new coder please use getArticle static PyObject *qterm_copyArticle(PyObject *, PyObject *args) { long lp; if (!PyArg_ParseTuple(args, "l", &lp)) return NULL; Window *pWin=(Window*)lp; QStringList strList; QString strArticle; while(1) { // check it there is duplicated string // it starts from the end in the range of one screen height // so this is a non-greedy match QString strTemp = pWin->stripWhitespace( pWin->m_pBuffer->screen(0)->getText()); int i=0; int start=0; for(QStringList::Iterator it=strList.fromLast(); it!=strList.begin(), i < pWin->m_pBuffer->line()-1; // not exceeeding the last screen --it, i++) { if(*it!=strTemp) continue; QStringList::Iterator it2 = it; bool dup=true; // match more to see if its duplicated for(int j=0; j<=i; j++, it2++) { QString str1 = pWin->stripWhitespace( pWin->m_pBuffer->screen(j)->getText()); if(*it2!=str1) { dup = false; break; } } if(dup) { // set the start point start = i+1; break; } } // add new lines for(i=start;i<pWin->m_pBuffer->line()-1;i++) strList+=pWin->stripWhitespace( pWin->m_pBuffer->screen(i)->getText()); // the end of article if( pWin->m_pBuffer->screen( pWin->m_pBuffer->line()-1)->getText().find("%") == -1 ) break; // continue pWin->m_pTelnet->write(" ", 1); if(!pWin->m_wcWaiting.wait(10000)) // timeout break; } #if defined(_OS_WIN32_) || defined(Q_OS_WIN32) strArticle = strList.join("\r\n"); #else strArticle = strList.join("\n"); #endif PyObject *py_text = PyString_FromString(strArticle.toLocal8Bit); Py_INCREF(py_text); return py_text; }
void XBPyThread::Process() { CLog::Log(LOGDEBUG,"Python thread: start processing"); int m_Py_file_input = Py_file_input; // get the global lock PyEval_AcquireLock(); PyThreadState* state = Py_NewInterpreter(); if (!state) { PyEval_ReleaseLock(); CLog::Log(LOGERROR,"Python thread: FAILED to get thread state!"); return; } // swap in my thread state PyThreadState_Swap(state); m_pExecuter->InitializeInterpreter(); CLog::Log(LOGDEBUG, "%s - The source file to load is %s", __FUNCTION__, m_source); // get path from script file name and add python path's // this is used for python so it will search modules from script path first CStdString scriptDir; CUtil::GetDirectory(_P(m_source), scriptDir); CUtil::RemoveSlashAtEnd(scriptDir); CStdString path = scriptDir; // add on any addon modules the user has installed ADDON::VECADDONS addons; ADDON::CAddonMgr::Get().GetAddons(ADDON::ADDON_SCRIPT_MODULE, addons); for (unsigned int i = 0; i < addons.size(); ++i) path += PY_PATH_SEP + _P(addons[i]->LibPath()); // and add on whatever our default path is path += PY_PATH_SEP; #if (defined USE_EXTERNAL_PYTHON) { // we want to use sys.path so it includes site-packages // if this fails, default to using Py_GetPath PyObject *sysMod(PyImport_ImportModule("sys")); // must call Py_DECREF when finished PyObject *sysModDict(PyModule_GetDict(sysMod)); // borrowed ref, no need to delete PyObject *pathObj(PyDict_GetItemString(sysModDict, "path")); // borrowed ref, no need to delete if( pathObj && PyList_Check(pathObj) ) { for( int i = 0; i < PyList_Size(pathObj); i++ ) { PyObject *e = PyList_GetItem(pathObj, i); // borrowed ref, no need to delete if( e && PyString_Check(e) ) { path += PyString_AsString(e); // returns internal data, don't delete or modify path += PY_PATH_SEP; } } } else { path += Py_GetPath(); } Py_DECREF(sysMod); // release ref to sysMod } #else path += Py_GetPath(); #endif // set current directory and python's path. if (m_argv != NULL) PySys_SetArgv(m_argc, m_argv); CLog::Log(LOGDEBUG, "%s - Setting the Python path to %s", __FUNCTION__, path.c_str()); PySys_SetPath((char *)path.c_str()); CLog::Log(LOGDEBUG, "%s - Entering source directory %s", __FUNCTION__, scriptDir.c_str()); PyObject* module = PyImport_AddModule((char*)"__main__"); PyObject* moduleDict = PyModule_GetDict(module); // when we are done initing we store thread state so we can be aborted PyThreadState_Swap(NULL); PyEval_ReleaseLock(); // we need to check if we was asked to abort before we had inited bool stopping = false; { CSingleLock lock(m_pExecuter->m_critSection); m_threadState = state; stopping = m_stopping; } PyEval_AcquireLock(); PyThreadState_Swap(state); xbp_chdir(scriptDir.c_str()); if (!stopping) { if (m_type == 'F') { // run script from file FILE *fp = fopen_utf8(_P(m_source).c_str(), "r"); if (fp) { PyObject *f = PyString_FromString(_P(m_source).c_str()); PyDict_SetItemString(moduleDict, "__file__", f); Py_DECREF(f); PyRun_File(fp, _P(m_source).c_str(), m_Py_file_input, moduleDict, moduleDict); fclose(fp); } else CLog::Log(LOGERROR, "%s not found!", m_source); } else { //run script PyRun_String(m_source, m_Py_file_input, moduleDict, moduleDict); } } if (!PyErr_Occurred()) CLog::Log(LOGINFO, "Scriptresult: Success"); else if (PyErr_ExceptionMatches(PyExc_SystemExit)) CLog::Log(LOGINFO, "Scriptresult: Aborted"); else { PyObject* exc_type; PyObject* exc_value; PyObject* exc_traceback; PyObject* pystring; pystring = NULL; PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); if (exc_type == 0 && exc_value == 0 && exc_traceback == 0) { CLog::Log(LOGINFO, "Strange: No Python exception occured"); } else { if (exc_type != NULL && (pystring = PyObject_Str(exc_type)) != NULL && (PyString_Check(pystring))) { PyObject *tracebackModule; CLog::Log(LOGINFO, "-->Python script returned the following error<--"); CLog::Log(LOGERROR, "Error Type: %s", PyString_AsString(PyObject_Str(exc_type))); if (PyObject_Str(exc_value)) CLog::Log(LOGERROR, "Error Contents: %s", PyString_AsString(PyObject_Str(exc_value))); tracebackModule = PyImport_ImportModule((char*)"traceback"); if (tracebackModule != NULL) { PyObject *tbList, *emptyString, *strRetval; tbList = PyObject_CallMethod(tracebackModule, (char*)"format_exception", (char*)"OOO", exc_type, exc_value == NULL ? Py_None : exc_value, exc_traceback == NULL ? Py_None : exc_traceback); emptyString = PyString_FromString(""); strRetval = PyObject_CallMethod(emptyString, (char*)"join", (char*)"O", tbList); CLog::Log(LOGERROR, "%s", PyString_AsString(strRetval)); Py_DECREF(tbList); Py_DECREF(emptyString); Py_DECREF(strRetval); Py_DECREF(tracebackModule); } CLog::Log(LOGINFO, "-->End of Python script error report<--"); } else { pystring = NULL; CLog::Log(LOGINFO, "<unknown exception type>"); } CGUIDialogKaiToast *pDlgToast = (CGUIDialogKaiToast*)g_windowManager.GetWindow(WINDOW_DIALOG_KAI_TOAST); if (pDlgToast) { CStdString desc; CStdString path; CStdString script; CUtil::Split(m_source, path, script); if (script.Equals("default.py")) { CStdString path2; CUtil::RemoveSlashAtEnd(path); CUtil::Split(path, path2, script); } desc.Format(g_localizeStrings.Get(2100), script); pDlgToast->QueueNotification(CGUIDialogKaiToast::Error, g_localizeStrings.Get(257), desc); } } Py_XDECREF(exc_type); Py_XDECREF(exc_value); // caller owns all 3 Py_XDECREF(exc_traceback); // already NULL'd out Py_XDECREF(pystring); } PyObject *m = PyImport_AddModule((char*)"xbmc"); if(!m || PyObject_SetAttrString(m, (char*)"abortRequested", PyBool_FromLong(1))) CLog::Log(LOGERROR, "Scriptresult: failed to set abortRequested"); // make sure all sub threads have finished for(PyThreadState* s = state->interp->tstate_head, *old = NULL; s;) { if(s == state) { s = s->next; continue; } if(old != s) { CLog::Log(LOGINFO, "Scriptresult: Waiting on thread %"PRIu64, (uint64_t)s->thread_id); old = s; } Py_BEGIN_ALLOW_THREADS Sleep(100); Py_END_ALLOW_THREADS s = state->interp->tstate_head; } // pending calls must be cleared out PyXBMC_ClearPendingCalls(state); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); { CSingleLock lock(m_pExecuter->m_critSection); m_threadState = NULL; } PyEval_AcquireLock(); PyThreadState_Swap(state); m_pExecuter->DeInitializeInterpreter(); Py_EndInterpreter(state); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); }
static PyObject *PyRRD_xport( PyObject UNUSED(*self), PyObject * args) { PyObject *r; int argc, xsize; char **argv, **legend_v; time_t start, end; unsigned long step, col_cnt; rrd_value_t *data, *datai; if (create_args("xport", args, &argc, &argv) < 0) return NULL; if (rrd_xport(argc, argv, &xsize, &start, &end, &step, &col_cnt, &legend_v, &data) == -1) { PyErr_SetString(ErrorObject, rrd_get_error()); rrd_clear_error(); r = NULL; } else { PyObject *meta_dict, *data_list, *legend_list, *t; unsigned long i, j; rrd_value_t dv; unsigned long row_cnt = ((end - start) / step); r = PyDict_New(); meta_dict = PyDict_New(); legend_list = PyList_New(col_cnt); data_list = PyList_New(row_cnt); PyDict_SetItem(r, PyString_FromString("meta"), meta_dict); PyDict_SetItem(r, PyString_FromString("data"), data_list); datai = data; PyDict_SetItem(meta_dict, PyString_FromString("start"), PyInt_FromLong((long) start)); PyDict_SetItem(meta_dict, PyString_FromString("end"), PyInt_FromLong((long) end)); PyDict_SetItem(meta_dict, PyString_FromString("step"), PyInt_FromLong((long) step)); PyDict_SetItem(meta_dict, PyString_FromString("rows"), PyInt_FromLong((long) row_cnt)); PyDict_SetItem(meta_dict, PyString_FromString("columns"), PyInt_FromLong((long) col_cnt)); PyDict_SetItem(meta_dict, PyString_FromString("legend"), legend_list); for (i = 0; i < col_cnt; i++) { PyList_SET_ITEM(legend_list, i, PyString_FromString(legend_v[i])); } for (i = 0; i < row_cnt; i++) { t = PyTuple_New(col_cnt); PyList_SET_ITEM(data_list, i, t); for (j = 0; j < col_cnt; j++) { dv = *(datai++); if (isnan(dv)) { PyTuple_SET_ITEM(t, j, Py_None); Py_INCREF(Py_None); } else { PyTuple_SET_ITEM(t, j, PyFloat_FromDouble((double) dv)); } } } for (i = 0; i < col_cnt; i++) { rrd_freemem(legend_v[i]); } rrd_freemem(legend_v); rrd_freemem(data); } destroy_args(&argv); return r; }
static PyObject * swig_varlink_repr(swig_varlinkobject *v) { v = v; return PyString_FromString("<Global variables>"); }