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);
}
