#include "uwsgi_python.h"

extern struct uwsgi_server uwsgi;

extern struct uwsgi_python up;

extern struct uwsgi_plugin python_plugin;

#define py_uwsgi_context_argument_check(request_context) if(request_context!=NULL) {\

if(!PyObject_TypeCheck(request_context, &uwsgi_RequestContextType)) {\

return PyErr_Format(PyExc_TypeError, "Invalid argument!");\

}}

PyTypeObject uwsgi_RequestContextType = {

PyVarObject_HEAD_INIT(NULL, 0)

"uwsgi.RequestContext",

sizeof(uwsgi_RequestContext),

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

0,

Py_TPFLAGS_DEFAULT,

"",

};

struct wsgi_request *py_current_wsgi_req_from_context(PyObject *context) {

uwsgi_RequestContext *ctx = (uwsgi_RequestContext *)context;

if (ctx->wsgi_req == NULL || !(ctx->wsgi_req->fd)) {

return NULL;

}

//verify

if(uwsgi.mywid != ctx->mywid ||

uwsgi.workers[uwsgi.mywid].cores[ctx->wsgi_req->async_id].requests != ctx->requests) {

return NULL;

}

int in_request = uwsgi.workers[uwsgi.mywid].cores[ctx->wsgi_req->async_id].in_request;

if (!in_request) {

return NULL;

}

return ctx->wsgi_req;

}

static PyObject *py_uwsgi_add_var(PyObject * self, PyObject * args) {

char *key = NULL;

Py_ssize_t keylen = 0;

char *val = NULL;

Py_ssize_t vallen = 0;

struct wsgi_request *wsgi_req = py_current_wsgi_req();

if (!PyArg_ParseTuple(args, "s#s#", &key, &keylen, &val, &vallen)) {

return NULL;

}

if (!uwsgi_req_append(wsgi_req, key, keylen, val, vallen)) {

return PyErr_Format(PyExc_ValueError, "unable to add request var, check your buffer size");

}

Py_INCREF(Py_True);

return Py_True;

}

static PyObject *py_uwsgi_micros(PyObject * self, PyObject * args) {

return PyLong_FromUnsignedLongLong(uwsgi_micros());

}

static PyObject *py_uwsgi_signal_wait(PyObject * self, PyObject * args) {

struct wsgi_request *wsgi_req = py_current_wsgi_req();

int wait_for_specific_signal = 0;

uint8_t uwsgi_signal = 0;

int received_signal;

wsgi_req->signal_received = -1;

if (PyTuple_Size(args) > 0) {

if (!PyArg_ParseTuple(args, "|B:", &uwsgi_signal)) {

return NULL;

}

wait_for_specific_signal = 1;

}

UWSGI_RELEASE_GIL;

if (wait_for_specific_signal) {

received_signal = uwsgi_signal_wait(wsgi_req, uwsgi_signal);

}

else {

received_signal = uwsgi_signal_wait(wsgi_req, -1);

}

if (received_signal < 0) {

UWSGI_GET_GIL;

return PyErr_Format(PyExc_SystemError, "error waiting for signal");

}

wsgi_req->signal_received = received_signal;

UWSGI_GET_GIL;

return PyString_FromString("");

}

static PyObject *py_uwsgi_signal_received(PyObject * self, PyObject * args) {

struct wsgi_request *wsgi_req = py_current_wsgi_req();

return PyInt_FromLong(wsgi_req->signal_received);

}

