static void recv_cb(uv_udp_t* handle, ssize_t nread, const uv_buf_t* buf, const struct sockaddr* addr, unsigned flags) { int r; if (nread < 0) { ASSERT(0 && "unexpected error"); } if (nread == 0) { /* Returning unused buffer */ /* Don't count towards sv_recv_cb_called */ ASSERT(addr == NULL); return; } ASSERT(flags == 0); ASSERT(addr != NULL); ASSERT(nread == 4); ASSERT(memcmp("PING", buf->base, nread) == 0); r = uv_udp_recv_stop(handle); ASSERT(r == 0); uv_close((uv_handle_t*) handle, close_cb); }
int xPLController::discoverxPLPort() { int portTCP; uv_udp_t sock; struct sockaddr_in addr; int r; r = uv_udp_init(uv_default_loop(), &sock); if(r!=0) return XPL_DEFAULT_PORT; portTCP = XPL_DEFAULT_PORT; do { uv_ip4_addr("0.0.0.0", portTCP, &addr); r = uv_udp_bind(&sock, (const struct sockaddr*) &addr, UV_UDP_REUSEADDR); if(r==0) break; if(portTCP == XPL_DEFAULT_PORT) portTCP = XPL_PORT_LOWER_BOUND-1; portTCP++; } while(portTCP != XPL_PORT_UPPER_BOUND); uv_udp_recv_stop(&sock); if(r!=0) return XPL_DEFAULT_PORT; return portTCP; }
CAMLprim value uwt_udp_recv_start(value o_udp, value o_cb) { HANDLE_INIT2_NO_UNINIT(u, o_udp, o_cb); /* uninit allowed, but forbidden by me :D */ value ret; if ( u->cb_read != CB_INVALID ){ ret = VAL_UWT_INT_RESULT_EBUSY; } else { int erg = 0; uv_udp_t* ux = (uv_udp_t*)u->handle; if ( u->can_reuse_cb_read == 1 ){ erg = uv_udp_recv_stop(ux); } if ( erg >= 0 ){ erg = uv_udp_recv_start(ux, uwt__alloc_cb, uwt_udp_recv_cb); if ( erg >= 0 ){ u->c_read_size = DEF_ALLOC_SIZE; uwt__gr_register(&u->cb_read,o_cb); ++u->in_use_cnt; } u->can_reuse_cb_read = 0; u->read_waiting = 0; } ret = VAL_UWT_UNIT_RESULT(erg); } CAMLreturn(ret); }
static int luv_udp_recv_stop(lua_State* L) { uv_udp_t* handle = luv_check_udp(L, 1); int ret = uv_udp_recv_stop(handle); if (ret < 0) return luv_error(L, ret); lua_pushinteger(L, ret); return 1; }
bool UDPSocket::recvStop() { // This method must not throw since it is called internally via libuv // callbacks. if (!ptr()) return false; return uv_udp_recv_stop(ptr<uv_udp_t>()) == 0; }
int io_stop_read(uv_handle_t *handle) { if (handle->type == UV_UDP) { return uv_udp_recv_stop((uv_udp_t *)handle); } else { return uv_read_stop((uv_stream_t *)handle); } }
int luv_udp_recv_stop(lua_State* L) { uv_udp_t* handle = (uv_udp_t*)luv_checkudata(L, 1, "udp"); if (uv_udp_recv_stop(handle)) { uv_err_t err = uv_last_error(luv_get_loop(L)); return luaL_error(L, "udp_recv_stop: %s", uv_strerror(err)); } luv_handle_unref(L, handle->data); return 0; }
void UdpSocketBaton::close() { uv_udp_recv_stop(&handle); uv_close((uv_handle_t*)&handle, NULL); set_timeout(2000, [this] () { delete this; }); }
void uv_udp_close(uv_loop_t* loop, uv_udp_t* handle) { uv_udp_recv_stop(handle); closesocket(handle->socket); uv__handle_start(handle); if (handle->reqs_pending == 0) { uv_want_endgame(loop, (uv_handle_t*) handle); } }
/* * Class: com_oracle_libuv_handles_UDPHandle * Method: _recv_stop * Signature: (J)I */ JNIEXPORT jint JNICALL Java_com_oracle_libuv_handles_UDPHandle__1recv_1stop (JNIEnv *env, jobject that, jlong udp) { assert(udp); uv_udp_t* handle = reinterpret_cast<uv_udp_t*>(udp); int r = uv_udp_recv_stop(handle); if (r) { ThrowException(env, handle->loop, "uv_udp_recv_stop"); } return r; }
void uv_udp_close(uv_loop_t* loop, uv_udp_t* handle) { uv_udp_recv_stop(handle); closesocket(handle->socket); handle->socket = INVALID_SOCKET; uv__handle_closing(handle); if (handle->reqs_pending == 0) { uv_want_endgame(loop, (uv_handle_t*) handle); } }
int Udp::RecvStop() { assert(IsOpened() || IsClosing()); assert(IsRecvStarted()); int result = uv_udp_recv_stop(*this); m_pRecvHandler = NULL; Unref(); return result; }
void UDPClient::disconnect(bool wait = false) { if (not isConnected()) { return; } int i = uv_udp_recv_stop(&server); uvEXT(i, "Unable to disconnect"); if (wait) { joinListenThread(); } _connected = false; }
UvUdpSocket::~UvUdpSocket() { if (m_udp_req) { free(m_udp_req); } if (m_uv_udp) { uv_udp_recv_stop(m_uv_udp); uv_close((uv_handle_t*)m_uv_udp,UvSocket::on_close); } }
static void lluv_on_udp_recv_cb(uv_udp_t *arg, ssize_t nread, const uv_buf_t* buf, const struct sockaddr* addr, unsigned flags){ lluv_handle_t *handle = lluv_handle_byptr((uv_handle_t*)arg); lua_State *L = LLUV_HCALLBACK_L(handle); LLUV_CHECK_LOOP_CB_INVARIANT(L); if((nread == 0) && (addr == NULL)){ /* ** The receive callback will be called with ** nread == 0 and addr == NULL when there is ** nothing to read */ lluv_free_buffer((uv_handle_t*)arg, buf); return; } lua_rawgeti(L, LLUV_LUA_REGISTRY, LLUV_READ_CB(handle)); assert(!lua_isnil(L, -1)); lluv_handle_pushself(L, handle); if(nread >= 0){ assert(addr); lua_pushnil(L); lua_pushlstring(L, buf->base, nread); lluv_free_buffer((uv_handle_t*)arg, buf); } else{ lluv_free_buffer((uv_handle_t*)arg, buf); /* The callee is responsible for stopping closing the stream * when an error happens by calling uv_read_stop() or uv_close(). * Trying to read from the stream again is undefined. */ uv_udp_recv_stop(arg); luaL_unref(L, LLUV_LUA_REGISTRY, LLUV_READ_CB(handle)); LLUV_READ_CB(handle) = LUA_NOREF; lluv_error_create(L, LLUV_ERR_UV, (uv_errno_t)nread, NULL); lua_pushnil(L); lluv_handle_unlock(L, handle, LLUV_LOCK_READ); } lua_pushinteger(L, flags); LLUV_HANDLE_CALL_CB(L, handle, 4 + lluv_push_addr(L, (const struct sockaddr_storage*)addr)); LLUV_CHECK_LOOP_CB_INVARIANT(L); }
static void sv_recv_cb(uv_udp_t* handle, ssize_t nread, uv_buf_t buf, struct sockaddr* addr, unsigned flags) { uv_udp_send_t* req; int r; if (nread < 0) { ASSERT(0 && "unexpected error"); } if (nread == 0) { /* Returning unused buffer */ /* Don't count towards sv_recv_cb_called */ ASSERT(addr == NULL); return; } CHECK_HANDLE(handle); ASSERT(flags == 0); ASSERT(addr != NULL); ASSERT(nread == 4); ASSERT(!memcmp("PING", buf.base, nread)); /* FIXME? `uv_udp_recv_stop` does what it says: recv_cb is not called * anymore. That's problematic because the read buffer won't be returned * either... Not sure I like that but it's consistent with `uv_read_stop`. */ r = uv_udp_recv_stop(handle); ASSERT(r == 0); req = malloc(sizeof *req); ASSERT(req != NULL); buf = uv_buf_init("PONG", 4); r = uv_udp_send(req, handle, &buf, 1, *(struct sockaddr_in*)addr, sv_send_cb); ASSERT(r == 0); sv_recv_cb_called++; }
ALWAYS_INLINE void releaseHandle(uv_udp_ext_t *handle) { if(handle->flag & UV_UDP_READ_START){ handle->flag &= ~UV_UDP_READ_START; uv_udp_recv_stop((uv_udp_t *) handle); } if(handle->flag & UV_UDP_HANDLE_START){ handle->flag &= ~UV_UDP_HANDLE_START; uv_unref((uv_handle_t *) handle); } if(handle->flag & UV_UDP_HANDLE_INTERNAL_REF){ handle->flag &= ~UV_UDP_HANDLE_INTERNAL_REF; ((uv_udp_ext_t *) handle)->udp_object_data->decRefAndRelease(); } }
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 int lluv_udp_stop_recv(lua_State *L){ lluv_handle_t *handle = lluv_check_udp(L, 1, LLUV_FLAG_OPEN); int err; lluv_check_none(L, 2); err = uv_udp_recv_stop(LLUV_H(handle, uv_udp_t)); if(err < 0){ return lluv_fail(L, handle->flags, LLUV_ERR_UV, err, NULL); } if(LLUV_READ_CB(handle) != LUA_NOREF){ luaL_unref(L, LLUV_LUA_REGISTRY, LLUV_READ_CB(handle)); LLUV_READ_CB(handle) = LUA_NOREF; lluv_handle_unlock(L, handle, LLUV_LOCK_READ); } lua_settop(L, 1); return 1; }
// event handler for closing a tcp socket static void utb_on_close(uv_handle_t *handle) { uv_stream_t *stream = (uv_stream_t *)handle; utb_t *utb; // free the data object if (stream->data != 0) { UTB_PRINTF("free %p",stream->data); utb = (utb_t *)stream->data; // stop udp receiving uv_udp_recv_stop(&utb->udp_sock); // mark tcp is closed utb->tcp_closed = 1; // close udp socket uv_close((uv_handle_t *)&utb->udp_sock,on_udp_close); } UTB_PRINTF("free %p",stream); }
static PyObject * UDP_func_stop_recv(UDP *self) { int err; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); err = uv_udp_recv_stop(&self->udp_h); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_UDPError); return NULL; } Py_XDECREF(self->on_read_cb); self->on_read_cb = NULL; PYUV_HANDLE_DECREF(self); Py_RETURN_NONE; }
CAMLprim value uwt_udp_recv_stop(value o_udp, value o_abort) { HANDLE_NO_UNINIT_CLOSED_INT_RESULT(o_udp); HANDLE_INIT(u,o_udp); value ret; if ( u->cb_read == CB_INVALID || /* see comment to uwt_read_stop */ (u->read_waiting == 1 && Long_val(o_abort) == 0 )){ ret = Val_long(0); } else { const int erg = uv_udp_recv_stop((uv_udp_t*)u->handle); if ( erg >= 0 ){ u->can_reuse_cb_read = 0; u->read_waiting = 0; --u->in_use_cnt; uwt__gr_unregister(&u->cb_read); } ret = VAL_UWT_UNIT_RESULT(erg); } CAMLreturn(ret); }
int melo_udp_shutdown(melo_udp_t * mudp) { uv_udp_recv_stop(&mudp->uvudp); uv_close((uv_handle_t*) &mudp->uvudp, NULL); return OK; }
void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle, uv_req_t* req) { uv_buf_t buf; int partial; assert(handle->type == UV_UDP); handle->flags &= ~UV_HANDLE_READ_PENDING; if (!REQ_SUCCESS(req)) { DWORD err = GET_REQ_SOCK_ERROR(req); if (err == WSAEMSGSIZE) { /* Not a real error, it just indicates that the received packet */ /* was bigger than the receive buffer. */ } else if (err == WSAECONNRESET || err == WSAENETRESET) { /* A previous sendto operation failed; ignore this error. If */ /* zero-reading we need to call WSARecv/WSARecvFrom _without_ the */ /* MSG_PEEK flag to clear out the error queue. For nonzero reads, */ /* immediately queue a new receive. */ if (!(handle->flags & UV_HANDLE_ZERO_READ)) { goto done; } } else { /* A real error occurred. Report the error to the user only if we're */ /* currently reading. */ if (handle->flags & UV_HANDLE_READING) { uv__set_sys_error(loop, err); uv_udp_recv_stop(handle); buf = (handle->flags & UV_HANDLE_ZERO_READ) ? uv_buf_init(NULL, 0) : handle->recv_buffer; handle->recv_cb(handle, -1, buf, NULL, 0); } goto done; } } if (!(handle->flags & UV_HANDLE_ZERO_READ)) { /* Successful read */ partial = !REQ_SUCCESS(req); handle->recv_cb(handle, req->overlapped.InternalHigh, handle->recv_buffer, (struct sockaddr*) &handle->recv_from, partial ? UV_UDP_PARTIAL : 0); } else if (handle->flags & UV_HANDLE_READING) { DWORD bytes, err, flags; struct sockaddr_storage from; int from_len; /* Do a nonblocking receive */ /* TODO: try to read multiple datagrams at once. FIONREAD maybe? */ buf = handle->alloc_cb((uv_handle_t*) handle, 65536); assert(buf.len > 0); memset(&from, 0, sizeof from); from_len = sizeof from; flags = 0; if (WSARecvFrom(handle->socket, (WSABUF*)&buf, 1, &bytes, &flags, (struct sockaddr*) &from, &from_len, NULL, NULL) != SOCKET_ERROR) { /* Message received */ handle->recv_cb(handle, bytes, buf, (struct sockaddr*) &from, 0); } else { err = WSAGetLastError(); if (err == WSAEMSGSIZE) { /* Message truncated */ handle->recv_cb(handle, bytes, buf, (struct sockaddr*) &from, UV_UDP_PARTIAL); } if (err == WSAEWOULDBLOCK) { /* Kernel buffer empty */ uv__set_sys_error(loop, WSAEWOULDBLOCK); handle->recv_cb(handle, 0, buf, NULL, 0); } else if (err != WSAECONNRESET && err != WSAENETRESET) { /* Serious error. WSAECONNRESET/WSANETRESET is ignored because this */ /* just indicates that a previous sendto operation failed. */ uv_udp_recv_stop(handle); uv__set_sys_error(loop, err); handle->recv_cb(handle, -1, buf, NULL, 0); } } } done: /* Post another read if still reading and not closing. */ if ((handle->flags & UV_HANDLE_READING) && !(handle->flags & UV_HANDLE_READ_PENDING)) { uv_udp_queue_recv(loop, handle); } DECREASE_PENDING_REQ_COUNT(handle); }
static void uwt_udp_recv_own_cb(uv_udp_t* handle, ssize_t nread, const uv_buf_t* buf, const struct sockaddr* addr, unsigned int flags) { HANDLE_CB_INIT_WITH_CLEAN(uh, handle); value exn = Val_unit; #ifndef UWT_NO_COPY_READ bool buf_not_cleaned = true; const int read_ba = uh->use_read_ba; #else (void) buf; #endif if ( uh->close_called == 0 && (nread != 0 || addr != NULL) ){ /* nread == 0 && addr == NULL only means we need to clear the buffer */ assert ( uh->cb_read != CB_INVALID ); value param; if ( nread < 0 ){ param = caml_alloc_small(1,Error_tag); Field(param,0) = Val_uwt_error(nread); } else { value triple = Val_unit; value sockaddr = Val_unit; param = Val_unit; Begin_roots3(triple,sockaddr,param); value is_partial; if ( addr != NULL ){ param = uwt__alloc_sockaddr(addr); if ( param != Val_unit ){ sockaddr = caml_alloc_small(1,Some_tag); Field(sockaddr,0) = param; } } if ( flags & UV_UDP_PARTIAL ){ is_partial = Val_long(1); } else { is_partial = Val_long(0); } #ifndef UWT_NO_COPY_READ if ( nread != 0 && read_ba == 0 ){ value o = Field(GET_CB_VAL(uh->cb_read),0); memcpy(String_val(o) + uh->x.obuf_offset, buf->base, nread); } #endif triple = caml_alloc_small(3,0); Field(triple,0) = Val_long(nread); Field(triple,1) = is_partial; Field(triple,2) = sockaddr; param = caml_alloc_small(1,Ok_tag); Field(param,0) = triple; End_roots(); } #ifndef UWT_NO_COPY_READ if ( buf->base && read_ba == 0 ){ buf_not_cleaned = false; uwt__free_uv_buf_t_const(buf); } #endif uh->can_reuse_cb_read = 1; uh->read_waiting = 0; uh->in_use_cnt--; exn = Field(GET_CB_VAL(uh->cb_read),1); uwt__gr_unregister(&uh->cb_read); exn = caml_callback2_exn(*uwt__global_wakeup,exn,param); if ( uh->close_called == 0 && uh->can_reuse_cb_read == 1 ){ uv_udp_recv_stop(handle); uh->can_reuse_cb_read = 0; } } #ifndef UWT_NO_COPY_READ if ( read_ba == 0 && buf_not_cleaned && buf->base ){ uwt__free_uv_buf_t_const(buf); } #endif HANDLE_CB_RET(exn); }
int close_socket(unsigned int loc_idx) { uv_udp_recv_stop(&udp_servers[loc_idx]); uv_close((uv_handle_t*)&udp_servers[loc_idx], NULL); return 0; }
void uv_close(uv_handle_t* handle, uv_close_cb cb) { uv_pipe_t* pipe; uv_udp_t* udp; uv_process_t* process; uv_loop_t* loop = handle->loop; if (handle->flags & UV_HANDLE_CLOSING) { return; } handle->flags |= UV_HANDLE_CLOSING; handle->close_cb = cb; /* Handle-specific close actions */ switch (handle->type) { case UV_TCP: uv_tcp_close((uv_tcp_t*)handle); return; case UV_NAMED_PIPE: pipe = (uv_pipe_t*)handle; pipe->flags &= ~(UV_HANDLE_READING | UV_HANDLE_LISTENING); close_pipe(pipe, NULL, NULL); if (pipe->reqs_pending == 0) { uv_want_endgame(loop, handle); } return; case UV_TTY: uv_tty_close((uv_tty_t*) handle); return; case UV_UDP: udp = (uv_udp_t*) handle; uv_udp_recv_stop(udp); closesocket(udp->socket); if (udp->reqs_pending == 0) { uv_want_endgame(loop, handle); } return; case UV_POLL: uv_poll_close(handle->loop, (uv_poll_t*) handle); return; case UV_TIMER: uv_timer_stop((uv_timer_t*)handle); uv_want_endgame(loop, handle); return; case UV_PREPARE: uv_prepare_stop((uv_prepare_t*)handle); uv_want_endgame(loop, handle); return; case UV_CHECK: uv_check_stop((uv_check_t*)handle); uv_want_endgame(loop, handle); return; case UV_IDLE: uv_idle_stop((uv_idle_t*)handle); uv_want_endgame(loop, handle); return; case UV_ASYNC: if (!((uv_async_t*)handle)->async_sent) { uv_want_endgame(loop, handle); } return; case UV_PROCESS: process = (uv_process_t*)handle; uv_process_close(loop, process); return; case UV_FS_EVENT: uv_fs_event_close(loop, (uv_fs_event_t*)handle); return; default: /* Not supported */ abort(); } }
void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle, uv_req_t* req) { uv_buf_t buf; int partial; assert(handle->type == UV_UDP); handle->flags &= ~UV_HANDLE_READ_PENDING; if (!REQ_SUCCESS(req) && GET_REQ_STATUS(req) != STATUS_RECEIVE_EXPEDITED) { /* An error occurred doing the read. */ if ((handle->flags & UV_HANDLE_READING)) { uv__set_sys_error(loop, GET_REQ_SOCK_ERROR(req)); uv_udp_recv_stop(handle); #if 0 buf = (handle->flags & UV_HANDLE_ZERO_READ) ? uv_buf_init(NULL, 0) : handle->recv_buffer; #else buf = handle->recv_buffer; #endif handle->recv_cb(handle, -1, buf, NULL, 0); } goto done; } #if 0 if (!(handle->flags & UV_HANDLE_ZERO_READ)) { #endif /* Successful read */ partial = (GET_REQ_STATUS(req) == STATUS_RECEIVE_EXPEDITED); handle->recv_cb(handle, req->overlapped.InternalHigh, handle->recv_buffer, (struct sockaddr*) &handle->recv_from, partial ? UV_UDP_PARTIAL : 0); #if 0 } else { DWORD bytes, err, flags; struct sockaddr_storage from; int from_len; /* Do a nonblocking receive */ /* TODO: try to read multiple datagrams at once. FIONREAD maybe? */ buf = handle->alloc_cb((uv_handle_t*) handle, 65536); assert(buf.len > 0); memset(&from, 0, sizeof from); from_len = sizeof from; flags = MSG_PARTIAL; if (WSARecvFrom(handle->socket, (WSABUF*)&buf, 1, &bytes, &flags, (struct sockaddr*) &from, &from_len, NULL, NULL) != SOCKET_ERROR) { /* Message received */ handle->recv_cb(handle, bytes, buf, (struct sockaddr*) &from, (flags & MSG_PARTIAL) ? UV_UDP_PARTIAL : 0); } else { err = WSAGetLastError(); if (err == WSAEWOULDBLOCK) { uv__set_sys_error(loop, WSAEWOULDBLOCK); handle->recv_cb(handle, 0, buf, NULL, 0); } else { /* Ouch! serious error. */ uv__set_sys_error(loop, err); handle->recv_cb(handle, -1, buf, NULL, 0); } } } #endif done: /* Post another read if still reading and not closing. */ if ((handle->flags & UV_HANDLE_READING) && !(handle->flags & UV_HANDLE_READ_PENDING)) { uv_udp_queue_recv(loop, handle); } DECREASE_PENDING_REQ_COUNT(handle); }
void uv_close(uv_handle_t* handle, uv_close_cb cb) { uv_tcp_t* tcp; uv_pipe_t* pipe; uv_udp_t* udp; uv_process_t* process; if (handle->flags & UV_HANDLE_CLOSING) { return; } handle->flags |= UV_HANDLE_CLOSING; handle->close_cb = cb; /* Handle-specific close actions */ switch (handle->type) { case UV_TCP: tcp = (uv_tcp_t*)handle; /* If we don't shutdown before calling closesocket, windows will */ /* silently discard the kernel send buffer and reset the connection. */ if (!(tcp->flags & UV_HANDLE_SHUT)) { shutdown(tcp->socket, SD_SEND); tcp->flags |= UV_HANDLE_SHUT; } tcp->flags &= ~(UV_HANDLE_READING | UV_HANDLE_LISTENING); closesocket(tcp->socket); if (tcp->reqs_pending == 0) { uv_want_endgame(handle); } return; case UV_NAMED_PIPE: pipe = (uv_pipe_t*)handle; pipe->flags &= ~(UV_HANDLE_READING | UV_HANDLE_LISTENING); close_pipe(pipe, NULL, NULL); if (pipe->reqs_pending == 0) { uv_want_endgame(handle); } return; case UV_UDP: udp = (uv_udp_t*) handle; uv_udp_recv_stop(udp); closesocket(udp->socket); if (udp->reqs_pending == 0) { uv_want_endgame(handle); } return; case UV_TIMER: uv_timer_stop((uv_timer_t*)handle); uv_want_endgame(handle); return; case UV_PREPARE: uv_prepare_stop((uv_prepare_t*)handle); uv_want_endgame(handle); return; case UV_CHECK: uv_check_stop((uv_check_t*)handle); uv_want_endgame(handle); return; case UV_IDLE: uv_idle_stop((uv_idle_t*)handle); uv_want_endgame(handle); return; case UV_ASYNC: if (!((uv_async_t*)handle)->async_sent) { uv_want_endgame(handle); } return; case UV_PROCESS: process = (uv_process_t*)handle; uv_process_close(process); return; default: /* Not supported */ abort(); } }
extern "C" int rust_uv_udp_recv_stop(uv_udp_t* server) { return uv_udp_recv_stop(server); }