diff options
Diffstat (limited to 'openvpn/event.c')
| -rw-r--r-- | openvpn/event.c | 1061 |
1 files changed, 1061 insertions, 0 deletions
diff --git a/openvpn/event.c b/openvpn/event.c new file mode 100644 index 0000000..0d2c096 --- /dev/null +++ b/openvpn/event.c @@ -0,0 +1,1061 @@ +/* + * OpenVPN -- An application to securely tunnel IP networks + * over a single TCP/UDP port, with support for SSL/TLS-based + * session authentication and key exchange, + * packet encryption, packet authentication, and + * packet compression. + * + * Copyright (C) 2002-2005 OpenVPN Solutions LLC <info@openvpn.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program (see the file COPYING included with this + * distribution); if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifdef WIN32 +#include "config-win32.h" +#else +#include "config.h" +#endif + +#include "syshead.h" + +#include "buffer.h" +#include "error.h" +#include "integer.h" +#include "event.h" + +#include "memdbg.h" + +/* + * Some OSes will prefer select() over poll() + * when both are available. + */ +#if defined(TARGET_DARWIN) +#define SELECT_PREFERRED_OVER_POLL +#endif + +/* + * All non-windows OSes are assumed to have select() + */ +#ifdef WIN32 +#define SELECT 0 +#else +#define SELECT 1 +#endif + +/* + * This should be set to the highest file descriptor + * which can be used in one of the FD_ macros. + */ +#ifdef FD_SETSIZE +#define SELECT_MAX_FDS FD_SETSIZE +#else +#define SELECT_MAX_FDS 256 +#endif + +static inline int +tv_to_ms_timeout (const struct timeval *tv) +{ + if (tv->tv_sec == 0 && tv->tv_usec == 0) + return 0; + else + return max_int (tv->tv_sec * 1000 + (tv->tv_usec + 500) / 1000, 1); +} + +#ifdef WIN32 + +struct we_set +{ + struct event_set_functions func; + bool fast; + HANDLE *events; + struct event_set_return *esr; + int n_events; + int capacity; +}; + +static inline void +we_set_event (struct we_set *wes, int i, event_t event, unsigned int rwflags, void *arg) +{ + ASSERT (i >= 0 && i < wes->capacity); + + if (rwflags == EVENT_READ) + { + ASSERT (event->read != NULL); + wes->events[i] = event->read; + } + else if (rwflags == EVENT_WRITE) + { + ASSERT (event->write != NULL); + wes->events[i] = event->write; + } + else + msg (M_FATAL, "fatal error in we_set_events: rwflags=%d", rwflags); + + wes->esr[i].rwflags = rwflags; + wes->esr[i].arg = arg; +} + +static inline bool +we_append_event (struct we_set *wes, event_t event, unsigned int rwflags, void *arg) +{ + if (rwflags & EVENT_WRITE) + { + if (wes->n_events < wes->capacity) + { + we_set_event (wes, wes->n_events, event, EVENT_WRITE, arg); + ++wes->n_events; + } + else + return false; + } + if (rwflags & EVENT_READ) + { + if (wes->n_events < wes->capacity) + { + we_set_event (wes, wes->n_events, event, EVENT_READ, arg); + ++wes->n_events; + } + else + return false; + } + return true; +} + +static void +we_del_event (struct we_set *wes, event_t event) +{ + int i, j = 0; + const int len = wes->n_events; + + for (i = 0; i < len; ++i) + { + const HANDLE h = wes->events[i]; + if (h == event->read || h == event->write) + --wes->n_events; + else + { + if (i != j) + { + wes->events[j] = wes->events[i]; + wes->esr[j] = wes->esr[i]; + } + ++j; + } + } +} + +static void +we_del_index (struct we_set *wes, int index) +{ + int i; + ASSERT (index >= 0 && index < wes->n_events); + for (i = index; i < wes->n_events - 1; ++i) + { + wes->events[i] = wes->events[i+1]; + wes->esr[i] = wes->esr[i+1]; + } + --wes->n_events; +} + +static void +we_get_rw_indices (struct we_set *wes, event_t event, int *ri, int *wi) +{ + int i; + *ri = *wi = -1; + for (i = 0; i < wes->n_events; ++i) + { + const HANDLE h = wes->events[i]; + if (h == event->read) + { + ASSERT (*ri == -1); + *ri = i; + } + else if (h == event->write) + { + ASSERT (*wi == -1); + *wi = i; + } + } +} + +static void +we_free (struct event_set *es) +{ + struct we_set *wes = (struct we_set *) es; + free (wes->events); + free (wes->esr); + free (wes); +} + +static void +we_reset (struct event_set *es) +{ + struct we_set *wes = (struct we_set *) es; + ASSERT (wes->fast); + wes->n_events = 0; +} + +static void +we_del (struct event_set *es, event_t event) +{ + struct we_set *wes = (struct we_set *) es; + ASSERT (!wes->fast); + we_del_event (wes, event); +} + +static void +we_ctl (struct event_set *es, event_t event, unsigned int rwflags, void *arg) +{ + struct we_set *wes = (struct we_set *) es; + + dmsg (D_EVENT_WAIT, "WE_CTL n=%d ev=0x%08x rwflags=0x%04x arg=" ptr_format, + wes->n_events, + (unsigned int)event, + rwflags, + (ptr_type)arg); + + if (wes->fast) + { + if (!we_append_event (wes, event, rwflags, arg)) + goto err; + } + else + { + int ri, wi; + int one = -1; + int n = 0; + + we_get_rw_indices (wes, event, &ri, &wi); + if (wi >= 0) + { + one = wi; + ++n; + } + if (ri >= 0) + { + one = ri; + ++n; + } + switch (rwflags) + { + case 0: + switch (n) + { + case 0: + break; + case 1: + we_del_index (wes, one); + break; + case 2: + we_del_event (wes, event); + break; + default: + ASSERT (0); + } + break; + case EVENT_READ: + switch (n) + { + case 0: + if (!we_append_event (wes, event, EVENT_READ, arg)) + goto err; + break; + case 1: + we_set_event (wes, one, event, EVENT_READ, arg); + break; + case 2: + we_del_index (wes, wi); + break; + default: + ASSERT (0); + } + break; + case EVENT_WRITE: + switch (n) + { + case 0: + if (!we_append_event (wes, event, EVENT_WRITE, arg)) + goto err; + break; + case 1: + we_set_event (wes, one, event, EVENT_WRITE, arg); + break; + case 2: + we_del_index (wes, ri); + break; + default: + ASSERT (0); + } + break; + case EVENT_READ|EVENT_WRITE: + switch (n) + { + case 0: + if (!we_append_event (wes, event, EVENT_READ|EVENT_WRITE, arg)) + goto err; + break; + case 1: + if (ri == -1) + { + ASSERT (wi != -1); + if (!we_append_event (wes, event, EVENT_READ, arg)) + goto err; + } + else if (wi == -1) + { + if (!we_append_event (wes, event, EVENT_WRITE, arg)) + goto err; + } + else + ASSERT (0); + break; + case 2: + break; + default: + ASSERT (0); + } + break; + default: + msg (M_FATAL, "fatal error in we_ctl: rwflags=%d", rwflags); + } + } + return; + + err: + msg (D_EVENT_ERRORS, "Error: Windows resource limit WSA_MAXIMUM_WAIT_EVENTS (%d) has been exceeded", WSA_MAXIMUM_WAIT_EVENTS); +} + +static int +we_wait (struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen) +{ + struct we_set *wes = (struct we_set *) es; + const int timeout = tv_to_ms_timeout (tv); + DWORD status; + + dmsg (D_EVENT_WAIT, "WE_WAIT enter n=%d to=%d", wes->n_events, timeout); + +#ifdef ENABLE_DEBUG + if (check_debug_level (D_EVENT_WAIT)) { + int i; + for (i = 0; i < wes->n_events; ++i) + dmsg (D_EVENT_WAIT, "[%d] ev=0x%08x rwflags=0x%04x arg=" ptr_format, + i, + (unsigned int)wes->events[i], + wes->esr[i].rwflags, + (ptr_type)wes->esr[i].arg); + } +#endif + + /* + * First poll our event list with 0 timeout + */ + status = WSAWaitForMultipleEvents( + (DWORD) wes->n_events, + wes->events, + FALSE, + (DWORD) 0, + FALSE); + + /* + * If at least one event is already set, we must + * individually poll the whole list. + */ + if (status >= WSA_WAIT_EVENT_0 && status < WSA_WAIT_EVENT_0 + (DWORD) wes->n_events) + { + int i; + int j = 0; + for (i = 0; i < wes->n_events; ++i) + { + if (j >= outlen) + break; + if (WaitForSingleObject (wes->events[i], 0) == WAIT_OBJECT_0) + { + *out = wes->esr[i]; + dmsg (D_EVENT_WAIT, "WE_WAIT leave [%d,%d] rwflags=0x%04x arg=" ptr_format, + i, j, out->rwflags, (ptr_type)out->arg); + ++j; + ++out; + } + } + return j; + } + else + { + /* + * If caller specified timeout > 0, we know at this point + * that no events are set, so wait only for the first event + * (or timeout) and return at most one event_set_return object. + * + * If caller specified timeout == 0, the second call to + * WSAWaitForMultipleEvents would be redundant -- just + * return 0 indicating timeout. + */ + if (timeout > 0) + status = WSAWaitForMultipleEvents( + (DWORD) wes->n_events, + wes->events, + FALSE, + (DWORD) timeout, + FALSE); + + if (outlen >= 1 && status >= WSA_WAIT_EVENT_0 && status < WSA_WAIT_EVENT_0 + (DWORD) wes->n_events) + { + *out = wes->esr[status - WSA_WAIT_EVENT_0]; + dmsg (D_EVENT_WAIT, "WE_WAIT leave rwflags=0x%04x arg=" ptr_format, + out->rwflags, (ptr_type)out->arg); + return 1; + } + else if (status == WSA_WAIT_TIMEOUT) + return 0; + else + return -1; + } +} + +static struct event_set * +we_init (int *maxevents, unsigned int flags) +{ + struct we_set *wes; + + dmsg (D_EVENT_WAIT, "WE_INIT maxevents=%d flags=0x%08x", *maxevents, flags); + + ALLOC_OBJ_CLEAR (wes, struct we_set); + + /* set dispatch functions */ + wes->func.free = we_free; + wes->func.reset = we_reset; + wes->func.del = we_del; + wes->func.ctl = we_ctl; + wes->func.wait = we_wait; + + if (flags & EVENT_METHOD_FAST) + wes->fast = true; + wes->n_events = 0; + + /* Figure our event capacity */ + ASSERT (*maxevents > 0); + wes->capacity = min_int (*maxevents * 2, WSA_MAXIMUM_WAIT_EVENTS); + *maxevents = min_int (*maxevents, WSA_MAXIMUM_WAIT_EVENTS); + + /* Allocate space for Win32 event handles */ + ALLOC_ARRAY_CLEAR (wes->events, HANDLE, wes->capacity); + + /* Allocate space for event_set_return objects */ + ALLOC_ARRAY_CLEAR (wes->esr, struct event_set_return, wes->capacity); + + dmsg (D_EVENT_WAIT, "WE_INIT maxevents=%d capacity=%d", + *maxevents, wes->capacity); + + return (struct event_set *) wes; +} + +#endif /* WIN32 */ + +#if EPOLL + +struct ep_set +{ + struct event_set_functions func; + bool fast; + int epfd; + int maxevents; + struct epoll_event *events; +}; + +static void +ep_free (struct event_set *es) +{ + struct ep_set *eps = (struct ep_set *) es; + close (eps->epfd); + free (eps->events); + free (eps); +} + +static void +ep_reset (struct event_set *es) +{ + const struct ep_set *eps = (struct ep_set *) es; + ASSERT (eps->fast); +} + +static void +ep_del (struct event_set *es, event_t event) +{ + struct epoll_event ev; + struct ep_set *eps = (struct ep_set *) es; + + dmsg (D_EVENT_WAIT, "EP_DEL ev=%d", (int)event); + + ASSERT (!eps->fast); + CLEAR (ev); + epoll_ctl (eps->epfd, EPOLL_CTL_DEL, event, &ev); +} + +static void +ep_ctl (struct event_set *es, event_t event, unsigned int rwflags, void *arg) +{ + struct ep_set *eps = (struct ep_set *) es; + struct epoll_event ev; + + CLEAR (ev); + + ev.data.ptr = arg; + if (rwflags & EVENT_READ) + ev.events |= EPOLLIN; + if (rwflags & EVENT_WRITE) + ev.events |= EPOLLOUT; + + dmsg (D_EVENT_WAIT, "EP_CTL fd=%d rwflags=0x%04x ev=0x%08x arg=" ptr_format, + (int)event, + rwflags, + (unsigned int)ev.events, + (ptr_type)ev.data.ptr); + + if (epoll_ctl (eps->epfd, EPOLL_CTL_MOD, event, &ev) < 0) + { + if (errno == ENOENT) + { + if (epoll_ctl (eps->epfd, EPOLL_CTL_ADD, event, &ev) < 0) + msg (M_ERR, "EVENT: epoll_ctl EPOLL_CTL_ADD failed"); + } + else + msg (M_ERR, "EVENT: epoll_ctl EPOLL_CTL_MOD failed"); + } +} + +static int +ep_wait (struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen) +{ + struct ep_set *eps = (struct ep_set *) es; + int stat; + + if (outlen > eps->maxevents) + outlen = eps->maxevents; + + stat = epoll_wait (eps->epfd, eps->events, outlen, tv_to_ms_timeout (tv)); + ASSERT (stat <= outlen); + + if (stat > 0) + { + int i; + const struct epoll_event *ev = eps->events; + struct event_set_return *esr = out; + for (i = 0; i < stat; ++i) + { + esr->rwflags = 0; + if (ev->events & (EPOLLIN|EPOLLPRI|EPOLLERR)) + esr->rwflags |= EVENT_READ; + if (ev->events & EPOLLOUT) + esr->rwflags |= EVENT_WRITE; + esr->arg = ev->data.ptr; + dmsg (D_EVENT_WAIT, "EP_WAIT[%d] rwflags=0x%04x ev=0x%08x arg=" ptr_format, + i, esr->rwflags, ev->events, (ptr_type)ev->data.ptr); + ++ev; + ++esr; + } + } + return stat; +} + +static struct event_set * +ep_init (int *maxevents, unsigned int flags) +{ + struct ep_set *eps; + int fd; + + dmsg (D_EVENT_WAIT, "EP_INIT maxevents=%d flags=0x%08x", *maxevents, flags); + + /* open epoll file descriptor */ + fd = epoll_create (*maxevents); + if (fd < 0) + return NULL; + + ALLOC_OBJ_CLEAR (eps, struct ep_set); + + /* set dispatch functions */ + eps->func.free = ep_free; + eps->func.reset = ep_reset; + eps->func.del = ep_del; + eps->func.ctl = ep_ctl; + eps->func.wait = ep_wait; + + /* fast method ("sort of") corresponds to epoll one-shot */ + if (flags & EVENT_METHOD_FAST) + eps->fast = true; + + /* allocate space for epoll_wait return */ + ASSERT (*maxevents > 0); + eps->maxevents = *maxevents; + ALLOC_ARRAY_CLEAR (eps->events, struct epoll_event, eps->maxevents); + + /* set epoll control fd */ + eps->epfd = fd; + + return (struct event_set *) eps; +} +#endif /* EPOLL */ + +#if POLL + +struct po_set +{ + struct event_set_functions func; + bool fast; + struct pollfd *events; + void **args; + int n_events; + int capacity; +}; + +static void +po_free (struct event_set *es) +{ + struct po_set *pos = (struct po_set *) es; + free (pos->events); + free (pos->args); + free (pos); +} + +static void +po_reset (struct event_set *es) +{ + struct po_set *pos = (struct po_set *) es; + ASSERT (pos->fast); + pos->n_events = 0; +} + +static void +po_del (struct event_set *es, event_t event) +{ + struct po_set *pos = (struct po_set *) es; + int i; + + dmsg (D_EVENT_WAIT, "PO_DEL ev=%d", (int)event); + + ASSERT (!pos->fast); + for (i = 0; i < pos->n_events; ++i) + { + if (pos->events[i].fd == event) + { + int j; + for (j = i; j < pos->n_events - 1; ++j) + { + pos->events[j] = pos->events[j+1]; + pos->args[j] = pos->args[j+1]; + } + --pos->n_events; + break; + } + } +} + +static inline void +po_set_pollfd_events (struct pollfd *pfdp, unsigned int rwflags) +{ + pfdp->events = 0; + if (rwflags & EVENT_WRITE) + pfdp->events |= POLLOUT; + if (rwflags & EVENT_READ) + pfdp->events |= (POLLIN|POLLPRI); +} + +static inline bool +po_append_event (struct po_set *pos, event_t event, unsigned int rwflags, void *arg) +{ + if (pos->n_events < pos->capacity) + { + struct pollfd *pfdp = &pos->events[pos->n_events]; + pfdp->fd = event; + pos->args[pos->n_events] = arg; + po_set_pollfd_events (pfdp, rwflags); + ++pos->n_events; + return true; + } + else + return false; +} + +static void +po_ctl (struct event_set *es, event_t event, unsigned int rwflags, void *arg) +{ + struct po_set *pos = (struct po_set *) es; + + dmsg (D_EVENT_WAIT, "PO_CTL rwflags=0x%04x ev=%d arg=" ptr_format, + rwflags, (int)event, (ptr_type)arg); + + if (pos->fast) + { + if (!po_append_event (pos, event, rwflags, arg)) + goto err; + } + else + { + int i; + for (i = 0; i < pos->n_events; ++i) + { + struct pollfd *pfdp = &pos->events[i]; + if (pfdp->fd == event) + { + pos->args[i] = arg; + po_set_pollfd_events (pfdp, rwflags); + goto done; + } + } + if (!po_append_event (pos, event, rwflags, arg)) + goto err; + } + + done: + return; + + err: + msg (D_EVENT_ERRORS, "Error: poll: too many I/O wait events"); +} + +static int +po_wait (struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen) +{ + struct po_set *pos = (struct po_set *) es; + int stat; + + stat = poll (pos->events, pos->n_events, tv_to_ms_timeout (tv)); + + ASSERT (stat <= pos->n_events); + + if (stat > 0) + { + int i, j=0; + const struct pollfd *pfdp = pos->events; + for (i = 0; i < pos->n_events && j < outlen; ++i) + { + if (pfdp->revents & (POLLIN|POLLPRI|POLLERR|POLLHUP|POLLOUT)) + { + out->rwflags = 0; + if (pfdp->revents & (POLLIN|POLLPRI|POLLERR|POLLHUP)) + out->rwflags |= EVENT_READ; + if (pfdp->revents & POLLOUT) + out->rwflags |= EVENT_WRITE; + out->arg = pos->args[i]; + dmsg (D_EVENT_WAIT, "PO_WAIT[%d,%d] fd=%d rev=0x%08x rwflags=0x%04x arg=" ptr_format " %s", + i, j, pfdp->fd, pfdp->revents, out->rwflags, (ptr_type)out->arg, pos->fast ? "" : "[scalable]"); + ++out; + ++j; + } + else if (pfdp->revents) + { + msg (D_EVENT_ERRORS, "Error: poll: unknown revents=0x%04x", (unsigned int)pfdp->revents); + } + ++pfdp; + } + return j; + } + return stat; +} + +static struct event_set * +po_init (int *maxevents, unsigned int flags) +{ + struct po_set *pos; + + dmsg (D_EVENT_WAIT, "PO_INIT maxevents=%d flags=0x%08x", *maxevents, flags); + + ALLOC_OBJ_CLEAR (pos, struct po_set); + + /* set dispatch functions */ + pos->func.free = po_free; + pos->func.reset = po_reset; + pos->func.del = po_del; + pos->func.ctl = po_ctl; + pos->func.wait = po_wait; + + if (flags & EVENT_METHOD_FAST) + pos->fast = true; + + pos->n_events = 0; + + /* Figure our event capacity */ + ASSERT (*maxevents > 0); + pos->capacity = *maxevents; + + /* Allocate space for pollfd structures to be passed to poll() */ + ALLOC_ARRAY_CLEAR (pos->events, struct pollfd, pos->capacity); + + /* Allocate space for event_set_return objects */ + ALLOC_ARRAY_CLEAR (pos->args, void *, pos->capacity); + + return (struct event_set *) pos; +} +#endif /* POLL */ + +#if SELECT + +struct se_set +{ + struct event_set_functions func; + bool fast; + fd_set readfds; + fd_set writefds; + void **args; /* allocated to capacity size */ + int maxfd; /* largest fd seen so far, always < capacity */ + int capacity; /* fixed largest fd + 1 */ +}; + +static void +se_free (struct event_set *es) +{ + struct se_set *ses = (struct se_set *) es; + free (ses->args); + free (ses); +} + +static void +se_reset (struct event_set *es) +{ + struct se_set *ses = (struct se_set *) es; + int i; + ASSERT (ses->fast); + + dmsg (D_EVENT_WAIT, "SE_RESET"); + + FD_ZERO (&ses->readfds); + FD_ZERO (&ses->writefds); + for (i = 0; i <= ses->maxfd; ++i) + ses->args[i] = NULL; + ses->maxfd = -1; +} + +static void +se_del (struct event_set *es, event_t event) +{ + struct se_set *ses = (struct se_set *) es; + ASSERT (!ses->fast); + + dmsg (D_EVENT_WAIT, "SE_DEL ev=%d", (int)event); + + if (event >= 0 && event < ses->capacity) + { + FD_CLR (event, &ses->readfds); + FD_CLR (event, &ses->writefds); + ses->args[event] = NULL; + } + else + msg (D_EVENT_ERRORS, "Error: select/se_del: too many I/O wait events"); + return; +} + +static void +se_ctl (struct event_set *es, event_t event, unsigned int rwflags, void *arg) +{ + struct se_set *ses = (struct se_set *) es; + + dmsg (D_EVENT_WAIT, "SE_CTL rwflags=0x%04x ev=%d fast=%d cap=%d maxfd=%d arg=" ptr_format, + rwflags, (int)event, (int)ses->fast, ses->capacity, ses->maxfd, (ptr_type)arg); + + if (event >= 0 && event < ses->capacity) + { + ses->maxfd = max_int (event, ses->maxfd); + ses->args[event] = arg; + if (ses->fast) + { + if (rwflags & EVENT_READ) + FD_SET (event, &ses->readfds); + if (rwflags & EVENT_WRITE) + FD_SET (event, &ses->writefds); + } + else + { + if (rwflags & EVENT_READ) + FD_SET (event, &ses->readfds); + else + FD_CLR (event, &ses->readfds); + if (rwflags & EVENT_WRITE) + FD_SET (event, &ses->writefds); + else + FD_CLR (event, &ses->writefds); + } + } + else + { + msg (D_EVENT_ERRORS, "Error: select: too many I/O wait events, fd=%d cap=%d", + (int) event, + ses->capacity); + } +} + +static int +se_wait_return (struct se_set *ses, + fd_set *read, + fd_set *write, + struct event_set_return *out, + int outlen) +{ + int i, j = 0; + for (i = 0; i <= ses->maxfd && j < outlen; ++i) + { + const bool r = FD_ISSET (i, read); + const bool w = FD_ISSET (i, write); + if (r || w) + { + out->rwflags = 0; + if (r) + out->rwflags |= EVENT_READ; + if (w) + out->rwflags |= EVENT_WRITE; + out->arg = ses->args[i]; + dmsg (D_EVENT_WAIT, "SE_WAIT[%d,%d] rwflags=0x%04x arg=" ptr_format, + i, j, out->rwflags, (ptr_type)out->arg); + ++out; + ++j; + } + } + return j; +} + +static int +se_wait_fast (struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen) +{ + struct se_set *ses = (struct se_set *) es; + struct timeval tv_tmp = *tv; + int stat; + + dmsg (D_EVENT_WAIT, "SE_WAIT_FAST maxfd=%d tv=%d/%d", + ses->maxfd, + (int)tv_tmp.tv_sec, + (int)tv_tmp.tv_usec); + + stat = select (ses->maxfd + 1, &ses->readfds, &ses->writefds, NULL, &tv_tmp); + + if (stat > 0) + stat = se_wait_return (ses, &ses->readfds, &ses->writefds, out, outlen); + + return stat; +} + +static int +se_wait_scalable (struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen) +{ + struct se_set *ses = (struct se_set *) es; + struct timeval tv_tmp = *tv; + fd_set read = ses->readfds; + fd_set write = ses->writefds; + int stat; + + dmsg (D_EVENT_WAIT, "SE_WAIT_SCALEABLE maxfd=%d tv=%d/%d", + ses->maxfd, (int)tv_tmp.tv_sec, (int)tv_tmp.tv_usec); + + stat = select (ses->maxfd + 1, &read, &write, NULL, &tv_tmp); + + if (stat > 0) + stat = se_wait_return (ses, &read, &write, out, outlen); + + return stat; +} + +static struct event_set * +se_init (int *maxevents, unsigned int flags) +{ + struct se_set *ses; + + dmsg (D_EVENT_WAIT, "SE_INIT maxevents=%d flags=0x%08x", *maxevents, flags); + + ALLOC_OBJ_CLEAR (ses, struct se_set); + + /* set dispatch functions */ + ses->func.free = se_free; + ses->func.reset = se_reset; + ses->func.del = se_del; + ses->func.ctl = se_ctl; + ses->func.wait = se_wait_scalable; + + if (flags & EVENT_METHOD_FAST) + { + ses->fast = true; + ses->func.wait = se_wait_fast; + } + + /* Select needs to be passed this value + 1 */ + ses->maxfd = -1; + + /* Set our event capacity */ + ASSERT (*maxevents > 0); + *maxevents = min_int (*maxevents, SELECT_MAX_FDS); + ses->capacity = SELECT_MAX_FDS; + + /* Allocate space for event_set_return void * args */ + ALLOC_ARRAY_CLEAR (ses->args, void *, ses->capacity); + + return (struct event_set *) ses; +} +#endif /* SELECT */ + +static struct event_set * +event_set_init_simple (int *maxevents, unsigned int flags) +{ + struct event_set *ret = NULL; +#ifdef WIN32 + ret = we_init (maxevents, flags); +#elif POLL && SELECT +#if 0 /* Define to 1 if EVENT_METHOD_US_TIMEOUT should cause select to be favored over poll */ + if (flags & EVENT_METHOD_US_TIMEOUT) + ret = se_init (maxevents, flags); +#endif +# ifdef SELECT_PREFERRED_OVER_POLL + if (!ret) + ret = se_init (maxevents, flags); + if (!ret) + ret = po_init (maxevents, flags); +# else + if (!ret) + ret = po_init (maxevents, flags); + if (!ret) + ret = se_init (maxevents, flags); +# endif +#elif POLL + ret = po_init (maxevents, flags); +#elif SELECT + ret = se_init (maxevents, flags); +#else +#error At least one of poll, select, or WSAWaitForMultipleEvents must be supported by the kernel +#endif + ASSERT (ret); + return ret; +} + +static struct event_set * +event_set_init_scalable (int *maxevents, unsigned int flags) +{ + struct event_set *ret = NULL; +#if EPOLL + ret = ep_init (maxevents, flags); + if (!ret) + { + msg (M_WARN, "Note: sys_epoll API is unavailable, falling back to poll/select API"); + ret = event_set_init_simple (maxevents, flags); + } +#else + ret = event_set_init_simple (maxevents, flags); +#endif + ASSERT (ret); + return ret; +} + +struct event_set * +event_set_init (int *maxevents, unsigned int flags) +{ + if (flags & EVENT_METHOD_FAST) + return event_set_init_simple (maxevents, flags); + else + return event_set_init_scalable (maxevents, flags); +} |