char *uwsgi_encode_pydict(PyObject * pydict, uint16_t * size) {

int i;

PyObject *zero, *key, *val;

uint16_t keysize, valsize;

char *buf, *bufptr;

PyObject *vars = PyDict_Items(pydict);

if (!vars) {

PyErr_Print();

return NULL;

}

*size = 0;

// calc the packet size

// try to fallback whenever possible

for (i = 0; i < PyList_Size(vars); i++) {

zero = PyList_GetItem(vars, i);

if (!zero) {

PyErr_Print();

continue;

}

if (!PyTuple_Check(zero)) {

uwsgi_log("invalid python dictionary item\n");

continue;

}

if (PyTuple_Size(zero) < 2) {

uwsgi_log("invalid python dictionary item\n");

continue;

}

key = PyTuple_GetItem(zero, 0);

val = PyTuple_GetItem(zero, 1);

if (!PyString_Check(key) || !PyString_Check(val)) {

continue;

}

keysize = PyString_Size(key);

valsize = PyString_Size(val);

*size += (keysize + 2 + valsize + 2);

// do not DECREF here !!!

//Py_DECREF(zero);

}

if (*size <= 4) {

uwsgi_log("empty python dictionary\n");

return NULL;

}

// remember to free this memory !!!

buf = malloc(*size);

if (!buf) {

uwsgi_error("malloc()");

return NULL;

}

bufptr = buf;

for (i = 0; i < PyList_Size(vars); i++) {

zero = PyList_GetItem(vars, i);

if (!zero) {

PyErr_Print();

continue;

}

if (!PyTuple_Check(zero)) {

uwsgi_log("invalid python dictionary item\n");

continue;

}

if (PyTuple_Size(zero) < 2) {

uwsgi_log("invalid python dictionary item\n");

continue;

}

key = PyTuple_GetItem(zero, 0);

val = PyTuple_GetItem(zero, 1);

if (!key || !val) {

PyErr_Print();

continue;

}

if (!PyString_Check(key) || !PyString_Check(val)) {

continue;

}

keysize = PyString_Size(key);

valsize = PyString_Size(val);

if (bufptr + keysize + 2 + valsize + 2 <= buf + *size) {

*bufptr++ = (uint8_t) (keysize & 0xff);

*bufptr++ = (uint8_t) ((keysize >> 8) & 0xff);

memcpy(bufptr, PyString_AsString(key), keysize);

bufptr += keysize;

*bufptr++ = (uint8_t) (valsize & 0xff);

*bufptr++ = (uint8_t) ((valsize >> 8) & 0xff);

memcpy(bufptr, PyString_AsString(val), valsize);

bufptr += valsize;

}

}

return buf;

}

static PyObject *py_uwsgi_listen_queue(PyObject * self, PyObject * args) {

int id = 0;

if (!PyArg_ParseTuple(args, "|i:listen_queue", &id)) {

return NULL;

}

struct uwsgi_socket *uwsgi_sock = uwsgi_get_socket_by_num(id);

if (!uwsgi_sock) {

return PyErr_Format(PyExc_ValueError, "unable to find socket %d", id);

}

return PyInt_FromLong(uwsgi_sock->queue);

}

