static PyObject *make_app_cb_info(void) { PyObject *app_cb_info; int pos; app_cb_info = PyStructSequence_New(&BlenderAppCbType); if (app_cb_info == NULL) { return NULL; } for (pos = 0; pos < BLI_CB_EVT_TOT; pos++) { if (app_cb_info_fields[pos].name == NULL) { Py_FatalError("invalid callback slots 1"); } PyStructSequence_SET_ITEM(app_cb_info, pos, (py_cb_array[pos] = PyList_New(0))); } if (app_cb_info_fields[pos + APP_CB_OTHER_FIELDS].name != NULL) { Py_FatalError("invalid callback slots 2"); } /* custom function */ PyStructSequence_SET_ITEM(app_cb_info, pos++, (PyObject *)&BPyPersistent_Type); return app_cb_info; }
static void sets(PyObject *v, int i, char* val) { if (val) PyStructSequence_SET_ITEM(v, i, PyString_FromString(val)); else { PyStructSequence_SET_ITEM(v, i, Py_None); Py_INCREF(Py_None); } }
static void sets(PyObject *v, int i, const char* val) { if (val) { PyObject *o = PyUnicode_DecodeFSDefault(val); PyStructSequence_SET_ITEM(v, i, o); } else { PyStructSequence_SET_ITEM(v, i, Py_None); Py_INCREF(Py_None); } }
static void sets(PyObject *v, int i, const char* val) { if (val) { PyObject *o = PyUnicode_Decode(val, strlen(val), Py_FileSystemDefaultEncoding, "surrogateescape"); PyStructSequence_SET_ITEM(v, i, o); } else { PyStructSequence_SET_ITEM(v, i, Py_None); Py_INCREF(Py_None); } }
static void nameinfo_cb(void *arg, int status, int timeouts, char *node, char *service) { PyGILState_STATE gstate = PyGILState_Ensure(); PyObject *callback, *errorno, *dns_node, *dns_service, *dns_result, *result; callback = (PyObject *)arg; ASSERT(callback); if (status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } dns_result = PyStructSequence_New(&AresNameinfoResultType); 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 = Py_BuildValue("s", node); if (service) { dns_service = Py_BuildValue("s", service); } else { dns_service = Py_None; Py_INCREF(Py_None); } PyStructSequence_SET_ITEM(dns_result, 0, dns_node); PyStructSequence_SET_ITEM(dns_result, 1, dns_service); errorno = Py_None; Py_INCREF(Py_None); callback: result = PyObject_CallFunctionObjArgs(callback, dns_result, errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(callback); } Py_XDECREF(result); Py_DECREF(dns_result); Py_DECREF(errorno); Py_DECREF(callback); PyGILState_Release(gstate); }
/** * Simple utility function to initialize #PyStructSequence_Desc */ static PyObject *py_structseq_from_strings( PyTypeObject *py_type, PyStructSequence_Desc *py_sseq_desc, const char **str_items) { PyObject *py_struct_seq; int pos = 0; const char **str_iter; PyStructSequence_Field *desc; /* initialize array */ /* We really populate the contexts' fields here! */ for (str_iter = str_items, desc = py_sseq_desc->fields; *str_iter; str_iter++, desc++) { desc->name = (char *)*str_iter; desc->doc = NULL; } /* end sentinel */ desc->name = desc->doc = NULL; PyStructSequence_InitType(py_type, py_sseq_desc); /* initialize pytype */ py_struct_seq = PyStructSequence_New(py_type); BLI_assert(py_struct_seq != NULL); for (str_iter = str_items; *str_iter; str_iter++) { PyStructSequence_SET_ITEM(py_struct_seq, pos++, PyUnicode_FromString((*str_iter))); } return py_struct_seq; }
static PyObject * tmtotuple(struct tm *p) { PyObject *v = PyStructSequence_New(&StructTimeType); if (v == NULL) return NULL; #define SET(i,val) PyStructSequence_SET_ITEM(v, i, PyLong_FromLong((long) val)) SET(0, p->tm_year + 1900); SET(1, p->tm_mon + 1); /* Want January == 1 */ SET(2, p->tm_mday); SET(3, p->tm_hour); SET(4, p->tm_min); SET(5, p->tm_sec); SET(6, (p->tm_wday + 6) % 7); /* Want Monday == 0 */ SET(7, p->tm_yday + 1); /* Want January, 1 == 1 */ SET(8, p->tm_isdst); #ifdef HAVE_STRUCT_TM_TM_ZONE PyStructSequence_SET_ITEM(v, 9, PyUnicode_DecodeLocale(p->tm_zone, "surrogateescape")); SET(10, p->tm_gmtoff); #endif /* HAVE_STRUCT_TM_TM_ZONE */ #undef SET if (PyErr_Occurred()) { Py_XDECREF(v); return NULL; } return v; }
static PyObject * Util_func_interface_addresses(PyObject *obj) { int i, count; char ip[INET6_ADDRSTRLEN]; uv_interface_address_t* interfaces; uv_err_t err; PyObject *result, *item, *exc_data; UNUSED_ARG(obj); err = uv_interface_addresses(&interfaces, &count); if (err.code == UV_OK) { result = PyList_New(count); if (!result) { uv_free_interface_addresses(interfaces, count); return NULL; } for (i = 0; i < count; i++) { item = PyStructSequence_New(&InterfaceAddressesResultType); if (!item) { Py_DECREF(result); uv_free_interface_addresses(interfaces, count); return NULL; } PyStructSequence_SET_ITEM(item, 0, Py_BuildValue("s", interfaces[i].name)); PyStructSequence_SET_ITEM(item, 1, PyBool_FromLong((long)interfaces[i].is_internal)); if (interfaces[i].address.address4.sin_family == AF_INET) { uv_ip4_name(&interfaces[i].address.address4, ip, INET_ADDRSTRLEN); } else if (interfaces[i].address.address4.sin_family == AF_INET6) { uv_ip6_name(&interfaces[i].address.address6, ip, INET6_ADDRSTRLEN); } PyStructSequence_SET_ITEM(item, 2, Py_BuildValue("s", ip)); PyList_SET_ITEM(result, i, item); } uv_free_interface_addresses(interfaces, count); return result; } else { exc_data = Py_BuildValue("(is)", err.code, uv_strerror(err)); if (exc_data != NULL) { PyErr_SetObject(PyExc_UVError, exc_data); Py_DECREF(exc_data); } return NULL; } }
static void fill_time(PyObject *v, int index, time_t sec, unsigned long nsec) { PyObject *fval,*ival; #if SIZEOF_TIME_T > SIZEOF_LONG ival = PyLong_FromLongLong((PY_LONG_LONG)sec); #else ival = PyInt_FromLong((long)sec); #endif if (!ival) return; if (_stat_float_times) { fval = PyFloat_FromDouble(sec + 1e-9*nsec); } else { fval = ival; Py_INCREF(fval); } PyStructSequence_SET_ITEM(v, index, ival); PyStructSequence_SET_ITEM(v, index+3, fval); }
PyObject * test(PyObject *self, PyObject *args) { /* FWIW, this assumes that we called: PyStructSequence_InitType(&CoordType, &coord_desc); when initializing the module: */ PyObject *obj = PyStructSequence_New(&CoordType); if (!obj) { return NULL; } /* These PyInt_ calls can't fail; the SET_ITEM macros steal the new ref they give us, so this is correct: */ PyStructSequence_SET_ITEM(obj, 0, PyInt_FromLong(0)); PyStructSequence_SET_ITEM(obj, 1, PyInt_FromLong(0)); return obj; }
PyObject *term_to_nametuple(const char *s, int arity, term_t t) { PyObject *o; #if PY_MAJOR_VERSION >= 3 PyTypeObject *typp; PyObject *key = PyUnicode_FromString(s); if (py_F2P && PyDict_Contains(py_F2P, key)) { typp = (PyTypeObject *)PyDict_GetItem(py_F2P, key); } else { typp = PyMem_Malloc(sizeof(PyTypeObject)); PyStructSequence_Desc *desc = PyMem_Malloc(sizeof(PyStructSequence_Desc)); desc->name = PyUnicode_AsUTF8(key); desc->doc = "YAPTerm"; desc->fields = pnull; desc->n_in_sequence = 32; if (PyStructSequence_InitType2(typp, desc) < 0) return NULL; typp->tp_str = structseq_str; typp->tp_repr = structseq_repr; // typp = PyStructSequence_NewType(desc); Py_INCREF(typp); // typp->tp_flags |= Py_TPFLAGS_HEAPTYPE; PyModule_AddObject(py_Yapex, s, (PyObject *)typp); if (py_F2P) PyDict_SetItem(py_F2P, key, (PyObject *)typp); } o = PyTuple_New(typp); #else o = PyTuple_New(arity); #endif term_t tleft = PL_new_term_ref(); int i; for (i = 0; i < arity; i++) { PyObject *pArg; if (!PL_get_arg(i + 1, t, tleft)) return NULL; pArg = term_to_python(tleft, false); if (pArg == NULL) return NULL; #if PY_MAJOR_VERSION >= 3 /* pArg reference stolen here: */ PyStructSequence_SET_ITEM(o, i, pArg); } ((PyStructSequence *)o)->ob_base.ob_size = arity; return o; #else /* pArg reference stolen here: */ PyTuple_SET_ITEM(o, i, pArg); }
static PyObject * Util_func_cpu_info(PyObject *obj) { int i, count; uv_cpu_info_t* cpus; int err; PyObject *result, *item, *times, *exc_data; UNUSED_ARG(obj); err = uv_cpu_info(&cpus, &count); if (err == 0) { result = PyList_New(count); if (!result) { uv_free_cpu_info(cpus, count); return NULL; } for (i = 0; i < count; i++) { item = PyStructSequence_New(&CPUInfoResultType); times = PyStructSequence_New(&CPUInfoTimesResultType); if (!item || !times) { Py_XDECREF(item); Py_XDECREF(times); Py_DECREF(result); uv_free_cpu_info(cpus, count); return NULL; } PyStructSequence_SET_ITEM(item, 0, Py_BuildValue("s", cpus[i].model)); PyStructSequence_SET_ITEM(item, 1, PyInt_FromLong((long)cpus[i].speed)); PyStructSequence_SET_ITEM(item, 2, times); PyList_SET_ITEM(result, i, item); PyStructSequence_SET_ITEM(times, 0, PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)cpus[i].cpu_times.sys)); PyStructSequence_SET_ITEM(times, 1, PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)cpus[i].cpu_times.user)); PyStructSequence_SET_ITEM(times, 2, PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)cpus[i].cpu_times.idle)); PyStructSequence_SET_ITEM(times, 3, PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)cpus[i].cpu_times.irq)); PyStructSequence_SET_ITEM(times, 4, PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)cpus[i].cpu_times.nice)); } uv_free_cpu_info(cpus, count); return result; } else { exc_data = Py_BuildValue("(is)", err, uv_strerror(err)); if (exc_data != NULL) { PyErr_SetObject(PyExc_UVError, exc_data); Py_DECREF(exc_data); } return NULL; } }
static PyObject * mkpwent(struct passwd *p) { int setIndex = 0; PyObject *v = PyStructSequence_New(&StructPwdType); if (v == NULL) return NULL; #define SETI(i,val) PyStructSequence_SET_ITEM(v, i, PyLong_FromLong((long) val)) #define SETS(i,val) sets(v, i, val) SETS(setIndex++, p->pw_name); #if defined(HAVE_STRUCT_PASSWD_PW_PASSWD) && !defined(__ANDROID__) SETS(setIndex++, p->pw_passwd); #else SETS(setIndex++, ""); #endif PyStructSequence_SET_ITEM(v, setIndex++, _PyLong_FromUid(p->pw_uid)); PyStructSequence_SET_ITEM(v, setIndex++, _PyLong_FromGid(p->pw_gid)); #if defined(HAVE_STRUCT_PASSWD_PW_GECOS) SETS(setIndex++, p->pw_gecos); #else SETS(setIndex++, ""); #endif SETS(setIndex++, p->pw_dir); SETS(setIndex++, p->pw_shell); #undef SETS #undef SETI if (PyErr_Occurred()) { Py_XDECREF(v); return NULL; } return v; }
static void _seq_set_string(PyObject* seq, locale_t loc, ssize_t index, const char* data) { if (!data) return; size_t needed = mbstowcs_l(NULL, data, 0, loc); wchar_t space[30]; wchar_t *buf; if (needed==(size_t)-1) // Should we log an error here? return; if (needed<sizeof(space)) buf=space; else if ((buf=PyMem_Malloc(needed+1))==NULL) return; size_t length = mbstowcs_l(buf, data, needed+1, loc); PyStructSequence_SET_ITEM(seq, index, PyUnicode_FromWideChar(buf, length)); if (buf!=space) PyMem_Free(buf); }
static void _seq_set_grouping(PyObject* seq, locale_t loc, ssize_t index, const char* data) { PyObject* groups = PyList_New(0);; if (groups==NULL) return; if (*data) { int i = -1; do { i++; PyObject* item = PyInt_FromLong(data[i]); if (item==NULL) break; if (PyList_Append(groups, item)==-1) { Py_DECREF(item); Py_DECREF(groups); return; } } while (data[i] && data[i]!=CHAR_MAX); } PyStructSequence_SET_ITEM(seq, index, groups); }
static PyObject *make_app_cb_info(void) { PyObject *app_cb_info; int pos= 0; app_cb_info= PyStructSequence_New(&BlenderAppCbType); if (app_cb_info == NULL) { return NULL; } for(pos= 0; pos < BLI_CB_EVT_TOT; pos++) { if(app_cb_info_fields[pos].name == NULL) { Py_FatalError("invalid callback slots 1"); } PyStructSequence_SET_ITEM(app_cb_info, pos, (py_cb_array[pos]= PyList_New(0))); } if(app_cb_info_fields[pos].name != NULL) { Py_FatalError("invalid callback slots 2"); } return app_cb_info; }
void PyStructSequence_SetItem(PyObject* op, Py_ssize_t i, PyObject* v) { PyStructSequence_SET_ITEM(op, i, v); }
static void host_cb(void *arg, int status, int timeouts, struct hostent *hostent) { PyGILState_STATE gstate = PyGILState_Ensure(); char ip[INET6_ADDRSTRLEN]; char **ptr; PyObject *callback, *dns_name, *errorno, *dns_aliases, *dns_addrlist, *dns_result, *tmp, *result; callback = (PyObject *)arg; ASSERT(callback); 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 = PyStructSequence_New(&AresHostResultType); 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 = Py_BuildValue("s", *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) { ares_inet_ntop(AF_INET, *ptr, ip, INET_ADDRSTRLEN); tmp = Py_BuildValue("s", ip); } else if (hostent->h_addrtype == AF_INET6) { ares_inet_ntop(AF_INET6, *ptr, ip, INET6_ADDRSTRLEN); tmp = Py_BuildValue("s", ip); } else { continue; } if (tmp == NULL) { break; } PyList_Append(dns_addrlist, tmp); Py_DECREF(tmp); } dns_name = Py_BuildValue("s", hostent->h_name); PyStructSequence_SET_ITEM(dns_result, 0, dns_name); PyStructSequence_SET_ITEM(dns_result, 1, dns_aliases); PyStructSequence_SET_ITEM(dns_result, 2, dns_addrlist); errorno = Py_None; Py_INCREF(Py_None); callback: result = PyObject_CallFunctionObjArgs(callback, dns_result, errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(callback); } Py_XDECREF(result); Py_DECREF(dns_result); Py_DECREF(errorno); Py_DECREF(callback); PyGILState_Release(gstate); }
static void query_naptr_cb(void *arg, int status,int timeouts, unsigned char *answer_buf, int answer_len) { PyGILState_STATE gstate = PyGILState_Ensure(); int parse_status; struct ares_naptr_reply *naptr_reply, *naptr_ptr; PyObject *dns_result, *errorno, *tmp, *result, *callback; naptr_reply = NULL; callback = (PyObject *)arg; ASSERT(callback); if (status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } parse_status = ares_parse_naptr_reply(answer_buf, answer_len, &naptr_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 (naptr_ptr = naptr_reply; naptr_ptr != NULL; naptr_ptr = naptr_ptr->next) { tmp = PyStructSequence_New(&AresQueryNAPTRResultType); if (tmp == NULL) { break; } PyStructSequence_SET_ITEM(tmp, 0, PyInt_FromLong((long)naptr_ptr->order)); PyStructSequence_SET_ITEM(tmp, 1, PyInt_FromLong((long)naptr_ptr->preference)); PyStructSequence_SET_ITEM(tmp, 2, Py_BuildValue("s", (char *)naptr_ptr->flags)); PyStructSequence_SET_ITEM(tmp, 3, Py_BuildValue("s", (char *)naptr_ptr->service)); PyStructSequence_SET_ITEM(tmp, 4, Py_BuildValue("s", (char *)naptr_ptr->regexp)); PyStructSequence_SET_ITEM(tmp, 5, Py_BuildValue("s", naptr_ptr->replacement)); PyList_Append(dns_result, tmp); Py_DECREF(tmp); } errorno = Py_None; Py_INCREF(Py_None); callback: result = PyObject_CallFunctionObjArgs(callback, dns_result, errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(callback); } Py_XDECREF(result); Py_DECREF(dns_result); Py_DECREF(errorno); if (naptr_reply) { ares_free_data(naptr_reply); } Py_DECREF(callback); PyGILState_Release(gstate); }
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; PyObject *dns_result, *errorno, *tmp, *result, *callback; srv_reply = NULL; callback = (PyObject *)arg; ASSERT(callback); 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 = PyStructSequence_New(&AresQuerySRVResultType); if (tmp == NULL) { break; } PyStructSequence_SET_ITEM(tmp, 0, Py_BuildValue("s", srv_ptr->host)); PyStructSequence_SET_ITEM(tmp, 1, PyInt_FromLong((long)srv_ptr->port)); PyStructSequence_SET_ITEM(tmp, 2, PyInt_FromLong((long)srv_ptr->priority)); PyStructSequence_SET_ITEM(tmp, 3, PyInt_FromLong((long)srv_ptr->weight)); PyList_Append(dns_result, tmp); Py_DECREF(tmp); } errorno = Py_None; Py_INCREF(Py_None); callback: result = PyObject_CallFunctionObjArgs(callback, dns_result, errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(callback); } Py_XDECREF(result); Py_DECREF(dns_result); Py_DECREF(errorno); if (srv_reply) { ares_free_data(srv_reply); } Py_DECREF(callback); PyGILState_Release(gstate); }
/* pack a system stat C structure into the Python stat tuple (used by posix_stat() and posix_fstat()) */ PyObject * pystat_fromstructstat(struct statstb const * st) { unsigned long ansec, mnsec, cnsec; PyObject *v = PyStructSequence_New(&StatResultType); if (v == NULL) return NULL; PyStructSequence_SET_ITEM(v, 0, PyInt_FromLong((long)st->st_mode)); #ifdef HAVE_LARGEFILE_SUPPORT PyStructSequence_SET_ITEM(v, 1, PyLong_FromLongLong((PY_LONG_LONG)st->st_ino)); #else PyStructSequence_SET_ITEM(v, 1, PyInt_FromLong((long)st->st_ino)); #endif #if defined(HAVE_LONG_LONG) && !defined(MS_WINDOWS) PyStructSequence_SET_ITEM(v, 2, PyLong_FromLongLong((PY_LONG_LONG)st->st_dev)); #else PyStructSequence_SET_ITEM(v, 2, PyInt_FromLong((long)st->st_dev)); #endif PyStructSequence_SET_ITEM(v, 3, PyInt_FromLong((long)st->st_nlink)); PyStructSequence_SET_ITEM(v, 4, PyInt_FromLong((long)st->st_uid)); PyStructSequence_SET_ITEM(v, 5, PyInt_FromLong((long)st->st_gid)); #ifdef HAVE_LARGEFILE_SUPPORT PyStructSequence_SET_ITEM(v, 6, PyLong_FromLongLong((PY_LONG_LONG)st->st_size)); #else PyStructSequence_SET_ITEM(v, 6, PyInt_FromLong(st->st_size)); #endif #if defined(HAVE_STAT_TV_NSEC) ansec = st->st_atim.tv_nsec; mnsec = st->st_mtim.tv_nsec; cnsec = st->st_ctim.tv_nsec; #elif defined(HAVE_STAT_TV_NSEC2) ansec = st->st_atimespec.tv_nsec; mnsec = st->st_mtimespec.tv_nsec; cnsec = st->st_ctimespec.tv_nsec; #elif defined(HAVE_STAT_NSEC) ansec = st->st_atime_nsec; mnsec = st->st_mtime_nsec; cnsec = st->st_ctime_nsec; #else ansec = mnsec = cnsec = 0; #endif fill_time(v, 7, st->st_atime, ansec); fill_time(v, 8, st->st_mtime, mnsec); fill_time(v, 9, st->st_ctime, cnsec); #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE PyStructSequence_SET_ITEM(v, ST_BLKSIZE_IDX, PyInt_FromLong((long)st->st_blksize)); #endif #ifdef HAVE_STRUCT_STAT_ST_BLOCKS PyStructSequence_SET_ITEM(v, ST_BLOCKS_IDX, PyInt_FromLong((long)st->st_blocks)); #endif #ifdef HAVE_STRUCT_STAT_ST_RDEV PyStructSequence_SET_ITEM(v, ST_RDEV_IDX, PyInt_FromLong((long)st->st_rdev)); #endif #ifdef HAVE_STRUCT_STAT_ST_GEN PyStructSequence_SET_ITEM(v, ST_GEN_IDX, PyInt_FromLong((long)st->st_gen)); #endif #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME { PyObject *val; unsigned long bsec,bnsec; bsec = (long)st->st_birthtime; #ifdef HAVE_STAT_TV_NSEC2 bnsec = st->st_birthtimespec.tv_nsec; #else bnsec = 0; #endif if (_stat_float_times) { val = PyFloat_FromDouble(bsec + 1e-9*bnsec); } else { val = PyInt_FromLong((long)bsec); } PyStructSequence_SET_ITEM(v, ST_BIRTHTIME_IDX, val); } #endif #ifdef HAVE_STRUCT_STAT_ST_FLAGS PyStructSequence_SET_ITEM(v, ST_FLAGS_IDX, PyInt_FromLong((long)st->st_flags)); #endif if (PyErr_Occurred()) { Py_DECREF(v); return NULL; } return v; }
PyObject* PyThread_GetInfo(void) { PyObject *threadinfo, *value; int pos = 0; #if (defined(_POSIX_THREADS) && defined(HAVE_CONFSTR) \ && defined(_CS_GNU_LIBPTHREAD_VERSION)) char buffer[255]; int len; #endif if (ThreadInfoType.tp_name == 0) { if (PyStructSequence_InitType2(&ThreadInfoType, &threadinfo_desc) < 0) return NULL; } threadinfo = PyStructSequence_New(&ThreadInfoType); if (threadinfo == NULL) return NULL; value = PyUnicode_FromString(PYTHREAD_NAME); if (value == NULL) { Py_DECREF(threadinfo); return NULL; } PyStructSequence_SET_ITEM(threadinfo, pos++, value); #ifdef _POSIX_THREADS #ifdef USE_SEMAPHORES value = PyUnicode_FromString("semaphore"); #else value = PyUnicode_FromString("mutex+cond"); #endif if (value == NULL) { Py_DECREF(threadinfo); return NULL; } #else Py_INCREF(Py_None); value = Py_None; #endif PyStructSequence_SET_ITEM(threadinfo, pos++, value); #if (defined(_POSIX_THREADS) && defined(HAVE_CONFSTR) \ && defined(_CS_GNU_LIBPTHREAD_VERSION)) value = NULL; len = confstr(_CS_GNU_LIBPTHREAD_VERSION, buffer, sizeof(buffer)); if (1 < len && len < sizeof(buffer)) { value = PyUnicode_DecodeFSDefaultAndSize(buffer, len-1); if (value == NULL) PyErr_Clear(); } if (value == NULL) #endif { Py_INCREF(Py_None); value = Py_None; } PyStructSequence_SET_ITEM(threadinfo, pos++, value); return threadinfo; }
static void _seq_set_int(PyObject* seq, locale_t loc, ssize_t index, char data) { PyObject* item = PyInt_FromSize_t(data); if (item!=NULL) PyStructSequence_SET_ITEM(seq, index, item); }
static void getaddrinfo_cb(uv_getaddrinfo_t* req, int status, struct addrinfo* res) { PyGILState_STATE gstate = PyGILState_Ensure(); struct addrinfo *ptr; uv_err_t err; Loop *loop; PyObject *callback, *addr, *item, *errorno, *dns_result, *result; ASSERT(req); callback = (PyObject *)req->data; loop = (Loop *)req->loop->data; if (status != 0) { err = uv_last_error(loop->uv_loop); errorno = PyInt_FromLong((long)err.code); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } dns_result = PyList_New(0); if (!dns_result) { 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_Clear(); break; } item = PyStructSequence_New(&AddrinfoResultType); if (!item) { PyErr_Clear(); break; } PyStructSequence_SET_ITEM(item, 0, PyInt_FromLong((long)ptr->ai_family)); PyStructSequence_SET_ITEM(item, 1, PyInt_FromLong((long)ptr->ai_socktype)); PyStructSequence_SET_ITEM(item, 2, PyInt_FromLong((long)ptr->ai_protocol)); PyStructSequence_SET_ITEM(item, 3, Py_BuildValue("s", ptr->ai_canonname ? ptr->ai_canonname : "")); PyStructSequence_SET_ITEM(item, 4, addr); PyList_Append(dns_result, item); Py_DECREF(item); } errorno = Py_None; Py_INCREF(Py_None); callback: result = PyObject_CallFunctionObjArgs(callback, dns_result, errorno, NULL); if (result == NULL) { handle_uncaught_exception(loop); } Py_XDECREF(result); Py_DECREF(dns_result); Py_DECREF(errorno); Py_DECREF(loop); Py_DECREF(callback); uv_freeaddrinfo(res); PyMem_Free(req); PyGILState_Release(gstate); }
static PyObject * Util_func_getrusage(PyObject *obj) { int err; uv_rusage_t ru; PyObject *result; UNUSED_ARG(obj); err = uv_getrusage(&ru); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_UVError); return NULL; } result = PyStructSequence_New(&RusageResultType); if (!result) return NULL; #define pyuv__doubletime(TV) ((double)(TV).tv_sec + 1e-6*(TV).tv_usec) PyStructSequence_SET_ITEM(result, 0, PyFloat_FromDouble(pyuv__doubletime(ru.ru_utime))); PyStructSequence_SET_ITEM(result, 1, PyFloat_FromDouble(pyuv__doubletime(ru.ru_stime))); PyStructSequence_SET_ITEM(result, 2, PyLong_FromLong(ru.ru_maxrss)); PyStructSequence_SET_ITEM(result, 3, PyLong_FromLong(ru.ru_ixrss)); PyStructSequence_SET_ITEM(result, 4, PyLong_FromLong(ru.ru_idrss)); PyStructSequence_SET_ITEM(result, 5, PyLong_FromLong(ru.ru_isrss)); PyStructSequence_SET_ITEM(result, 6, PyLong_FromLong(ru.ru_minflt)); PyStructSequence_SET_ITEM(result, 7, PyLong_FromLong(ru.ru_majflt)); PyStructSequence_SET_ITEM(result, 8, PyLong_FromLong(ru.ru_nswap)); PyStructSequence_SET_ITEM(result, 9, PyLong_FromLong(ru.ru_inblock)); PyStructSequence_SET_ITEM(result, 10, PyLong_FromLong(ru.ru_oublock)); PyStructSequence_SET_ITEM(result, 11, PyLong_FromLong(ru.ru_msgsnd)); PyStructSequence_SET_ITEM(result, 12, PyLong_FromLong(ru.ru_msgrcv)); PyStructSequence_SET_ITEM(result, 13, PyLong_FromLong(ru.ru_nsignals)); PyStructSequence_SET_ITEM(result, 14, PyLong_FromLong(ru.ru_nvcsw)); PyStructSequence_SET_ITEM(result, 15, PyLong_FromLong(ru.ru_nivcsw)); #undef pyuv__doubletime if (PyErr_Occurred()) { Py_DECREF(result); return NULL; } return result; }
static PyObject * Util_func_interface_addresses(PyObject *obj) { static char buf[INET6_ADDRSTRLEN+1]; int i, count; uv_interface_address_t* interfaces; int err; PyObject *result, *item, *exc_data; UNUSED_ARG(obj); err = uv_interface_addresses(&interfaces, &count); if (err < 0) { exc_data = Py_BuildValue("(is)", err, uv_strerror(err)); if (exc_data != NULL) { PyErr_SetObject(PyExc_UVError, exc_data); Py_DECREF(exc_data); } return NULL; } result = PyList_New(count); if (!result) { uv_free_interface_addresses(interfaces, count); return NULL; } for (i = 0; i < count; i++) { item = PyStructSequence_New(&InterfaceAddressesResultType); if (!item) { Py_DECREF(result); uv_free_interface_addresses(interfaces, count); return NULL; } PyStructSequence_SET_ITEM(item, 0, Py_BuildValue("s", interfaces[i].name)); PyStructSequence_SET_ITEM(item, 1, PyBool_FromLong((long)interfaces[i].is_internal)); if (interfaces[i].address.address4.sin_family == AF_INET) { uv_ip4_name(&interfaces[i].address.address4, buf, sizeof(buf)); } else if (interfaces[i].address.address4.sin_family == AF_INET6) { uv_ip6_name(&interfaces[i].address.address6, buf, sizeof(buf)); } PyStructSequence_SET_ITEM(item, 2, Py_BuildValue("s", buf)); if (interfaces[i].netmask.netmask4.sin_family == AF_INET) { uv_ip4_name(&interfaces[i].netmask.netmask4, buf, sizeof(buf)); } else if (interfaces[i].netmask.netmask4.sin_family == AF_INET6) { uv_ip6_name(&interfaces[i].netmask.netmask6, buf, sizeof(buf)); } PyStructSequence_SET_ITEM(item, 3, Py_BuildValue("s", buf)); PyOS_snprintf(buf, sizeof(buf), "%02x:%02x:%02x:%02x:%02x:%02x", (unsigned char)interfaces[i].phys_addr[0], (unsigned char)interfaces[i].phys_addr[1], (unsigned char)interfaces[i].phys_addr[2], (unsigned char)interfaces[i].phys_addr[3], (unsigned char)interfaces[i].phys_addr[4], (unsigned char)interfaces[i].phys_addr[5]); PyStructSequence_SET_ITEM(item, 4, Py_BuildValue("s", buf)); PyList_SET_ITEM(result, i, item); } uv_free_interface_addresses(interfaces, count); return result; }
static PyObject * resource_getrusage(PyObject *self, PyObject *args) { int who; struct rusage ru; PyObject *result; if (!PyArg_ParseTuple(args, "i:getrusage", &who)) return NULL; if (getrusage(who, &ru) == -1) { if (errno == EINVAL) { PyErr_SetString(PyExc_ValueError, "invalid who parameter"); return NULL; } PyErr_SetFromErrno(ResourceError); return NULL; } result = PyStructSequence_New(&StructRUsageType); if (!result) return NULL; PyStructSequence_SET_ITEM(result, 0, PyFloat_FromDouble(doubletime(ru.ru_utime))); PyStructSequence_SET_ITEM(result, 1, PyFloat_FromDouble(doubletime(ru.ru_stime))); PyStructSequence_SET_ITEM(result, 2, PyLong_FromLong(ru.ru_maxrss)); PyStructSequence_SET_ITEM(result, 3, PyLong_FromLong(ru.ru_ixrss)); PyStructSequence_SET_ITEM(result, 4, PyLong_FromLong(ru.ru_idrss)); PyStructSequence_SET_ITEM(result, 5, PyLong_FromLong(ru.ru_isrss)); PyStructSequence_SET_ITEM(result, 6, PyLong_FromLong(ru.ru_minflt)); PyStructSequence_SET_ITEM(result, 7, PyLong_FromLong(ru.ru_majflt)); PyStructSequence_SET_ITEM(result, 8, PyLong_FromLong(ru.ru_nswap)); PyStructSequence_SET_ITEM(result, 9, PyLong_FromLong(ru.ru_inblock)); PyStructSequence_SET_ITEM(result, 10, PyLong_FromLong(ru.ru_oublock)); PyStructSequence_SET_ITEM(result, 11, PyLong_FromLong(ru.ru_msgsnd)); PyStructSequence_SET_ITEM(result, 12, PyLong_FromLong(ru.ru_msgrcv)); PyStructSequence_SET_ITEM(result, 13, PyLong_FromLong(ru.ru_nsignals)); PyStructSequence_SET_ITEM(result, 14, PyLong_FromLong(ru.ru_nvcsw)); PyStructSequence_SET_ITEM(result, 15, PyLong_FromLong(ru.ru_nivcsw)); if (PyErr_Occurred()) { Py_DECREF(result); return NULL; } return result; }
static void _seq_set_bool(PyObject* seq, locale_t loc, ssize_t index, char data) { PyObject* item = PyBool_FromLong(data); if (item!=NULL) PyStructSequence_SET_ITEM(seq, index, item); }
static void query_soa_cb(void *arg, int status,int timeouts, unsigned char *answer_buf, int answer_len) { PyGILState_STATE gstate = PyGILState_Ensure(); int parse_status; struct ares_soa_reply *soa_reply = NULL; PyObject *dns_result, *errorno, *result, *callback; callback = (PyObject *)arg; ASSERT(callback); if (status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } parse_status = ares_parse_soa_reply(answer_buf, answer_len, &soa_reply); if (parse_status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)parse_status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } dns_result = PyStructSequence_New(&AresQuerySOAResultType); 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; } PyStructSequence_SET_ITEM(dns_result, 0, Py_BuildValue("s", soa_reply->nsname)); PyStructSequence_SET_ITEM(dns_result, 1, Py_BuildValue("s", soa_reply->hostmaster)); PyStructSequence_SET_ITEM(dns_result, 2, PyInt_FromLong((long)soa_reply->serial)); PyStructSequence_SET_ITEM(dns_result, 3, PyInt_FromLong((long)soa_reply->refresh)); PyStructSequence_SET_ITEM(dns_result, 4, PyInt_FromLong((long)soa_reply->retry)); PyStructSequence_SET_ITEM(dns_result, 5, PyInt_FromLong((long)soa_reply->expire)); PyStructSequence_SET_ITEM(dns_result, 6, PyInt_FromLong((long)soa_reply->minttl)); errorno = Py_None; Py_INCREF(Py_None); callback: result = PyObject_CallFunctionObjArgs(callback, dns_result, errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(callback); } Py_XDECREF(result); Py_DECREF(dns_result); Py_DECREF(errorno); if (soa_reply) { ares_free_data(soa_reply); } Py_DECREF(callback); PyGILState_Release(gstate); }