Lines Matching refs:handle
27 #include "handle-inl.h"
39 int uv_udp_getpeername(const uv_udp_t* handle,
43 return uv__getsockpeername((const uv_handle_t*) handle,
51 int uv_udp_getsockname(const uv_udp_t* handle,
55 return uv__getsockpeername((const uv_handle_t*) handle,
63 static int uv__udp_set_socket(uv_loop_t* loop, uv_udp_t* handle, SOCKET socket,
69 if (handle->socket != INVALID_SOCKET)
108 handle->flags |= UV_HANDLE_SYNC_BYPASS_IOCP;
109 handle->func_wsarecv = uv__wsarecv_workaround;
110 handle->func_wsarecvfrom = uv__wsarecvfrom_workaround;
116 handle->socket = socket;
119 handle->flags |= UV_HANDLE_IPV6;
121 assert(!(handle->flags & UV_HANDLE_IPV6));
129 uv_udp_t* handle,
132 uv__handle_init(loop, (uv_handle_t*) handle, UV_UDP);
133 handle->socket = INVALID_SOCKET;
134 handle->reqs_pending = 0;
135 handle->activecnt = 0;
136 handle->func_wsarecv = WSARecv;
137 handle->func_wsarecvfrom = WSARecvFrom;
138 handle->send_queue_size = 0;
139 handle->send_queue_count = 0;
140 UV_REQ_INIT(&handle->recv_req, UV_UDP_RECV);
141 handle->recv_req.data = handle;
143 /* If anything fails beyond this point we need to remove the handle from
144 * the handle queue, since it was added by uv__handle_init.
154 QUEUE_REMOVE(&handle->handle_queue);
158 err = uv__udp_set_socket(handle->loop, handle, sock, domain);
161 QUEUE_REMOVE(&handle->handle_queue);
170 void uv__udp_close(uv_loop_t* loop, uv_udp_t* handle) {
171 uv_udp_recv_stop(handle);
172 closesocket(handle->socket);
173 handle->socket = INVALID_SOCKET;
175 uv__handle_closing(handle);
177 if (handle->reqs_pending == 0) {
178 uv__want_endgame(loop, (uv_handle_t*) handle);
183 void uv__udp_endgame(uv_loop_t* loop, uv_udp_t* handle) {
184 if (handle->flags & UV_HANDLE_CLOSING &&
185 handle->reqs_pending == 0) {
186 assert(!(handle->flags & UV_HANDLE_CLOSED));
187 uv__handle_close(handle);
192 int uv_udp_using_recvmmsg(const uv_udp_t* handle) {
197 static int uv__udp_maybe_bind(uv_udp_t* handle,
205 if (handle->flags & UV_HANDLE_BOUND)
213 if (handle->socket == INVALID_SOCKET) {
219 err = uv__udp_set_socket(handle->loop, handle, sock, addr->sa_family);
229 if (setsockopt(handle->socket,
240 handle->flags |= UV_HANDLE_IPV6;
246 /* TODO: how to handle errors? This may fail if there is no ipv4 stack
249 setsockopt(handle->socket,
256 r = bind(handle->socket, addr, addrlen);
261 handle->flags |= UV_HANDLE_BOUND;
267 static void uv__udp_queue_recv(uv_loop_t* loop, uv_udp_t* handle) {
273 assert(handle->flags & UV_HANDLE_READING);
274 assert(!(handle->flags & UV_HANDLE_READ_PENDING));
276 req = &handle->recv_req;
284 handle->flags &= ~UV_HANDLE_ZERO_READ;
286 handle->recv_buffer = uv_buf_init(NULL, 0);
287 handle->alloc_cb((uv_handle_t*) handle, UV__UDP_DGRAM_MAXSIZE, &handle->recv_buffer);
288 if (handle->recv_buffer.base == NULL || handle->recv_buffer.len == 0) {
289 handle->recv_cb(handle, UV_ENOBUFS, &handle->recv_buffer, NULL, 0);
292 assert(handle->recv_buffer.base != NULL);
294 buf = handle->recv_buffer;
295 memset(&handle->recv_from, 0, sizeof handle->recv_from);
296 handle->recv_from_len = sizeof handle->recv_from;
299 result = handle->func_wsarecvfrom(handle->socket,
304 (struct sockaddr*) &handle->recv_from,
305 &handle->recv_from_len,
311 handle->flags |= UV_HANDLE_READ_PENDING;
313 handle->reqs_pending++;
317 handle->flags |= UV_HANDLE_READ_PENDING;
318 handle->reqs_pending++;
323 handle->reqs_pending++;
327 handle->flags |= UV_HANDLE_ZERO_READ;
333 result = handle->func_wsarecv(handle->socket,
343 handle->flags |= UV_HANDLE_READ_PENDING;
345 handle->reqs_pending++;
349 handle->flags |= UV_HANDLE_READ_PENDING;
350 handle->reqs_pending++;
355 handle->reqs_pending++;
361 int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb,
363 uv_loop_t* loop = handle->loop;
366 if (handle->flags & UV_HANDLE_READING) {
370 err = uv__udp_maybe_bind(handle,
377 handle->flags |= UV_HANDLE_READING;
378 INCREASE_ACTIVE_COUNT(loop, handle);
381 handle->recv_cb = recv_cb;
382 handle->alloc_cb = alloc_cb;
386 if (!(handle->flags & UV_HANDLE_READ_PENDING))
387 uv__udp_queue_recv(loop, handle);
393 int uv__udp_recv_stop(uv_udp_t* handle) {
394 if (handle->flags & UV_HANDLE_READING) {
395 handle->flags &= ~UV_HANDLE_READING;
396 handle->loop->active_udp_streams--;
397 DECREASE_ACTIVE_COUNT(loop, handle);
405 uv_udp_t* handle,
411 uv_loop_t* loop = handle->loop;
415 req->handle = handle;
419 result = WSASendTo(handle->socket,
432 handle->reqs_pending++;
433 handle->send_queue_size += req->u.io.queued_bytes;
434 handle->send_queue_count++;
435 REGISTER_HANDLE_REQ(loop, handle, req);
440 handle->reqs_pending++;
441 handle->send_queue_size += req->u.io.queued_bytes;
442 handle->send_queue_count++;
443 REGISTER_HANDLE_REQ(loop, handle, req);
453 void uv__process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle,
458 assert(handle->type == UV_UDP);
460 handle->flags &= ~UV_HANDLE_READ_PENDING;
472 if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
478 if (handle->flags & UV_HANDLE_READING) {
479 uv_udp_recv_stop(handle);
480 buf = (handle->flags & UV_HANDLE_ZERO_READ) ?
481 uv_buf_init(NULL, 0) : handle->recv_buffer;
482 handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);
488 if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
491 handle->recv_cb(handle,
493 &handle->recv_buffer,
494 (const struct sockaddr*) &handle->recv_from,
496 } else if (handle->flags & UV_HANDLE_READING) {
504 handle->alloc_cb((uv_handle_t*) handle, UV__UDP_DGRAM_MAXSIZE, &buf);
506 handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0);
516 if (WSARecvFrom(handle->socket,
527 handle->recv_cb(handle, bytes, &buf, (const struct sockaddr*) &from, 0);
532 handle->recv_cb(handle,
539 handle->recv_cb(handle, 0, &buf, NULL, 0);
544 handle->recv_cb(handle, 0, &buf, NULL, 0);
547 uv_udp_recv_stop(handle);
548 handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);
555 if ((handle->flags & UV_HANDLE_READING) &&
556 !(handle->flags & UV_HANDLE_READ_PENDING)) {
557 uv__udp_queue_recv(loop, handle);
560 DECREASE_PENDING_REQ_COUNT(handle);
564 void uv__process_udp_send_req(uv_loop_t* loop, uv_udp_t* handle,
568 assert(handle->type == UV_UDP);
570 assert(handle->send_queue_size >= req->u.io.queued_bytes);
571 assert(handle->send_queue_count >= 1);
572 handle->send_queue_size -= req->u.io.queued_bytes;
573 handle->send_queue_count--;
575 UNREGISTER_HANDLE_REQ(loop, handle, req);
585 DECREASE_PENDING_REQ_COUNT(handle);
589 static int uv__udp_set_membership4(uv_udp_t* handle,
597 if (handle->flags & UV_HANDLE_IPV6)
601 err = uv__udp_maybe_bind(handle,
631 if (setsockopt(handle->socket,
643 int uv__udp_set_membership6(uv_udp_t* handle,
652 if ((handle->flags & UV_HANDLE_BOUND) && !(handle->flags & UV_HANDLE_IPV6))
655 err = uv__udp_maybe_bind(handle,
686 if (setsockopt(handle->socket,
698 static int uv__udp_set_source_membership4(uv_udp_t* handle,
707 if (handle->flags & UV_HANDLE_IPV6)
711 err = uv__udp_maybe_bind(handle,
738 if (setsockopt(handle->socket,
750 int uv__udp_set_source_membership6(uv_udp_t* handle,
763 if ((handle->flags & UV_HANDLE_BOUND) && !(handle->flags & UV_HANDLE_IPV6))
766 err = uv__udp_maybe_bind(handle,
795 if (setsockopt(handle->socket,
807 int uv_udp_set_membership(uv_udp_t* handle,
815 return uv__udp_set_membership4(handle, &addr4, interface_addr, membership);
817 return uv__udp_set_membership6(handle, &addr6, interface_addr, membership);
823 int uv_udp_set_source_membership(uv_udp_t* handle,
849 return uv__udp_set_source_membership6(handle,
859 return uv__udp_set_source_membership4(handle,
867 int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) {
877 if (handle->flags & UV_HANDLE_IPV6) {
892 if (handle->socket == INVALID_SOCKET)
896 if (setsockopt(handle->socket,
904 if (setsockopt(handle->socket,
920 int uv_udp_set_broadcast(uv_udp_t* handle, int value) {
923 if (handle->socket == INVALID_SOCKET)
926 if (setsockopt(handle->socket,
938 int uv__udp_is_bound(uv_udp_t* handle) {
943 if (uv_udp_getsockname(handle, (struct sockaddr*) &addr, &addrlen) != 0)
950 int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) {
965 err = uv__udp_set_socket(handle->loop,
966 handle,
972 if (uv__udp_is_bound(handle))
973 handle->flags |= UV_HANDLE_BOUND;
975 if (uv__udp_is_connected(handle))
976 handle->flags |= UV_HANDLE_UDP_CONNECTED;
983 int uv_udp_set_##name(uv_udp_t* handle, int value) { \
990 if (handle->socket == INVALID_SOCKET) \
993 if (!(handle->flags & UV_HANDLE_IPV6)) { \
995 if (setsockopt(handle->socket, \
1004 if (setsockopt(handle->socket, \
1041 int uv__udp_bind(uv_udp_t* handle,
1047 err = uv__udp_maybe_bind(handle, addr, addrlen, flags);
1055 int uv__udp_connect(uv_udp_t* handle,
1061 if (!(handle->flags & UV_HANDLE_BOUND)) {
1069 err = uv__udp_maybe_bind(handle, bind_addr, addrlen, 0);
1074 err = connect(handle->socket, addr, addrlen);
1078 handle->flags |= UV_HANDLE_UDP_CONNECTED;
1084 int uv__udp_disconnect(uv_udp_t* handle) {
1090 err = connect(handle->socket, (struct sockaddr*) &addr, sizeof(addr));
1094 handle->flags &= ~UV_HANDLE_UDP_CONNECTED;
1103 uv_udp_t* handle,
1112 if (!(handle->flags & UV_HANDLE_BOUND)) {
1120 err = uv__udp_maybe_bind(handle, bind_addr, addrlen, 0);
1125 err = uv__send(req, handle, bufs, nbufs, addr, addrlen, send_cb);
1133 int uv__udp_try_send(uv_udp_t* handle,
1153 if (handle->send_queue_count != 0)
1156 if (!(handle->flags & UV_HANDLE_BOUND)) {
1163 err = uv__udp_maybe_bind(handle, bind_addr, addrlen, 0);
1168 err = WSASendTo(handle->socket,