static PyObject *py_uwsgi_close(PyObject * self, PyObject * args) {

int fd;

if (!PyArg_ParseTuple(args, "i:close", &fd)) {

return NULL;

}

close(fd);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_uwsgi_add_cron(PyObject * self, PyObject * args) {

uint8_t uwsgi_signal;

int minute, hour, day, month, week;

if (!PyArg_ParseTuple(args, "Biiiii:add_cron", &uwsgi_signal, &minute, &hour, &day, &month, &week)) {

return NULL;

}

if (uwsgi_signal_add_cron(uwsgi_signal, minute, hour, day, month, week)) {

return PyErr_Format(PyExc_ValueError, "unable to add cron");

}

Py_INCREF(Py_True);

return Py_True;

}

static PyObject *py_uwsgi_add_timer(PyObject * self, PyObject * args) {

uint8_t uwsgi_signal;

int secs;

if (!PyArg_ParseTuple(args, "Bi:add_timer", &uwsgi_signal, &secs)) {

return NULL;

}

if (uwsgi_add_timer(uwsgi_signal, secs))

return PyErr_Format(PyExc_ValueError, "unable to add timer");

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *py_uwsgi_add_ms_timer(PyObject * self, PyObject * args) {

uint8_t uwsgi_signal;

long msecs;

int secs;

if (!PyArg_ParseTuple(args, "Bl:add_ms_timer", &uwsgi_signal, &msecs)) {

return NULL;

}

secs = msecs / 1000;

msecs = msecs - secs * 1000;

if (uwsgi_add_timer_hr(uwsgi_signal, secs, msecs * 1000000))

return PyErr_Format(PyExc_ValueError, "unable to add timer");

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_add_rb_timer(PyObject * self, PyObject * args) {

uint8_t uwsgi_signal;

int secs;

int iterations = 0;

if (!PyArg_ParseTuple(args, "Bi|i:add_rb_timer", &uwsgi_signal, &secs, &iterations)) {

return NULL;

}

if (uwsgi_signal_add_rb_timer(uwsgi_signal, secs, iterations))

return PyErr_Format(PyExc_ValueError, "unable to add rb_timer");

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_add_file_monitor(PyObject * self, PyObject * args) {

uint8_t uwsgi_signal;

char *filename;

if (!PyArg_ParseTuple(args, "Bs:add_file_monitor", &uwsgi_signal, &filename)) {

return NULL;

}

if (uwsgi_add_file_monitor(uwsgi_signal, filename))

return PyErr_Format(PyExc_ValueError, "unable to add file monitor");

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_call(PyObject * self, PyObject * args) {

char *func;

uint64_t size = 0;

PyObject *py_func;

int argc = PyTuple_Size(args);

int i;

char *argv[256];

uint16_t argvs[256];

// TODO better error reporting

if (argc < 1)

goto clear;

py_func = PyTuple_GetItem(args, 0);

if (!PyString_Check(py_func))

goto clear;

func = PyString_AsString(py_func);

for (i = 0; i < (argc - 1); i++) {

PyObject *py_str = PyTuple_GetItem(args, i + 1);

if (!PyString_Check(py_str)) {

goto clear;

}

argv[i] = PyString_AsString(py_str);

argvs[i] = PyString_Size(py_str);

}

UWSGI_RELEASE_GIL;

// response must always be freed

char *response = uwsgi_do_rpc(NULL, func, argc - 1, argv, argvs, &size);

UWSGI_GET_GIL;

if (response) {

PyObject *ret = PyString_FromStringAndSize(response, size);

free(response);

return ret;

}

Py_INCREF(Py_None);

return Py_None;

clear:

return PyErr_Format(PyExc_ValueError, "unable to call rpc function");

}

PyObject *py_uwsgi_rpc_list(PyObject * self, PyObject * args) {

uint64_t i;

PyObject *rpc_list = PyTuple_New(uwsgi.shared->rpc_count[uwsgi.mywid]);

int pos = (uwsgi.mywid * uwsgi.rpc_max);

for (i = 0; i < uwsgi.shared->rpc_count[uwsgi.mywid]; i++) {

if (uwsgi.rpc_table[pos + i].name[0] != 0) {

PyTuple_SetItem(rpc_list, i, PyString_FromString(uwsgi.rpc_table[pos + i].name));

}

}

return rpc_list;

}

PyObject *py_uwsgi_rpc(PyObject * self, PyObject * args) {

char *node = NULL, *func;

uint64_t size = 0;

PyObject *py_node, *py_func;

int argc = PyTuple_Size(args);

char *argv[256];

uint16_t argvs[256];

int i;

// TODO better error reporting

if (argc < 2)

goto clear;

py_node = PyTuple_GetItem(args, 0);

if (PyString_Check(py_node)) {

node = PyString_AsString(py_node);

}

#ifdef PYTHREE

else if (PyUnicode_Check(py_node)) {

node = PyBytes_AsString(PyUnicode_AsLatin1String(py_node));

}

py_func = PyTuple_GetItem(args, 1);

if (!PyString_Check(py_func))

goto clear;

func = PyString_AsString(py_func);

for (i = 0; i < (argc - 2); i++) {

PyObject *py_str = PyTuple_GetItem(args, i + 2);

if (!PyString_Check(py_str))

goto clear;

argv[i] = PyString_AsString(py_str);

argvs[i] = PyString_Size(py_str);

}

UWSGI_RELEASE_GIL;

char *response = uwsgi_do_rpc(node, func, argc - 2, argv, argvs, &size);

UWSGI_GET_GIL;

if (response) {

PyObject *ret = PyString_FromStringAndSize(response, size);

free(response);

return ret;

}

Py_INCREF(Py_None);

return Py_None;

clear:

return PyErr_Format(PyExc_ValueError, "unable to call rpc function");

}

PyObject *py_uwsgi_register_rpc(PyObject * self, PyObject * args) {

uint8_t argc = 0;

char *name;

PyObject *func;

if (!PyArg_ParseTuple(args, "sO|B:register_rpc", &name, &func, &argc)) {

return NULL;

}

Py_INCREF(func);

if (uwsgi_register_rpc(name, &python_plugin, argc, func)) {

return PyErr_Format(PyExc_ValueError, "unable to register rpc function");

}

Py_INCREF(Py_True);

return Py_True;

}

PyObject *py_uwsgi_signal_registered(PyObject * self, PyObject * args) {

uint8_t uwsgi_signal;

if (!PyArg_ParseTuple(args, "B:signal_registered", &uwsgi_signal)) {

return NULL;

}

if (uwsgi_signal_registered(uwsgi_signal)) {

Py_INCREF(Py_True);

return Py_True;

}

Py_INCREF(Py_None);

return Py_None;

}

#ifdef UWSGI_SSL

PyObject *py_uwsgi_i_am_the_lord(PyObject * self, PyObject * args) {

char *legion_name = NULL;

if (!PyArg_ParseTuple(args, "s:i_am_the_lord", &legion_name)) {

return NULL;

}

if (uwsgi_legion_i_am_the_lord(legion_name)) {

Py_INCREF(Py_True);

return Py_True;

}

Py_INCREF(Py_False);

return Py_False;

}

PyObject *py_uwsgi_lord_scroll(PyObject * self, PyObject * args) {

char *legion_name = NULL;

if (!PyArg_ParseTuple(args, "s:lord_scroll", &legion_name)) {

return NULL;

}

uint16_t rlen = 0;

char *buf = uwsgi_legion_lord_scroll(legion_name, &rlen);

if (!buf) {

Py_INCREF(Py_None);

return Py_None;

}

PyObject *ret = PyString_FromStringAndSize(buf, rlen);

free(buf);

return ret;

}

static void scrolls_items(uint16_t pos, char *key, uint16_t keylen, void *data) {

PyObject *list = (PyObject *) data;

PyObject *zero = PyString_FromStringAndSize(key, keylen);

PyList_Append(list, zero);

Py_DECREF(zero);

}

PyObject *py_uwsgi_scrolls(PyObject * self, PyObject * args) {

char *legion_name = NULL;

if (!PyArg_ParseTuple(args, "s:scrolls", &legion_name)) {

return NULL;

}

uint64_t rlen = 0;

char *buf = uwsgi_legion_scrolls(legion_name, &rlen);

if (!buf) goto end;

PyObject *list = PyList_New(0);

if (uwsgi_hooked_parse_array(buf, rlen, scrolls_items, list)) {

goto error;

}

free(buf);

return list;

error:

free(buf);

end:

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_register_signal(PyObject * self, PyObject * args) {

uint8_t uwsgi_signal;

char *signal_kind;

PyObject *handler;

if (!PyArg_ParseTuple(args, "BsO:register_signal", &uwsgi_signal, &signal_kind, &handler)) {

return NULL;

}

Py_INCREF(handler);

if (uwsgi_register_signal(uwsgi_signal, signal_kind, handler, 0)) {

return PyErr_Format(PyExc_ValueError, "unable to register signal");

}

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_signal(PyObject * self, PyObject * args) {

uint8_t uwsgi_signal;

char *remote = NULL;

if (!PyArg_ParseTuple(args, "B|s:signal", &uwsgi_signal, &remote)) {

return NULL;

}

if (remote) {

#ifdef UWSGI_DEBUG

uwsgi_log("sending signal %d to node %s\n", uwsgi_signal, remote);

int ret = uwsgi_remote_signal_send(remote, uwsgi_signal);

if (ret == 1) goto clear;

if (ret == -1)

return PyErr_Format(PyExc_IOError, "unable to deliver signal %d to node %s", uwsgi_signal, remote);

if (ret == 0)

return PyErr_Format(PyExc_ValueError, "node %s rejected signal %d", remote, uwsgi_signal);

}

else {

#ifdef UWSGI_DEBUG

uwsgi_log("sending signal %d to master\n", uwsgi_signal);

uwsgi_signal_send(uwsgi.signal_socket, uwsgi_signal);

}

clear:

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_log_this(PyObject * self, PyObject * args) {

struct wsgi_request *wsgi_req = py_current_wsgi_req();

wsgi_req->log_this = 1;

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_alarm(PyObject * self, PyObject * args) {

char *alarm = NULL;

char *msg = NULL;

Py_ssize_t msg_len = 0;

if (!PyArg_ParseTuple(args, "ss#:alarm", &alarm, &msg, &msg_len)) {

return NULL;

}

uwsgi_alarm_trigger(alarm, msg, msg_len);

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_get_logvar(PyObject * self, PyObject * args) {

char *key = NULL;

Py_ssize_t keylen = 0;

struct wsgi_request *wsgi_req = py_current_wsgi_req();

if (!PyArg_ParseTuple(args, "s#:get_logvar", &key, &keylen)) {

return NULL;

}

struct uwsgi_logvar *lv = uwsgi_logvar_get(wsgi_req, key, keylen);

if (lv) {

return PyString_FromStringAndSize(lv->val, lv->vallen);

}

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_set_logvar(PyObject * self, PyObject * args) {

char *key = NULL;

Py_ssize_t keylen = 0;

char *val = NULL;

Py_ssize_t vallen = 0;

struct wsgi_request *wsgi_req = py_current_wsgi_req();

if (!PyArg_ParseTuple(args, "s#s#:set_logvar", &key, &keylen, &val, &vallen)) {

return NULL;

}

uwsgi_logvar_add(wsgi_req, key, keylen, val, vallen);

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_recv(PyObject * self, PyObject * args) {

int fd, max_size = 4096;

char buf[4096];

ssize_t rlen;

if (!PyArg_ParseTuple(args, "i|i:recv", &fd, &max_size)) {

return NULL;

}

UWSGI_RELEASE_GIL

// security check

if (max_size > 4096)

max_size = 4096;

rlen = read(fd, buf, max_size);

UWSGI_GET_GIL if (rlen > 0) {

return PyString_FromStringAndSize(buf, rlen);

}

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_is_connected(PyObject * self, PyObject * args) {

int fd = -1;

if (!PyArg_ParseTuple(args, "i:is_connected", &fd)) {

return NULL;

}

if (uwsgi_is_connected(fd)) {

Py_INCREF(Py_True);

return Py_True;

}

Py_INCREF(Py_False);

return Py_False;

}

PyObject *py_uwsgi_send(PyObject * self, PyObject * args) {

PyObject *data;

PyObject *arg1, *arg2;

struct wsgi_request *wsgi_req = py_current_wsgi_req();

int uwsgi_fd = wsgi_req->fd;

if (!PyArg_ParseTuple(args, "O|O:send", &arg1, &arg2)) {

return NULL;

}

if (PyTuple_Size(args) > 1) {

uwsgi_fd = PyInt_AsLong(arg1);

data = arg2;

}

else {

data = arg1;

}

UWSGI_RELEASE_GIL if (write(uwsgi_fd, PyString_AsString(data), PyString_Size(data)) < 0) {

uwsgi_error("write()");

UWSGI_GET_GIL Py_INCREF(Py_None);

return Py_None;

}

UWSGI_GET_GIL Py_INCREF(Py_True);

return Py_True;

}

#ifdef UWSGI_ROUTING

static PyObject *py_uwsgi_route(PyObject * self, PyObject * args) {

struct wsgi_request *wsgi_req = py_current_wsgi_req();

char *router_name = NULL;

char *router_args = NULL;

if (!PyArg_ParseTuple(args, "ss:route", &router_name, &router_args)) {

return NULL;

}

int ret = uwsgi_route_api_func(wsgi_req, router_name, uwsgi_str(router_args));

return PyInt_FromLong(ret);

}

PyObject *py_uwsgi_offload(PyObject * self, PyObject * args) {

return PyString_FromString("");

}

PyObject *py_uwsgi_advanced_sendfile(PyObject * self, PyObject * args) {

PyObject *what;

char *filename;

size_t chunk = 0;

off_t pos = 0;

size_t filesize = 0;

struct wsgi_request *wsgi_req = py_current_wsgi_req();

int fd = -1;

if (!PyArg_ParseTuple(args, "O|iii:sendfile", &what, &chunk, &pos, &filesize)) {

return NULL;

}

if (PyString_Check(what)) {

filename = PyString_AsString(what);

fd = open(filename, O_RDONLY);

if (fd < 0) {

uwsgi_error_open(filename);

goto clear;

}

}

#ifdef PYTHREE

else if (PyUnicode_Check(what)) {

filename = PyBytes_AsString(PyUnicode_AsLatin1String(what));

fd = open(filename, O_RDONLY);

if (fd < 0) {

uwsgi_error_open(filename);

goto clear;

}

}

else {

fd = PyObject_AsFileDescriptor(what);

if (fd < 0)

goto clear;

// check for mixing file_wrapper and sendfile

if (fd == wsgi_req->sendfile_fd) {

Py_INCREF(what);

}

}

UWSGI_RELEASE_GIL

// fd is closed by the following function

uwsgi_response_sendfile_do(wsgi_req, fd, pos, filesize);

UWSGI_GET_GIL

// revert to old values

uwsgi_py_check_write_errors {

uwsgi_py_write_exception(wsgi_req);

return NULL;

}

Py_INCREF(Py_True);

return Py_True;

clear:

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_async_sleep(PyObject * self, PyObject * args) {

float timeout;

int sec_timeout;

if (!PyArg_ParseTuple(args, "f:async_sleep", &timeout)) {

return NULL;

}

sec_timeout = (int) timeout;

if (sec_timeout > 0) {

async_add_timeout(uwsgi.wsgi_req, sec_timeout);

}

return PyString_FromString("");

}

PyObject *py_uwsgi_warning(PyObject * self, PyObject * args) {

char *message;

int len;

if (!PyArg_ParseTuple(args, "s:set_warning_message", &message)) {

return NULL;

}

len = strlen(message);

if (len > 80) {

uwsgi_log("- warning message must be max 80 chars, it will be truncated -");

memcpy(uwsgi.shared->warning_message, message, 80);

uwsgi.shared->warning_message[80] = 0;

}

else {

memcpy(uwsgi.shared->warning_message, message, len);

uwsgi.shared->warning_message[len] = 0;

}

Py_INCREF(Py_True);

return Py_True;

}

PyObject *py_uwsgi_log(PyObject * self, PyObject * args) {

char *logline;

if (!PyArg_ParseTuple(args, "s:log", &logline)) {

return NULL;

}

uwsgi_log("%s\n", logline);

Py_INCREF(Py_True);

return Py_True;

}

PyObject *py_uwsgi_set_user_harakiri(PyObject * self, PyObject * args) {

struct wsgi_request *wsgi_req = py_current_wsgi_req();

int sec = 0;

if (!PyArg_ParseTuple(args, "i:set_user_harakiri", &sec)) {

return NULL;

}

set_user_harakiri(wsgi_req, sec);

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_i_am_the_spooler(PyObject * self, PyObject * args) {

if (uwsgi.i_am_a_spooler) {

Py_INCREF(Py_True);

return Py_True;

}

Py_INCREF(Py_None);

return Py_None;

}

PyObject *py_uwsgi_is_locked(PyObject * self, PyObject * args) {

int lock_num = 0;

// the spooler cannot lock resources

if (uwsgi.i_am_a_spooler) {

return PyErr_Format(PyExc_ValueError, "The spooler cannot lock/unlock resources");

}

if (!PyArg_ParseTuple(args, "|i:is_locked", &lock_num)) {

return NULL;

}

if (lock_num < 0 || lock_num > uwsgi.locks) {

return PyErr_Format(PyExc_ValueError, "Invalid lock number");

}

UWSGI_RELEASE_GIL