Lines Matching refs:handle
27 #include "handle-inl.h"
34 int uv_udp_getpeername(const uv_udp_t* handle,
38 return uv__getsockpeername((const uv_handle_t*) handle,
46 int uv_udp_getsockname(const uv_udp_t* handle,
50 return uv__getsockpeername((const uv_handle_t*) handle,
58 static int uv__udp_set_socket(uv_loop_t* loop, uv_udp_t* handle, SOCKET socket,
64 if (handle->socket != INVALID_SOCKET)
103 handle->flags |= UV_HANDLE_SYNC_BYPASS_IOCP;
104 handle->func_wsarecv = uv__wsarecv_workaround;
105 handle->func_wsarecvfrom = uv__wsarecvfrom_workaround;
111 handle->socket = socket;
114 handle->flags |= UV_HANDLE_IPV6;
116 assert(!(handle->flags & UV_HANDLE_IPV6));
124 uv_udp_t* handle,
127 uv__handle_init(loop, (uv_handle_t*) handle, UV_UDP);
128 handle->socket = INVALID_SOCKET;
129 handle->reqs_pending = 0;
130 handle->activecnt = 0;
131 handle->func_wsarecv = WSARecv;
132 handle->func_wsarecvfrom = WSARecvFrom;
133 handle->send_queue_size = 0;
134 handle->send_queue_count = 0;
135 UV_REQ_INIT(&handle->recv_req, UV_UDP_RECV);
136 handle->recv_req.data = handle;
138 /* If anything fails beyond this point we need to remove the handle from
139 * the handle queue, since it was added by uv__handle_init.
149 uv__queue_remove(&handle->handle_queue);
153 err = uv__udp_set_socket(handle->loop, handle, sock, domain);
156 uv__queue_remove(&handle->handle_queue);
165 void uv__udp_close(uv_loop_t* loop, uv_udp_t* handle) {
166 uv_udp_recv_stop(handle);
167 closesocket(handle->socket);
168 handle->socket = INVALID_SOCKET;
170 uv__handle_closing(handle);
172 if (handle->reqs_pending == 0) {
173 uv__want_endgame(loop, (uv_handle_t*) handle);
178 void uv__udp_endgame(uv_loop_t* loop, uv_udp_t* handle) {
179 if (handle->flags & UV_HANDLE_CLOSING &&
180 handle->reqs_pending == 0) {
181 assert(!(handle->flags & UV_HANDLE_CLOSED));
182 uv__handle_close(handle);
187 int uv_udp_using_recvmmsg(const uv_udp_t* handle) {
192 static int uv__udp_maybe_bind(uv_udp_t* handle,
200 if (handle->flags & UV_HANDLE_BOUND)
208 if (handle->socket == INVALID_SOCKET) {
214 err = uv__udp_set_socket(handle->loop, handle, sock, addr->sa_family);
224 if (setsockopt(handle->socket,
235 handle->flags |= UV_HANDLE_IPV6;
241 /* TODO: how to handle errors? This may fail if there is no ipv4 stack
244 setsockopt(handle->socket,
251 r = bind(handle->socket, addr, addrlen);
256 handle->flags |= UV_HANDLE_BOUND;
262 static void uv__udp_queue_recv(uv_loop_t* loop, uv_udp_t* handle) {
268 assert(handle->flags & UV_HANDLE_READING);
269 assert(!(handle->flags & UV_HANDLE_READ_PENDING));
271 req = &handle->recv_req;
274 handle->flags |= UV_HANDLE_ZERO_READ;
280 result = handle->func_wsarecv(handle->socket,
290 handle->flags |= UV_HANDLE_READ_PENDING;
292 handle->reqs_pending++;
296 handle->flags |= UV_HANDLE_READ_PENDING;
297 handle->reqs_pending++;
302 handle->reqs_pending++;
307 int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb,
309 uv_loop_t* loop = handle->loop;
312 if (handle->flags & UV_HANDLE_READING) {
316 err = uv__udp_maybe_bind(handle,
323 handle->flags |= UV_HANDLE_READING;
324 INCREASE_ACTIVE_COUNT(loop, handle);
326 handle->recv_cb = recv_cb;
327 handle->alloc_cb = alloc_cb;
331 if (!(handle->flags & UV_HANDLE_READ_PENDING))
332 uv__udp_queue_recv(loop, handle);
338 int uv__udp_recv_stop(uv_udp_t* handle) {
339 if (handle->flags & UV_HANDLE_READING) {
340 handle->flags &= ~UV_HANDLE_READING;
341 DECREASE_ACTIVE_COUNT(loop, handle);
349 uv_udp_t* handle,
355 uv_loop_t* loop = handle->loop;
359 req->handle = handle;
363 result = WSASendTo(handle->socket,
376 handle->reqs_pending++;
377 handle->send_queue_size += req->u.io.queued_bytes;
378 handle->send_queue_count++;
379 REGISTER_HANDLE_REQ(loop, handle, req);
384 handle->reqs_pending++;
385 handle->send_queue_size += req->u.io.queued_bytes;
386 handle->send_queue_count++;
387 REGISTER_HANDLE_REQ(loop, handle, req);
397 void uv__process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle,
402 assert(handle->type == UV_UDP);
404 handle->flags &= ~UV_HANDLE_READ_PENDING;
416 if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
422 if (handle->flags & UV_HANDLE_READING) {
423 uv_udp_recv_stop(handle);
424 buf = (handle->flags & UV_HANDLE_ZERO_READ) ?
425 uv_buf_init(NULL, 0) : handle->recv_buffer;
426 handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);
432 if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
435 handle->recv_cb(handle,
437 &handle->recv_buffer,
438 (const struct sockaddr*) &handle->recv_from,
440 } else if (handle->flags & UV_HANDLE_READING) {
453 handle->alloc_cb((uv_handle_t*) handle, UV__UDP_DGRAM_MAXSIZE, &buf);
455 handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0);
464 if (WSARecvFrom(handle->socket,
476 handle->recv_cb(handle, bytes, &buf, (const struct sockaddr*) &from, 0);
481 handle->recv_cb(handle,
488 handle->recv_cb(handle, 0, &buf, NULL, 0);
493 handle->recv_cb(handle, 0, &buf, NULL, 0);
496 uv_udp_recv_stop(handle);
497 handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);
503 /* The recv_cb callback may decide to pause or close the handle. */
504 (handle->flags & UV_HANDLE_READING) &&
505 !(handle->flags & UV_HANDLE_READ_PENDING));
510 if ((handle->flags & UV_HANDLE_READING) &&
511 !(handle->flags & UV_HANDLE_READ_PENDING)) {
512 uv__udp_queue_recv(loop, handle);
515 DECREASE_PENDING_REQ_COUNT(handle);
519 void uv__process_udp_send_req(uv_loop_t* loop, uv_udp_t* handle,
523 assert(handle->type == UV_UDP);
525 assert(handle->send_queue_size >= req->u.io.queued_bytes);
526 assert(handle->send_queue_count >= 1);
527 handle->send_queue_size -= req->u.io.queued_bytes;
528 handle->send_queue_count--;
530 UNREGISTER_HANDLE_REQ(loop, handle, req);
540 DECREASE_PENDING_REQ_COUNT(handle);
544 static int uv__udp_set_membership4(uv_udp_t* handle,
552 if (handle->flags & UV_HANDLE_IPV6)
556 err = uv__udp_maybe_bind(handle,
586 if (setsockopt(handle->socket,
598 int uv__udp_set_membership6(uv_udp_t* handle,
607 if ((handle->flags & UV_HANDLE_BOUND) && !(handle->flags & UV_HANDLE_IPV6))
610 err = uv__udp_maybe_bind(handle,
641 if (setsockopt(handle->socket,
653 static int uv__udp_set_source_membership4(uv_udp_t* handle,
662 if (handle->flags & UV_HANDLE_IPV6)
666 err = uv__udp_maybe_bind(handle,
693 if (setsockopt(handle->socket,
705 int uv__udp_set_source_membership6(uv_udp_t* handle,
718 if ((handle->flags & UV_HANDLE_BOUND) && !(handle->flags & UV_HANDLE_IPV6))
721 err = uv__udp_maybe_bind(handle,
750 if (setsockopt(handle->socket,
762 int uv_udp_set_membership(uv_udp_t* handle,
770 return uv__udp_set_membership4(handle, &addr4, interface_addr, membership);
772 return uv__udp_set_membership6(handle, &addr6, interface_addr, membership);
778 int uv_udp_set_source_membership(uv_udp_t* handle,
804 return uv__udp_set_source_membership6(handle,
814 return uv__udp_set_source_membership4(handle,
822 int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) {
832 if (handle->flags & UV_HANDLE_IPV6) {
847 if (handle->socket == INVALID_SOCKET)
851 if (setsockopt(handle->socket,
859 if (setsockopt(handle->socket,
875 int uv_udp_set_broadcast(uv_udp_t* handle, int value) {
878 if (handle->socket == INVALID_SOCKET)
881 if (setsockopt(handle->socket,
893 int uv__udp_is_bound(uv_udp_t* handle) {
898 if (uv_udp_getsockname(handle, (struct sockaddr*) &addr, &addrlen) != 0)
905 int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) {
920 err = uv__udp_set_socket(handle->loop,
921 handle,
927 if (uv__udp_is_bound(handle))
928 handle->flags |= UV_HANDLE_BOUND;
930 if (uv__udp_is_connected(handle))
931 handle->flags |= UV_HANDLE_UDP_CONNECTED;
938 int uv_udp_set_##name(uv_udp_t* handle, int value) { \
945 if (handle->socket == INVALID_SOCKET) \
948 if (!(handle->flags & UV_HANDLE_IPV6)) { \
950 if (setsockopt(handle->socket, \
959 if (setsockopt(handle->socket, \
996 int uv__udp_bind(uv_udp_t* handle,
1002 err = uv__udp_maybe_bind(handle, addr, addrlen, flags);
1010 int uv__udp_connect(uv_udp_t* handle,
1016 if (!(handle->flags & UV_HANDLE_BOUND)) {
1024 err = uv__udp_maybe_bind(handle, bind_addr, addrlen, 0);
1029 err = connect(handle->socket, addr, addrlen);
1033 handle->flags |= UV_HANDLE_UDP_CONNECTED;
1039 int uv__udp_disconnect(uv_udp_t* handle) {
1045 err = connect(handle->socket, (struct sockaddr*) &addr, sizeof(addr));
1049 handle->flags &= ~UV_HANDLE_UDP_CONNECTED;
1058 uv_udp_t* handle,
1067 if (!(handle->flags & UV_HANDLE_BOUND)) {
1075 err = uv__udp_maybe_bind(handle, bind_addr, addrlen, 0);
1080 err = uv__send(req, handle, bufs, nbufs, addr, addrlen, send_cb);
1088 int uv__udp_try_send(uv_udp_t* handle,
1108 if (handle->send_queue_count != 0)
1111 if (!(handle->flags & UV_HANDLE_BOUND)) {
1118 err = uv__udp_maybe_bind(handle, bind_addr, addrlen, 0);
1123 err = WSASendTo(handle->socket,