static int Pipe_tp_init(Pipe *self, PyObject *args, PyObject *kwargs) { int err; Loop *loop; PyObject *ipc = Py_False; UNUSED_ARG(kwargs); RAISE_IF_HANDLE_INITIALIZED(self, -1); if (!PyArg_ParseTuple(args, "O!|O!:__init__", &LoopType, &loop, &PyBool_Type, &ipc)) { return -1; } err = uv_pipe_init(loop->uv_loop, &self->pipe_h, (ipc == Py_True) ? 1 : 0); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_PipeError); return -1; } initialize_handle(HANDLE(self), loop); return 0; }
static PyObject * Pipe_func_getsockname(Pipe *self) { #ifdef _WIN32 /* MAX_PATH is in characters, not bytes. Make sure we have enough headroom. */ char buf[MAX_PATH * 4]; #else char buf[PATH_MAX]; #endif size_t buf_len; int err; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); buf_len = sizeof(buf); err = uv_pipe_getsockname(&self->pipe_h, buf, &buf_len); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_PipeError); return NULL; } if (buf_len == 0) { return PyBytes_FromString(""); } else if (buf[0] == '\0') { /* Linux abstract namespace */ return PyBytes_FromStringAndSize(buf, buf_len); } else { return PyBytes_FromStringAndSize(buf, buf_len-1); } }
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 * 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 * 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_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 * 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 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 * 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 PyObject * Idle_func_start(Idle *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", &callback)) { return NULL; } if (!PyCallable_Check(callback)) { PyErr_SetString(PyExc_TypeError, "a callable is required"); return NULL; } err = uv_idle_start(&self->idle_h, pyuv__idle_cb); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_IdleError); return NULL; } tmp = self->callback; Py_INCREF(callback); self->callback = callback; Py_XDECREF(tmp); PYUV_HANDLE_INCREF(self); 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 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 * 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 err, flags; struct sockaddr_storage ss; PyObject *addr; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); flags = 0; if (!PyArg_ParseTuple(args, "O|i:bind", &addr, &flags)) { return NULL; } if (pyuv_parse_addr_tuple(addr, &ss) < 0) { /* Error is set by the function itself */ return NULL; } err = uv_udp_bind(&self->udp_h, (struct sockaddr *)&ss, flags); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_UDPError); return NULL; } Py_RETURN_NONE; }
static int SignalChecker_tp_init(SignalChecker *self, PyObject *args, PyObject *kwargs) { int err; long fd; Loop *loop; UNUSED_ARG(kwargs); RAISE_IF_HANDLE_INITIALIZED(self, -1); if (!PyArg_ParseTuple(args, "O!l:__init__", &LoopType, &loop, &fd)) { return -1; } err = uv_poll_init_socket(loop->uv_loop, &self->poll_h, (uv_os_sock_t)fd); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_UVError); return -1; } self->fd = fd; initialize_handle(HANDLE(self), loop); return 0; }
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_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 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 * 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 * 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 * Timer_func_start(Timer *self, PyObject *args, PyObject *kwargs) { int err; double timeout, repeat; PyObject *tmp, *callback; static char *kwlist[] = {"callback", "timeout", "repeat", NULL}; tmp = NULL; RAISE_IF_HANDLE_NOT_INITIALIZED(self, 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; } err = uv_timer_start(&self->timer_h, on_timer_callback, (uint64_t)(timeout * 1000), (uint64_t)(repeat * 1000)); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_TimerError); return NULL; } tmp = self->callback; Py_INCREF(callback); self->callback = callback; Py_XDECREF(tmp); PYUV_HANDLE_INCREF(self); 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_again(Timer *self) { int err; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); err = uv_timer_again(&self->timer_h); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_TimerError); return NULL; } 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 * 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 * 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 PyObject * SignalChecker_func_stop(SignalChecker *self) { int err; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); err = uv_poll_stop(&self->poll_h); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_UVError); return NULL; } PYUV_HANDLE_DECREF(self); Py_RETURN_NONE; }
static PyObject * UDP_func_getsockname(UDP *self) { int err, namelen; struct sockaddr_storage sockname; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); namelen = sizeof(sockname); err = uv_udp_getsockname(&self->udp_h, (struct sockaddr *)&sockname, &namelen); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_UDPError); return NULL; } return makesockaddr((struct sockaddr *)&sockname, namelen); }
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); }