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