Lines Matching refs:handle
49 static void uv__udp_run_completed(uv_udp_t* handle);
51 static void uv__udp_recvmsg(uv_udp_t* handle);
52 static void uv__udp_sendmsg(uv_udp_t* handle);
53 static int uv__udp_maybe_deferred_bind(uv_udp_t* handle,
61 static int uv__udp_recvmmsg(uv_udp_t* handle, uv_buf_t* buf);
62 static void uv__udp_sendmmsg(uv_udp_t* handle);
88 void uv__udp_close(uv_udp_t* handle) {
89 uv__io_close(handle->loop, &handle->io_watcher);
90 uv__handle_stop(handle);
92 if (handle->io_watcher.fd != -1) {
93 uv__close(handle->io_watcher.fd);
94 handle->io_watcher.fd = -1;
99 void uv__udp_finish_close(uv_udp_t* handle) {
103 assert(!uv__io_active(&handle->io_watcher, POLLIN | POLLOUT));
104 assert(handle->io_watcher.fd == -1);
106 while (!QUEUE_EMPTY(&handle->write_queue)) {
107 q = QUEUE_HEAD(&handle->write_queue);
112 QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
115 uv__udp_run_completed(handle);
117 assert(handle->send_queue_size == 0);
118 assert(handle->send_queue_count == 0);
120 /* Now tear down the handle. */
121 handle->recv_cb = NULL;
122 handle->alloc_cb = NULL;
127 static void uv__udp_run_completed(uv_udp_t* handle) {
131 assert(!(handle->flags & UV_HANDLE_UDP_PROCESSING));
132 handle->flags |= UV_HANDLE_UDP_PROCESSING;
134 while (!QUEUE_EMPTY(&handle->write_completed_queue)) {
135 q = QUEUE_HEAD(&handle->write_completed_queue);
139 uv__req_unregister(handle->loop, req);
141 handle->send_queue_size -= uv__count_bufs(req->bufs, req->nbufs);
142 handle->send_queue_count--;
160 if (QUEUE_EMPTY(&handle->write_queue)) {
162 uv__io_stop(handle->loop, &handle->io_watcher, POLLOUT);
163 if (!uv__io_active(&handle->io_watcher, POLLIN))
164 uv__handle_stop(handle);
167 handle->flags &= ~UV_HANDLE_UDP_PROCESSING;
172 uv_udp_t* handle;
174 handle = container_of(w, uv_udp_t, io_watcher);
175 assert(handle->type == UV_UDP);
178 uv__udp_recvmsg(handle);
181 uv__udp_sendmsg(handle);
182 uv__udp_run_completed(handle);
187 static int uv__udp_recvmmsg(uv_udp_t* handle, uv_buf_t* buf) {
215 nread = uv__recvmmsg(handle->io_watcher.fd, msgs, chunks);
220 handle->recv_cb(handle, 0, buf, NULL, 0);
222 handle->recv_cb(handle, UV__ERR(errno), buf, NULL, 0);
225 for (k = 0; k < (size_t) nread && handle->recv_cb != NULL; k++) {
231 handle->recv_cb(handle,
239 if (handle->recv_cb != NULL)
240 handle->recv_cb(handle, 0, buf, NULL, UV_UDP_MMSG_FREE);
246 static void uv__udp_recvmsg(uv_udp_t* handle) {
254 assert(handle->recv_cb != NULL);
255 assert(handle->alloc_cb != NULL);
264 handle->alloc_cb((uv_handle_t*) handle, UV__UDP_DGRAM_MAXSIZE, &buf);
266 handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0);
272 if (uv_udp_using_recvmmsg(handle)) {
273 nread = uv__udp_recvmmsg(handle, &buf);
288 nread = recvmsg(handle->io_watcher.fd, &h, 0);
294 handle->recv_cb(handle, 0, &buf, NULL, 0);
296 handle->recv_cb(handle, UV__ERR(errno), &buf, NULL, 0);
303 handle->recv_cb(handle, nread, &buf, (const struct sockaddr*) &peer, flags);
307 /* recv_cb callback may decide to pause or close the handle */
310 && handle->io_watcher.fd != -1
311 && handle->recv_cb != NULL);
315 static void uv__udp_sendmmsg(uv_udp_t* handle) {
324 if (QUEUE_EMPTY(&handle->write_queue))
328 for (pkts = 0, q = QUEUE_HEAD(&handle->write_queue);
329 pkts < UV__MMSG_MAXWIDTH && q != &handle->write_queue;
358 npkts = uv__sendmmsg(handle->io_watcher.fd, h, pkts);
364 for (i = 0, q = QUEUE_HEAD(&handle->write_queue);
365 i < pkts && q != &handle->write_queue;
366 ++i, q = QUEUE_HEAD(&handle->write_queue)) {
373 QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
375 uv__io_feed(handle->loop, &handle->io_watcher);
382 for (i = 0, q = QUEUE_HEAD(&handle->write_queue);
383 i < (size_t)npkts && q != &handle->write_queue;
384 ++i, q = QUEUE_HEAD(&handle->write_queue)) {
393 * why we don't handle partial writes. Just pop the request
397 QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
401 if (!QUEUE_EMPTY(&handle->write_queue))
403 uv__io_feed(handle->loop, &handle->io_watcher);
408 static void uv__udp_sendmsg(uv_udp_t* handle) {
417 uv__udp_sendmmsg(handle);
422 while (!QUEUE_EMPTY(&handle->write_queue)) {
423 q = QUEUE_HEAD(&handle->write_queue);
450 size = sendmsg(handle->io_watcher.fd, &h, 0);
462 * why we don't handle partial writes. Just pop the request
466 QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
467 uv__io_feed(handle->loop, &handle->io_watcher);
532 int uv__udp_bind(uv_udp_t* handle,
548 fd = handle->io_watcher.fd;
554 handle->io_watcher.fd = fd;
592 handle->flags |= UV_HANDLE_IPV6;
594 handle->flags |= UV_HANDLE_BOUND;
599 static int uv__udp_maybe_deferred_bind(uv_udp_t* handle,
605 if (handle->io_watcher.fd != -1)
632 return uv__udp_bind(handle, &taddr.addr, addrlen, flags);
636 int uv__udp_connect(uv_udp_t* handle,
641 err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);
647 err = connect(handle->io_watcher.fd, addr, addrlen);
653 handle->flags |= UV_HANDLE_UDP_CONNECTED;
689 int uv__udp_disconnect(uv_udp_t* handle) {
713 r = connect(handle->io_watcher.fd, (struct sockaddr*) NULL, 0);
715 r = connect(handle->io_watcher.fd, (struct sockaddr*) &addr, sizeof(addr));
728 handle->flags &= ~UV_HANDLE_UDP_CONNECTED;
733 uv_udp_t* handle,
745 err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);
754 empty_queue = (handle->send_queue_count == 0);
756 uv__req_init(handle->loop, req, UV_UDP_SEND);
763 req->handle = handle;
771 uv__req_unregister(handle->loop, req);
776 handle->send_queue_size += uv__count_bufs(req->bufs, req->nbufs);
777 handle->send_queue_count++;
778 QUEUE_INSERT_TAIL(&handle->write_queue, &req->queue);
779 uv__handle_start(handle);
781 if (empty_queue && !(handle->flags & UV_HANDLE_UDP_PROCESSING)) {
782 uv__udp_sendmsg(handle);
788 if (!QUEUE_EMPTY(&handle->write_queue))
789 uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
791 uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
798 int uv__udp_try_send(uv_udp_t* handle,
810 if (handle->send_queue_count != 0)
814 err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);
818 assert(handle->flags & UV_HANDLE_UDP_CONNECTED);
828 size = sendmsg(handle->io_watcher.fd, &h, 0);
842 static int uv__udp_set_membership4(uv_udp_t* handle,
873 if (setsockopt(handle->io_watcher.fd,
889 static int uv__udp_set_membership6(uv_udp_t* handle,
920 if (setsockopt(handle->io_watcher.fd,
942 static int uv__udp_set_source_membership4(uv_udp_t* handle,
951 err = uv__udp_maybe_deferred_bind(handle, AF_INET, UV_UDP_REUSEADDR);
975 if (setsockopt(handle->io_watcher.fd,
987 static int uv__udp_set_source_membership6(uv_udp_t* handle,
997 err = uv__udp_maybe_deferred_bind(handle, AF_INET6, UV_UDP_REUSEADDR);
1024 if (setsockopt(handle->io_watcher.fd,
1038 uv_udp_t* handle,
1050 uv__handle_init(loop, (uv_handle_t*)handle, UV_UDP);
1051 handle->alloc_cb = NULL;
1052 handle->recv_cb = NULL;
1053 handle->send_queue_size = 0;
1054 handle->send_queue_count = 0;
1055 uv__io_init(&handle->io_watcher, uv__udp_io, fd);
1056 QUEUE_INIT(&handle->write_queue);
1057 QUEUE_INIT(&handle->write_completed_queue);
1063 int uv_udp_using_recvmmsg(const uv_udp_t* handle) {
1065 if (handle->flags & UV_HANDLE_UDP_RECVMMSG) {
1074 int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) {
1078 if (handle->io_watcher.fd != -1)
1081 if (uv__fd_exists(handle->loop, sock))
1092 handle->io_watcher.fd = sock;
1093 if (uv__udp_is_connected(handle))
1094 handle->flags |= UV_HANDLE_UDP_CONNECTED;
1100 int uv_udp_set_membership(uv_udp_t* handle,
1109 err = uv__udp_maybe_deferred_bind(handle, AF_INET, UV_UDP_REUSEADDR);
1112 return uv__udp_set_membership4(handle, &addr4, interface_addr, membership);
1114 err = uv__udp_maybe_deferred_bind(handle, AF_INET6, UV_UDP_REUSEADDR);
1117 return uv__udp_set_membership6(handle, &addr6, interface_addr, membership);
1124 int uv_udp_set_source_membership(uv_udp_t* handle,
1147 return uv__udp_set_source_membership6(handle,
1157 return uv__udp_set_source_membership4(handle,
1168 static int uv__setsockopt(uv_udp_t* handle,
1175 if (handle->flags & UV_HANDLE_IPV6)
1176 r = setsockopt(handle->io_watcher.fd,
1182 r = setsockopt(handle->io_watcher.fd,
1193 static int uv__setsockopt_maybe_char(uv_udp_t* handle,
1208 return uv__setsockopt(handle, option4, option6, &arg, sizeof(arg));
1212 int uv_udp_set_broadcast(uv_udp_t* handle, int on) {
1213 if (setsockopt(handle->io_watcher.fd,
1225 int uv_udp_set_ttl(uv_udp_t* handle, int ttl) {
1230 if (!(handle->flags & UV_HANDLE_IPV6))
1243 return uv__setsockopt(handle,
1252 return uv__setsockopt_maybe_char(handle,
1262 int uv_udp_set_multicast_ttl(uv_udp_t* handle, int ttl) {
1271 if (handle->flags & UV_HANDLE_IPV6)
1272 return uv__setsockopt(handle,
1280 return uv__setsockopt_maybe_char(handle,
1287 int uv_udp_set_multicast_loop(uv_udp_t* handle, int on) {
1296 if (handle->flags & UV_HANDLE_IPV6)
1297 return uv__setsockopt(handle,
1305 return uv__setsockopt_maybe_char(handle,
1311 int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) {
1321 if (handle->flags & UV_HANDLE_IPV6) {
1337 if (setsockopt(handle->io_watcher.fd,
1345 if (setsockopt(handle->io_watcher.fd,
1360 int uv_udp_getpeername(const uv_udp_t* handle,
1364 return uv__getsockpeername((const uv_handle_t*) handle,
1370 int uv_udp_getsockname(const uv_udp_t* handle,
1374 return uv__getsockpeername((const uv_handle_t*) handle,
1381 int uv__udp_recv_start(uv_udp_t* handle,
1389 if (uv__io_active(&handle->io_watcher, POLLIN))
1392 err = uv__udp_maybe_deferred_bind(handle, AF_INET, 0);
1396 handle->alloc_cb = alloc_cb;
1397 handle->recv_cb = recv_cb;
1399 uv__io_start(handle->loop, &handle->io_watcher, POLLIN);
1400 uv__handle_start(handle);
1406 int uv__udp_recv_stop(uv_udp_t* handle) {
1407 uv__io_stop(handle->loop, &handle->io_watcher, POLLIN);
1409 if (!uv__io_active(&handle->io_watcher, POLLOUT))
1410 uv__handle_stop(handle);
1412 handle->alloc_cb = NULL;
1413 handle->recv_cb = NULL;