2 * Copyright (C) 2004-2008 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1998-2003 Internet Software Consortium.
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
18 /* $Id: socket.c,v 1.237.18.56.2.1 2008/12/23 00:14:34 marka Exp $ */
24 #include <sys/param.h>
25 #include <sys/types.h>
26 #include <sys/socket.h>
38 #include <isc/buffer.h>
39 #include <isc/bufferlist.h>
40 #include <isc/condition.h>
41 #include <isc/formatcheck.h>
46 #include <isc/mutex.h>
49 #include <isc/platform.h>
50 #include <isc/print.h>
51 #include <isc/region.h>
52 #include <isc/socket.h>
53 #include <isc/strerror.h>
55 #include <isc/thread.h>
58 #ifdef ISC_PLATFORM_HAVESYSUNH
61 #ifdef ISC_PLATFORM_HAVEKQUEUE
62 #include <sys/event.h>
64 #ifdef ISC_PLATFORM_HAVEEPOLL
65 #include <sys/epoll.h>
67 #ifdef ISC_PLATFORM_HAVEDEVPOLL
68 #include <sys/devpoll.h>
71 #include "errno2result.h"
73 #ifndef ISC_PLATFORM_USETHREADS
75 #endif /* ISC_PLATFORM_USETHREADS */
78 * Choose the most preferable multiplex method.
80 #ifdef ISC_PLATFORM_HAVEKQUEUE
82 #elif defined (ISC_PLATFORM_HAVEEPOLL)
84 #elif defined (ISC_PLATFORM_HAVEDEVPOLL)
87 unsigned int want_read : 1,
92 #endif /* ISC_PLATFORM_HAVEKQUEUE */
94 #ifndef ISC_PLATFORM_USETHREADS
95 #if defined(USE_KQUEUE) || defined(USE_EPOLL) || defined(USE_DEVPOLL)
96 struct isc_socketwait {
99 #elif defined (USE_SELECT)
100 struct isc_socketwait {
106 #endif /* USE_KQUEUE */
107 #endif /* !ISC_PLATFORM_USETHREADS */
110 * Maximum number of allowable open sockets. This is also the maximum
111 * allowable socket file descriptor.
113 * Care should be taken before modifying this value for select():
114 * The API standard doesn't ensure select() accept more than (the system default
115 * of) FD_SETSIZE descriptors, and the default size should in fact be fine in
116 * the vast majority of cases. This constant should therefore be increased only
117 * when absolutely necessary and possible, i.e., the server is exhausting all
118 * available file descriptors (up to FD_SETSIZE) and the select() function
119 * and FD_xxx macros support larger values than FD_SETSIZE (which may not
120 * always by true, but we keep using some of them to ensure as much
121 * portability as possible). Note also that overall server performance
122 * may be rather worsened with a larger value of this constant due to
123 * inherent scalability problems of select().
125 * As a special note, this value shouldn't have to be touched if
126 * this is a build for an authoritative only DNS server.
128 #ifndef ISC_SOCKET_MAXSOCKETS
129 #if defined(USE_KQUEUE) || defined(USE_EPOLL) || defined(USE_DEVPOLL)
130 #define ISC_SOCKET_MAXSOCKETS 4096
131 #elif defined(USE_SELECT)
132 #define ISC_SOCKET_MAXSOCKETS FD_SETSIZE
133 #endif /* USE_KQUEUE... */
134 #endif /* ISC_SOCKET_MAXSOCKETS */
138 * Mac OS X needs a special definition to support larger values in select().
139 * We always define this because a larger value can be specified run-time.
142 #define _DARWIN_UNLIMITED_SELECT
143 #endif /* __APPLE__ */
144 #endif /* USE_SELECT */
146 #ifdef ISC_SOCKET_USE_POLLWATCH
148 * If this macro is defined, enable workaround for a Solaris /dev/poll kernel
149 * bug: DP_POLL ioctl could keep sleeping even if socket I/O is possible for
150 * some of the specified FD. The idea is based on the observation that it's
151 * likely for a busy server to keep receiving packets. It specifically works
152 * as follows: the socket watcher is first initialized with the state of
153 * "poll_idle". While it's in the idle state it keeps sleeping until a socket
154 * event occurs. When it wakes up for a socket I/O event, it moves to the
155 * poll_active state, and sets the poll timeout to a short period
156 * (ISC_SOCKET_POLLWATCH_TIMEOUT msec). If timeout occurs in this state, the
157 * watcher goes to the poll_checking state with the same timeout period.
158 * In this state, the watcher tries to detect whether this is a break
159 * during intermittent events or the kernel bug is triggered. If the next
160 * polling reports an event within the short period, the previous timeout is
161 * likely to be a kernel bug, and so the watcher goes back to the active state.
162 * Otherwise, it moves to the idle state again.
164 * It's not clear whether this is a thread-related bug, but since we've only
165 * seen this with threads, this workaround is used only when enabling threads.
168 typedef enum { poll_idle, poll_active, poll_checking } pollstate_t;
170 #ifndef ISC_SOCKET_POLLWATCH_TIMEOUT
171 #define ISC_SOCKET_POLLWATCH_TIMEOUT 10
172 #endif /* ISC_SOCKET_POLLWATCH_TIMEOUT */
173 #endif /* ISC_SOCKET_USE_POLLWATCH */
176 * Size of per-FD lock buckets.
178 #ifdef ISC_PLATFORM_USETHREADS
179 #define FDLOCK_COUNT 1024
180 #define FDLOCK_ID(fd) ((fd) % FDLOCK_COUNT)
182 #define FDLOCK_COUNT 1
183 #define FDLOCK_ID(fd) 0
184 #endif /* ISC_PLATFORM_USETHREADS */
187 * Maximum number of events communicated with the kernel. There should normally
188 * be no need for having a large number.
190 #if defined(USE_KQUEUE) || defined(USE_EPOLL) || defined(USE_DEVPOLL)
191 #ifndef ISC_SOCKET_MAXEVENTS
192 #define ISC_SOCKET_MAXEVENTS 64
197 * Some systems define the socket length argument as an int, some as size_t,
198 * some as socklen_t. This is here so it can be easily changed if needed.
200 #ifndef ISC_SOCKADDR_LEN_T
201 #define ISC_SOCKADDR_LEN_T unsigned int
205 #if defined(SO_BSDCOMPAT) && defined(__linux__)
206 #include <sys/utsname.h>
210 * Define what the possible "soft" errors can be. These are non-fatal returns
211 * of various network related functions, like recv() and so on.
213 * For some reason, BSDI (and perhaps others) will sometimes return <0
214 * from recv() but will have errno==0. This is broken, but we have to
215 * work around it here.
217 #define SOFT_ERROR(e) ((e) == EAGAIN || \
218 (e) == EWOULDBLOCK || \
222 #define DLVL(x) ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_SOCKET, ISC_LOG_DEBUG(x)
225 * DLVL(90) -- Function entry/exit and other tracing.
226 * DLVL(70) -- Socket "correctness" -- including returning of events, etc.
227 * DLVL(60) -- Socket data send/receive
228 * DLVL(50) -- Event tracing, including receiving/sending completion events.
229 * DLVL(20) -- Socket creation/destruction.
231 #define TRACE_LEVEL 90
232 #define CORRECTNESS_LEVEL 70
233 #define IOEVENT_LEVEL 60
234 #define EVENT_LEVEL 50
235 #define CREATION_LEVEL 20
237 #define TRACE DLVL(TRACE_LEVEL)
238 #define CORRECTNESS DLVL(CORRECTNESS_LEVEL)
239 #define IOEVENT DLVL(IOEVENT_LEVEL)
240 #define EVENT DLVL(EVENT_LEVEL)
241 #define CREATION DLVL(CREATION_LEVEL)
243 typedef isc_event_t intev_t;
245 #define SOCKET_MAGIC ISC_MAGIC('I', 'O', 'i', 'o')
246 #define VALID_SOCKET(t) ISC_MAGIC_VALID(t, SOCKET_MAGIC)
249 * IPv6 control information. If the socket is an IPv6 socket we want
250 * to collect the destination address and interface so the client can
251 * set them on outgoing packets.
253 #ifdef ISC_PLATFORM_HAVEIN6PKTINFO
260 * NetBSD and FreeBSD can timestamp packets. XXXMLG Should we have
261 * a setsockopt() like interface to request timestamps, and if the OS
262 * doesn't do it for us, call gettimeofday() on every UDP receive?
271 * The size to raise the recieve buffer to (from BIND 8).
273 #define RCVBUFSIZE (32*1024)
276 * The number of times a send operation is repeated if the result is EINTR.
283 isc_socketmgr_t *manager;
285 isc_sockettype_t type;
287 /* Locked by socket lock. */
288 ISC_LINK(isc_socket_t) link;
289 unsigned int references;
293 ISC_LIST(isc_socketevent_t) send_list;
294 ISC_LIST(isc_socketevent_t) recv_list;
295 ISC_LIST(isc_socket_newconnev_t) accept_list;
296 isc_socket_connev_t *connect_ev;
299 * Internal events. Posted when a descriptor is readable or
300 * writable. These are statically allocated and never freed.
301 * They will be set to non-purgable before use.
306 isc_sockaddr_t address; /* remote address */
308 unsigned int pending_recv : 1,
311 listener : 1, /* listener socket */
313 connecting : 1, /* connect pending */
314 bound : 1; /* bound to local addr */
316 #ifdef ISC_NET_RECVOVERFLOW
317 unsigned char overflow; /* used for MSG_TRUNC fake */
321 ISC_SOCKADDR_LEN_T recvcmsgbuflen;
323 ISC_SOCKADDR_LEN_T sendcmsgbuflen;
326 #define SOCKET_MANAGER_MAGIC ISC_MAGIC('I', 'O', 'm', 'g')
327 #define VALID_MANAGER(m) ISC_MAGIC_VALID(m, SOCKET_MANAGER_MAGIC)
329 struct isc_socketmgr {
338 struct kevent *events;
339 #endif /* USE_KQUEUE */
343 struct epoll_event *events;
344 #endif /* USE_EPOLL */
348 struct pollfd *events;
349 #endif /* USE_DEVPOLL */
352 #endif /* USE_SELECT */
353 unsigned int maxsocks;
354 #ifdef ISC_PLATFORM_USETHREADS
358 /* Locked by fdlock. */
362 pollinfo_t *fdpollinfo;
365 /* Locked by manager lock. */
366 ISC_LIST(isc_socket_t) socklist;
369 fd_set *read_fds_copy;
371 fd_set *write_fds_copy;
373 #endif /* USE_SELECT */
374 int reserved; /* unlocked */
375 #ifdef ISC_PLATFORM_USETHREADS
376 isc_thread_t watcher;
377 isc_condition_t shutdown_ok;
378 #else /* ISC_PLATFORM_USETHREADS */
380 #endif /* ISC_PLATFORM_USETHREADS */
383 #ifndef ISC_PLATFORM_USETHREADS
384 static isc_socketmgr_t *socketmgr = NULL;
385 #endif /* ISC_PLATFORM_USETHREADS */
387 #define CLOSED 0 /* this one must be zero */
389 #define CLOSE_PENDING 2
392 * send() and recv() iovec counts
394 #define MAXSCATTERGATHER_SEND (ISC_SOCKET_MAXSCATTERGATHER)
395 #ifdef ISC_NET_RECVOVERFLOW
396 # define MAXSCATTERGATHER_RECV (ISC_SOCKET_MAXSCATTERGATHER + 1)
398 # define MAXSCATTERGATHER_RECV (ISC_SOCKET_MAXSCATTERGATHER)
401 static void send_recvdone_event(isc_socket_t *, isc_socketevent_t **);
402 static void send_senddone_event(isc_socket_t *, isc_socketevent_t **);
403 static void free_socket(isc_socket_t **);
404 static isc_result_t allocate_socket(isc_socketmgr_t *, isc_sockettype_t,
406 static void destroy(isc_socket_t **);
407 static void internal_accept(isc_task_t *, isc_event_t *);
408 static void internal_connect(isc_task_t *, isc_event_t *);
409 static void internal_recv(isc_task_t *, isc_event_t *);
410 static void internal_send(isc_task_t *, isc_event_t *);
411 static void process_cmsg(isc_socket_t *, struct msghdr *, isc_socketevent_t *);
412 static void build_msghdr_send(isc_socket_t *, isc_socketevent_t *,
413 struct msghdr *, struct iovec *, size_t *);
414 static void build_msghdr_recv(isc_socket_t *, isc_socketevent_t *,
415 struct msghdr *, struct iovec *, size_t *);
416 #ifdef ISC_PLATFORM_USETHREADS
417 static isc_boolean_t process_ctlfd(isc_socketmgr_t *manager);
420 #define SELECT_POKE_SHUTDOWN (-1)
421 #define SELECT_POKE_NOTHING (-2)
422 #define SELECT_POKE_READ (-3)
423 #define SELECT_POKE_ACCEPT (-3) /*%< Same as _READ */
424 #define SELECT_POKE_WRITE (-4)
425 #define SELECT_POKE_CONNECT (-4) /*%< Same as _WRITE */
426 #define SELECT_POKE_CLOSE (-5)
428 #define SOCK_DEAD(s) ((s)->references == 0)
431 manager_log(isc_socketmgr_t *sockmgr,
432 isc_logcategory_t *category, isc_logmodule_t *module, int level,
433 const char *fmt, ...) ISC_FORMAT_PRINTF(5, 6);
435 manager_log(isc_socketmgr_t *sockmgr,
436 isc_logcategory_t *category, isc_logmodule_t *module, int level,
437 const char *fmt, ...)
442 if (! isc_log_wouldlog(isc_lctx, level))
446 vsnprintf(msgbuf, sizeof(msgbuf), fmt, ap);
449 isc_log_write(isc_lctx, category, module, level,
450 "sockmgr %p: %s", sockmgr, msgbuf);
454 socket_log(isc_socket_t *sock, isc_sockaddr_t *address,
455 isc_logcategory_t *category, isc_logmodule_t *module, int level,
456 isc_msgcat_t *msgcat, int msgset, int message,
457 const char *fmt, ...) ISC_FORMAT_PRINTF(9, 10);
459 socket_log(isc_socket_t *sock, isc_sockaddr_t *address,
460 isc_logcategory_t *category, isc_logmodule_t *module, int level,
461 isc_msgcat_t *msgcat, int msgset, int message,
462 const char *fmt, ...)
465 char peerbuf[ISC_SOCKADDR_FORMATSIZE];
468 if (! isc_log_wouldlog(isc_lctx, level))
472 vsnprintf(msgbuf, sizeof(msgbuf), fmt, ap);
475 if (address == NULL) {
476 isc_log_iwrite(isc_lctx, category, module, level,
477 msgcat, msgset, message,
478 "socket %p: %s", sock, msgbuf);
480 isc_sockaddr_format(address, peerbuf, sizeof(peerbuf));
481 isc_log_iwrite(isc_lctx, category, module, level,
482 msgcat, msgset, message,
483 "socket %p %s: %s", sock, peerbuf, msgbuf);
487 #if defined(_AIX) && defined(ISC_NET_BSD44MSGHDR) && \
488 defined(USE_CMSG) && defined(IPV6_RECVPKTINFO)
490 * AIX has a kernel bug where IPV6_RECVPKTINFO gets cleared by
491 * setting IPV6_V6ONLY.
494 FIX_IPV6_RECVPKTINFO(isc_socket_t *sock)
496 char strbuf[ISC_STRERRORSIZE];
499 if (sock->pf != AF_INET6 || sock->type != isc_sockettype_udp)
502 if (setsockopt(sock->fd, IPPROTO_IPV6, IPV6_RECVPKTINFO,
503 (void *)&on, sizeof(on)) < 0) {
505 UNEXPECTED_ERROR(__FILE__, __LINE__,
506 "setsockopt(%d, IPV6_RECVPKTINFO) "
508 isc_msgcat_get(isc_msgcat,
516 #define FIX_IPV6_RECVPKTINFO(sock) (void)0
519 static inline isc_result_t
520 watch_fd(isc_socketmgr_t *manager, int fd, int msg) {
521 isc_result_t result = ISC_R_SUCCESS;
524 struct kevent evchange;
526 memset(&evchange, 0, sizeof(evchange));
527 if (msg == SELECT_POKE_READ)
528 evchange.filter = EVFILT_READ;
530 evchange.filter = EVFILT_WRITE;
531 evchange.flags = EV_ADD;
533 if (kevent(manager->kqueue_fd, &evchange, 1, NULL, 0, NULL) != 0)
534 result = isc__errno2result(errno);
537 #elif defined(USE_EPOLL)
538 struct epoll_event event;
540 if (msg == SELECT_POKE_READ)
541 event.events = EPOLLIN;
543 event.events = EPOLLOUT;
545 if (epoll_ctl(manager->epoll_fd, EPOLL_CTL_ADD, fd, &event) == -1 &&
547 result = isc__errno2result(errno);
551 #elif defined(USE_DEVPOLL)
553 int lockid = FDLOCK_ID(fd);
555 memset(&pfd, 0, sizeof(pfd));
556 if (msg == SELECT_POKE_READ)
559 pfd.events = POLLOUT;
562 LOCK(&manager->fdlock[lockid]);
563 if (write(manager->devpoll_fd, &pfd, sizeof(pfd)) == -1)
564 result = isc__errno2result(errno);
566 if (msg == SELECT_POKE_READ)
567 manager->fdpollinfo[fd].want_read = 1;
569 manager->fdpollinfo[fd].want_write = 1;
571 UNLOCK(&manager->fdlock[lockid]);
574 #elif defined(USE_SELECT)
575 LOCK(&manager->lock);
576 if (msg == SELECT_POKE_READ)
577 FD_SET(fd, manager->read_fds);
578 if (msg == SELECT_POKE_WRITE)
579 FD_SET(fd, manager->write_fds);
580 UNLOCK(&manager->lock);
586 static inline isc_result_t
587 unwatch_fd(isc_socketmgr_t *manager, int fd, int msg) {
588 isc_result_t result = ISC_R_SUCCESS;
591 struct kevent evchange;
593 memset(&evchange, 0, sizeof(evchange));
594 if (msg == SELECT_POKE_READ)
595 evchange.filter = EVFILT_READ;
597 evchange.filter = EVFILT_WRITE;
598 evchange.flags = EV_DELETE;
600 if (kevent(manager->kqueue_fd, &evchange, 1, NULL, 0, NULL) != 0)
601 result = isc__errno2result(errno);
604 #elif defined(USE_EPOLL)
605 struct epoll_event event;
607 if (msg == SELECT_POKE_READ)
608 event.events = EPOLLIN;
610 event.events = EPOLLOUT;
612 if (epoll_ctl(manager->epoll_fd, EPOLL_CTL_DEL, fd, &event) == -1 &&
614 char strbuf[ISC_STRERRORSIZE];
615 isc__strerror(errno, strbuf, sizeof(strbuf));
616 UNEXPECTED_ERROR(__FILE__, __LINE__,
617 "epoll_ctl(DEL), %d: %s", fd, strbuf);
618 result = ISC_R_UNEXPECTED;
621 #elif defined(USE_DEVPOLL)
622 struct pollfd pfds[2];
623 size_t writelen = sizeof(pfds[0]);
624 int lockid = FDLOCK_ID(fd);
626 memset(pfds, 0, sizeof(pfds));
627 pfds[0].events = POLLREMOVE;
631 * Canceling read or write polling via /dev/poll is tricky. Since it
632 * only provides a way of canceling per FD, we may need to re-poll the
633 * socket for the other operation.
635 LOCK(&manager->fdlock[lockid]);
636 if (msg == SELECT_POKE_READ &&
637 manager->fdpollinfo[fd].want_write == 1) {
638 pfds[1].events = POLLOUT;
640 writelen += sizeof(pfds[1]);
642 if (msg == SELECT_POKE_WRITE &&
643 manager->fdpollinfo[fd].want_read == 1) {
644 pfds[1].events = POLLIN;
646 writelen += sizeof(pfds[1]);
649 if (write(manager->devpoll_fd, pfds, writelen) == -1)
650 result = isc__errno2result(errno);
652 if (msg == SELECT_POKE_READ)
653 manager->fdpollinfo[fd].want_read = 0;
655 manager->fdpollinfo[fd].want_write = 0;
657 UNLOCK(&manager->fdlock[lockid]);
660 #elif defined(USE_SELECT)
661 LOCK(&manager->lock);
662 if (msg == SELECT_POKE_READ)
663 FD_CLR(fd, manager->read_fds);
664 else if (msg == SELECT_POKE_WRITE)
665 FD_CLR(fd, manager->write_fds);
666 UNLOCK(&manager->lock);
673 wakeup_socket(isc_socketmgr_t *manager, int fd, int msg) {
675 int lockid = FDLOCK_ID(fd);
678 * This is a wakeup on a socket. If the socket is not in the
679 * process of being closed, start watching it for either reads
683 INSIST(fd >= 0 && fd < (int)manager->maxsocks);
685 if (msg == SELECT_POKE_CLOSE) {
686 /* No one should be updating fdstate, so no need to lock it */
687 INSIST(manager->fdstate[fd] == CLOSE_PENDING);
688 manager->fdstate[fd] = CLOSED;
689 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
690 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
695 LOCK(&manager->fdlock[lockid]);
696 if (manager->fdstate[fd] == CLOSE_PENDING) {
697 UNLOCK(&manager->fdlock[lockid]);
699 * We accept (and ignore) any error from unwatch_fd() as we are
700 * closing the socket, hoping it doesn't leave dangling state in
702 * Note that unwatch_fd() must be called after releasing the
703 * fdlock; otherwise it could cause deadlock due to a lock order
706 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
707 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
710 if (manager->fdstate[fd] != MANAGED) {
711 UNLOCK(&manager->fdlock[lockid]);
714 UNLOCK(&manager->fdlock[lockid]);
719 result = watch_fd(manager, fd, msg);
720 if (result != ISC_R_SUCCESS) {
722 * XXXJT: what should we do? Ignoring the failure of watching
723 * a socket will make the application dysfunctional, but there
724 * seems to be no reasonable recovery process.
726 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
727 ISC_LOGMODULE_SOCKET, ISC_LOG_ERROR,
728 "failed to start watching FD (%d): %s",
729 fd, isc_result_totext(result));
733 #ifdef ISC_PLATFORM_USETHREADS
735 * Poke the select loop when there is something for us to do.
736 * The write is required (by POSIX) to complete. That is, we
737 * will not get partial writes.
740 select_poke(isc_socketmgr_t *mgr, int fd, int msg) {
743 char strbuf[ISC_STRERRORSIZE];
749 cc = write(mgr->pipe_fds[1], buf, sizeof(buf));
752 * Treat ENOSR as EAGAIN but loop slowly as it is
753 * unlikely to clear fast.
755 if (cc < 0 && errno == ENOSR) {
760 } while (cc < 0 && SOFT_ERROR(errno));
763 isc__strerror(errno, strbuf, sizeof(strbuf));
764 FATAL_ERROR(__FILE__, __LINE__,
765 isc_msgcat_get(isc_msgcat, ISC_MSGSET_SOCKET,
768 "during watcher poke: %s"),
772 INSIST(cc == sizeof(buf));
776 * Read a message on the internal fd.
779 select_readmsg(isc_socketmgr_t *mgr, int *fd, int *msg) {
782 char strbuf[ISC_STRERRORSIZE];
784 cc = read(mgr->pipe_fds[0], buf, sizeof(buf));
786 *msg = SELECT_POKE_NOTHING;
787 *fd = -1; /* Silence compiler. */
788 if (SOFT_ERROR(errno))
791 isc__strerror(errno, strbuf, sizeof(strbuf));
792 FATAL_ERROR(__FILE__, __LINE__,
793 isc_msgcat_get(isc_msgcat, ISC_MSGSET_SOCKET,
796 "during watcher poke: %s"),
801 INSIST(cc == sizeof(buf));
806 #else /* ISC_PLATFORM_USETHREADS */
808 * Update the state of the socketmgr when something changes.
811 select_poke(isc_socketmgr_t *manager, int fd, int msg) {
812 if (msg == SELECT_POKE_SHUTDOWN)
815 wakeup_socket(manager, fd, msg);
818 #endif /* ISC_PLATFORM_USETHREADS */
821 * Make a fd non-blocking.
824 make_nonblock(int fd) {
827 char strbuf[ISC_STRERRORSIZE];
828 #ifdef USE_FIONBIO_IOCTL
831 ret = ioctl(fd, FIONBIO, (char *)&on);
833 flags = fcntl(fd, F_GETFL, 0);
834 flags |= PORT_NONBLOCK;
835 ret = fcntl(fd, F_SETFL, flags);
839 isc__strerror(errno, strbuf, sizeof(strbuf));
840 UNEXPECTED_ERROR(__FILE__, __LINE__,
841 #ifdef USE_FIONBIO_IOCTL
842 "ioctl(%d, FIONBIO, &on): %s", fd,
844 "fcntl(%d, F_SETFL, %d): %s", fd, flags,
848 return (ISC_R_UNEXPECTED);
851 return (ISC_R_SUCCESS);
856 * Not all OSes support advanced CMSG macros: CMSG_LEN and CMSG_SPACE.
857 * In order to ensure as much portability as possible, we provide wrapper
858 * functions of these macros.
859 * Note that cmsg_space() could run slow on OSes that do not have
862 static inline ISC_SOCKADDR_LEN_T
863 cmsg_len(ISC_SOCKADDR_LEN_T len) {
865 return (CMSG_LEN(len));
867 ISC_SOCKADDR_LEN_T hdrlen;
870 * Cast NULL so that any pointer arithmetic performed by CMSG_DATA
873 hdrlen = (ISC_SOCKADDR_LEN_T)CMSG_DATA(((struct cmsghdr *)NULL));
874 return (hdrlen + len);
878 static inline ISC_SOCKADDR_LEN_T
879 cmsg_space(ISC_SOCKADDR_LEN_T len) {
881 return (CMSG_SPACE(len));
884 struct cmsghdr *cmsgp;
886 * XXX: The buffer length is an ad-hoc value, but should be enough
887 * in a practical sense.
889 char dummybuf[sizeof(struct cmsghdr) + 1024];
891 memset(&msg, 0, sizeof(msg));
892 msg.msg_control = dummybuf;
893 msg.msg_controllen = sizeof(dummybuf);
895 cmsgp = (struct cmsghdr *)dummybuf;
896 cmsgp->cmsg_len = cmsg_len(len);
898 cmsgp = CMSG_NXTHDR(&msg, cmsgp);
900 return ((char *)cmsgp - (char *)msg.msg_control);
905 #endif /* USE_CMSG */
908 * Process control messages received on a socket.
911 process_cmsg(isc_socket_t *sock, struct msghdr *msg, isc_socketevent_t *dev) {
913 struct cmsghdr *cmsgp;
914 #ifdef ISC_PLATFORM_HAVEIN6PKTINFO
915 struct in6_pktinfo *pktinfop;
918 struct timeval *timevalp;
923 * sock is used only when ISC_NET_BSD44MSGHDR and USE_CMSG are defined.
924 * msg and dev are used only when ISC_NET_BSD44MSGHDR is defined.
925 * They are all here, outside of the CPP tests, because it is
926 * more consistent with the usual ISC coding style.
932 #ifdef ISC_NET_BSD44MSGHDR
935 if ((msg->msg_flags & MSG_TRUNC) == MSG_TRUNC)
936 dev->attributes |= ISC_SOCKEVENTATTR_TRUNC;
940 if ((msg->msg_flags & MSG_CTRUNC) == MSG_CTRUNC)
941 dev->attributes |= ISC_SOCKEVENTATTR_CTRUNC;
947 if (msg->msg_controllen == 0U || msg->msg_control == NULL)
953 #ifdef ISC_PLATFORM_HAVEIN6PKTINFO
957 cmsgp = CMSG_FIRSTHDR(msg);
958 while (cmsgp != NULL) {
959 socket_log(sock, NULL, TRACE,
960 isc_msgcat, ISC_MSGSET_SOCKET, ISC_MSG_PROCESSCMSG,
961 "processing cmsg %p", cmsgp);
963 #ifdef ISC_PLATFORM_HAVEIN6PKTINFO
964 if (cmsgp->cmsg_level == IPPROTO_IPV6
965 && cmsgp->cmsg_type == IPV6_PKTINFO) {
967 pktinfop = (struct in6_pktinfo *)CMSG_DATA(cmsgp);
968 memcpy(&dev->pktinfo, pktinfop,
969 sizeof(struct in6_pktinfo));
970 dev->attributes |= ISC_SOCKEVENTATTR_PKTINFO;
971 socket_log(sock, NULL, TRACE,
972 isc_msgcat, ISC_MSGSET_SOCKET,
974 "interface received on ifindex %u",
975 dev->pktinfo.ipi6_ifindex);
976 if (IN6_IS_ADDR_MULTICAST(&pktinfop->ipi6_addr))
977 dev->attributes |= ISC_SOCKEVENTATTR_MULTICAST;
983 if (cmsgp->cmsg_level == SOL_SOCKET
984 && cmsgp->cmsg_type == SCM_TIMESTAMP) {
985 timevalp = (struct timeval *)CMSG_DATA(cmsgp);
986 dev->timestamp.seconds = timevalp->tv_sec;
987 dev->timestamp.nanoseconds = timevalp->tv_usec * 1000;
988 dev->attributes |= ISC_SOCKEVENTATTR_TIMESTAMP;
994 cmsgp = CMSG_NXTHDR(msg, cmsgp);
996 #endif /* USE_CMSG */
998 #endif /* ISC_NET_BSD44MSGHDR */
1002 * Construct an iov array and attach it to the msghdr passed in. This is
1003 * the SEND constructor, which will use the used region of the buffer
1004 * (if using a buffer list) or will use the internal region (if a single
1005 * buffer I/O is requested).
1007 * Nothing can be NULL, and the done event must list at least one buffer
1008 * on the buffer linked list for this function to be meaningful.
1010 * If write_countp != NULL, *write_countp will hold the number of bytes
1011 * this transaction can send.
1014 build_msghdr_send(isc_socket_t *sock, isc_socketevent_t *dev,
1015 struct msghdr *msg, struct iovec *iov, size_t *write_countp)
1017 unsigned int iovcount;
1018 isc_buffer_t *buffer;
1023 memset(msg, 0, sizeof(*msg));
1025 if (!sock->connected) {
1026 msg->msg_name = (void *)&dev->address.type.sa;
1027 msg->msg_namelen = dev->address.length;
1029 msg->msg_name = NULL;
1030 msg->msg_namelen = 0;
1033 buffer = ISC_LIST_HEAD(dev->bufferlist);
1038 * Single buffer I/O? Skip what we've done so far in this region.
1040 if (buffer == NULL) {
1041 write_count = dev->region.length - dev->n;
1042 iov[0].iov_base = (void *)(dev->region.base + dev->n);
1043 iov[0].iov_len = write_count;
1051 * Skip the data in the buffer list that we have already written.
1053 skip_count = dev->n;
1054 while (buffer != NULL) {
1055 REQUIRE(ISC_BUFFER_VALID(buffer));
1056 if (skip_count < isc_buffer_usedlength(buffer))
1058 skip_count -= isc_buffer_usedlength(buffer);
1059 buffer = ISC_LIST_NEXT(buffer, link);
1062 while (buffer != NULL) {
1063 INSIST(iovcount < MAXSCATTERGATHER_SEND);
1065 isc_buffer_usedregion(buffer, &used);
1067 if (used.length > 0) {
1068 iov[iovcount].iov_base = (void *)(used.base
1070 iov[iovcount].iov_len = used.length - skip_count;
1071 write_count += (used.length - skip_count);
1075 buffer = ISC_LIST_NEXT(buffer, link);
1078 INSIST(skip_count == 0U);
1082 msg->msg_iovlen = iovcount;
1084 #ifdef ISC_NET_BSD44MSGHDR
1085 msg->msg_control = NULL;
1086 msg->msg_controllen = 0;
1088 #if defined(USE_CMSG) && defined(ISC_PLATFORM_HAVEIN6PKTINFO)
1089 if ((sock->type == isc_sockettype_udp)
1090 && ((dev->attributes & ISC_SOCKEVENTATTR_PKTINFO) != 0)) {
1091 struct cmsghdr *cmsgp;
1092 struct in6_pktinfo *pktinfop;
1094 socket_log(sock, NULL, TRACE,
1095 isc_msgcat, ISC_MSGSET_SOCKET, ISC_MSG_SENDTODATA,
1096 "sendto pktinfo data, ifindex %u",
1097 dev->pktinfo.ipi6_ifindex);
1099 msg->msg_controllen = cmsg_space(sizeof(struct in6_pktinfo));
1100 INSIST(msg->msg_controllen <= sock->sendcmsgbuflen);
1101 msg->msg_control = (void *)sock->sendcmsgbuf;
1103 cmsgp = (struct cmsghdr *)sock->sendcmsgbuf;
1104 cmsgp->cmsg_level = IPPROTO_IPV6;
1105 cmsgp->cmsg_type = IPV6_PKTINFO;
1106 cmsgp->cmsg_len = cmsg_len(sizeof(struct in6_pktinfo));
1107 pktinfop = (struct in6_pktinfo *)CMSG_DATA(cmsgp);
1108 memcpy(pktinfop, &dev->pktinfo, sizeof(struct in6_pktinfo));
1110 #endif /* USE_CMSG && ISC_PLATFORM_HAVEIPV6 */
1111 #else /* ISC_NET_BSD44MSGHDR */
1112 msg->msg_accrights = NULL;
1113 msg->msg_accrightslen = 0;
1114 #endif /* ISC_NET_BSD44MSGHDR */
1116 if (write_countp != NULL)
1117 *write_countp = write_count;
1121 * Construct an iov array and attach it to the msghdr passed in. This is
1122 * the RECV constructor, which will use the avialable region of the buffer
1123 * (if using a buffer list) or will use the internal region (if a single
1124 * buffer I/O is requested).
1126 * Nothing can be NULL, and the done event must list at least one buffer
1127 * on the buffer linked list for this function to be meaningful.
1129 * If read_countp != NULL, *read_countp will hold the number of bytes
1130 * this transaction can receive.
1133 build_msghdr_recv(isc_socket_t *sock, isc_socketevent_t *dev,
1134 struct msghdr *msg, struct iovec *iov, size_t *read_countp)
1136 unsigned int iovcount;
1137 isc_buffer_t *buffer;
1138 isc_region_t available;
1141 memset(msg, 0, sizeof(struct msghdr));
1143 if (sock->type == isc_sockettype_udp) {
1144 memset(&dev->address, 0, sizeof(dev->address));
1145 #ifdef BROKEN_RECVMSG
1146 if (sock->pf == AF_INET) {
1147 msg->msg_name = (void *)&dev->address.type.sin;
1148 msg->msg_namelen = sizeof(dev->address.type.sin6);
1149 } else if (sock->pf == AF_INET6) {
1150 msg->msg_name = (void *)&dev->address.type.sin6;
1151 msg->msg_namelen = sizeof(dev->address.type.sin6);
1152 #ifdef ISC_PLATFORM_HAVESYSUNH
1153 } else if (sock->pf == AF_UNIX) {
1154 msg->msg_name = (void *)&dev->address.type.sunix;
1155 msg->msg_namelen = sizeof(dev->address.type.sunix);
1158 msg->msg_name = (void *)&dev->address.type.sa;
1159 msg->msg_namelen = sizeof(dev->address.type);
1162 msg->msg_name = (void *)&dev->address.type.sa;
1163 msg->msg_namelen = sizeof(dev->address.type);
1165 #ifdef ISC_NET_RECVOVERFLOW
1166 /* If needed, steal one iovec for overflow detection. */
1170 msg->msg_name = NULL;
1171 msg->msg_namelen = 0;
1172 dev->address = sock->address;
1175 buffer = ISC_LIST_HEAD(dev->bufferlist);
1179 * Single buffer I/O? Skip what we've done so far in this region.
1181 if (buffer == NULL) {
1182 read_count = dev->region.length - dev->n;
1183 iov[0].iov_base = (void *)(dev->region.base + dev->n);
1184 iov[0].iov_len = read_count;
1192 * Skip empty buffers.
1194 while (buffer != NULL) {
1195 REQUIRE(ISC_BUFFER_VALID(buffer));
1196 if (isc_buffer_availablelength(buffer) != 0)
1198 buffer = ISC_LIST_NEXT(buffer, link);
1202 while (buffer != NULL) {
1203 INSIST(iovcount < MAXSCATTERGATHER_RECV);
1205 isc_buffer_availableregion(buffer, &available);
1207 if (available.length > 0) {
1208 iov[iovcount].iov_base = (void *)(available.base);
1209 iov[iovcount].iov_len = available.length;
1210 read_count += available.length;
1213 buffer = ISC_LIST_NEXT(buffer, link);
1219 * If needed, set up to receive that one extra byte. Note that
1220 * we know there is at least one iov left, since we stole it
1221 * at the top of this function.
1223 #ifdef ISC_NET_RECVOVERFLOW
1224 if (sock->type == isc_sockettype_udp) {
1225 iov[iovcount].iov_base = (void *)(&sock->overflow);
1226 iov[iovcount].iov_len = 1;
1232 msg->msg_iovlen = iovcount;
1234 #ifdef ISC_NET_BSD44MSGHDR
1235 msg->msg_control = NULL;
1236 msg->msg_controllen = 0;
1238 #if defined(USE_CMSG)
1239 if (sock->type == isc_sockettype_udp) {
1240 msg->msg_control = sock->recvcmsgbuf;
1241 msg->msg_controllen = sock->recvcmsgbuflen;
1243 #endif /* USE_CMSG */
1244 #else /* ISC_NET_BSD44MSGHDR */
1245 msg->msg_accrights = NULL;
1246 msg->msg_accrightslen = 0;
1247 #endif /* ISC_NET_BSD44MSGHDR */
1249 if (read_countp != NULL)
1250 *read_countp = read_count;
1254 set_dev_address(isc_sockaddr_t *address, isc_socket_t *sock,
1255 isc_socketevent_t *dev)
1257 if (sock->type == isc_sockettype_udp) {
1258 if (address != NULL)
1259 dev->address = *address;
1261 dev->address = sock->address;
1262 } else if (sock->type == isc_sockettype_tcp) {
1263 INSIST(address == NULL);
1264 dev->address = sock->address;
1269 destroy_socketevent(isc_event_t *event) {
1270 isc_socketevent_t *ev = (isc_socketevent_t *)event;
1272 INSIST(ISC_LIST_EMPTY(ev->bufferlist));
1274 (ev->destroy)(event);
1277 static isc_socketevent_t *
1278 allocate_socketevent(isc_socket_t *sock, isc_eventtype_t eventtype,
1279 isc_taskaction_t action, const void *arg)
1281 isc_socketevent_t *ev;
1283 ev = (isc_socketevent_t *)isc_event_allocate(sock->manager->mctx,
1291 ev->result = ISC_R_UNEXPECTED;
1292 ISC_LINK_INIT(ev, ev_link);
1293 ISC_LIST_INIT(ev->bufferlist);
1294 ev->region.base = NULL;
1298 ev->destroy = ev->ev_destroy;
1299 ev->ev_destroy = destroy_socketevent;
1304 #if defined(ISC_SOCKET_DEBUG)
1306 dump_msg(struct msghdr *msg) {
1309 printf("MSGHDR %p\n", msg);
1310 printf("\tname %p, namelen %ld\n", msg->msg_name,
1311 (long) msg->msg_namelen);
1312 printf("\tiov %p, iovlen %ld\n", msg->msg_iov,
1313 (long) msg->msg_iovlen);
1314 for (i = 0; i < (unsigned int)msg->msg_iovlen; i++)
1315 printf("\t\t%d\tbase %p, len %ld\n", i,
1316 msg->msg_iov[i].iov_base,
1317 (long) msg->msg_iov[i].iov_len);
1318 #ifdef ISC_NET_BSD44MSGHDR
1319 printf("\tcontrol %p, controllen %ld\n", msg->msg_control,
1320 (long) msg->msg_controllen);
1325 #define DOIO_SUCCESS 0 /* i/o ok, event sent */
1326 #define DOIO_SOFT 1 /* i/o ok, soft error, no event sent */
1327 #define DOIO_HARD 2 /* i/o error, event sent */
1328 #define DOIO_EOF 3 /* EOF, no event sent */
1331 doio_recv(isc_socket_t *sock, isc_socketevent_t *dev) {
1333 struct iovec iov[MAXSCATTERGATHER_RECV];
1335 size_t actual_count;
1336 struct msghdr msghdr;
1337 isc_buffer_t *buffer;
1339 char strbuf[ISC_STRERRORSIZE];
1341 build_msghdr_recv(sock, dev, &msghdr, iov, &read_count);
1343 #if defined(ISC_SOCKET_DEBUG)
1347 cc = recvmsg(sock->fd, &msghdr, 0);
1350 #if defined(ISC_SOCKET_DEBUG)
1355 if (SOFT_ERROR(recv_errno))
1358 if (isc_log_wouldlog(isc_lctx, IOEVENT_LEVEL)) {
1359 isc__strerror(recv_errno, strbuf, sizeof(strbuf));
1360 socket_log(sock, NULL, IOEVENT,
1361 isc_msgcat, ISC_MSGSET_SOCKET,
1363 "doio_recv: recvmsg(%d) %d bytes, err %d/%s",
1364 sock->fd, cc, recv_errno, strbuf);
1367 #define SOFT_OR_HARD(_system, _isc) \
1368 if (recv_errno == _system) { \
1369 if (sock->connected) { \
1370 dev->result = _isc; \
1371 return (DOIO_HARD); \
1373 return (DOIO_SOFT); \
1375 #define ALWAYS_HARD(_system, _isc) \
1376 if (recv_errno == _system) { \
1377 dev->result = _isc; \
1378 return (DOIO_HARD); \
1381 SOFT_OR_HARD(ECONNREFUSED, ISC_R_CONNREFUSED);
1382 SOFT_OR_HARD(ENETUNREACH, ISC_R_NETUNREACH);
1383 SOFT_OR_HARD(EHOSTUNREACH, ISC_R_HOSTUNREACH);
1384 SOFT_OR_HARD(EHOSTDOWN, ISC_R_HOSTDOWN);
1385 /* HPUX 11.11 can return EADDRNOTAVAIL. */
1386 SOFT_OR_HARD(EADDRNOTAVAIL, ISC_R_ADDRNOTAVAIL);
1387 ALWAYS_HARD(ENOBUFS, ISC_R_NORESOURCES);
1389 * HPUX returns EPROTO and EINVAL on receiving some ICMP/ICMPv6
1393 SOFT_OR_HARD(EPROTO, ISC_R_HOSTUNREACH);
1395 SOFT_OR_HARD(EINVAL, ISC_R_HOSTUNREACH);
1400 dev->result = isc__errno2result(recv_errno);
1405 * On TCP, zero length reads indicate EOF, while on
1406 * UDP, zero length reads are perfectly valid, although
1409 if ((sock->type == isc_sockettype_tcp) && (cc == 0))
1412 if (sock->type == isc_sockettype_udp) {
1413 dev->address.length = msghdr.msg_namelen;
1414 if (isc_sockaddr_getport(&dev->address) == 0) {
1415 if (isc_log_wouldlog(isc_lctx, IOEVENT_LEVEL)) {
1416 socket_log(sock, &dev->address, IOEVENT,
1417 isc_msgcat, ISC_MSGSET_SOCKET,
1419 "dropping source port zero packet");
1425 socket_log(sock, &dev->address, IOEVENT,
1426 isc_msgcat, ISC_MSGSET_SOCKET, ISC_MSG_PKTRECV,
1427 "packet received correctly");
1430 * Overflow bit detection. If we received MORE bytes than we should,
1431 * this indicates an overflow situation. Set the flag in the
1432 * dev entry and adjust how much we read by one.
1434 #ifdef ISC_NET_RECVOVERFLOW
1435 if ((sock->type == isc_sockettype_udp) && ((size_t)cc > read_count)) {
1436 dev->attributes |= ISC_SOCKEVENTATTR_TRUNC;
1442 * If there are control messages attached, run through them and pull
1443 * out the interesting bits.
1445 if (sock->type == isc_sockettype_udp)
1446 process_cmsg(sock, &msghdr, dev);
1449 * update the buffers (if any) and the i/o count
1453 buffer = ISC_LIST_HEAD(dev->bufferlist);
1454 while (buffer != NULL && actual_count > 0U) {
1455 REQUIRE(ISC_BUFFER_VALID(buffer));
1456 if (isc_buffer_availablelength(buffer) <= actual_count) {
1457 actual_count -= isc_buffer_availablelength(buffer);
1458 isc_buffer_add(buffer,
1459 isc_buffer_availablelength(buffer));
1461 isc_buffer_add(buffer, actual_count);
1465 buffer = ISC_LIST_NEXT(buffer, link);
1466 if (buffer == NULL) {
1467 INSIST(actual_count == 0U);
1472 * If we read less than we expected, update counters,
1473 * and let the upper layer poke the descriptor.
1475 if (((size_t)cc != read_count) && (dev->n < dev->minimum))
1479 * Full reads are posted, or partials if partials are ok.
1481 dev->result = ISC_R_SUCCESS;
1482 return (DOIO_SUCCESS);
1487 * DOIO_SUCCESS The operation succeeded. dev->result contains
1490 * DOIO_HARD A hard or unexpected I/O error was encountered.
1491 * dev->result contains the appropriate error.
1493 * DOIO_SOFT A soft I/O error was encountered. No senddone
1494 * event was sent. The operation should be retried.
1496 * No other return values are possible.
1499 doio_send(isc_socket_t *sock, isc_socketevent_t *dev) {
1501 struct iovec iov[MAXSCATTERGATHER_SEND];
1503 struct msghdr msghdr;
1504 char addrbuf[ISC_SOCKADDR_FORMATSIZE];
1507 char strbuf[ISC_STRERRORSIZE];
1509 build_msghdr_send(sock, dev, &msghdr, iov, &write_count);
1512 cc = sendmsg(sock->fd, &msghdr, 0);
1516 * Check for error or block condition.
1519 if (send_errno == EINTR && ++attempts < NRETRIES)
1522 if (SOFT_ERROR(send_errno))
1525 #define SOFT_OR_HARD(_system, _isc) \
1526 if (send_errno == _system) { \
1527 if (sock->connected) { \
1528 dev->result = _isc; \
1529 return (DOIO_HARD); \
1531 return (DOIO_SOFT); \
1533 #define ALWAYS_HARD(_system, _isc) \
1534 if (send_errno == _system) { \
1535 dev->result = _isc; \
1536 return (DOIO_HARD); \
1539 SOFT_OR_HARD(ECONNREFUSED, ISC_R_CONNREFUSED);
1540 ALWAYS_HARD(EACCES, ISC_R_NOPERM);
1541 ALWAYS_HARD(EAFNOSUPPORT, ISC_R_ADDRNOTAVAIL);
1542 ALWAYS_HARD(EADDRNOTAVAIL, ISC_R_ADDRNOTAVAIL);
1543 ALWAYS_HARD(EHOSTUNREACH, ISC_R_HOSTUNREACH);
1545 ALWAYS_HARD(EHOSTDOWN, ISC_R_HOSTUNREACH);
1547 ALWAYS_HARD(ENETUNREACH, ISC_R_NETUNREACH);
1548 ALWAYS_HARD(ENOBUFS, ISC_R_NORESOURCES);
1549 ALWAYS_HARD(EPERM, ISC_R_HOSTUNREACH);
1550 ALWAYS_HARD(EPIPE, ISC_R_NOTCONNECTED);
1551 ALWAYS_HARD(ECONNRESET, ISC_R_CONNECTIONRESET);
1557 * The other error types depend on whether or not the
1558 * socket is UDP or TCP. If it is UDP, some errors
1559 * that we expect to be fatal under TCP are merely
1560 * annoying, and are really soft errors.
1562 * However, these soft errors are still returned as
1565 isc_sockaddr_format(&dev->address, addrbuf, sizeof(addrbuf));
1566 isc__strerror(send_errno, strbuf, sizeof(strbuf));
1567 UNEXPECTED_ERROR(__FILE__, __LINE__, "internal_send: %s: %s",
1569 dev->result = isc__errno2result(send_errno);
1574 UNEXPECTED_ERROR(__FILE__, __LINE__,
1575 "internal_send: send() %s 0",
1576 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
1577 ISC_MSG_RETURNED, "returned"));
1580 * If we write less than we expected, update counters, poke.
1583 if ((size_t)cc != write_count)
1587 * Exactly what we wanted to write. We're done with this
1588 * entry. Post its completion event.
1590 dev->result = ISC_R_SUCCESS;
1591 return (DOIO_SUCCESS);
1597 * Caller must ensure that the socket is not locked and no external
1601 closesocket(isc_socketmgr_t *manager, isc_sockettype_t type, int fd) {
1602 int lockid = FDLOCK_ID(fd);
1607 * No one has this socket open, so the watcher doesn't have to be
1608 * poked, and the socket doesn't have to be locked.
1610 LOCK(&manager->fdlock[lockid]);
1611 manager->fds[fd] = NULL;
1612 manager->fdstate[fd] = CLOSE_PENDING;
1613 UNLOCK(&manager->fdlock[lockid]);
1614 select_poke(manager, fd, SELECT_POKE_CLOSE);
1617 * update manager->maxfd here (XXX: this should be implemented more
1621 LOCK(&manager->lock);
1622 if (manager->maxfd == fd) {
1626 for (i = fd - 1; i >= 0; i--) {
1627 lockid = FDLOCK_ID(i);
1629 LOCK(&manager->fdlock[lockid]);
1630 if (manager->fdstate[i] == MANAGED) {
1632 UNLOCK(&manager->fdlock[lockid]);
1635 UNLOCK(&manager->fdlock[lockid]);
1637 #ifdef ISC_PLATFORM_USETHREADS
1638 if (manager->maxfd < manager->pipe_fds[0])
1639 manager->maxfd = manager->pipe_fds[0];
1642 UNLOCK(&manager->lock);
1643 #endif /* USE_SELECT */
1647 destroy(isc_socket_t **sockp) {
1649 isc_socket_t *sock = *sockp;
1650 isc_socketmgr_t *manager = sock->manager;
1652 socket_log(sock, NULL, CREATION, isc_msgcat, ISC_MSGSET_SOCKET,
1653 ISC_MSG_DESTROYING, "destroying");
1655 INSIST(ISC_LIST_EMPTY(sock->accept_list));
1656 INSIST(ISC_LIST_EMPTY(sock->recv_list));
1657 INSIST(ISC_LIST_EMPTY(sock->send_list));
1658 INSIST(sock->connect_ev == NULL);
1659 REQUIRE(sock->fd == -1 || sock->fd < (int)manager->maxsocks);
1661 if (sock->fd >= 0) {
1664 closesocket(manager, sock->type, fd);
1667 LOCK(&manager->lock);
1669 ISC_LIST_UNLINK(manager->socklist, sock, link);
1671 #ifdef ISC_PLATFORM_USETHREADS
1672 if (ISC_LIST_EMPTY(manager->socklist))
1673 SIGNAL(&manager->shutdown_ok);
1674 #endif /* ISC_PLATFORM_USETHREADS */
1676 UNLOCK(&manager->lock);
1682 allocate_socket(isc_socketmgr_t *manager, isc_sockettype_t type,
1683 isc_socket_t **socketp)
1686 isc_result_t result;
1687 ISC_SOCKADDR_LEN_T cmsgbuflen;
1689 sock = isc_mem_get(manager->mctx, sizeof(*sock));
1692 return (ISC_R_NOMEMORY);
1694 result = ISC_R_UNEXPECTED;
1697 sock->references = 0;
1699 sock->manager = manager;
1703 ISC_LINK_INIT(sock, link);
1705 sock->recvcmsgbuf = NULL;
1706 sock->sendcmsgbuf = NULL;
1709 * set up cmsg buffers
1712 #if defined(USE_CMSG) && defined(ISC_PLATFORM_HAVEIN6PKTINFO)
1713 cmsgbuflen = cmsg_space(sizeof(struct in6_pktinfo));
1715 #if defined(USE_CMSG) && defined(SO_TIMESTAMP)
1716 cmsgbuflen += cmsg_space(sizeof(struct timeval));
1718 sock->recvcmsgbuflen = cmsgbuflen;
1719 if (sock->recvcmsgbuflen != 0U) {
1720 sock->recvcmsgbuf = isc_mem_get(manager->mctx, cmsgbuflen);
1721 if (sock->recvcmsgbuf == NULL)
1726 #if defined(USE_CMSG) && defined(ISC_PLATFORM_HAVEIN6PKTINFO)
1727 cmsgbuflen = cmsg_space(sizeof(struct in6_pktinfo));
1729 sock->sendcmsgbuflen = cmsgbuflen;
1730 if (sock->sendcmsgbuflen != 0U) {
1731 sock->sendcmsgbuf = isc_mem_get(manager->mctx, cmsgbuflen);
1732 if (sock->sendcmsgbuf == NULL)
1737 * set up list of readers and writers to be initially empty
1739 ISC_LIST_INIT(sock->recv_list);
1740 ISC_LIST_INIT(sock->send_list);
1741 ISC_LIST_INIT(sock->accept_list);
1742 sock->connect_ev = NULL;
1743 sock->pending_recv = 0;
1744 sock->pending_send = 0;
1745 sock->pending_accept = 0;
1747 sock->connected = 0;
1748 sock->connecting = 0;
1752 * initialize the lock
1754 result = isc_mutex_init(&sock->lock);
1755 if (result != ISC_R_SUCCESS) {
1761 * Initialize readable and writable events
1763 ISC_EVENT_INIT(&sock->readable_ev, sizeof(intev_t),
1764 ISC_EVENTATTR_NOPURGE, NULL, ISC_SOCKEVENT_INTR,
1765 NULL, sock, sock, NULL, NULL);
1766 ISC_EVENT_INIT(&sock->writable_ev, sizeof(intev_t),
1767 ISC_EVENTATTR_NOPURGE, NULL, ISC_SOCKEVENT_INTW,
1768 NULL, sock, sock, NULL, NULL);
1770 sock->magic = SOCKET_MAGIC;
1773 return (ISC_R_SUCCESS);
1776 if (sock->recvcmsgbuf != NULL)
1777 isc_mem_put(manager->mctx, sock->recvcmsgbuf,
1778 sock->recvcmsgbuflen);
1779 if (sock->sendcmsgbuf != NULL)
1780 isc_mem_put(manager->mctx, sock->sendcmsgbuf,
1781 sock->sendcmsgbuflen);
1782 isc_mem_put(manager->mctx, sock, sizeof(*sock));
1788 * This event requires that the various lists be empty, that the reference
1789 * count be 1, and that the magic number is valid. The other socket bits,
1790 * like the lock, must be initialized as well. The fd associated must be
1791 * marked as closed, by setting it to -1 on close, or this routine will
1792 * also close the socket.
1795 free_socket(isc_socket_t **socketp) {
1796 isc_socket_t *sock = *socketp;
1798 INSIST(sock->references == 0);
1799 INSIST(VALID_SOCKET(sock));
1800 INSIST(!sock->connecting);
1801 INSIST(!sock->pending_recv);
1802 INSIST(!sock->pending_send);
1803 INSIST(!sock->pending_accept);
1804 INSIST(ISC_LIST_EMPTY(sock->recv_list));
1805 INSIST(ISC_LIST_EMPTY(sock->send_list));
1806 INSIST(ISC_LIST_EMPTY(sock->accept_list));
1807 INSIST(!ISC_LINK_LINKED(sock, link));
1809 if (sock->recvcmsgbuf != NULL)
1810 isc_mem_put(sock->manager->mctx, sock->recvcmsgbuf,
1811 sock->recvcmsgbuflen);
1812 if (sock->sendcmsgbuf != NULL)
1813 isc_mem_put(sock->manager->mctx, sock->sendcmsgbuf,
1814 sock->sendcmsgbuflen);
1818 DESTROYLOCK(&sock->lock);
1820 isc_mem_put(sock->manager->mctx, sock, sizeof(*sock));
1827 * This really should not be necessary to do. Having to workout
1828 * which kernel version we are on at run time so that we don't cause
1829 * the kernel to issue a warning about us using a deprecated socket option.
1830 * Such warnings should *never* be on by default in production kernels.
1832 * We can't do this a build time because executables are moved between
1833 * machines and hence kernels.
1835 * We can't just not set SO_BSDCOMAT because some kernels require it.
1838 static isc_once_t bsdcompat_once = ISC_ONCE_INIT;
1839 isc_boolean_t bsdcompat = ISC_TRUE;
1842 clear_bsdcompat(void) {
1849 uname(&buf); /* Can only fail if buf is bad in Linux. */
1851 /* Paranoia in parsing can be increased, but we trust uname(). */
1852 major = strtol(buf.release, &endp, 10);
1854 minor = strtol(endp+1, &endp, 10);
1855 if ((major > 2) || ((major == 2) && (minor >= 4))) {
1856 bsdcompat = ISC_FALSE;
1859 #endif /* __linux __ */
1864 opensocket(isc_socketmgr_t *manager, isc_socket_t *sock) {
1865 char strbuf[ISC_STRERRORSIZE];
1866 const char *err = "socket";
1868 #if defined(USE_CMSG) || defined(SO_BSDCOMPAT)
1871 #if defined(SO_RCVBUF)
1872 ISC_SOCKADDR_LEN_T optlen;
1877 switch (sock->type) {
1878 case isc_sockettype_udp:
1879 sock->fd = socket(sock->pf, SOCK_DGRAM, IPPROTO_UDP);
1881 case isc_sockettype_tcp:
1882 sock->fd = socket(sock->pf, SOCK_STREAM, IPPROTO_TCP);
1884 case isc_sockettype_unix:
1885 sock->fd = socket(sock->pf, SOCK_STREAM, 0);
1888 if (sock->fd == -1 && errno == EINTR && tries++ < 42)
1893 * Leave a space for stdio and TCP to work in.
1895 if (manager->reserved != 0 && sock->type == isc_sockettype_udp &&
1896 sock->fd >= 0 && sock->fd < manager->reserved) {
1898 new = fcntl(sock->fd, F_DUPFD, manager->reserved);
1900 (void)close(sock->fd);
1903 err = "isc_socket_create: fcntl/reserved";
1904 } else if (sock->fd >= 0 && sock->fd < 20) {
1906 new = fcntl(sock->fd, F_DUPFD, 20);
1908 (void)close(sock->fd);
1911 err = "isc_socket_create: fcntl";
1915 if (sock->fd >= (int)manager->maxsocks) {
1916 (void)close(sock->fd);
1917 isc_log_iwrite(isc_lctx, ISC_LOGCATEGORY_GENERAL,
1918 ISC_LOGMODULE_SOCKET, ISC_LOG_ERROR,
1919 isc_msgcat, ISC_MSGSET_SOCKET,
1921 "socket: file descriptor exceeds limit (%d/%u)",
1922 sock->fd, manager->maxsocks);
1923 return (ISC_R_NORESOURCES);
1931 return (ISC_R_NORESOURCES);
1933 case EPROTONOSUPPORT:
1937 * Linux 2.2 (and maybe others) return EINVAL instead of
1941 return (ISC_R_FAMILYNOSUPPORT);
1944 isc__strerror(errno, strbuf, sizeof(strbuf));
1945 UNEXPECTED_ERROR(__FILE__, __LINE__,
1947 isc_msgcat_get(isc_msgcat,
1952 return (ISC_R_UNEXPECTED);
1956 if (make_nonblock(sock->fd) != ISC_R_SUCCESS) {
1957 (void)close(sock->fd);
1958 return (ISC_R_UNEXPECTED);
1962 RUNTIME_CHECK(isc_once_do(&bsdcompat_once,
1963 clear_bsdcompat) == ISC_R_SUCCESS);
1964 if (sock->type != isc_sockettype_unix && bsdcompat &&
1965 setsockopt(sock->fd, SOL_SOCKET, SO_BSDCOMPAT,
1966 (void *)&on, sizeof(on)) < 0) {
1967 isc__strerror(errno, strbuf, sizeof(strbuf));
1968 UNEXPECTED_ERROR(__FILE__, __LINE__,
1969 "setsockopt(%d, SO_BSDCOMPAT) %s: %s",
1971 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
1972 ISC_MSG_FAILED, "failed"),
1979 if (setsockopt(sock->fd, SOL_SOCKET, SO_NOSIGPIPE,
1980 (void *)&on, sizeof(on)) < 0) {
1981 isc__strerror(errno, strbuf, sizeof(strbuf));
1982 UNEXPECTED_ERROR(__FILE__, __LINE__,
1983 "setsockopt(%d, SO_NOSIGPIPE) %s: %s",
1985 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
1986 ISC_MSG_FAILED, "failed"),
1992 #if defined(USE_CMSG) || defined(SO_RCVBUF)
1993 if (sock->type == isc_sockettype_udp) {
1995 #if defined(USE_CMSG)
1996 #if defined(SO_TIMESTAMP)
1997 if (setsockopt(sock->fd, SOL_SOCKET, SO_TIMESTAMP,
1998 (void *)&on, sizeof(on)) < 0
1999 && errno != ENOPROTOOPT) {
2000 isc__strerror(errno, strbuf, sizeof(strbuf));
2001 UNEXPECTED_ERROR(__FILE__, __LINE__,
2002 "setsockopt(%d, SO_TIMESTAMP) %s: %s",
2004 isc_msgcat_get(isc_msgcat,
2011 #endif /* SO_TIMESTAMP */
2013 #if defined(ISC_PLATFORM_HAVEIPV6)
2014 if (sock->pf == AF_INET6 && sock->recvcmsgbuflen == 0U) {
2016 * Warn explicitly because this anomaly can be hidden
2017 * in usual operation (and unexpectedly appear later).
2019 UNEXPECTED_ERROR(__FILE__, __LINE__,
2020 "No buffer available to receive "
2021 "IPv6 destination");
2023 #ifdef ISC_PLATFORM_HAVEIN6PKTINFO
2024 #ifdef IPV6_RECVPKTINFO
2026 if ((sock->pf == AF_INET6)
2027 && (setsockopt(sock->fd, IPPROTO_IPV6, IPV6_RECVPKTINFO,
2028 (void *)&on, sizeof(on)) < 0)) {
2029 isc__strerror(errno, strbuf, sizeof(strbuf));
2030 UNEXPECTED_ERROR(__FILE__, __LINE__,
2031 "setsockopt(%d, IPV6_RECVPKTINFO) "
2033 isc_msgcat_get(isc_msgcat,
2041 if ((sock->pf == AF_INET6)
2042 && (setsockopt(sock->fd, IPPROTO_IPV6, IPV6_PKTINFO,
2043 (void *)&on, sizeof(on)) < 0)) {
2044 isc__strerror(errno, strbuf, sizeof(strbuf));
2045 UNEXPECTED_ERROR(__FILE__, __LINE__,
2046 "setsockopt(%d, IPV6_PKTINFO) %s: %s",
2048 isc_msgcat_get(isc_msgcat,
2054 #endif /* IPV6_RECVPKTINFO */
2055 #endif /* ISC_PLATFORM_HAVEIN6PKTINFO */
2056 #ifdef IPV6_USE_MIN_MTU /* RFC 3542, not too common yet*/
2057 /* use minimum MTU */
2058 if (sock->pf == AF_INET6) {
2059 (void)setsockopt(sock->fd, IPPROTO_IPV6,
2061 (void *)&on, sizeof(on));
2064 #endif /* ISC_PLATFORM_HAVEIPV6 */
2065 #endif /* defined(USE_CMSG) */
2067 #if defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DONT)
2069 * Turn off Path MTU discovery on IPv4/UDP sockets.
2071 if (sock->pf == AF_INET) {
2072 int action = IP_PMTUDISC_DONT;
2073 (void)setsockopt(sock->fd, IPPROTO_IP, IP_MTU_DISCOVER,
2074 &action, sizeof(action));
2077 #if defined(IP_DONTFRAG)
2079 * Turn off Path MTU discovery on IPv4/UDP sockets.
2081 if (sock->pf == AF_INET) {
2083 (void)setsockopt(sock->fd, IPPROTO_IP, IP_DONTFRAG,
2088 #if defined(SO_RCVBUF)
2089 optlen = sizeof(size);
2090 if (getsockopt(sock->fd, SOL_SOCKET, SO_RCVBUF,
2091 (void *)&size, &optlen) >= 0 &&
2092 size < RCVBUFSIZE) {
2094 if (setsockopt(sock->fd, SOL_SOCKET, SO_RCVBUF,
2095 (void *)&size, sizeof(size)) == -1) {
2096 isc__strerror(errno, strbuf, sizeof(strbuf));
2097 UNEXPECTED_ERROR(__FILE__, __LINE__,
2098 "setsockopt(%d, SO_RCVBUF, %d) %s: %s",
2100 isc_msgcat_get(isc_msgcat,
2109 #endif /* defined(USE_CMSG) || defined(SO_RCVBUF) */
2111 return (ISC_R_SUCCESS);
2115 * Create a new 'type' socket managed by 'manager'. Events
2116 * will be posted to 'task' and when dispatched 'action' will be
2117 * called with 'arg' as the arg value. The new socket is returned
2121 isc_socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
2122 isc_socket_t **socketp)
2124 isc_socket_t *sock = NULL;
2125 isc_result_t result;
2128 REQUIRE(VALID_MANAGER(manager));
2129 REQUIRE(socketp != NULL && *socketp == NULL);
2131 result = allocate_socket(manager, type, &sock);
2132 if (result != ISC_R_SUCCESS)
2136 result = opensocket(manager, sock);
2137 if (result != ISC_R_SUCCESS) {
2142 sock->references = 1;
2146 * Note we don't have to lock the socket like we normally would because
2147 * there are no external references to it yet.
2150 lockid = FDLOCK_ID(sock->fd);
2151 LOCK(&manager->fdlock[lockid]);
2152 manager->fds[sock->fd] = sock;
2153 manager->fdstate[sock->fd] = MANAGED;
2155 INSIST(sock->manager->fdpollinfo[sock->fd].want_read == 0 &&
2156 sock->manager->fdpollinfo[sock->fd].want_write == 0);
2158 UNLOCK(&manager->fdlock[lockid]);
2160 LOCK(&manager->lock);
2161 ISC_LIST_APPEND(manager->socklist, sock, link);
2163 if (manager->maxfd < sock->fd)
2164 manager->maxfd = sock->fd;
2166 UNLOCK(&manager->lock);
2168 socket_log(sock, NULL, CREATION, isc_msgcat, ISC_MSGSET_SOCKET,
2169 ISC_MSG_CREATED, "created");
2171 return (ISC_R_SUCCESS);
2175 isc_socket_open(isc_socket_t *sock) {
2176 isc_result_t result;
2178 REQUIRE(VALID_SOCKET(sock));
2181 REQUIRE(sock->references == 1);
2182 UNLOCK(&sock->lock);
2184 * We don't need to retain the lock hereafter, since no one else has
2187 REQUIRE(sock->fd == -1);
2189 result = opensocket(sock->manager, sock);
2190 if (result != ISC_R_SUCCESS)
2193 if (result == ISC_R_SUCCESS) {
2194 int lockid = FDLOCK_ID(sock->fd);
2196 LOCK(&sock->manager->fdlock[lockid]);
2197 sock->manager->fds[sock->fd] = sock;
2198 sock->manager->fdstate[sock->fd] = MANAGED;
2200 INSIST(sock->manager->fdpollinfo[sock->fd].want_read == 0 &&
2201 sock->manager->fdpollinfo[sock->fd].want_write == 0);
2203 UNLOCK(&sock->manager->fdlock[lockid]);
2206 LOCK(&sock->manager->lock);
2207 if (sock->manager->maxfd < sock->fd)
2208 sock->manager->maxfd = sock->fd;
2209 UNLOCK(&sock->manager->lock);
2217 * Attach to a socket. Caller must explicitly detach when it is done.
2220 isc_socket_attach(isc_socket_t *sock, isc_socket_t **socketp) {
2221 REQUIRE(VALID_SOCKET(sock));
2222 REQUIRE(socketp != NULL && *socketp == NULL);
2226 UNLOCK(&sock->lock);
2232 * Dereference a socket. If this is the last reference to it, clean things
2233 * up by destroying the socket.
2236 isc_socket_detach(isc_socket_t **socketp) {
2238 isc_boolean_t kill_socket = ISC_FALSE;
2240 REQUIRE(socketp != NULL);
2242 REQUIRE(VALID_SOCKET(sock));
2245 REQUIRE(sock->references > 0);
2247 if (sock->references == 0)
2248 kill_socket = ISC_TRUE;
2249 UNLOCK(&sock->lock);
2258 isc_socket_close(isc_socket_t *sock) {
2261 REQUIRE(VALID_SOCKET(sock));
2264 REQUIRE(sock->references == 1);
2265 UNLOCK(&sock->lock);
2267 * We don't need to retain the lock hereafter, since no one else has
2271 REQUIRE(sock->fd >= 0 && sock->fd < (int)sock->manager->maxsocks);
2273 INSIST(!sock->connecting);
2274 INSIST(!sock->pending_recv);
2275 INSIST(!sock->pending_send);
2276 INSIST(!sock->pending_accept);
2277 INSIST(ISC_LIST_EMPTY(sock->recv_list));
2278 INSIST(ISC_LIST_EMPTY(sock->send_list));
2279 INSIST(ISC_LIST_EMPTY(sock->accept_list));
2280 INSIST(sock->connect_ev == NULL);
2285 sock->connected = 0;
2286 sock->connecting = 0;
2288 isc_sockaddr_any(&sock->address);
2290 closesocket(sock->manager, sock->type, fd);
2292 return (ISC_R_SUCCESS);
2296 * I/O is possible on a given socket. Schedule an event to this task that
2297 * will call an internal function to do the I/O. This will charge the
2298 * task with the I/O operation and let our select loop handler get back
2299 * to doing something real as fast as possible.
2301 * The socket and manager must be locked before calling this function.
2304 dispatch_recv(isc_socket_t *sock) {
2306 isc_socketevent_t *ev;
2308 INSIST(!sock->pending_recv);
2310 ev = ISC_LIST_HEAD(sock->recv_list);
2314 sock->pending_recv = 1;
2315 iev = &sock->readable_ev;
2317 socket_log(sock, NULL, EVENT, NULL, 0, 0,
2318 "dispatch_recv: event %p -> task %p", ev, ev->ev_sender);
2321 iev->ev_sender = sock;
2322 iev->ev_action = internal_recv;
2325 isc_task_send(ev->ev_sender, (isc_event_t **)&iev);
2329 dispatch_send(isc_socket_t *sock) {
2331 isc_socketevent_t *ev;
2333 INSIST(!sock->pending_send);
2335 ev = ISC_LIST_HEAD(sock->send_list);
2339 sock->pending_send = 1;
2340 iev = &sock->writable_ev;
2342 socket_log(sock, NULL, EVENT, NULL, 0, 0,
2343 "dispatch_send: event %p -> task %p", ev, ev->ev_sender);
2346 iev->ev_sender = sock;
2347 iev->ev_action = internal_send;
2350 isc_task_send(ev->ev_sender, (isc_event_t **)&iev);
2354 * Dispatch an internal accept event.
2357 dispatch_accept(isc_socket_t *sock) {
2359 isc_socket_newconnev_t *ev;
2361 INSIST(!sock->pending_accept);
2364 * Are there any done events left, or were they all canceled
2365 * before the manager got the socket lock?
2367 ev = ISC_LIST_HEAD(sock->accept_list);
2371 sock->pending_accept = 1;
2372 iev = &sock->readable_ev;
2374 sock->references++; /* keep socket around for this internal event */
2375 iev->ev_sender = sock;
2376 iev->ev_action = internal_accept;
2379 isc_task_send(ev->ev_sender, (isc_event_t **)&iev);
2383 dispatch_connect(isc_socket_t *sock) {
2385 isc_socket_connev_t *ev;
2387 iev = &sock->writable_ev;
2389 ev = sock->connect_ev;
2390 INSIST(ev != NULL); /* XXX */
2392 INSIST(sock->connecting);
2394 sock->references++; /* keep socket around for this internal event */
2395 iev->ev_sender = sock;
2396 iev->ev_action = internal_connect;
2399 isc_task_send(ev->ev_sender, (isc_event_t **)&iev);
2403 * Dequeue an item off the given socket's read queue, set the result code
2404 * in the done event to the one provided, and send it to the task it was
2407 * If the event to be sent is on a list, remove it before sending. If
2408 * asked to, send and detach from the socket as well.
2410 * Caller must have the socket locked if the event is attached to the socket.
2413 send_recvdone_event(isc_socket_t *sock, isc_socketevent_t **dev) {
2416 task = (*dev)->ev_sender;
2418 (*dev)->ev_sender = sock;
2420 if (ISC_LINK_LINKED(*dev, ev_link))
2421 ISC_LIST_DEQUEUE(sock->recv_list, *dev, ev_link);
2423 if (((*dev)->attributes & ISC_SOCKEVENTATTR_ATTACHED)
2424 == ISC_SOCKEVENTATTR_ATTACHED)
2425 isc_task_sendanddetach(&task, (isc_event_t **)dev);
2427 isc_task_send(task, (isc_event_t **)dev);
2431 * See comments for send_recvdone_event() above.
2433 * Caller must have the socket locked if the event is attached to the socket.
2436 send_senddone_event(isc_socket_t *sock, isc_socketevent_t **dev) {
2439 INSIST(dev != NULL && *dev != NULL);
2441 task = (*dev)->ev_sender;
2442 (*dev)->ev_sender = sock;
2444 if (ISC_LINK_LINKED(*dev, ev_link))
2445 ISC_LIST_DEQUEUE(sock->send_list, *dev, ev_link);
2447 if (((*dev)->attributes & ISC_SOCKEVENTATTR_ATTACHED)
2448 == ISC_SOCKEVENTATTR_ATTACHED)
2449 isc_task_sendanddetach(&task, (isc_event_t **)dev);
2451 isc_task_send(task, (isc_event_t **)dev);
2455 * Call accept() on a socket, to get the new file descriptor. The listen
2456 * socket is used as a prototype to create a new isc_socket_t. The new
2457 * socket has one outstanding reference. The task receiving the event
2458 * will be detached from just after the event is delivered.
2460 * On entry to this function, the event delivered is the internal
2461 * readable event, and the first item on the accept_list should be
2462 * the done event we want to send. If the list is empty, this is a no-op,
2463 * so just unlock and return.
2466 internal_accept(isc_task_t *me, isc_event_t *ev) {
2468 isc_socketmgr_t *manager;
2469 isc_socket_newconnev_t *dev;
2471 ISC_SOCKADDR_LEN_T addrlen;
2473 isc_result_t result = ISC_R_SUCCESS;
2474 char strbuf[ISC_STRERRORSIZE];
2475 const char *err = "accept";
2479 sock = ev->ev_sender;
2480 INSIST(VALID_SOCKET(sock));
2483 socket_log(sock, NULL, TRACE,
2484 isc_msgcat, ISC_MSGSET_SOCKET, ISC_MSG_ACCEPTLOCK,
2485 "internal_accept called, locked socket");
2487 manager = sock->manager;
2488 INSIST(VALID_MANAGER(manager));
2490 INSIST(sock->listener);
2491 INSIST(sock->pending_accept == 1);
2492 sock->pending_accept = 0;
2494 INSIST(sock->references > 0);
2495 sock->references--; /* the internal event is done with this socket */
2496 if (sock->references == 0) {
2497 UNLOCK(&sock->lock);
2503 * Get the first item off the accept list.
2504 * If it is empty, unlock the socket and return.
2506 dev = ISC_LIST_HEAD(sock->accept_list);
2508 UNLOCK(&sock->lock);
2513 * Try to accept the new connection. If the accept fails with
2514 * EAGAIN or EINTR, simply poke the watcher to watch this socket
2515 * again. Also ignore ECONNRESET, which has been reported to
2516 * be spuriously returned on Linux 2.2.19 although it is not
2517 * a documented error for accept(). ECONNABORTED has been
2518 * reported for Solaris 8. The rest are thrown in not because
2519 * we have seen them but because they are ignored by other
2520 * deamons such as BIND 8 and Apache.
2523 addrlen = sizeof(dev->newsocket->address.type);
2524 memset(&dev->newsocket->address.type, 0, addrlen);
2525 fd = accept(sock->fd, &dev->newsocket->address.type.sa,
2530 * Leave a space for stdio to work in.
2532 if (fd >= 0 && fd < 20) {
2534 new = fcntl(fd, F_DUPFD, 20);
2539 err = "accept/fcntl";
2544 if (SOFT_ERROR(errno))
2549 isc_log_iwrite(isc_lctx, ISC_LOGCATEGORY_GENERAL,
2550 ISC_LOGMODULE_SOCKET, ISC_LOG_ERROR,
2551 isc_msgcat, ISC_MSGSET_SOCKET,
2553 "%s: too many open file descriptors",
2576 isc__strerror(errno, strbuf, sizeof(strbuf));
2577 UNEXPECTED_ERROR(__FILE__, __LINE__,
2578 "internal_accept: %s() %s: %s", err,
2579 isc_msgcat_get(isc_msgcat,
2585 result = ISC_R_UNEXPECTED;
2587 if (addrlen == 0U) {
2588 UNEXPECTED_ERROR(__FILE__, __LINE__,
2589 "internal_accept(): "
2590 "accept() failed to return "
2595 } else if (dev->newsocket->address.type.sa.sa_family !=
2598 UNEXPECTED_ERROR(__FILE__, __LINE__,
2599 "internal_accept(): "
2600 "accept() returned peer address "
2601 "family %u (expected %u)",
2602 dev->newsocket->address.
2607 } else if (fd >= (int)manager->maxsocks) {
2608 isc_log_iwrite(isc_lctx, ISC_LOGCATEGORY_GENERAL,
2609 ISC_LOGMODULE_SOCKET, ISC_LOG_ERROR,
2610 isc_msgcat, ISC_MSGSET_SOCKET,
2613 "file descriptor exceeds limit (%d/%u)",
2614 fd, manager->maxsocks);
2621 dev->newsocket->address.length = addrlen;
2622 dev->newsocket->pf = sock->pf;
2626 * Pull off the done event.
2628 ISC_LIST_UNLINK(sock->accept_list, dev, ev_link);
2631 * Poke watcher if there are more pending accepts.
2633 if (!ISC_LIST_EMPTY(sock->accept_list))
2634 select_poke(sock->manager, sock->fd, SELECT_POKE_ACCEPT);
2636 UNLOCK(&sock->lock);
2638 if (fd != -1 && (make_nonblock(fd) != ISC_R_SUCCESS)) {
2641 result = ISC_R_UNEXPECTED;
2645 * -1 means the new socket didn't happen.
2648 int lockid = FDLOCK_ID(fd);
2650 LOCK(&manager->fdlock[lockid]);
2651 manager->fds[fd] = dev->newsocket;
2652 manager->fdstate[fd] = MANAGED;
2653 UNLOCK(&manager->fdlock[lockid]);
2655 LOCK(&manager->lock);
2656 ISC_LIST_APPEND(manager->socklist, dev->newsocket, link);
2658 dev->newsocket->fd = fd;
2659 dev->newsocket->bound = 1;
2660 dev->newsocket->connected = 1;
2663 * Save away the remote address
2665 dev->address = dev->newsocket->address;
2668 if (manager->maxfd < fd)
2669 manager->maxfd = fd;
2672 socket_log(sock, &dev->newsocket->address, CREATION,
2673 isc_msgcat, ISC_MSGSET_SOCKET, ISC_MSG_ACCEPTEDCXN,
2674 "accepted connection, new socket %p",
2677 UNLOCK(&manager->lock);
2679 dev->newsocket->references--;
2680 free_socket(&dev->newsocket);
2684 * Fill in the done event details and send it off.
2686 dev->result = result;
2687 task = dev->ev_sender;
2688 dev->ev_sender = sock;
2690 isc_task_sendanddetach(&task, ISC_EVENT_PTR(&dev));
2694 select_poke(sock->manager, sock->fd, SELECT_POKE_ACCEPT);
2695 UNLOCK(&sock->lock);
2700 internal_recv(isc_task_t *me, isc_event_t *ev) {
2701 isc_socketevent_t *dev;
2704 INSIST(ev->ev_type == ISC_SOCKEVENT_INTR);
2706 sock = ev->ev_sender;
2707 INSIST(VALID_SOCKET(sock));
2710 socket_log(sock, NULL, IOEVENT,
2711 isc_msgcat, ISC_MSGSET_SOCKET, ISC_MSG_INTERNALRECV,
2712 "internal_recv: task %p got event %p", me, ev);
2714 INSIST(sock->pending_recv == 1);
2715 sock->pending_recv = 0;
2717 INSIST(sock->references > 0);
2718 sock->references--; /* the internal event is done with this socket */
2719 if (sock->references == 0) {
2720 UNLOCK(&sock->lock);
2726 * Try to do as much I/O as possible on this socket. There are no
2727 * limits here, currently.
2729 dev = ISC_LIST_HEAD(sock->recv_list);
2730 while (dev != NULL) {
2731 switch (doio_recv(sock, dev)) {
2737 * read of 0 means the remote end was closed.
2738 * Run through the event queue and dispatch all
2739 * the events with an EOF result code.
2742 dev->result = ISC_R_EOF;
2743 send_recvdone_event(sock, &dev);
2744 dev = ISC_LIST_HEAD(sock->recv_list);
2745 } while (dev != NULL);
2750 send_recvdone_event(sock, &dev);
2754 dev = ISC_LIST_HEAD(sock->recv_list);
2758 if (!ISC_LIST_EMPTY(sock->recv_list))
2759 select_poke(sock->manager, sock->fd, SELECT_POKE_READ);
2761 UNLOCK(&sock->lock);
2765 internal_send(isc_task_t *me, isc_event_t *ev) {
2766 isc_socketevent_t *dev;
2769 INSIST(ev->ev_type == ISC_SOCKEVENT_INTW);
2772 * Find out what socket this is and lock it.
2774 sock = (isc_socket_t *)ev->ev_sender;
2775 INSIST(VALID_SOCKET(sock));
2778 socket_log(sock, NULL, IOEVENT,
2779 isc_msgcat, ISC_MSGSET_SOCKET, ISC_MSG_INTERNALSEND,
2780 "internal_send: task %p got event %p", me, ev);
2782 INSIST(sock->pending_send == 1);
2783 sock->pending_send = 0;
2785 INSIST(sock->references > 0);
2786 sock->references--; /* the internal event is done with this socket */
2787 if (sock->references == 0) {
2788 UNLOCK(&sock->lock);
2794 * Try to do as much I/O as possible on this socket. There are no
2795 * limits here, currently.
2797 dev = ISC_LIST_HEAD(sock->send_list);
2798 while (dev != NULL) {
2799 switch (doio_send(sock, dev)) {
2805 send_senddone_event(sock, &dev);
2809 dev = ISC_LIST_HEAD(sock->send_list);
2813 if (!ISC_LIST_EMPTY(sock->send_list))
2814 select_poke(sock->manager, sock->fd, SELECT_POKE_WRITE);
2816 UNLOCK(&sock->lock);
2820 * Process read/writes on each fd here. Avoid locking
2821 * and unlocking twice if both reads and writes are possible.
2824 process_fd(isc_socketmgr_t *manager, int fd, isc_boolean_t readable,
2825 isc_boolean_t writeable)
2828 isc_boolean_t unlock_sock;
2829 int lockid = FDLOCK_ID(fd);
2832 * If the socket is going to be closed, don't do more I/O.
2834 LOCK(&manager->fdlock[lockid]);
2835 if (manager->fdstate[fd] == CLOSE_PENDING) {
2836 UNLOCK(&manager->fdlock[lockid]);
2838 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
2839 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
2843 sock = manager->fds[fd];
2844 UNLOCK(&manager->fdlock[lockid]);
2845 unlock_sock = ISC_FALSE;
2848 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
2851 unlock_sock = ISC_TRUE;
2853 if (!SOCK_DEAD(sock)) {
2855 dispatch_accept(sock);
2857 dispatch_recv(sock);
2859 (void)unwatch_fd(manager, fd, SELECT_POKE_READ);
2864 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
2868 unlock_sock = ISC_TRUE;
2871 if (!SOCK_DEAD(sock)) {
2872 if (sock->connecting)
2873 dispatch_connect(sock);
2875 dispatch_send(sock);
2877 (void)unwatch_fd(manager, fd, SELECT_POKE_WRITE);
2880 UNLOCK(&sock->lock);
2884 static isc_boolean_t
2885 process_fds(isc_socketmgr_t *manager, struct kevent *events, int nevents) {
2887 isc_boolean_t readable, writable;
2888 isc_boolean_t done = ISC_FALSE;
2889 #ifdef ISC_PLATFORM_USETHREADS
2890 isc_boolean_t have_ctlevent = ISC_FALSE;
2893 if (nevents == manager->nevents) {
2895 * This is not an error, but something unexpected. If this
2896 * happens, it may indicate the need for increasing
2897 * ISC_SOCKET_MAXEVENTS.
2899 manager_log(manager, ISC_LOGCATEGORY_GENERAL,
2900 ISC_LOGMODULE_SOCKET, ISC_LOG_INFO,
2901 "maximum number of FD events (%d) received",
2905 for (i = 0; i < nevents; i++) {
2906 REQUIRE(events[i].ident < manager->maxsocks);
2907 #ifdef ISC_PLATFORM_USETHREADS
2908 if (events[i].ident == (uintptr_t)manager->pipe_fds[0]) {
2909 have_ctlevent = ISC_TRUE;
2913 readable = ISC_TF(events[i].filter == EVFILT_READ);
2914 writable = ISC_TF(events[i].filter == EVFILT_WRITE);
2915 process_fd(manager, events[i].ident, readable, writable);
2918 #ifdef ISC_PLATFORM_USETHREADS
2920 done = process_ctlfd(manager);
2925 #elif defined(USE_EPOLL)
2926 static isc_boolean_t
2927 process_fds(isc_socketmgr_t *manager, struct epoll_event *events, int nevents) {
2929 isc_boolean_t done = ISC_FALSE;
2930 #ifdef ISC_PLATFORM_USETHREADS
2931 isc_boolean_t have_ctlevent = ISC_FALSE;
2934 if (nevents == manager->nevents) {
2935 manager_log(manager, ISC_LOGCATEGORY_GENERAL,
2936 ISC_LOGMODULE_SOCKET, ISC_LOG_INFO,
2937 "maximum number of FD events (%d) received",
2941 for (i = 0; i < nevents; i++) {
2942 REQUIRE(events[i].data.fd < (int)manager->maxsocks);
2943 #ifdef ISC_PLATFORM_USETHREADS
2944 if (events[i].data.fd == manager->pipe_fds[0]) {
2945 have_ctlevent = ISC_TRUE;
2949 if ((events[i].events & EPOLLERR) != 0 ||
2950 (events[i].events & EPOLLHUP) != 0) {
2952 * epoll does not set IN/OUT bits on an erroneous
2953 * condition, so we need to try both anyway. This is a
2954 * bit inefficient, but should be okay for such rare
2955 * events. Note also that the read or write attempt
2956 * won't block because we use non-blocking sockets.
2958 events[i].events |= (EPOLLIN | EPOLLOUT);
2960 process_fd(manager, events[i].data.fd,
2961 (events[i].events & EPOLLIN) != 0,
2962 (events[i].events & EPOLLOUT) != 0);
2965 #ifdef ISC_PLATFORM_USETHREADS
2967 done = process_ctlfd(manager);
2972 #elif defined(USE_DEVPOLL)
2973 static isc_boolean_t
2974 process_fds(isc_socketmgr_t *manager, struct pollfd *events, int nevents) {
2976 isc_boolean_t done = ISC_FALSE;
2977 #ifdef ISC_PLATFORM_USETHREADS
2978 isc_boolean_t have_ctlevent = ISC_FALSE;
2981 if (nevents == manager->nevents) {
2982 manager_log(manager, ISC_LOGCATEGORY_GENERAL,
2983 ISC_LOGMODULE_SOCKET, ISC_LOG_INFO,
2984 "maximum number of FD events (%d) received",
2988 for (i = 0; i < nevents; i++) {
2989 REQUIRE(events[i].fd < (int)manager->maxsocks);
2990 #ifdef ISC_PLATFORM_USETHREADS
2991 if (events[i].fd == manager->pipe_fds[0]) {
2992 have_ctlevent = ISC_TRUE;
2996 process_fd(manager, events[i].fd,
2997 (events[i].events & POLLIN) != 0,
2998 (events[i].events & POLLOUT) != 0);
3001 #ifdef ISC_PLATFORM_USETHREADS
3003 done = process_ctlfd(manager);
3008 #elif defined(USE_SELECT)
3010 process_fds(isc_socketmgr_t *manager, int maxfd,
3011 fd_set *readfds, fd_set *writefds)
3015 REQUIRE(maxfd <= (int)manager->maxsocks);
3017 for (i = 0; i < maxfd; i++) {
3018 #ifdef ISC_PLATFORM_USETHREADS
3019 if (i == manager->pipe_fds[0] || i == manager->pipe_fds[1])
3021 #endif /* ISC_PLATFORM_USETHREADS */
3022 process_fd(manager, i, FD_ISSET(i, readfds),
3023 FD_ISSET(i, writefds));
3028 #ifdef ISC_PLATFORM_USETHREADS
3029 static isc_boolean_t
3030 process_ctlfd(isc_socketmgr_t *manager) {
3034 select_readmsg(manager, &fd, &msg);
3036 manager_log(manager, IOEVENT,
3037 isc_msgcat_get(isc_msgcat, ISC_MSGSET_SOCKET,
3039 "watcher got message %d "
3040 "for socket %d"), msg, fd);
3045 if (msg == SELECT_POKE_NOTHING)
3049 * Handle shutdown message. We really should
3050 * jump out of this loop right away, but
3051 * it doesn't matter if we have to do a little
3054 if (msg == SELECT_POKE_SHUTDOWN)
3058 * This is a wakeup on a socket. Look
3059 * at the event queue for both read and write,
3060 * and decide if we need to watch on it now
3063 wakeup_socket(manager, fd, msg);
3070 * This is the thread that will loop forever, always in a select or poll
3073 * When select returns something to do, track down what thread gets to do
3074 * this I/O and post the event to it.
3076 static isc_threadresult_t
3077 watcher(void *uap) {
3078 isc_socketmgr_t *manager = uap;
3083 const char *fnname = "kevent()";
3084 #elif defined (USE_EPOLL)
3085 const char *fnname = "epoll_wait()";
3086 #elif defined(USE_DEVPOLL)
3087 const char *fnname = "ioctl(DP_POLL)";
3089 #elif defined (USE_SELECT)
3090 const char *fnname = "select()";
3093 char strbuf[ISC_STRERRORSIZE];
3094 #ifdef ISC_SOCKET_USE_POLLWATCH
3095 pollstate_t pollstate = poll_idle;
3099 * Get the control fd here. This will never change.
3101 ctlfd = manager->pipe_fds[0];
3106 cc = kevent(manager->kqueue_fd, NULL, 0,
3107 manager->events, manager->nevents, NULL);
3108 #elif defined(USE_EPOLL)
3109 cc = epoll_wait(manager->epoll_fd, manager->events,
3110 manager->nevents, -1);
3111 #elif defined(USE_DEVPOLL)
3112 dvp.dp_fds = manager->events;
3113 dvp.dp_nfds = manager->nevents;
3114 #ifndef ISC_SOCKET_USE_POLLWATCH
3115 dvp.dp_timeout = -1;
3117 if (pollstate == poll_idle)
3118 dvp.dp_timeout = -1;
3120 dvp.dp_timeout = ISC_SOCKET_POLLWATCH_TIMEOUT;
3121 #endif /* ISC_SOCKET_USE_POLLWATCH */
3122 cc = ioctl(manager->devpoll_fd, DP_POLL, &dvp);
3123 #elif defined(USE_SELECT)
3124 LOCK(&manager->lock);
3125 memcpy(manager->read_fds_copy, manager->read_fds,
3126 manager->fd_bufsize);
3127 memcpy(manager->write_fds_copy, manager->write_fds,
3128 manager->fd_bufsize);
3129 maxfd = manager->maxfd + 1;
3130 UNLOCK(&manager->lock);
3132 cc = select(maxfd, manager->read_fds_copy,
3133 manager->write_fds_copy, NULL, NULL);
3134 #endif /* USE_KQUEUE */
3136 if (cc < 0 && !SOFT_ERROR(errno)) {
3137 isc__strerror(errno, strbuf, sizeof(strbuf));
3138 FATAL_ERROR(__FILE__, __LINE__,
3139 "%s %s: %s", fnname,
3140 isc_msgcat_get(isc_msgcat,
3146 #if defined(USE_DEVPOLL) && defined(ISC_SOCKET_USE_POLLWATCH)
3148 if (pollstate == poll_active)
3149 pollstate = poll_checking;
3150 else if (pollstate == poll_checking)
3151 pollstate = poll_idle;
3152 } else if (cc > 0) {
3153 if (pollstate == poll_checking) {
3155 * XXX: We'd like to use a more
3156 * verbose log level as it's actually an
3157 * unexpected event, but the kernel bug
3158 * reportedly happens pretty frequently
3159 * (and it can also be a false positive)
3160 * so it would be just too noisy.
3162 manager_log(manager,
3163 ISC_LOGCATEGORY_GENERAL,
3164 ISC_LOGMODULE_SOCKET,
3166 "unexpected POLL timeout");
3168 pollstate = poll_active;
3173 #if defined(USE_KQUEUE) || defined (USE_EPOLL) || defined (USE_DEVPOLL)
3174 done = process_fds(manager, manager->events, cc);
3175 #elif defined(USE_SELECT)
3176 process_fds(manager, maxfd, manager->read_fds_copy,
3177 manager->write_fds_copy);
3180 * Process reads on internal, control fd.
3182 if (FD_ISSET(ctlfd, manager->read_fds_copy))
3183 done = process_ctlfd(manager);
3187 manager_log(manager, TRACE,
3188 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
3189 ISC_MSG_EXITING, "watcher exiting"));
3191 return ((isc_threadresult_t)0);
3193 #endif /* ISC_PLATFORM_USETHREADS */
3196 isc__socketmgr_setreserved(isc_socketmgr_t *manager, isc_uint32_t reserved) {
3198 REQUIRE(VALID_MANAGER(manager));
3200 manager->reserved = reserved;
3204 * Create a new socket manager.
3208 setup_watcher(isc_mem_t *mctx, isc_socketmgr_t *manager) {
3209 isc_result_t result;
3212 manager->nevents = ISC_SOCKET_MAXEVENTS;
3213 manager->events = isc_mem_get(mctx, sizeof(struct kevent) *
3215 if (manager->events == NULL)
3216 return (ISC_R_NOMEMORY);
3217 manager->kqueue_fd = kqueue();
3218 if (manager->kqueue_fd == -1) {
3219 result = isc__errno2result(errno);
3220 isc_mem_put(mctx, manager->events,
3221 sizeof(struct kevent) * manager->nevents);
3225 #ifdef ISC_PLATFORM_USETHREADS
3226 result = watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
3227 if (result != ISC_R_SUCCESS) {
3228 close(manager->kqueue_fd);
3229 isc_mem_put(mctx, manager->events,
3230 sizeof(struct kevent) * manager->nevents);
3233 #endif /* ISC_PLATFORM_USETHREADS */
3234 #elif defined(USE_EPOLL)
3235 manager->nevents = ISC_SOCKET_MAXEVENTS;
3236 manager->events = isc_mem_get(mctx, sizeof(struct epoll_event) *
3238 if (manager->events == NULL)
3239 return (ISC_R_NOMEMORY);
3240 manager->epoll_fd = epoll_create(manager->nevents);
3241 if (manager->epoll_fd == -1) {
3242 result = isc__errno2result(errno);
3243 isc_mem_put(mctx, manager->events,
3244 sizeof(struct epoll_event) * manager->nevents);
3247 #ifdef ISC_PLATFORM_USETHREADS
3248 result = watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
3249 if (result != ISC_R_SUCCESS) {
3250 close(manager->epoll_fd);
3251 isc_mem_put(mctx, manager->events,
3252 sizeof(struct epoll_event) * manager->nevents);
3255 #endif /* ISC_PLATFORM_USETHREADS */
3256 #elif defined(USE_DEVPOLL)
3258 * XXXJT: /dev/poll seems to reject large numbers of events,
3259 * so we should be careful about redefining ISC_SOCKET_MAXEVENTS.
3261 manager->nevents = ISC_SOCKET_MAXEVENTS;
3262 manager->events = isc_mem_get(mctx, sizeof(struct pollfd) *
3264 if (manager->events == NULL)
3265 return (ISC_R_NOMEMORY);
3267 * Note: fdpollinfo should be able to support all possible FDs, so
3268 * it must have maxsocks entries (not nevents).
3270 manager->fdpollinfo = isc_mem_get(mctx, sizeof(pollinfo_t) *
3272 if (manager->fdpollinfo == NULL) {
3273 isc_mem_put(mctx, manager->events,
3274 sizeof(pollinfo_t) * manager->maxsocks);
3275 return (ISC_R_NOMEMORY);
3277 memset(manager->fdpollinfo, 0, sizeof(pollinfo_t) * manager->maxsocks);
3278 manager->devpoll_fd = open("/dev/poll", O_RDWR);
3279 if (manager->devpoll_fd == -1) {
3280 result = isc__errno2result(errno);
3281 isc_mem_put(mctx, manager->events,
3282 sizeof(struct pollfd) * manager->nevents);
3283 isc_mem_put(mctx, manager->fdpollinfo,
3284 sizeof(pollinfo_t) * manager->maxsocks);
3287 #ifdef ISC_PLATFORM_USETHREADS
3288 result = watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
3289 if (result != ISC_R_SUCCESS) {
3290 close(manager->devpoll_fd);
3291 isc_mem_put(mctx, manager->events,
3292 sizeof(struct pollfd) * manager->nevents);
3293 isc_mem_put(mctx, manager->fdpollinfo,
3294 sizeof(pollinfo_t) * manager->maxsocks);
3297 #endif /* ISC_PLATFORM_USETHREADS */
3298 #elif defined(USE_SELECT)
3301 #if ISC_SOCKET_MAXSOCKETS > FD_SETSIZE
3303 * Note: this code should also cover the case of MAXSOCKETS <=
3304 * FD_SETSIZE, but we separate the cases to avoid possible portability
3305 * issues regarding howmany() and the actual representation of fd_set.
3307 manager->fd_bufsize = howmany(manager->maxsocks, NFDBITS) *
3310 manager->fd_bufsize = sizeof(fd_set);
3313 manager->read_fds = NULL;
3314 manager->read_fds_copy = NULL;
3315 manager->write_fds = NULL;
3316 manager->write_fds_copy = NULL;
3318 manager->read_fds = isc_mem_get(mctx, manager->fd_bufsize);
3319 if (manager->read_fds != NULL)
3320 manager->read_fds_copy = isc_mem_get(mctx, manager->fd_bufsize);
3321 if (manager->read_fds_copy != NULL)
3322 manager->write_fds = isc_mem_get(mctx, manager->fd_bufsize);
3323 if (manager->write_fds != NULL) {
3324 manager->write_fds_copy = isc_mem_get(mctx,
3325 manager->fd_bufsize);
3327 if (manager->write_fds_copy == NULL) {
3328 if (manager->write_fds != NULL) {
3329 isc_mem_put(mctx, manager->write_fds,
3330 manager->fd_bufsize);
3332 if (manager->read_fds_copy != NULL) {
3333 isc_mem_put(mctx, manager->read_fds_copy,
3334 manager->fd_bufsize);
3336 if (manager->read_fds != NULL) {
3337 isc_mem_put(mctx, manager->read_fds,
3338 manager->fd_bufsize);
3340 return (ISC_R_NOMEMORY);
3342 memset(manager->read_fds, 0, manager->fd_bufsize);
3343 memset(manager->write_fds, 0, manager->fd_bufsize);
3345 #ifdef ISC_PLATFORM_USETHREADS
3346 (void)watch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
3347 manager->maxfd = manager->pipe_fds[0];
3348 #else /* ISC_PLATFORM_USETHREADS */
3350 #endif /* ISC_PLATFORM_USETHREADS */
3351 #endif /* USE_KQUEUE */
3353 return (ISC_R_SUCCESS);
3357 cleanup_watcher(isc_mem_t *mctx, isc_socketmgr_t *manager) {
3358 #ifdef ISC_PLATFORM_USETHREADS
3359 isc_result_t result;
3361 result = unwatch_fd(manager, manager->pipe_fds[0], SELECT_POKE_READ);
3362 if (result != ISC_R_SUCCESS) {
3363 UNEXPECTED_ERROR(__FILE__, __LINE__,
3364 "epoll_ctl(DEL) %s",
3365 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
3366 ISC_MSG_FAILED, "failed"));
3368 #endif /* ISC_PLATFORM_USETHREADS */
3371 close(manager->kqueue_fd);
3372 isc_mem_put(mctx, manager->events,
3373 sizeof(struct kevent) * manager->nevents);
3374 #elif defined(USE_EPOLL)
3375 close(manager->epoll_fd);
3376 isc_mem_put(mctx, manager->events,
3377 sizeof(struct epoll_event) * manager->nevents);
3378 #elif defined(USE_DEVPOLL)
3379 close(manager->devpoll_fd);
3380 isc_mem_put(mctx, manager->events,
3381 sizeof(struct pollfd) * manager->nevents);
3382 isc_mem_put(mctx, manager->fdpollinfo,
3383 sizeof(pollinfo_t) * manager->maxsocks);
3384 #elif defined(USE_SELECT)
3385 if (manager->read_fds != NULL)
3386 isc_mem_put(mctx, manager->read_fds, manager->fd_bufsize);
3387 if (manager->read_fds_copy != NULL)
3388 isc_mem_put(mctx, manager->read_fds_copy, manager->fd_bufsize);
3389 if (manager->write_fds != NULL)
3390 isc_mem_put(mctx, manager->write_fds, manager->fd_bufsize);
3391 if (manager->write_fds_copy != NULL)
3392 isc_mem_put(mctx, manager->write_fds_copy, manager->fd_bufsize);
3393 #endif /* USE_KQUEUE */
3397 isc_socketmgr_create(isc_mem_t *mctx, isc_socketmgr_t **managerp) {
3398 return (isc_socketmgr_create2(mctx, managerp, 0));
3402 isc_socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
3403 unsigned int maxsocks)
3406 isc_socketmgr_t *manager;
3407 #ifdef ISC_PLATFORM_USETHREADS
3408 char strbuf[ISC_STRERRORSIZE];
3410 isc_result_t result;
3412 REQUIRE(managerp != NULL && *managerp == NULL);
3414 #ifndef ISC_PLATFORM_USETHREADS
3415 if (socketmgr != NULL) {
3416 /* Don't allow maxsocks to be updated */
3417 if (maxsocks > 0 && socketmgr->maxsocks != maxsocks)
3418 return (ISC_R_EXISTS);
3421 *managerp = socketmgr;
3422 return (ISC_R_SUCCESS);
3424 #endif /* ISC_PLATFORM_USETHREADS */
3427 maxsocks = ISC_SOCKET_MAXSOCKETS;
3429 manager = isc_mem_get(mctx, sizeof(*manager));
3430 if (manager == NULL)
3431 return (ISC_R_NOMEMORY);
3433 /* zero-clear so that necessary cleanup on failure will be easy */
3434 memset(manager, 0, sizeof(*manager));
3435 manager->maxsocks = maxsocks;
3436 manager->reserved = 0;
3437 manager->fds = isc_mem_get(mctx,
3438 manager->maxsocks * sizeof(isc_socket_t *));
3439 if (manager->fds == NULL) {
3440 result = ISC_R_NOMEMORY;
3443 manager->fdstate = isc_mem_get(mctx, manager->maxsocks * sizeof(int));
3444 if (manager->fds == NULL) {
3445 result = ISC_R_NOMEMORY;
3449 manager->magic = SOCKET_MANAGER_MAGIC;
3450 manager->mctx = NULL;
3451 memset(manager->fds, 0, manager->maxsocks * sizeof(isc_socket_t *));
3452 ISC_LIST_INIT(manager->socklist);
3453 result = isc_mutex_init(&manager->lock);
3454 if (result != ISC_R_SUCCESS)
3456 manager->fdlock = isc_mem_get(mctx, FDLOCK_COUNT * sizeof(isc_mutex_t));
3457 if (manager->fdlock == NULL) {
3458 result = ISC_R_NOMEMORY;
3461 for (i = 0; i < FDLOCK_COUNT; i++) {
3462 result = isc_mutex_init(&manager->fdlock[i]);
3463 if (result != ISC_R_SUCCESS) {
3465 DESTROYLOCK(&manager->fdlock[i]);
3466 isc_mem_put(mctx, manager->fdlock,
3467 FDLOCK_COUNT * sizeof(isc_mutex_t));
3468 manager->fdlock = NULL;
3473 #ifdef ISC_PLATFORM_USETHREADS
3474 if (isc_condition_init(&manager->shutdown_ok) != ISC_R_SUCCESS) {
3475 UNEXPECTED_ERROR(__FILE__, __LINE__,
3476 "isc_condition_init() %s",
3477 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
3478 ISC_MSG_FAILED, "failed"));
3479 result = ISC_R_UNEXPECTED;
3484 * Create the special fds that will be used to wake up the
3485 * select/poll loop when something internal needs to be done.
3487 if (pipe(manager->pipe_fds) != 0) {
3488 isc__strerror(errno, strbuf, sizeof(strbuf));
3489 UNEXPECTED_ERROR(__FILE__, __LINE__,
3491 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
3492 ISC_MSG_FAILED, "failed"),
3494 result = ISC_R_UNEXPECTED;
3495 goto cleanup_condition;
3498 RUNTIME_CHECK(make_nonblock(manager->pipe_fds[0]) == ISC_R_SUCCESS);
3500 RUNTIME_CHECK(make_nonblock(manager->pipe_fds[1]) == ISC_R_SUCCESS);
3502 #else /* ISC_PLATFORM_USETHREADS */
3504 #endif /* ISC_PLATFORM_USETHREADS */
3507 * Set up initial state for the select loop
3509 result = setup_watcher(mctx, manager);
3510 if (result != ISC_R_SUCCESS)
3512 memset(manager->fdstate, 0, manager->maxsocks * sizeof(int));
3513 #ifdef ISC_PLATFORM_USETHREADS
3515 * Start up the select/poll thread.
3517 if (isc_thread_create(watcher, manager, &manager->watcher) !=
3519 UNEXPECTED_ERROR(__FILE__, __LINE__,
3520 "isc_thread_create() %s",
3521 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
3522 ISC_MSG_FAILED, "failed"));
3523 cleanup_watcher(mctx, manager);
3524 result = ISC_R_UNEXPECTED;
3527 #endif /* ISC_PLATFORM_USETHREADS */
3528 isc_mem_attach(mctx, &manager->mctx);
3530 #ifndef ISC_PLATFORM_USETHREADS
3531 socketmgr = manager;
3532 #endif /* ISC_PLATFORM_USETHREADS */
3533 *managerp = manager;
3535 return (ISC_R_SUCCESS);
3538 #ifdef ISC_PLATFORM_USETHREADS
3539 (void)close(manager->pipe_fds[0]);
3540 (void)close(manager->pipe_fds[1]);
3541 #endif /* ISC_PLATFORM_USETHREADS */
3543 #ifdef ISC_PLATFORM_USETHREADS
3545 (void)isc_condition_destroy(&manager->shutdown_ok);
3546 #endif /* ISC_PLATFORM_USETHREADS */
3550 if (manager->fdlock != NULL) {
3551 for (i = 0; i < FDLOCK_COUNT; i++)
3552 DESTROYLOCK(&manager->fdlock[i]);
3554 DESTROYLOCK(&manager->lock);
3557 if (manager->fdlock != NULL) {
3558 isc_mem_put(mctx, manager->fdlock,
3559 FDLOCK_COUNT * sizeof(isc_mutex_t));
3561 if (manager->fdstate != NULL) {
3562 isc_mem_put(mctx, manager->fdstate,
3563 manager->maxsocks * sizeof(int));
3565 if (manager->fds != NULL) {
3566 isc_mem_put(mctx, manager->fds,
3567 manager->maxsocks * sizeof(isc_socket_t *));
3569 isc_mem_put(mctx, manager, sizeof(*manager));
3575 isc_socketmgr_getmaxsockets(isc_socketmgr_t *manager, unsigned int *nsockp) {
3576 REQUIRE(VALID_MANAGER(manager));
3577 REQUIRE(nsockp != NULL);
3579 *nsockp = manager->maxsocks;
3581 return (ISC_R_SUCCESS);
3585 isc_socketmgr_destroy(isc_socketmgr_t **managerp) {
3586 isc_socketmgr_t *manager;
3591 * Destroy a socket manager.
3594 REQUIRE(managerp != NULL);
3595 manager = *managerp;
3596 REQUIRE(VALID_MANAGER(manager));
3598 #ifndef ISC_PLATFORM_USETHREADS
3599 if (manager->refs > 1) {
3604 #endif /* ISC_PLATFORM_USETHREADS */
3606 LOCK(&manager->lock);
3608 #ifdef ISC_PLATFORM_USETHREADS
3610 * Wait for all sockets to be destroyed.
3612 while (!ISC_LIST_EMPTY(manager->socklist)) {
3613 manager_log(manager, CREATION,
3614 isc_msgcat_get(isc_msgcat, ISC_MSGSET_SOCKET,
3615 ISC_MSG_SOCKETSREMAIN,
3617 WAIT(&manager->shutdown_ok, &manager->lock);
3619 #else /* ISC_PLATFORM_USETHREADS */
3621 * Hope all sockets have been destroyed.
3623 if (!ISC_LIST_EMPTY(manager->socklist)) {
3624 manager_log(manager, CREATION,
3625 isc_msgcat_get(isc_msgcat, ISC_MSGSET_SOCKET,
3626 ISC_MSG_SOCKETSREMAIN,
3630 #endif /* ISC_PLATFORM_USETHREADS */
3632 UNLOCK(&manager->lock);
3635 * Here, poke our select/poll thread. Do this by closing the write
3636 * half of the pipe, which will send EOF to the read half.
3637 * This is currently a no-op in the non-threaded case.
3639 select_poke(manager, 0, SELECT_POKE_SHUTDOWN);
3641 #ifdef ISC_PLATFORM_USETHREADS
3643 * Wait for thread to exit.
3645 if (isc_thread_join(manager->watcher, NULL) != ISC_R_SUCCESS)
3646 UNEXPECTED_ERROR(__FILE__, __LINE__,
3647 "isc_thread_join() %s",
3648 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
3649 ISC_MSG_FAILED, "failed"));
3650 #endif /* ISC_PLATFORM_USETHREADS */
3655 cleanup_watcher(manager->mctx, manager);
3657 #ifdef ISC_PLATFORM_USETHREADS
3658 (void)close(manager->pipe_fds[0]);
3659 (void)close(manager->pipe_fds[1]);
3660 (void)isc_condition_destroy(&manager->shutdown_ok);
3661 #endif /* ISC_PLATFORM_USETHREADS */
3663 for (i = 0; i < (int)manager->maxsocks; i++)
3664 if (manager->fdstate[i] == CLOSE_PENDING) /* no need to lock */
3667 isc_mem_put(manager->mctx, manager->fds,
3668 manager->maxsocks * sizeof(isc_socket_t *));
3669 isc_mem_put(manager->mctx, manager->fdstate,
3670 manager->maxsocks * sizeof(int));
3672 if (manager->fdlock != NULL) {
3673 for (i = 0; i < FDLOCK_COUNT; i++)
3674 DESTROYLOCK(&manager->fdlock[i]);
3675 isc_mem_put(manager->mctx, manager->fdlock,
3676 FDLOCK_COUNT * sizeof(isc_mutex_t));
3678 DESTROYLOCK(&manager->lock);
3680 mctx= manager->mctx;
3681 isc_mem_put(mctx, manager, sizeof(*manager));
3683 isc_mem_detach(&mctx);
3689 socket_recv(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
3693 isc_boolean_t have_lock = ISC_FALSE;
3694 isc_task_t *ntask = NULL;
3695 isc_result_t result = ISC_R_SUCCESS;
3697 dev->ev_sender = task;
3699 if (sock->type == isc_sockettype_udp) {
3700 io_state = doio_recv(sock, dev);
3703 have_lock = ISC_TRUE;
3705 if (ISC_LIST_EMPTY(sock->recv_list))
3706 io_state = doio_recv(sock, dev);
3708 io_state = DOIO_SOFT;
3714 * We couldn't read all or part of the request right now, so
3717 * Attach to socket and to task
3719 isc_task_attach(task, &ntask);
3720 dev->attributes |= ISC_SOCKEVENTATTR_ATTACHED;
3724 have_lock = ISC_TRUE;
3728 * Enqueue the request. If the socket was previously not being
3729 * watched, poke the watcher to start paying attention to it.
3731 if (ISC_LIST_EMPTY(sock->recv_list) && !sock->pending_recv)
3732 select_poke(sock->manager, sock->fd, SELECT_POKE_READ);
3733 ISC_LIST_ENQUEUE(sock->recv_list, dev, ev_link);
3735 socket_log(sock, NULL, EVENT, NULL, 0, 0,
3736 "socket_recv: event %p -> task %p",
3739 if ((flags & ISC_SOCKFLAG_IMMEDIATE) != 0)
3740 result = ISC_R_INPROGRESS;
3744 dev->result = ISC_R_EOF;
3749 if ((flags & ISC_SOCKFLAG_IMMEDIATE) == 0)
3750 send_recvdone_event(sock, &dev);
3755 UNLOCK(&sock->lock);
3761 isc_socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
3762 unsigned int minimum, isc_task_t *task,
3763 isc_taskaction_t action, const void *arg)
3765 isc_socketevent_t *dev;
3766 isc_socketmgr_t *manager;
3767 unsigned int iocount;
3768 isc_buffer_t *buffer;
3770 REQUIRE(VALID_SOCKET(sock));
3771 REQUIRE(buflist != NULL);
3772 REQUIRE(!ISC_LIST_EMPTY(*buflist));
3773 REQUIRE(task != NULL);
3774 REQUIRE(action != NULL);
3776 manager = sock->manager;
3777 REQUIRE(VALID_MANAGER(manager));
3779 iocount = isc_bufferlist_availablecount(buflist);
3780 REQUIRE(iocount > 0);
3782 INSIST(sock->bound);
3784 dev = allocate_socketevent(sock, ISC_SOCKEVENT_RECVDONE, action, arg);
3786 return (ISC_R_NOMEMORY);
3790 * UDP sockets are always partial read
3792 if (sock->type == isc_sockettype_udp)
3796 dev->minimum = iocount;
3798 dev->minimum = minimum;
3802 * Move each buffer from the passed in list to our internal one.
3804 buffer = ISC_LIST_HEAD(*buflist);
3805 while (buffer != NULL) {
3806 ISC_LIST_DEQUEUE(*buflist, buffer, link);
3807 ISC_LIST_ENQUEUE(dev->bufferlist, buffer, link);
3808 buffer = ISC_LIST_HEAD(*buflist);
3811 return (socket_recv(sock, dev, task, 0));
3815 isc_socket_recv(isc_socket_t *sock, isc_region_t *region, unsigned int minimum,
3816 isc_task_t *task, isc_taskaction_t action, const void *arg)
3818 isc_socketevent_t *dev;
3819 isc_socketmgr_t *manager;
3821 REQUIRE(VALID_SOCKET(sock));
3822 REQUIRE(action != NULL);
3824 manager = sock->manager;
3825 REQUIRE(VALID_MANAGER(manager));
3827 INSIST(sock->bound);
3829 dev = allocate_socketevent(sock, ISC_SOCKEVENT_RECVDONE, action, arg);
3831 return (ISC_R_NOMEMORY);
3833 return (isc_socket_recv2(sock, region, minimum, task, dev, 0));
3837 isc_socket_recv2(isc_socket_t *sock, isc_region_t *region,
3838 unsigned int minimum, isc_task_t *task,
3839 isc_socketevent_t *event, unsigned int flags)
3841 event->ev_sender = sock;
3842 event->result = ISC_R_UNEXPECTED;
3843 ISC_LIST_INIT(event->bufferlist);
3844 event->region = *region;
3847 event->attributes = 0;
3850 * UDP sockets are always partial read.
3852 if (sock->type == isc_sockettype_udp)
3856 event->minimum = region->length;
3858 event->minimum = minimum;
3861 return (socket_recv(sock, event, task, flags));
3865 socket_send(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
3866 isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
3870 isc_boolean_t have_lock = ISC_FALSE;
3871 isc_task_t *ntask = NULL;
3872 isc_result_t result = ISC_R_SUCCESS;
3874 dev->ev_sender = task;
3876 set_dev_address(address, sock, dev);
3877 if (pktinfo != NULL) {
3878 dev->attributes |= ISC_SOCKEVENTATTR_PKTINFO;
3879 dev->pktinfo = *pktinfo;
3881 if (!isc_sockaddr_issitelocal(&dev->address) &&
3882 !isc_sockaddr_islinklocal(&dev->address)) {
3883 socket_log(sock, NULL, TRACE, isc_msgcat,
3884 ISC_MSGSET_SOCKET, ISC_MSG_PKTINFOPROVIDED,
3885 "pktinfo structure provided, ifindex %u "
3886 "(set to 0)", pktinfo->ipi6_ifindex);
3889 * Set the pktinfo index to 0 here, to let the
3890 * kernel decide what interface it should send on.
3892 dev->pktinfo.ipi6_ifindex = 0;
3896 if (sock->type == isc_sockettype_udp)
3897 io_state = doio_send(sock, dev);
3900 have_lock = ISC_TRUE;
3902 if (ISC_LIST_EMPTY(sock->send_list))
3903 io_state = doio_send(sock, dev);
3905 io_state = DOIO_SOFT;
3911 * We couldn't send all or part of the request right now, so
3912 * queue it unless ISC_SOCKFLAG_NORETRY is set.
3914 if ((flags & ISC_SOCKFLAG_NORETRY) == 0) {
3915 isc_task_attach(task, &ntask);
3916 dev->attributes |= ISC_SOCKEVENTATTR_ATTACHED;
3920 have_lock = ISC_TRUE;
3924 * Enqueue the request. If the socket was previously
3925 * not being watched, poke the watcher to start
3926 * paying attention to it.
3928 if (ISC_LIST_EMPTY(sock->send_list) &&
3929 !sock->pending_send)
3930 select_poke(sock->manager, sock->fd,
3932 ISC_LIST_ENQUEUE(sock->send_list, dev, ev_link);
3934 socket_log(sock, NULL, EVENT, NULL, 0, 0,
3935 "socket_send: event %p -> task %p",
3938 if ((flags & ISC_SOCKFLAG_IMMEDIATE) != 0)
3939 result = ISC_R_INPROGRESS;
3945 if ((flags & ISC_SOCKFLAG_IMMEDIATE) == 0)
3946 send_senddone_event(sock, &dev);
3951 UNLOCK(&sock->lock);
3957 isc_socket_send(isc_socket_t *sock, isc_region_t *region,
3958 isc_task_t *task, isc_taskaction_t action, const void *arg)
3961 * REQUIRE() checking is performed in isc_socket_sendto().
3963 return (isc_socket_sendto(sock, region, task, action, arg, NULL,
3968 isc_socket_sendto(isc_socket_t *sock, isc_region_t *region,
3969 isc_task_t *task, isc_taskaction_t action, const void *arg,
3970 isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
3972 isc_socketevent_t *dev;
3973 isc_socketmgr_t *manager;
3975 REQUIRE(VALID_SOCKET(sock));
3976 REQUIRE(region != NULL);
3977 REQUIRE(task != NULL);
3978 REQUIRE(action != NULL);
3980 manager = sock->manager;
3981 REQUIRE(VALID_MANAGER(manager));
3983 INSIST(sock->bound);
3985 dev = allocate_socketevent(sock, ISC_SOCKEVENT_SENDDONE, action, arg);
3987 return (ISC_R_NOMEMORY);
3990 dev->region = *region;
3992 return (socket_send(sock, dev, task, address, pktinfo, 0));
3996 isc_socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
3997 isc_task_t *task, isc_taskaction_t action, const void *arg)
3999 return (isc_socket_sendtov(sock, buflist, task, action, arg, NULL,
4004 isc_socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
4005 isc_task_t *task, isc_taskaction_t action, const void *arg,
4006 isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
4008 isc_socketevent_t *dev;
4009 isc_socketmgr_t *manager;
4010 unsigned int iocount;
4011 isc_buffer_t *buffer;
4013 REQUIRE(VALID_SOCKET(sock));
4014 REQUIRE(buflist != NULL);
4015 REQUIRE(!ISC_LIST_EMPTY(*buflist));
4016 REQUIRE(task != NULL);
4017 REQUIRE(action != NULL);
4019 manager = sock->manager;
4020 REQUIRE(VALID_MANAGER(manager));
4022 iocount = isc_bufferlist_usedcount(buflist);
4023 REQUIRE(iocount > 0);
4025 dev = allocate_socketevent(sock, ISC_SOCKEVENT_SENDDONE, action, arg);
4027 return (ISC_R_NOMEMORY);
4031 * Move each buffer from the passed in list to our internal one.
4033 buffer = ISC_LIST_HEAD(*buflist);
4034 while (buffer != NULL) {
4035 ISC_LIST_DEQUEUE(*buflist, buffer, link);
4036 ISC_LIST_ENQUEUE(dev->bufferlist, buffer, link);
4037 buffer = ISC_LIST_HEAD(*buflist);
4040 return (socket_send(sock, dev, task, address, pktinfo, 0));
4044 isc_socket_sendto2(isc_socket_t *sock, isc_region_t *region,
4046 isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
4047 isc_socketevent_t *event, unsigned int flags)
4049 REQUIRE((flags & ~(ISC_SOCKFLAG_IMMEDIATE|ISC_SOCKFLAG_NORETRY)) == 0);
4050 if ((flags & ISC_SOCKFLAG_NORETRY) != 0)
4051 REQUIRE(sock->type == isc_sockettype_udp);
4052 event->ev_sender = sock;
4053 event->result = ISC_R_UNEXPECTED;
4054 ISC_LIST_INIT(event->bufferlist);
4055 event->region = *region;
4058 event->attributes = 0;
4060 return (socket_send(sock, event, task, address, pktinfo, flags));
4064 isc_socket_cleanunix(isc_sockaddr_t *sockaddr, isc_boolean_t active) {
4065 #ifdef ISC_PLATFORM_HAVESYSUNH
4068 char strbuf[ISC_STRERRORSIZE];
4070 if (sockaddr->type.sa.sa_family != AF_UNIX)
4074 #if defined(S_IFMT) && defined(S_IFSOCK)
4075 #define S_ISSOCK(mode) ((mode & S_IFMT)==S_IFSOCK)
4076 #elif defined(_S_IFMT) && defined(S_IFSOCK)
4077 #define S_ISSOCK(mode) ((mode & _S_IFMT)==S_IFSOCK)
4082 #if defined(S_IFMT) && defined(S_IFIFO)
4083 #define S_ISFIFO(mode) ((mode & S_IFMT)==S_IFIFO)
4084 #elif defined(_S_IFMT) && defined(S_IFIFO)
4085 #define S_ISFIFO(mode) ((mode & _S_IFMT)==S_IFIFO)
4089 #if !defined(S_ISFIFO) && !defined(S_ISSOCK)
4090 #error You need to define S_ISFIFO and S_ISSOCK as appropriate for your platform. See <sys/stat.h>.
4094 #define S_ISFIFO(mode) 0
4098 #define S_ISSOCK(mode) 0
4102 if (stat(sockaddr->type.sunix.sun_path, &sb) < 0) {
4103 isc__strerror(errno, strbuf, sizeof(strbuf));
4104 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
4105 ISC_LOGMODULE_SOCKET, ISC_LOG_ERROR,
4106 "isc_socket_cleanunix: stat(%s): %s",
4107 sockaddr->type.sunix.sun_path, strbuf);
4110 if (!(S_ISSOCK(sb.st_mode) || S_ISFIFO(sb.st_mode))) {
4111 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
4112 ISC_LOGMODULE_SOCKET, ISC_LOG_ERROR,
4113 "isc_socket_cleanunix: %s: not a socket",
4114 sockaddr->type.sunix.sun_path);
4117 if (unlink(sockaddr->type.sunix.sun_path) < 0) {
4118 isc__strerror(errno, strbuf, sizeof(strbuf));
4119 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
4120 ISC_LOGMODULE_SOCKET, ISC_LOG_ERROR,
4121 "isc_socket_cleanunix: unlink(%s): %s",
4122 sockaddr->type.sunix.sun_path, strbuf);
4127 s = socket(AF_UNIX, SOCK_STREAM, 0);
4129 isc__strerror(errno, strbuf, sizeof(strbuf));
4130 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
4131 ISC_LOGMODULE_SOCKET, ISC_LOG_WARNING,
4132 "isc_socket_cleanunix: socket(%s): %s",
4133 sockaddr->type.sunix.sun_path, strbuf);
4137 if (stat(sockaddr->type.sunix.sun_path, &sb) < 0) {
4139 case ENOENT: /* We exited cleanly last time */
4142 isc__strerror(errno, strbuf, sizeof(strbuf));
4143 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
4144 ISC_LOGMODULE_SOCKET, ISC_LOG_WARNING,
4145 "isc_socket_cleanunix: stat(%s): %s",
4146 sockaddr->type.sunix.sun_path, strbuf);
4152 if (!(S_ISSOCK(sb.st_mode) || S_ISFIFO(sb.st_mode))) {
4153 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
4154 ISC_LOGMODULE_SOCKET, ISC_LOG_WARNING,
4155 "isc_socket_cleanunix: %s: not a socket",
4156 sockaddr->type.sunix.sun_path);
4160 if (connect(s, (struct sockaddr *)&sockaddr->type.sunix,
4161 sizeof(sockaddr->type.sunix)) < 0) {
4165 if (unlink(sockaddr->type.sunix.sun_path) < 0) {
4166 isc__strerror(errno, strbuf, sizeof(strbuf));
4167 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
4168 ISC_LOGMODULE_SOCKET,
4170 "isc_socket_cleanunix: "
4172 sockaddr->type.sunix.sun_path,
4177 isc__strerror(errno, strbuf, sizeof(strbuf));
4178 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
4179 ISC_LOGMODULE_SOCKET, ISC_LOG_WARNING,
4180 "isc_socket_cleanunix: connect(%s): %s",
4181 sockaddr->type.sunix.sun_path, strbuf);
4194 isc_socket_permunix(isc_sockaddr_t *sockaddr, isc_uint32_t perm,
4195 isc_uint32_t owner, isc_uint32_t group)
4197 #ifdef ISC_PLATFORM_HAVESYSUNH
4198 isc_result_t result = ISC_R_SUCCESS;
4199 char strbuf[ISC_STRERRORSIZE];
4200 char path[sizeof(sockaddr->type.sunix.sun_path)];
4201 #ifdef NEED_SECURE_DIRECTORY
4205 REQUIRE(sockaddr->type.sa.sa_family == AF_UNIX);
4206 INSIST(strlen(sockaddr->type.sunix.sun_path) < sizeof(path));
4207 strcpy(path, sockaddr->type.sunix.sun_path);
4209 #ifdef NEED_SECURE_DIRECTORY
4210 slash = strrchr(path, '/');
4211 if (slash != NULL) {
4220 if (chmod(path, perm) < 0) {
4221 isc__strerror(errno, strbuf, sizeof(strbuf));
4222 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
4223 ISC_LOGMODULE_SOCKET, ISC_LOG_ERROR,
4224 "isc_socket_permunix: chmod(%s, %d): %s",
4225 path, perm, strbuf);
4226 result = ISC_R_FAILURE;
4228 if (chown(path, owner, group) < 0) {
4229 isc__strerror(errno, strbuf, sizeof(strbuf));
4230 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
4231 ISC_LOGMODULE_SOCKET, ISC_LOG_ERROR,
4232 "isc_socket_permunix: chown(%s, %d, %d): %s",
4235 result = ISC_R_FAILURE;
4243 return (ISC_R_NOTIMPLEMENTED);
4248 isc_socket_bind(isc_socket_t *sock, isc_sockaddr_t *sockaddr,
4249 unsigned int options) {
4250 char strbuf[ISC_STRERRORSIZE];
4255 INSIST(!sock->bound);
4257 if (sock->pf != sockaddr->type.sa.sa_family) {
4258 UNLOCK(&sock->lock);
4259 return (ISC_R_FAMILYMISMATCH);
4262 * Only set SO_REUSEADDR when we want a specific port.
4265 if (sock->pf == AF_UNIX)
4268 if ((options & ISC_SOCKET_REUSEADDRESS) != 0 &&
4269 isc_sockaddr_getport(sockaddr) != (in_port_t)0 &&
4270 setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, (void *)&on,
4272 UNEXPECTED_ERROR(__FILE__, __LINE__,
4273 "setsockopt(%d) %s", sock->fd,
4274 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
4275 ISC_MSG_FAILED, "failed"));
4281 if (bind(sock->fd, &sockaddr->type.sa, sockaddr->length) < 0) {
4282 UNLOCK(&sock->lock);
4285 return (ISC_R_NOPERM);
4287 return (ISC_R_ADDRNOTAVAIL);
4289 return (ISC_R_ADDRINUSE);
4291 return (ISC_R_BOUND);
4293 isc__strerror(errno, strbuf, sizeof(strbuf));
4294 UNEXPECTED_ERROR(__FILE__, __LINE__, "bind: %s",
4296 return (ISC_R_UNEXPECTED);
4300 socket_log(sock, sockaddr, TRACE,
4301 isc_msgcat, ISC_MSGSET_SOCKET, ISC_MSG_BOUND, "bound");
4304 UNLOCK(&sock->lock);
4305 return (ISC_R_SUCCESS);
4309 isc_socket_filter(isc_socket_t *sock, const char *filter) {
4310 #ifdef SO_ACCEPTFILTER
4311 char strbuf[ISC_STRERRORSIZE];
4312 struct accept_filter_arg afa;
4318 REQUIRE(VALID_SOCKET(sock));
4320 #ifdef SO_ACCEPTFILTER
4321 bzero(&afa, sizeof(afa));
4322 strncpy(afa.af_name, filter, sizeof(afa.af_name));
4323 if (setsockopt(sock->fd, SOL_SOCKET, SO_ACCEPTFILTER,
4324 &afa, sizeof(afa)) == -1) {
4325 isc__strerror(errno, strbuf, sizeof(strbuf));
4326 socket_log(sock, NULL, CREATION, isc_msgcat, ISC_MSGSET_SOCKET,
4327 ISC_MSG_FILTER, "setsockopt(SO_ACCEPTFILTER): %s",
4329 return (ISC_R_FAILURE);
4331 return (ISC_R_SUCCESS);
4333 return (ISC_R_NOTIMPLEMENTED);
4338 * Set up to listen on a given socket. We do this by creating an internal
4339 * event that will be dispatched when the socket has read activity. The
4340 * watcher will send the internal event to the task when there is a new
4343 * Unlike in read, we don't preallocate a done event here. Every time there
4344 * is a new connection we'll have to allocate a new one anyway, so we might
4345 * as well keep things simple rather than having to track them.
4348 isc_socket_listen(isc_socket_t *sock, unsigned int backlog) {
4349 char strbuf[ISC_STRERRORSIZE];
4351 REQUIRE(VALID_SOCKET(sock));
4355 REQUIRE(!sock->listener);
4356 REQUIRE(sock->bound);
4357 REQUIRE(sock->type == isc_sockettype_tcp ||
4358 sock->type == isc_sockettype_unix);
4361 backlog = SOMAXCONN;
4363 if (listen(sock->fd, (int)backlog) < 0) {
4364 UNLOCK(&sock->lock);
4365 isc__strerror(errno, strbuf, sizeof(strbuf));
4367 UNEXPECTED_ERROR(__FILE__, __LINE__, "listen: %s", strbuf);
4369 return (ISC_R_UNEXPECTED);
4374 UNLOCK(&sock->lock);
4375 return (ISC_R_SUCCESS);
4379 * This should try to do aggressive accept() XXXMLG
4382 isc_socket_accept(isc_socket_t *sock,
4383 isc_task_t *task, isc_taskaction_t action, const void *arg)
4385 isc_socket_newconnev_t *dev;
4386 isc_socketmgr_t *manager;
4387 isc_task_t *ntask = NULL;
4388 isc_socket_t *nsock;
4389 isc_result_t result;
4390 isc_boolean_t do_poke = ISC_FALSE;
4392 REQUIRE(VALID_SOCKET(sock));
4393 manager = sock->manager;
4394 REQUIRE(VALID_MANAGER(manager));
4398 REQUIRE(sock->listener);
4401 * Sender field is overloaded here with the task we will be sending
4402 * this event to. Just before the actual event is delivered the
4403 * actual ev_sender will be touched up to be the socket.
4405 dev = (isc_socket_newconnev_t *)
4406 isc_event_allocate(manager->mctx, task, ISC_SOCKEVENT_NEWCONN,
4407 action, arg, sizeof(*dev));
4409 UNLOCK(&sock->lock);
4410 return (ISC_R_NOMEMORY);
4412 ISC_LINK_INIT(dev, ev_link);
4414 result = allocate_socket(manager, sock->type, &nsock);
4415 if (result != ISC_R_SUCCESS) {
4416 isc_event_free(ISC_EVENT_PTR(&dev));
4417 UNLOCK(&sock->lock);
4422 * Attach to socket and to task.
4424 isc_task_attach(task, &ntask);
4425 nsock->references++;
4427 dev->ev_sender = ntask;
4428 dev->newsocket = nsock;
4431 * Poke watcher here. We still have the socket locked, so there
4432 * is no race condition. We will keep the lock for such a short
4433 * bit of time waking it up now or later won't matter all that much.
4435 if (ISC_LIST_EMPTY(sock->accept_list))
4438 ISC_LIST_ENQUEUE(sock->accept_list, dev, ev_link);
4441 select_poke(manager, sock->fd, SELECT_POKE_ACCEPT);
4443 UNLOCK(&sock->lock);
4444 return (ISC_R_SUCCESS);
4448 isc_socket_connect(isc_socket_t *sock, isc_sockaddr_t *addr,
4449 isc_task_t *task, isc_taskaction_t action, const void *arg)
4451 isc_socket_connev_t *dev;
4452 isc_task_t *ntask = NULL;
4453 isc_socketmgr_t *manager;
4455 char strbuf[ISC_STRERRORSIZE];
4457 REQUIRE(VALID_SOCKET(sock));
4458 REQUIRE(addr != NULL);
4459 REQUIRE(task != NULL);
4460 REQUIRE(action != NULL);
4462 manager = sock->manager;
4463 REQUIRE(VALID_MANAGER(manager));
4464 REQUIRE(addr != NULL);
4466 if (isc_sockaddr_ismulticast(addr))
4467 return (ISC_R_MULTICAST);
4471 REQUIRE(!sock->connecting);
4473 dev = (isc_socket_connev_t *)isc_event_allocate(manager->mctx, sock,
4474 ISC_SOCKEVENT_CONNECT,
4478 UNLOCK(&sock->lock);
4479 return (ISC_R_NOMEMORY);
4481 ISC_LINK_INIT(dev, ev_link);
4484 * Try to do the connect right away, as there can be only one
4485 * outstanding, and it might happen to complete.
4487 sock->address = *addr;
4488 cc = connect(sock->fd, &addr->type.sa, addr->length);
4491 * HP-UX "fails" to connect a UDP socket and sets errno to
4492 * EINPROGRESS if it's non-blocking. We'd rather regard this as
4493 * a success and let the user detect it if it's really an error
4494 * at the time of sending a packet on the socket.
4496 if (sock->type == isc_sockettype_udp && errno == EINPROGRESS) {
4500 if (SOFT_ERROR(errno) || errno == EINPROGRESS)
4504 #define ERROR_MATCH(a, b) case a: dev->result = b; goto err_exit;
4505 ERROR_MATCH(EACCES, ISC_R_NOPERM);
4506 ERROR_MATCH(EADDRNOTAVAIL, ISC_R_ADDRNOTAVAIL);
4507 ERROR_MATCH(EAFNOSUPPORT, ISC_R_ADDRNOTAVAIL);
4508 ERROR_MATCH(ECONNREFUSED, ISC_R_CONNREFUSED);
4509 ERROR_MATCH(EHOSTUNREACH, ISC_R_HOSTUNREACH);
4511 ERROR_MATCH(EHOSTDOWN, ISC_R_HOSTUNREACH);
4513 ERROR_MATCH(ENETUNREACH, ISC_R_NETUNREACH);
4514 ERROR_MATCH(ENOBUFS, ISC_R_NORESOURCES);
4515 ERROR_MATCH(EPERM, ISC_R_HOSTUNREACH);
4516 ERROR_MATCH(EPIPE, ISC_R_NOTCONNECTED);
4517 ERROR_MATCH(ECONNRESET, ISC_R_CONNECTIONRESET);
4521 sock->connected = 0;
4523 isc__strerror(errno, strbuf, sizeof(strbuf));
4524 UNEXPECTED_ERROR(__FILE__, __LINE__, "%d/%s", errno, strbuf);
4526 UNLOCK(&sock->lock);
4527 isc_event_free(ISC_EVENT_PTR(&dev));
4528 return (ISC_R_UNEXPECTED);
4531 sock->connected = 0;
4532 isc_task_send(task, ISC_EVENT_PTR(&dev));
4534 UNLOCK(&sock->lock);
4535 return (ISC_R_SUCCESS);
4539 * If connect completed, fire off the done event.
4543 sock->connected = 1;
4545 dev->result = ISC_R_SUCCESS;
4546 isc_task_send(task, ISC_EVENT_PTR(&dev));
4548 UNLOCK(&sock->lock);
4549 return (ISC_R_SUCCESS);
4557 isc_task_attach(task, &ntask);
4559 sock->connecting = 1;
4561 dev->ev_sender = ntask;
4564 * Poke watcher here. We still have the socket locked, so there
4565 * is no race condition. We will keep the lock for such a short
4566 * bit of time waking it up now or later won't matter all that much.
4568 if (sock->connect_ev == NULL)
4569 select_poke(manager, sock->fd, SELECT_POKE_CONNECT);
4571 sock->connect_ev = dev;
4573 UNLOCK(&sock->lock);
4574 return (ISC_R_SUCCESS);
4578 * Called when a socket with a pending connect() finishes.
4581 internal_connect(isc_task_t *me, isc_event_t *ev) {
4583 isc_socket_connev_t *dev;
4586 ISC_SOCKADDR_LEN_T optlen;
4587 char strbuf[ISC_STRERRORSIZE];
4588 char peerbuf[ISC_SOCKADDR_FORMATSIZE];
4591 INSIST(ev->ev_type == ISC_SOCKEVENT_INTW);
4593 sock = ev->ev_sender;
4594 INSIST(VALID_SOCKET(sock));
4599 * When the internal event was sent the reference count was bumped
4600 * to keep the socket around for us. Decrement the count here.
4602 INSIST(sock->references > 0);
4604 if (sock->references == 0) {
4605 UNLOCK(&sock->lock);
4611 * Has this event been canceled?
4613 dev = sock->connect_ev;
4615 INSIST(!sock->connecting);
4616 UNLOCK(&sock->lock);
4620 INSIST(sock->connecting);
4621 sock->connecting = 0;
4624 * Get any possible error status here.
4626 optlen = sizeof(cc);
4627 if (getsockopt(sock->fd, SOL_SOCKET, SO_ERROR,
4628 (void *)&cc, (void *)&optlen) < 0)
4635 * If the error is EAGAIN, just re-select on this
4636 * fd and pretend nothing strange happened.
4638 if (SOFT_ERROR(errno) || errno == EINPROGRESS) {
4639 sock->connecting = 1;
4640 select_poke(sock->manager, sock->fd,
4641 SELECT_POKE_CONNECT);
4642 UNLOCK(&sock->lock);
4648 * Translate other errors into ISC_R_* flavors.
4651 #define ERROR_MATCH(a, b) case a: dev->result = b; break;
4652 ERROR_MATCH(EACCES, ISC_R_NOPERM);
4653 ERROR_MATCH(EADDRNOTAVAIL, ISC_R_ADDRNOTAVAIL);
4654 ERROR_MATCH(EAFNOSUPPORT, ISC_R_ADDRNOTAVAIL);
4655 ERROR_MATCH(ECONNREFUSED, ISC_R_CONNREFUSED);
4656 ERROR_MATCH(EHOSTUNREACH, ISC_R_HOSTUNREACH);
4658 ERROR_MATCH(EHOSTDOWN, ISC_R_HOSTUNREACH);
4660 ERROR_MATCH(ENETUNREACH, ISC_R_NETUNREACH);
4661 ERROR_MATCH(ENOBUFS, ISC_R_NORESOURCES);
4662 ERROR_MATCH(EPERM, ISC_R_HOSTUNREACH);
4663 ERROR_MATCH(EPIPE, ISC_R_NOTCONNECTED);
4664 ERROR_MATCH(ETIMEDOUT, ISC_R_TIMEDOUT);
4665 ERROR_MATCH(ECONNRESET, ISC_R_CONNECTIONRESET);
4668 dev->result = ISC_R_UNEXPECTED;
4669 isc_sockaddr_format(&sock->address, peerbuf,
4671 isc__strerror(errno, strbuf, sizeof(strbuf));
4672 UNEXPECTED_ERROR(__FILE__, __LINE__,
4673 "internal_connect: connect(%s) %s",
4677 dev->result = ISC_R_SUCCESS;
4678 sock->connected = 1;
4682 sock->connect_ev = NULL;
4684 UNLOCK(&sock->lock);
4686 task = dev->ev_sender;
4687 dev->ev_sender = sock;
4688 isc_task_sendanddetach(&task, ISC_EVENT_PTR(&dev));
4692 isc_socket_getpeername(isc_socket_t *sock, isc_sockaddr_t *addressp) {
4693 isc_result_t result;
4695 REQUIRE(VALID_SOCKET(sock));
4696 REQUIRE(addressp != NULL);
4700 if (sock->connected) {
4701 *addressp = sock->address;
4702 result = ISC_R_SUCCESS;
4704 result = ISC_R_NOTCONNECTED;
4707 UNLOCK(&sock->lock);
4713 isc_socket_getsockname(isc_socket_t *sock, isc_sockaddr_t *addressp) {
4714 ISC_SOCKADDR_LEN_T len;
4715 isc_result_t result;
4716 char strbuf[ISC_STRERRORSIZE];
4718 REQUIRE(VALID_SOCKET(sock));
4719 REQUIRE(addressp != NULL);
4724 result = ISC_R_NOTBOUND;
4728 result = ISC_R_SUCCESS;
4730 len = sizeof(addressp->type);
4731 if (getsockname(sock->fd, &addressp->type.sa, (void *)&len) < 0) {
4732 isc__strerror(errno, strbuf, sizeof(strbuf));
4733 UNEXPECTED_ERROR(__FILE__, __LINE__, "getsockname: %s",
4735 result = ISC_R_UNEXPECTED;
4738 addressp->length = (unsigned int)len;
4741 UNLOCK(&sock->lock);
4747 * Run through the list of events on this socket, and cancel the ones
4748 * queued for task "task" of type "how". "how" is a bitmask.
4751 isc_socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how) {
4753 REQUIRE(VALID_SOCKET(sock));
4756 * Quick exit if there is nothing to do. Don't even bother locking
4765 * All of these do the same thing, more or less.
4767 * o If the internal event is marked as "posted" try to
4768 * remove it from the task's queue. If this fails, mark it
4769 * as canceled instead, and let the task clean it up later.
4770 * o For each I/O request for that task of that type, post
4771 * its done event with status of "ISC_R_CANCELED".
4772 * o Reset any state needed.
4774 if (((how & ISC_SOCKCANCEL_RECV) == ISC_SOCKCANCEL_RECV)
4775 && !ISC_LIST_EMPTY(sock->recv_list)) {
4776 isc_socketevent_t *dev;
4777 isc_socketevent_t *next;
4778 isc_task_t *current_task;
4780 dev = ISC_LIST_HEAD(sock->recv_list);
4782 while (dev != NULL) {
4783 current_task = dev->ev_sender;
4784 next = ISC_LIST_NEXT(dev, ev_link);
4786 if ((task == NULL) || (task == current_task)) {
4787 dev->result = ISC_R_CANCELED;
4788 send_recvdone_event(sock, &dev);
4794 if (((how & ISC_SOCKCANCEL_SEND) == ISC_SOCKCANCEL_SEND)
4795 && !ISC_LIST_EMPTY(sock->send_list)) {
4796 isc_socketevent_t *dev;
4797 isc_socketevent_t *next;
4798 isc_task_t *current_task;
4800 dev = ISC_LIST_HEAD(sock->send_list);
4802 while (dev != NULL) {
4803 current_task = dev->ev_sender;
4804 next = ISC_LIST_NEXT(dev, ev_link);
4806 if ((task == NULL) || (task == current_task)) {
4807 dev->result = ISC_R_CANCELED;
4808 send_senddone_event(sock, &dev);
4814 if (((how & ISC_SOCKCANCEL_ACCEPT) == ISC_SOCKCANCEL_ACCEPT)
4815 && !ISC_LIST_EMPTY(sock->accept_list)) {
4816 isc_socket_newconnev_t *dev;
4817 isc_socket_newconnev_t *next;
4818 isc_task_t *current_task;
4820 dev = ISC_LIST_HEAD(sock->accept_list);
4821 while (dev != NULL) {
4822 current_task = dev->ev_sender;
4823 next = ISC_LIST_NEXT(dev, ev_link);
4825 if ((task == NULL) || (task == current_task)) {
4827 ISC_LIST_UNLINK(sock->accept_list, dev,
4830 dev->newsocket->references--;
4831 free_socket(&dev->newsocket);
4833 dev->result = ISC_R_CANCELED;
4834 dev->ev_sender = sock;
4835 isc_task_sendanddetach(¤t_task,
4836 ISC_EVENT_PTR(&dev));
4844 * Connecting is not a list.
4846 if (((how & ISC_SOCKCANCEL_CONNECT) == ISC_SOCKCANCEL_CONNECT)
4847 && sock->connect_ev != NULL) {
4848 isc_socket_connev_t *dev;
4849 isc_task_t *current_task;
4851 INSIST(sock->connecting);
4852 sock->connecting = 0;
4854 dev = sock->connect_ev;
4855 current_task = dev->ev_sender;
4857 if ((task == NULL) || (task == current_task)) {
4858 sock->connect_ev = NULL;
4860 dev->result = ISC_R_CANCELED;
4861 dev->ev_sender = sock;
4862 isc_task_sendanddetach(¤t_task,
4863 ISC_EVENT_PTR(&dev));
4867 UNLOCK(&sock->lock);
4871 isc_socket_gettype(isc_socket_t *sock) {
4872 REQUIRE(VALID_SOCKET(sock));
4874 return (sock->type);
4878 isc_socket_isbound(isc_socket_t *sock) {
4882 val = ((sock->bound) ? ISC_TRUE : ISC_FALSE);
4883 UNLOCK(&sock->lock);
4889 isc_socket_ipv6only(isc_socket_t *sock, isc_boolean_t yes) {
4890 #if defined(IPV6_V6ONLY)
4891 int onoff = yes ? 1 : 0;
4897 REQUIRE(VALID_SOCKET(sock));
4900 if (sock->pf == AF_INET6) {
4901 if (setsockopt(sock->fd, IPPROTO_IPV6, IPV6_V6ONLY,
4902 (void *)&onoff, sizeof(int)) < 0) {
4903 char strbuf[ISC_STRERRORSIZE];
4905 UNEXPECTED_ERROR(__FILE__, __LINE__,
4906 "setsockopt(%d, IPV6_V6ONLY) "
4908 isc_msgcat_get(isc_msgcat,
4915 FIX_IPV6_RECVPKTINFO(sock); /* AIX */
4919 #ifndef ISC_PLATFORM_USETHREADS
4920 /* In our assumed scenario, we can simply use a single static object. */
4921 static isc_socketwait_t swait_private;
4924 isc__socketmgr_waitevents(struct timeval *tvp, isc_socketwait_t **swaitp) {
4927 struct timespec ts, *tsp;
4936 REQUIRE(swaitp != NULL && *swaitp == NULL);
4938 if (socketmgr == NULL)
4943 ts.tv_sec = tvp->tv_sec;
4944 ts.tv_nsec = tvp->tv_usec * 1000;
4948 swait_private.nevents = kevent(socketmgr->kqueue_fd, NULL, 0,
4949 socketmgr->events, socketmgr->nevents,
4951 n = swait_private.nevents;
4952 #elif defined(USE_EPOLL)
4954 timeout = tvp->tv_sec * 1000 + (tvp->tv_usec + 999) / 1000;
4957 swait_private.nevents = epoll_wait(socketmgr->epoll_fd,
4959 socketmgr->nevents, timeout);
4960 n = swait_private.nevents;
4961 #elif defined(USE_DEVPOLL)
4962 dvp.dp_fds = socketmgr->events;
4963 dvp.dp_nfds = socketmgr->nevents;
4965 dvp.dp_timeout = tvp->tv_sec * 1000 +
4966 (tvp->tv_usec + 999) / 1000;
4968 dvp.dp_timeout = -1;
4969 swait_private.nevents = ioctl(socketmgr->devpoll_fd, DP_POLL, &dvp);
4970 n = swait_private.nevents;
4971 #elif defined(USE_SELECT)
4972 memcpy(socketmgr->read_fds_copy, socketmgr->read_fds,
4973 socketmgr->fd_bufsize);
4974 memcpy(socketmgr->write_fds_copy, socketmgr->write_fds,
4975 socketmgr->fd_bufsize);
4977 swait_private.readset = socketmgr->read_fds_copy;
4978 swait_private.writeset = socketmgr->write_fds_copy;
4979 swait_private.maxfd = socketmgr->maxfd + 1;
4981 n = select(swait_private.maxfd, swait_private.readset,
4982 swait_private.writeset, NULL, tvp);
4985 *swaitp = &swait_private;
4990 isc__socketmgr_dispatch(isc_socketwait_t *swait) {
4991 REQUIRE(swait == &swait_private);
4993 if (socketmgr == NULL)
4994 return (ISC_R_NOTFOUND);
4996 #if defined(USE_KQUEUE) || defined(USE_EPOLL) || defined(USE_DEVPOLL)
4997 (void)process_fds(socketmgr, socketmgr->events, swait->nevents);
4998 return (ISC_R_SUCCESS);
4999 #elif defined(USE_SELECT)
5000 process_fds(socketmgr, swait->maxfd, swait->readset, swait->writeset);
5001 return (ISC_R_SUCCESS);
5004 #endif /* ISC_PLATFORM_USETHREADS */