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_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 *
Stream_func_start_read(Stream *self, PyObject *args)
{
int err;
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_read", &callback)) {
return NULL;
}
if (!PyCallable_Check(callback)) {
PyErr_SetString(PyExc_TypeError, "a callable is required");
return NULL;
}
err = uv_read_start((uv_stream_t *)UV_HANDLE(self), (uv_alloc_cb)pyuv__alloc_cb, (uv_read_cb)pyuv__stream_read_cb);
if (err < 0) {
RAISE_STREAM_EXCEPTION(err, UV_HANDLE(self));
return NULL;
}
tmp = self->on_read_cb;
Py_INCREF(callback);
self->on_read_cb = callback;
Py_XDECREF(tmp);
PYUV_HANDLE_INCREF(self);
Py_RETURN_NONE;
}
static PyObject *
Stream_func_try_write(Stream *self, PyObject *args)
{
int err;
uv_buf_t buf;
Py_buffer view;
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
if (!PyArg_ParseTuple(args, PYUV_BYTES"*:try_write", &view)) {
return NULL;
}
buf = uv_buf_init(view.buf, view.len);
err = uv_try_write((uv_stream_t *)UV_HANDLE(self), &buf, 1);
if (err < 0) {
RAISE_STREAM_EXCEPTION(err, UV_HANDLE(self));
PyBuffer_Release(&view);
return NULL;
}
PyBuffer_Release(&view);
return PyInt_FromLong((long)err);
}
static PyObject *
Pipe_func_accept(Pipe *self, PyObject *args)
{
int r;
PyObject *client;
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 *)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 *
Pipe_func_write2(Pipe *self, PyObject *args)
{
uv_buf_t buf;
stream_write_ctx *ctx;
Py_buffer *view;
PyObject *callback, *send_handle;
callback = Py_None;
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
ctx = PyMem_Malloc(sizeof *ctx);
if (!ctx) {
PyErr_NoMemory();
return NULL;
}
view = &ctx->view[0];
if (!PyArg_ParseTuple(args, PYUV_BYTES"*O|O:write", view, &send_handle, &callback)) {
PyMem_Free(ctx);
return NULL;
}
if (PyObject_IsSubclass((PyObject *)send_handle->ob_type, (PyObject *)&StreamType)) {
if (UV_HANDLE(send_handle)->type != UV_TCP && UV_HANDLE(send_handle)->type != UV_NAMED_PIPE) {
PyErr_SetString(PyExc_TypeError, "Only TCP and Pipe objects are supported for write2");
goto error;
}
} else if (PyObject_IsSubclass((PyObject *)send_handle->ob_type, (PyObject *)&UDPType)) {
/* empty */
} else {
PyErr_SetString(PyExc_TypeError, "Only Stream and UDP objects are supported");
goto error;
}
if (callback != Py_None && !PyCallable_Check(callback)) {
PyErr_SetString(PyExc_TypeError, "a callable or None is required");
goto error;
}
buf = uv_buf_init(view->buf, view->len);
return pyuv_stream_write((Stream *)self, ctx, view, &buf, 1, callback, send_handle);
error:
PyBuffer_Release(view);
PyMem_Free(ctx);
return NULL;
}
static PyObject *
pyuv__stream_write_bytes(Stream *self, PyObject *data, PyObject *callback, PyObject *send_handle)
{
int err;
uv_buf_t buf;
stream_write_ctx *ctx;
Py_buffer *view;
ctx = PyMem_Malloc(sizeof *ctx);
if (!ctx) {
PyErr_NoMemory();
return NULL;
}
ctx->views = ctx->viewsml;
view = &ctx->views[0];
if (PyObject_GetBuffer(data, view, PyBUF_SIMPLE) != 0) {
PyMem_Free(ctx);
return NULL;
}
ctx->view_count = 1;
ctx->obj = self;
ctx->callback = callback;
ctx->send_handle = send_handle;
Py_INCREF(callback);
Py_XINCREF(send_handle);
buf = uv_buf_init(view->buf, view->len);
if (send_handle != NULL) {
ASSERT(UV_HANDLE(self)->type == UV_NAMED_PIPE);
err = uv_write2(&ctx->req, (uv_stream_t *)UV_HANDLE(self), &buf, 1, (uv_stream_t *)UV_HANDLE(send_handle), pyuv__stream_write_cb);
} else {
err = uv_write(&ctx->req, (uv_stream_t *)UV_HANDLE(self), &buf, 1, pyuv__stream_write_cb);
}
if (err < 0) {
RAISE_STREAM_EXCEPTION(err, UV_HANDLE(self));
Py_DECREF(callback);
Py_XDECREF(send_handle);
PyBuffer_Release(view);
PyMem_Free(ctx);
return NULL;
}
/* Increase refcount so that object is not removed before the callback is called */
Py_INCREF(self);
Py_RETURN_NONE;
}
static int
Timer_repeat_set(Timer *self, PyObject *value, void *closure)
{
double repeat;
UNUSED_ARG(closure);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, -1);
if (!value) {
PyErr_SetString(PyExc_TypeError, "cannot delete attribute");
return -1;
}
repeat = PyFloat_AsDouble(value);
if (repeat == -1 && PyErr_Occurred()) {
return -1;
}
if (repeat < 0.0) {
PyErr_SetString(PyExc_ValueError, "a positive float or 0.0 is required");
return -1;
}
uv_timer_set_repeat((uv_timer_t *)UV_HANDLE(self), (int64_t)(repeat * 1000));
return 0;
}
static PyObject *
Timer_repeat_get(Timer *self, void *closure)
{
UNUSED_ARG(closure);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
return PyFloat_FromDouble(uv_timer_get_repeat((uv_timer_t *)UV_HANDLE(self))/1000.0);
}
static PyObject *
Check_func_start(Check *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_check_start((uv_check_t *)UV_HANDLE(self), on_check_callback);
if (r != 0) {
RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_CheckError);
return NULL;
}
tmp = self->callback;
Py_INCREF(callback);
self->callback = callback;
Py_XDECREF(tmp);
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 *
TCP_func_accept(TCP *self, PyObject *args)
{
int err;
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;
}
err = uv_accept((uv_stream_t *)&self->tcp_h, (uv_stream_t *)UV_HANDLE(client));
if (err < 0) {
RAISE_UV_EXCEPTION(err, PyExc_TCPError);
return NULL;
}
Py_RETURN_NONE;
}
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 *
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 int
Async_tp_init(Async *self, PyObject *args, PyObject *kwargs)
{
int r;
Loop *loop;
PyObject *callback, *tmp;
UNUSED_ARG(kwargs);
RAISE_IF_HANDLE_INITIALIZED(self, -1);
if (!PyArg_ParseTuple(args, "O!O:__init__", &LoopType, &loop, &callback)) {
return -1;
}
if (!PyCallable_Check(callback)) {
PyErr_SetString(PyExc_TypeError, "a callable is required");
return -1;
}
r = uv_async_init(loop->uv_loop, (uv_async_t *)UV_HANDLE(self), on_async_callback);
if (r != 0) {
RAISE_UV_EXCEPTION(loop->uv_loop, PyExc_AsyncError);
return -1;
}
tmp = self->callback;
Py_INCREF(callback);
self->callback = callback;
Py_XDECREF(tmp);
initialize_handle(HANDLE(self), loop);
return 0;
}
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 *
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 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 *
Stream_write_queue_size_get(Stream *self, void *closure)
{
UNUSED_ARG(closure);
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
return PyLong_FromSize_t(((uv_stream_t *)UV_HANDLE(self))->write_queue_size);
}
static PyObject *
Stream_writable_get(Stream *self, void *closure)
{
UNUSED_ARG(closure);
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
return PyBool_FromLong((long)uv_is_writable((uv_stream_t *)UV_HANDLE(self)));
}
static PyObject *
Stream_func_shutdown(Stream *self, PyObject *args)
{
int err;
stream_shutdown_ctx *ctx;
PyObject *callback;
ctx = NULL;
callback = Py_None;
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
if (!PyArg_ParseTuple(args, "|O:shutdown", &callback)) {
return NULL;
}
ctx = PyMem_Malloc(sizeof *ctx);
if (!ctx) {
PyErr_NoMemory();
return NULL;
}
Py_INCREF(callback);
ctx->obj = self;
ctx->callback = callback;
err = uv_shutdown(&ctx->req, (uv_stream_t *)UV_HANDLE(self), pyuv__stream_shutdown_cb);
if (err < 0) {
RAISE_STREAM_EXCEPTION(err, UV_HANDLE(self));
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(ctx);
return NULL;
}
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
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 INLINE PyObject *
pyuv_stream_write(Stream *self, stream_write_ctx *ctx, Py_buffer *views, uv_buf_t *bufs, int buf_count, PyObject *callback, PyObject *send_handle)
{
int i, err;
Py_INCREF(callback);
Py_XINCREF(send_handle);
ctx->obj = self;
ctx->callback = callback;
ctx->send_handle = send_handle;
ctx->views = views;
ctx->view_count = buf_count;
if (send_handle) {
err = uv_write2(&ctx->req, (uv_stream_t *)UV_HANDLE(self), bufs, buf_count, (uv_stream_t *)UV_HANDLE(send_handle), on_stream_write);
} else {
err = uv_write(&ctx->req, (uv_stream_t *)UV_HANDLE(self), bufs, buf_count, on_stream_write);
}
if (err < 0) {
RAISE_STREAM_EXCEPTION(err, UV_HANDLE(self));
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);
Py_XDECREF(send_handle);
for (i = 0; i < buf_count; i++) {
PyBuffer_Release(&views[i]);
}
if (ctx->views != ctx->view) {
PyMem_Free(views);
}
PyMem_Free(ctx);
return NULL;
}
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 PyObject *
Stream_func_fileno(Stream *self)
{
int err;
uv_os_fd_t fd;
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
err = uv_fileno(UV_HANDLE(self), &fd);
if (err < 0) {
RAISE_STREAM_EXCEPTION(err, UV_HANDLE(self));
return NULL;
}
/* us_os_fd_t is a HANDLE on Windows which is a 64-bit data type but which
* is guaranteed to contain only values < 2^24.
* For more information, see: http://www.viva64.com/en/k/0005/ */
return PyInt_FromLong((long) fd);
}
static PyObject *
Stream_func_stop_read(Stream *self)
{
int err;
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
err = uv_read_stop((uv_stream_t *)UV_HANDLE(self));
if (err < 0) {
RAISE_STREAM_EXCEPTION(err, UV_HANDLE(self));
return NULL;
}
Py_XDECREF(self->on_read_cb);
self->on_read_cb = NULL;
PYUV_HANDLE_DECREF(self);
Py_RETURN_NONE;
}
static PyObject *
TCP_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
TCP *self;
self = (TCP *)StreamType.tp_new(type, args, kwargs);
if (!self) {
return NULL;
}
self->tcp_h.data = self;
UV_HANDLE(self) = (uv_handle_t *)&self->tcp_h;
return (PyObject *)self;
}
static PyObject *
SignalChecker_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
SignalChecker *self;
self = (SignalChecker *)HandleType.tp_new(type, args, kwargs);
if (!self) {
return NULL;
}
self->poll_h.data = self;
UV_HANDLE(self) = (uv_handle_t *)&self->poll_h;
return (PyObject *)self;
}
static PyObject *
Timer_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
Timer *self;
self = (Timer *)HandleType.tp_new(type, args, kwargs);
if (!self) {
return NULL;
}
self->timer_h.data = self;
UV_HANDLE(self) = (uv_handle_t *)&self->timer_h;
return (PyObject *)self;
}
