static PyObject * Pipe_func_start_read2(Pipe *self, PyObject *args) { int r; PyObject *tmp, *callback; tmp = NULL; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:start_read2", &callback)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } r = uv_read2_start((uv_stream_t *)UV_HANDLE(self), (uv_alloc_cb)on_stream_alloc, (uv_read2_cb)on_pipe_read2); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_PipeError); return NULL; } tmp = ((Stream *)self)->on_read_cb; Py_INCREF(callback); ((Stream *)self)->on_read_cb = callback; Py_XDECREF(tmp); Py_RETURN_NONE; }
static PyObject * Pipe_func_accept(Pipe *self, PyObject *args) { int r; PyObject *client; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:accept", &client)) { return NULL; } if (PyObject_IsSubclass((PyObject *)client->ob_type, (PyObject *)&StreamType)) { if (UV_HANDLE(client)->type != UV_TCP && UV_HANDLE(client)->type != UV_NAMED_PIPE) { PyErr_SetString(PyExc_TypeError, "Only TCP and Pipe objects are supported for accept"); return NULL; } } else if (PyObject_IsSubclass((PyObject *)client->ob_type, (PyObject *)&UDPType)) { /* empty */ } else { PyErr_SetString(PyExc_TypeError, "Only Stream and UDP objects are supported for accept"); return NULL; } r = uv_accept((uv_stream_t *)UV_HANDLE(self), (uv_stream_t *)UV_HANDLE(client)); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_PipeError); return NULL; } Py_RETURN_NONE; }
static PyObject * UDP_func_set_ttl(UDP *self, PyObject *args) { int r, ttl; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "i:set_multicast_ttl", &ttl)) { return NULL; } if (ttl < 0 || ttl > 255) { PyErr_SetString(PyExc_ValueError, "ttl must be between 0 and 255"); return NULL; } r = uv_udp_set_ttl((uv_udp_t *)UV_HANDLE(self), ttl); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_UDPError); return NULL; } Py_RETURN_NONE; }
static PyObject * TCP_func_accept(TCP *self, PyObject *args) { int r; PyObject *client; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:accept", &client)) { return NULL; } if (!PyObject_IsSubclass((PyObject *)client->ob_type, (PyObject *)&StreamType)) { PyErr_SetString(PyExc_TypeError, "Only stream objects are supported for accept"); return NULL; } r = uv_accept((uv_stream_t *)&self->tcp_h, (uv_stream_t *)UV_HANDLE(client)); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError); return NULL; } Py_RETURN_NONE; }
static void on_tcp_connection(uv_stream_t *handle, int status) { PyGILState_STATE gstate = PyGILState_Ensure(); TCP *self; PyObject *result, *py_errorno; ASSERT(handle); self = PYUV_CONTAINER_OF(handle, TCP, tcp_h); /* Object could go out of scope in the callback, increase refcount to avoid it */ Py_INCREF(self); if (status != 0) { uv_err_t err = uv_last_error(UV_HANDLE_LOOP(self)); py_errorno = PyInt_FromLong((long)err.code); } else { py_errorno = Py_None; Py_INCREF(Py_None); } result = PyObject_CallFunctionObjArgs(self->on_new_connection_cb, self, py_errorno, NULL); if (result == NULL) { handle_uncaught_exception(HANDLE(self)->loop); } Py_XDECREF(result); Py_DECREF(py_errorno); Py_DECREF(self); PyGILState_Release(gstate); }
static void on_tcp_client_connection(uv_connect_t *req, int status) { PyGILState_STATE gstate = PyGILState_Ensure(); TCP *self; PyObject *callback, *result, *py_errorno; ASSERT(req); self = PYUV_CONTAINER_OF(req->handle, TCP, tcp_h); callback = (PyObject *)req->data; if (status != 0) { uv_err_t err = uv_last_error(UV_HANDLE_LOOP(self)); py_errorno = PyInt_FromLong(err.code); } else { py_errorno = Py_None; Py_INCREF(Py_None); } result = PyObject_CallFunctionObjArgs(callback, self, py_errorno, NULL); if (result == NULL) { handle_uncaught_exception(HANDLE(self)->loop); } Py_XDECREF(result); Py_DECREF(py_errorno); Py_DECREF(callback); PyMem_Free(req); /* Refcount was increased in the caller function */ Py_DECREF(self); PyGILState_Release(gstate); }
static void on_pipe_connection(uv_stream_t* server, int status) { PyGILState_STATE gstate = PyGILState_Ensure(); Pipe *self; PyObject *result, *py_errorno; ASSERT(server); self = (Pipe *)server->data; ASSERT(self); /* Object could go out of scope in the callback, increase refcount to avoid it */ Py_INCREF(self); if (status != 0) { uv_err_t err = uv_last_error(UV_HANDLE_LOOP(self)); py_errorno = PyInt_FromLong((long)err.code); } else { py_errorno = Py_None; Py_INCREF(Py_None); } result = PyObject_CallFunctionObjArgs(self->on_new_connection_cb, self, py_errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(self->on_new_connection_cb); } Py_XDECREF(result); Py_DECREF(py_errorno); Py_DECREF(self); PyGILState_Release(gstate); }
static PyObject * UDP_func_start_recv(UDP *self, PyObject *args) { int r; PyObject *tmp, *callback; tmp = NULL; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:start_recv", &callback)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } r = uv_udp_recv_start((uv_udp_t *)UV_HANDLE(self), (uv_alloc_cb)on_udp_alloc, (uv_udp_recv_cb)on_udp_read); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_UDPError); return NULL; } tmp = self->on_read_cb; Py_INCREF(callback); self->on_read_cb = callback; Py_XDECREF(tmp); Py_RETURN_NONE; }
static PyObject * TCP_func_bind(TCP *self, PyObject *args) { int r; struct sockaddr sa; PyObject *addr; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:bind", &addr)) { return NULL; } if (pyuv_parse_addr_tuple(addr, &sa) < 0) { /* Error is set by the function itself */ return NULL; } if (sa.sa_family == AF_INET) { r = uv_tcp_bind(&self->tcp_h, *(struct sockaddr_in *)&sa); } else { r = uv_tcp_bind6(&self->tcp_h, *(struct sockaddr_in6 *)&sa); } if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError); return NULL; } Py_RETURN_NONE; }
static void on_udp_read(uv_udp_t* handle, int nread, uv_buf_t buf, struct sockaddr* addr, unsigned flags) { PyGILState_STATE gstate = PyGILState_Ensure(); char ip[INET6_ADDRSTRLEN]; struct sockaddr_in addr4; struct sockaddr_in6 addr6; uv_err_t err; UDP *self; PyObject *result, *address_tuple, *data, *py_errorno; ASSERT(handle); ASSERT(flags == 0); self = (UDP *)handle->data; ASSERT(self); /* Object could go out of scope in the callback, increase refcount to avoid it */ Py_INCREF(self); if (nread == 0) { goto done; } if (nread > 0) { ASSERT(addr); if (addr->sa_family == AF_INET) { addr4 = *(struct sockaddr_in*)addr; uv_ip4_name(&addr4, ip, INET_ADDRSTRLEN); address_tuple = Py_BuildValue("(si)", ip, ntohs(addr4.sin_port)); } else { addr6 = *(struct sockaddr_in6*)addr; uv_ip6_name(&addr6, ip, INET6_ADDRSTRLEN); address_tuple = Py_BuildValue("(si)", ip, ntohs(addr6.sin6_port)); } data = PyBytes_FromStringAndSize(buf.base, nread); py_errorno = Py_None; Py_INCREF(Py_None); } else { address_tuple = Py_None; Py_INCREF(Py_None); data = Py_None; Py_INCREF(Py_None); err = uv_last_error(UV_HANDLE_LOOP(self)); py_errorno = PyInt_FromLong((long)err.code); } result = PyObject_CallFunctionObjArgs(self->on_read_cb, self, address_tuple, PyInt_FromLong((long)flags), data, py_errorno, NULL); if (result == NULL) { handle_uncaught_exception(HANDLE(self)->loop); } Py_XDECREF(result); Py_DECREF(address_tuple); Py_DECREF(data); Py_DECREF(py_errorno); done: Py_DECREF(self); PyGILState_Release(gstate); }
static PyObject * UDP_func_bind(UDP *self, PyObject *args) { int r, bind_port, address_type; char *bind_ip; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "(si):bind", &bind_ip, &bind_port)) { return NULL; } if (bind_port < 0 || bind_port > 65535) { PyErr_SetString(PyExc_ValueError, "port must be between 0 and 65535"); return NULL; } if (pyuv_guess_ip_family(bind_ip, &address_type)) { PyErr_SetString(PyExc_ValueError, "invalid IP address"); return NULL; } if (address_type == AF_INET) { r = uv_udp_bind((uv_udp_t *)UV_HANDLE(self), uv_ip4_addr(bind_ip, bind_port), 0); } else { r = uv_udp_bind6((uv_udp_t *)UV_HANDLE(self), uv_ip6_addr(bind_ip, bind_port), UV_UDP_IPV6ONLY); } if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_UDPError); return NULL; } Py_RETURN_NONE; }
static PyObject * Signal_func_start(Signal *self, PyObject *args) { int r, signum; PyObject *tmp, *callback; tmp = NULL; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "Oi:start", &callback, &signum)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } r = uv_signal_start((uv_signal_t *)UV_HANDLE(self), (uv_signal_cb)on_signal_callback, signum); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_SignalError); return NULL; } tmp = self->callback; Py_INCREF(callback); self->callback = callback; Py_XDECREF(tmp); Py_RETURN_NONE; }
static PyObject * UDP_func_getsockname(UDP *self) { int r, namelen; char ip[INET6_ADDRSTRLEN]; struct sockaddr sockname; struct sockaddr_in *addr4; struct sockaddr_in6 *addr6; namelen = sizeof(sockname); RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); r = uv_udp_getsockname((uv_udp_t *)UV_HANDLE(self), &sockname, &namelen); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_UDPError); return NULL; } if (sockname.sa_family == AF_INET) { addr4 = (struct sockaddr_in*)&sockname; uv_ip4_name(addr4, ip, INET_ADDRSTRLEN); return Py_BuildValue("si", ip, ntohs(addr4->sin_port)); } else if (sockname.sa_family == AF_INET6) { addr6 = (struct sockaddr_in6*)&sockname; uv_ip6_name(addr6, ip, INET6_ADDRSTRLEN); return Py_BuildValue("si", ip, ntohs(addr6->sin6_port)); } else { PyErr_SetString(PyExc_UDPError, "unknown address type detected"); return NULL; } }
static PyObject * Prepare_func_start(Prepare *self, PyObject *args) { int r; PyObject *tmp, *callback; tmp = NULL; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "O:start", &callback)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } r = uv_prepare_start(&self->prepare_h, on_prepare_callback); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_PrepareError); return NULL; } tmp = self->callback; Py_INCREF(callback); self->callback = callback; Py_XDECREF(tmp); Py_RETURN_NONE; }
static int Signal_tp_init(Signal *self, PyObject *args, PyObject *kwargs) { int r; uv_signal_t *uv_signal = NULL; Loop *loop; PyObject *tmp = NULL; UNUSED_ARG(kwargs); if (UV_HANDLE(self)) { PyErr_SetString(PyExc_SignalError, "Object already initialized"); return -1; } if (!PyArg_ParseTuple(args, "O!:__init__", &LoopType, &loop)) { return -1; } if (!loop->is_default) { PyErr_SetString(PyExc_RuntimeError, "Signal handlers are only supported in the default loop for now"); return -1; } tmp = (PyObject *)((Handle *)self)->loop; Py_INCREF(loop); ((Handle *)self)->loop = loop; Py_XDECREF(tmp); uv_signal = PyMem_Malloc(sizeof(uv_signal_t)); if (!uv_signal) { PyErr_NoMemory(); Py_DECREF(loop); return -1; } r = uv_signal_init(UV_HANDLE_LOOP(self), uv_signal); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_SignalError); Py_DECREF(loop); return -1; } uv_signal->data = (void *)self; UV_HANDLE(self) = (uv_handle_t *)uv_signal; return 0; }
static PyObject * TCP_func_connect(TCP *self, PyObject *args) { int r; struct sockaddr sa; uv_connect_t *connect_req = NULL; PyObject *addr, *callback; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "OO:connect", &addr, &callback)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } if (pyuv_parse_addr_tuple(addr, &sa) < 0) { /* Error is set by the function itself */ return NULL; } Py_INCREF(callback); connect_req = PyMem_Malloc(sizeof *connect_req); if (!connect_req) { PyErr_NoMemory(); goto error; } connect_req->data = callback; if (sa.sa_family == AF_INET) { r = uv_tcp_connect(connect_req, &self->tcp_h, *(struct sockaddr_in *)&sa, on_tcp_client_connection); } else { r = uv_tcp_connect6(connect_req, &self->tcp_h, *(struct sockaddr_in6 *)&sa, on_tcp_client_connection); } if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError); goto error; } /* Increase refcount so that object is not removed before the callback is called */ Py_INCREF(self); Py_RETURN_NONE; error: Py_DECREF(callback); PyMem_Free(connect_req); return NULL; }
static int TTY_tp_init(TTY *self, PyObject *args, PyObject *kwargs) { int fd, r; uv_tty_t *uv_tty; Loop *loop; PyObject *readable; PyObject *tmp = NULL; UNUSED_ARG(kwargs); if (UV_HANDLE(self)) { PyErr_SetString(PyExc_StreamError, "Object already initialized"); return -1; } if (!PyArg_ParseTuple(args, "O!iO!:__init__", &LoopType, &loop, &fd, &PyBool_Type, &readable)) { return -1; } tmp = (PyObject *)((Handle *)self)->loop; Py_INCREF(loop); ((Handle *)self)->loop = loop; Py_XDECREF(tmp); uv_tty = PyMem_Malloc(sizeof(uv_tty_t)); if (!uv_tty) { PyErr_NoMemory(); Py_DECREF(loop); return -1; } r = uv_tty_init(UV_HANDLE_LOOP(self), uv_tty, fd, (readable == Py_True) ? 1 : 0); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TTYError); Py_DECREF(loop); return -1; } uv_tty->data = (void *)self; UV_HANDLE(self) = (uv_handle_t *)uv_tty; return 0; }
static int Pipe_tp_init(Pipe *self, PyObject *args, PyObject *kwargs) { int r; uv_pipe_t *uv_pipe; Loop *loop; PyObject *tmp = NULL; PyObject *ipc = Py_False; UNUSED_ARG(kwargs); if (UV_HANDLE(self)) { PyErr_SetString(PyExc_PipeError, "Object already initialized"); return -1; } if (!PyArg_ParseTuple(args, "O!|O!:__init__", &LoopType, &loop, &PyBool_Type, &ipc)) { return -1; } tmp = (PyObject *)((Handle *)self)->loop; Py_INCREF(loop); ((Handle *)self)->loop = loop; Py_XDECREF(tmp); uv_pipe = PyMem_Malloc(sizeof(uv_pipe_t)); if (!uv_pipe) { PyErr_NoMemory(); Py_DECREF(loop); return -1; } r = uv_pipe_init(UV_HANDLE_LOOP(self), uv_pipe, (ipc == Py_True) ? 1 : 0); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_PipeError); Py_DECREF(loop); return -1; } uv_pipe->data = (void *)self; UV_HANDLE(self) = (uv_handle_t *)uv_pipe; return 0; }
static int Timer_tp_init(Timer *self, PyObject *args, PyObject *kwargs) { int r; uv_timer_t *uv_timer = NULL; Loop *loop; PyObject *tmp = NULL; UNUSED_ARG(kwargs); if (UV_HANDLE(self)) { PyErr_SetString(PyExc_TimerError, "Object already initialized"); return -1; } if (!PyArg_ParseTuple(args, "O!:__init__", &LoopType, &loop)) { return -1; } tmp = (PyObject *)((Handle *)self)->loop; Py_INCREF(loop); ((Handle *)self)->loop = loop; Py_XDECREF(tmp); uv_timer = PyMem_Malloc(sizeof(uv_timer_t)); if (!uv_timer) { PyErr_NoMemory(); return -1; } r = uv_timer_init(UV_HANDLE_LOOP(self), uv_timer); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TimerError); PyMem_Free(uv_timer); Py_DECREF(loop); return -1; } uv_timer->data = (void *)self; UV_HANDLE(self) = (uv_handle_t *)uv_timer; return 0; }
static void on_udp_send(uv_udp_send_t* req, int status) { PyGILState_STATE gstate = PyGILState_Ensure(); int i; udp_send_data_t* req_data; UDP *self; PyObject *callback, *result, *py_errorno; ASSERT(req); req_data = (udp_send_data_t *)req->data; self = (UDP *)req->handle->data; callback = req_data->callback; ASSERT(self); /* Object could go out of scope in the callback, increase refcount to avoid it */ Py_INCREF(self); if (callback != Py_None) { if (status < 0) { uv_err_t err = uv_last_error(UV_HANDLE_LOOP(self)); py_errorno = PyInt_FromLong((long)err.code); } else { py_errorno = Py_None; Py_INCREF(Py_None); } result = PyObject_CallFunctionObjArgs(callback, self, py_errorno, NULL); if (result == NULL) { handle_uncaught_exception(((Handle *)self)->loop); } Py_XDECREF(result); Py_DECREF(py_errorno); } if (req_data->buf_count == 1) { PyBuffer_Release(&req_data->data.view); } else { for (i = 0; i < req_data->buf_count; i++) { PyMem_Free(req_data->data.bufs[i].base); } PyMem_Free(req_data->data.bufs); } Py_DECREF(callback); PyMem_Free(req_data); PyMem_Free(req); Py_DECREF(self); PyGILState_Release(gstate); }
static PyObject * Signal_func_stop(Signal *self) { int r; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); r = uv_signal_stop((uv_signal_t *)UV_HANDLE(self)); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_SignalError); return NULL; } Py_RETURN_NONE; }
static PyObject * TTY_func_get_winsize(TTY *self) { int r, width, height; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); r = uv_tty_get_winsize((uv_tty_t *)UV_HANDLE(self), &width, &height); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TTYError); return NULL; } return Py_BuildValue("(ii)", width, height); }
static PyObject * Timer_func_again(Timer *self) { int r; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); r = uv_timer_again((uv_timer_t *)UV_HANDLE(self)); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TimerError); return NULL; } Py_RETURN_NONE; }
static PyObject * Async_func_send(Async *self) { int r; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); r = uv_async_send((uv_async_t *)UV_HANDLE(self)); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_AsyncError); return NULL; } Py_RETURN_NONE; }
static PyObject * Timer_func_start(Timer *self, PyObject *args, PyObject *kwargs) { int r; double timeout, repeat; PyObject *tmp, *callback; static char *kwlist[] = {"callback", "timeout", "repeat", NULL}; tmp = NULL; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Odd:__init__", kwlist, &callback, &timeout, &repeat)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } if (timeout < 0.0) { PyErr_SetString(PyExc_ValueError, "a positive value or zero is required"); return NULL; } if (repeat < 0.0) { PyErr_SetString(PyExc_ValueError, "a positive value or zero is required"); return NULL; } r = uv_timer_start((uv_timer_t *)UV_HANDLE(self), on_timer_callback, (int64_t)(timeout * 1000), (int64_t)(repeat * 1000)); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TimerError); return NULL; } tmp = self->callback; Py_INCREF(callback); self->callback = callback; Py_XDECREF(tmp); Py_RETURN_NONE; }
static PyObject * Prepare_func_stop(Prepare *self) { int r; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); r = uv_prepare_stop((uv_prepare_t *)UV_HANDLE(self)); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_PrepareError); return NULL; } Py_XDECREF(self->callback); self->callback = NULL; Py_RETURN_NONE; }
static PyObject * UDP_func_stop_recv(UDP *self) { int r; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); r = uv_udp_recv_stop((uv_udp_t *)UV_HANDLE(self)); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_UDPError); return NULL; } Py_XDECREF(self->on_read_cb); self->on_read_cb = NULL; Py_RETURN_NONE; }
static void on_pipe_read2(uv_pipe_t* handle, int nread, uv_buf_t buf, uv_handle_type pending) { PyGILState_STATE gstate = PyGILState_Ensure(); uv_err_t err; Stream *self; PyObject *result, *data, *py_errorno, *py_pending; ASSERT(handle); self = (Stream *)handle->data; ASSERT(self); /* Object could go out of scope in the callback, increase refcount to avoid it */ Py_INCREF(self); py_pending = PyInt_FromLong((long)pending); if (nread >= 0) { data = PyString_FromStringAndSize(buf.base, nread); py_errorno = Py_None; Py_INCREF(Py_None); } else if (nread < 0) { data = Py_None; Py_INCREF(Py_None); err = uv_last_error(UV_HANDLE_LOOP(self)); py_errorno = PyInt_FromLong((long)err.code); } result = PyObject_CallFunctionObjArgs(self->on_read_cb, self, data, py_pending, py_errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(self->on_read_cb); } Py_XDECREF(result); Py_DECREF(data); Py_DECREF(py_pending); Py_DECREF(py_errorno); /* In case of error libuv may not call alloc_cb */ if (buf.base != NULL) { PyMem_Free(buf.base); } Py_DECREF(self); PyGILState_Release(gstate); }
static PyObject * TTY_func_set_mode(TTY *self, PyObject *args) { int r, mode; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "i:set_mode", &mode)) { return NULL; } r = uv_tty_set_mode((uv_tty_t *)UV_HANDLE(self), mode); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TTYError); return NULL; } Py_RETURN_NONE; }
static PyObject * TCP_func_getpeername(TCP *self) { int r, namelen; struct sockaddr peername; namelen = sizeof(peername); RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); r = uv_tcp_getpeername(&self->tcp_h, &peername, &namelen); if (r != 0) { RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_TCPError); return NULL; } return makesockaddr(&peername, namelen); }