OpenVPN
event.c
Go to the documentation of this file.
1/*
2 * OpenVPN -- An application to securely tunnel IP networks
3 * over a single TCP/UDP port, with support for SSL/TLS-based
4 * session authentication and key exchange,
5 * packet encryption, packet authentication, and
6 * packet compression.
7 *
8 * Copyright (C) 2002-2026 OpenVPN Inc <sales@openvpn.net>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2
12 * as published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, see <https://www.gnu.org/licenses/>.
21 */
22
23#ifdef HAVE_CONFIG_H
24#include "config.h"
25#endif
26
27#include "syshead.h"
28
29#include "buffer.h"
30#include "error.h"
31#include "integer.h"
32#include "event.h"
33#include "fdmisc.h"
34
35#if EPOLL
36#include <sys/epoll.h>
37#endif
38
39#include "memdbg.h"
40
41/*
42 * Some OSes will prefer select() over poll()
43 * when both are available.
44 */
45#if defined(TARGET_DARWIN)
46#define SELECT_PREFERRED_OVER_POLL
47#endif
48
49/*
50 * All non-windows OSes are assumed to have select()
51 */
52#ifdef _WIN32
53#define SELECT 0
54#else
55#define SELECT 1
56#endif
57
58/*
59 * This should be set to the highest file descriptor
60 * which can be used in one of the FD_ macros.
61 */
62#ifdef FD_SETSIZE
63#define SELECT_MAX_FDS FD_SETSIZE
64#else
65#define SELECT_MAX_FDS 256
66#endif
67
77static inline int
78tv_to_ms_timeout(const struct timeval *tv)
79{
80 if (tv->tv_sec == 0 && tv->tv_usec == 0)
81 {
82 return 0;
83 }
84 else
85 {
86 /* might overflow but not for practically useful numbers */
87 return max_int((int)(tv->tv_sec * 1000 + (tv->tv_usec + 500) / 1000), 1);
88 }
89}
90
91#ifdef _WIN32
92
93struct we_set
94{
96 bool fast;
97 HANDLE *events;
101};
102
103static inline void
104we_set_event(struct we_set *wes, int i, event_t event, unsigned int rwflags, void *arg)
105{
106 ASSERT(i >= 0 && i < wes->capacity);
107
108 if (rwflags == EVENT_READ)
109 {
110 ASSERT(event->read != NULL);
111 wes->events[i] = event->read;
112 }
113 else if (rwflags == EVENT_WRITE)
114 {
115 ASSERT(event->write != NULL);
116 wes->events[i] = event->write;
117 }
118 else
119 {
120 msg(M_FATAL, "fatal error in we_set_events: rwflags=%u", rwflags);
121 }
122
123 wes->esr[i].rwflags = rwflags;
124 wes->esr[i].arg = arg;
125}
126
127static inline bool
128we_append_event(struct we_set *wes, event_t event, unsigned int rwflags, void *arg)
129{
130 if (rwflags & EVENT_WRITE)
131 {
132 if (wes->n_events < wes->capacity)
133 {
134 we_set_event(wes, wes->n_events, event, EVENT_WRITE, arg);
135 ++wes->n_events;
136 }
137 else
138 {
139 return false;
140 }
141 }
142 if (rwflags & EVENT_READ)
143 {
144 if (wes->n_events < wes->capacity)
145 {
146 we_set_event(wes, wes->n_events, event, EVENT_READ, arg);
147 ++wes->n_events;
148 }
149 else
150 {
151 return false;
152 }
153 }
154 return true;
155}
156
157static void
158we_del_event(struct we_set *wes, event_t event)
159{
160 int i, j = 0;
161 const int len = wes->n_events;
162
163 for (i = 0; i < len; ++i)
164 {
165 const HANDLE h = wes->events[i];
166 if (h == event->read || h == event->write)
167 {
168 --wes->n_events;
169 }
170 else
171 {
172 if (i != j)
173 {
174 wes->events[j] = wes->events[i];
175 wes->esr[j] = wes->esr[i];
176 }
177 ++j;
178 }
179 }
180}
181
182static void
183we_del_index(struct we_set *wes, int index)
184{
185 int i;
186 ASSERT(index >= 0 && index < wes->n_events);
187 for (i = index; i < wes->n_events - 1; ++i)
188 {
189 wes->events[i] = wes->events[i + 1];
190 wes->esr[i] = wes->esr[i + 1];
191 }
192 --wes->n_events;
193}
194
195static void
196we_get_rw_indices(struct we_set *wes, event_t event, int *ri, int *wi)
197{
198 int i;
199 *ri = *wi = -1;
200 for (i = 0; i < wes->n_events; ++i)
201 {
202 const HANDLE h = wes->events[i];
203 if (h == event->read)
204 {
205 ASSERT(*ri == -1);
206 *ri = i;
207 }
208 else if (h == event->write)
209 {
210 ASSERT(*wi == -1);
211 *wi = i;
212 }
213 }
214}
215
216static void
218{
219 struct we_set *wes = (struct we_set *)es;
220 free(wes->events);
221 free(wes->esr);
222 free(wes);
223}
224
225static void
227{
228 struct we_set *wes = (struct we_set *)es;
229 ASSERT(wes->fast);
230 wes->n_events = 0;
231}
232
233static void
234we_del(struct event_set *es, event_t event)
235{
236 struct we_set *wes = (struct we_set *)es;
237 ASSERT(!wes->fast);
238 we_del_event(wes, event);
239}
240
241static void
242we_ctl(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
243{
244 struct we_set *wes = (struct we_set *)es;
245
246 dmsg(D_EVENT_WAIT, "WE_CTL n=%d ev=%p rwflags=0x%04x arg=" ptr_format, wes->n_events, event,
247 rwflags, (ptr_type)arg);
248
249 if (wes->fast)
250 {
251 if (!we_append_event(wes, event, rwflags, arg))
252 {
253 goto err;
254 }
255 }
256 else
257 {
258 int ri, wi;
259 int one = -1;
260 int n = 0;
261
262 we_get_rw_indices(wes, event, &ri, &wi);
263 if (wi >= 0)
264 {
265 one = wi;
266 ++n;
267 }
268 if (ri >= 0)
269 {
270 one = ri;
271 ++n;
272 }
273 switch (rwflags)
274 {
275 case 0:
276 switch (n)
277 {
278 case 0:
279 break;
280
281 case 1:
282 we_del_index(wes, one);
283 break;
284
285 case 2:
286 we_del_event(wes, event);
287 break;
288
289 default:
290 ASSERT(0);
291 }
292 break;
293
294 case EVENT_READ:
295 switch (n)
296 {
297 case 0:
298 if (!we_append_event(wes, event, EVENT_READ, arg))
299 {
300 goto err;
301 }
302 break;
303
304 case 1:
305 we_set_event(wes, one, event, EVENT_READ, arg);
306 break;
307
308 case 2:
309 we_del_index(wes, wi);
310 break;
311
312 default:
313 ASSERT(0);
314 }
315 break;
316
317 case EVENT_WRITE:
318 switch (n)
319 {
320 case 0:
321 if (!we_append_event(wes, event, EVENT_WRITE, arg))
322 {
323 goto err;
324 }
325 break;
326
327 case 1:
328 we_set_event(wes, one, event, EVENT_WRITE, arg);
329 break;
330
331 case 2:
332 we_del_index(wes, ri);
333 break;
334
335 default:
336 ASSERT(0);
337 }
338 break;
339
340 case EVENT_READ | EVENT_WRITE:
341 switch (n)
342 {
343 case 0:
344 if (!we_append_event(wes, event, EVENT_READ | EVENT_WRITE, arg))
345 {
346 goto err;
347 }
348 break;
349
350 case 1:
351 if (ri == -1)
352 {
353 ASSERT(wi != -1);
354 if (!we_append_event(wes, event, EVENT_READ, arg))
355 {
356 goto err;
357 }
358 }
359 else if (wi == -1)
360 {
361 if (!we_append_event(wes, event, EVENT_WRITE, arg))
362 {
363 goto err;
364 }
365 }
366 else
367 {
368 ASSERT(0);
369 }
370 break;
371
372 case 2:
373 break;
374
375 default:
376 ASSERT(0);
377 }
378 break;
379
380 default:
381 msg(M_FATAL, "fatal error in we_ctl: rwflags=%u", rwflags);
382 }
383 }
384 return;
385
386err:
388 "Error: Windows resource limit WSA_MAXIMUM_WAIT_EVENTS (%d) has been exceeded",
389 WSA_MAXIMUM_WAIT_EVENTS);
390}
391
392static int
393we_wait(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
394{
395 struct we_set *wes = (struct we_set *)es;
396 const int timeout = tv_to_ms_timeout(tv);
397 DWORD status;
398
399 dmsg(D_EVENT_WAIT, "WE_WAIT enter n=%d to=%d", wes->n_events, timeout);
400
401#ifndef ENABLE_SMALL
403 {
404 int i;
405 for (i = 0; i < wes->n_events; ++i)
406 {
407 dmsg(D_EVENT_WAIT, "[%d] ev=%p rwflags=0x%04x arg=" ptr_format, i, wes->events[i],
408 wes->esr[i].rwflags, (ptr_type)wes->esr[i].arg);
409 }
410 }
411#endif
412
413 /* WSA_WAIT_EVENT_0 == 0 but the API documentation is written in a way
414 that doesn't guarantee that. So we make useless checks. */
415#if defined(__GNUC__)
416#pragma GCC diagnostic push
417#pragma GCC diagnostic ignored "-Wtype-limits"
418#endif
419
420 /*
421 * First poll our event list with 0 timeout
422 */
423 status = WSAWaitForMultipleEvents((DWORD)wes->n_events, wes->events, FALSE, (DWORD)0, FALSE);
424
425 /*
426 * If at least one event is already set, we must
427 * individually poll the whole list.
428 */
429 if (status >= WSA_WAIT_EVENT_0 && status < WSA_WAIT_EVENT_0 + (DWORD)wes->n_events)
430 {
431 int i;
432 int j = 0;
433 for (i = 0; i < wes->n_events; ++i)
434 {
435 if (j >= outlen)
436 {
437 break;
438 }
439 if (WaitForSingleObject(wes->events[i], 0) == WAIT_OBJECT_0)
440 {
441 *out = wes->esr[i];
442 dmsg(D_EVENT_WAIT, "WE_WAIT leave [%d,%d] rwflags=0x%04x arg=" ptr_format, i, j,
443 out->rwflags, (ptr_type)out->arg);
444 ++j;
445 ++out;
446 }
447 }
448 return j;
449 }
450 else
451 {
452 /*
453 * If caller specified timeout > 0, we know at this point
454 * that no events are set, so wait only for the first event
455 * (or timeout) and return at most one event_set_return object.
456 *
457 * If caller specified timeout == 0, the second call to
458 * WSAWaitForMultipleEvents would be redundant -- just
459 * return 0 indicating timeout.
460 */
461 if (timeout > 0)
462 {
463 status = WSAWaitForMultipleEvents((DWORD)wes->n_events, wes->events, FALSE,
464 (DWORD)timeout, FALSE);
465 }
466
467 if (outlen >= 1 && status >= WSA_WAIT_EVENT_0
468 && status < WSA_WAIT_EVENT_0 + (DWORD)wes->n_events)
469 {
470 *out = wes->esr[status - WSA_WAIT_EVENT_0];
471 dmsg(D_EVENT_WAIT, "WE_WAIT leave rwflags=0x%04x arg=" ptr_format, out->rwflags,
472 (ptr_type)out->arg);
473 return 1;
474 }
475 else if (status == WSA_WAIT_TIMEOUT)
476 {
477 return 0;
478 }
479 else
480 {
481 return -1;
482 }
483 }
484#if defined(__GNUC__)
485#pragma GCC diagnostic pop
486#endif
487}
488
489#if defined(__GNUC__) || defined(__clang__)
490#pragma GCC diagnostic push
491#pragma GCC diagnostic ignored "-Wsign-conversion"
492#endif
493
494static struct event_set *
495we_init(int *maxevents, unsigned int flags)
496{
497 struct we_set *wes;
498
499 dmsg(D_EVENT_WAIT, "WE_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
500
501 ALLOC_OBJ_CLEAR(wes, struct we_set);
502
503 /* set dispatch functions */
504 wes->func.free = we_free;
505 wes->func.reset = we_reset;
506 wes->func.del = we_del;
507 wes->func.ctl = we_ctl;
508 wes->func.wait = we_wait;
509
510 if (flags & EVENT_METHOD_FAST)
511 {
512 wes->fast = true;
513 }
514 wes->n_events = 0;
515
516 /* Figure our event capacity */
517 ASSERT(*maxevents > 0);
518 wes->capacity = min_int(*maxevents * 2, WSA_MAXIMUM_WAIT_EVENTS);
519 *maxevents = min_int(*maxevents, WSA_MAXIMUM_WAIT_EVENTS);
520
521 /* Allocate space for Win32 event handles */
522 ALLOC_ARRAY_CLEAR(wes->events, HANDLE, wes->capacity);
523
524 /* Allocate space for event_set_return objects */
526
527 dmsg(D_EVENT_WAIT, "WE_INIT maxevents=%d capacity=%d", *maxevents, wes->capacity);
528
529 return (struct event_set *)wes;
530}
531
532#if defined(__GNUC__) || defined(__clang__)
533#pragma GCC diagnostic pop
534#endif
535
536#endif /* _WIN32 */
537
538#if defined(__GNUC__) || defined(__clang__)
539#pragma GCC diagnostic push
540#pragma GCC diagnostic ignored "-Wsign-conversion"
541#endif
542
543#if EPOLL
544
545struct ep_set
546{
547 struct event_set_functions func;
548 bool fast;
549 int epfd;
550 int maxevents;
551 struct epoll_event *events;
552};
553
554static void
555ep_free(struct event_set *es)
556{
557 struct ep_set *eps = (struct ep_set *)es;
558 close(eps->epfd);
559 free(eps->events);
560 free(eps);
561}
562
563static void
564ep_reset(struct event_set *es)
565{
566 const struct ep_set *eps = (struct ep_set *)es;
567 ASSERT(eps->fast);
568}
569
570static void
571ep_del(struct event_set *es, event_t event)
572{
573 struct epoll_event ev;
574 const struct ep_set *eps = (struct ep_set *)es;
575
576 dmsg(D_EVENT_WAIT, "EP_DEL ev=%d", (int)event);
577
578 ASSERT(!eps->fast);
579 CLEAR(ev);
580 if (epoll_ctl(eps->epfd, EPOLL_CTL_DEL, event, &ev) < 0)
581 {
582 msg(M_WARN | M_ERRNO, "EVENT: epoll_ctl EPOLL_CTL_DEL failed, sd=%d", (int)event);
583 }
584}
585
586static void
587ep_ctl(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
588{
589 const struct ep_set *eps = (struct ep_set *)es;
590 struct epoll_event ev;
591
592 CLEAR(ev);
593
594 ev.data.ptr = arg;
595 if (rwflags & EVENT_READ)
596 {
597 ev.events |= EPOLLIN;
598 }
599 if (rwflags & EVENT_WRITE)
600 {
601 ev.events |= EPOLLOUT;
602 }
603
604 dmsg(D_EVENT_WAIT, "EP_CTL fd=%d rwflags=0x%04x ev=0x%08x arg=" ptr_format, (int)event, rwflags,
605 (unsigned int)ev.events, (ptr_type)ev.data.ptr);
606
607 if (epoll_ctl(eps->epfd, EPOLL_CTL_MOD, event, &ev) < 0)
608 {
609 if (errno == ENOENT)
610 {
611 if (epoll_ctl(eps->epfd, EPOLL_CTL_ADD, event, &ev) < 0)
612 {
613 msg(M_ERR, "EVENT: epoll_ctl EPOLL_CTL_ADD failed, sd=%d", (int)event);
614 }
615 }
616 else
617 {
618 msg(M_ERR, "EVENT: epoll_ctl EPOLL_CTL_MOD failed, sd=%d", (int)event);
619 }
620 }
621}
622
623static int
624ep_wait(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
625{
626 struct ep_set *eps = (struct ep_set *)es;
627 int stat;
628
629 if (outlen > eps->maxevents)
630 {
631 outlen = eps->maxevents;
632 }
633
634 stat = epoll_wait(eps->epfd, eps->events, outlen, tv_to_ms_timeout(tv));
635 ASSERT(stat <= outlen);
636
637 if (stat > 0)
638 {
639 int i;
640 const struct epoll_event *ev = eps->events;
641 struct event_set_return *esr = out;
642 for (i = 0; i < stat; ++i)
643 {
644 esr->rwflags = 0;
645 if (ev->events & (EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP))
646 {
647 esr->rwflags |= EVENT_READ;
648 }
649 if (ev->events & EPOLLOUT)
650 {
651 esr->rwflags |= EVENT_WRITE;
652 }
653 esr->arg = ev->data.ptr;
654 dmsg(D_EVENT_WAIT, "EP_WAIT[%d] rwflags=0x%04x ev=0x%08x arg=" ptr_format, i,
655 esr->rwflags, ev->events, (ptr_type)ev->data.ptr);
656 ++ev;
657 ++esr;
658 }
659 }
660 return stat;
661}
662
663static struct event_set *
664ep_init(int *maxevents, unsigned int flags)
665{
666 struct ep_set *eps;
667 int fd;
668
669 dmsg(D_EVENT_WAIT, "EP_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
670
671 /* open epoll file descriptor */
672 fd = epoll_create(*maxevents);
673 if (fd < 0)
674 {
675 return NULL;
676 }
677
678 set_cloexec(fd);
679
680 ALLOC_OBJ_CLEAR(eps, struct ep_set);
681
682 /* set dispatch functions */
683 eps->func.free = ep_free;
684 eps->func.reset = ep_reset;
685 eps->func.del = ep_del;
686 eps->func.ctl = ep_ctl;
687 eps->func.wait = ep_wait;
688
689 /* fast method ("sort of") corresponds to epoll one-shot */
690 if (flags & EVENT_METHOD_FAST)
691 {
692 eps->fast = true;
693 }
694
695 /* allocate space for epoll_wait return */
696 ASSERT(*maxevents > 0);
697 eps->maxevents = *maxevents;
698 ALLOC_ARRAY_CLEAR(eps->events, struct epoll_event, eps->maxevents);
699
700 /* set epoll control fd */
701 eps->epfd = fd;
702
703 return (struct event_set *)eps;
704}
705#endif /* EPOLL */
706
707#if POLL
708
709struct po_set
710{
711 struct event_set_functions func;
712 bool fast;
713 struct pollfd *events;
714 void **args;
715 int n_events;
716 int capacity;
717};
718
719static void
720po_free(struct event_set *es)
721{
722 struct po_set *pos = (struct po_set *)es;
723 free(pos->events);
724 free(pos->args);
725 free(pos);
726}
727
728static void
729po_reset(struct event_set *es)
730{
731 struct po_set *pos = (struct po_set *)es;
732 ASSERT(pos->fast);
733 pos->n_events = 0;
734}
735
736static void
737po_del(struct event_set *es, event_t event)
738{
739 struct po_set *pos = (struct po_set *)es;
740 int i;
741
742 dmsg(D_EVENT_WAIT, "PO_DEL ev=%d", (int)event);
743
744 ASSERT(!pos->fast);
745 for (i = 0; i < pos->n_events; ++i)
746 {
747 if (pos->events[i].fd == event)
748 {
749 int j;
750 for (j = i; j < pos->n_events - 1; ++j)
751 {
752 pos->events[j] = pos->events[j + 1];
753 pos->args[j] = pos->args[j + 1];
754 }
755 --pos->n_events;
756 break;
757 }
758 }
759}
760
761static inline void
762po_set_pollfd_events(struct pollfd *pfdp, unsigned int rwflags)
763{
764 pfdp->events = 0;
765 if (rwflags & EVENT_WRITE)
766 {
767 pfdp->events |= POLLOUT;
768 }
769 if (rwflags & EVENT_READ)
770 {
771 pfdp->events |= (POLLIN | POLLPRI);
772 }
773}
774
775static inline bool
776po_append_event(struct po_set *pos, event_t event, unsigned int rwflags, void *arg)
777{
778 if (pos->n_events < pos->capacity)
779 {
780 struct pollfd *pfdp = &pos->events[pos->n_events];
781 pfdp->fd = event;
782 pos->args[pos->n_events] = arg;
783 po_set_pollfd_events(pfdp, rwflags);
784 ++pos->n_events;
785 return true;
786 }
787 else
788 {
789 return false;
790 }
791}
792
793static void
794po_ctl(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
795{
796 struct po_set *pos = (struct po_set *)es;
797
798 dmsg(D_EVENT_WAIT, "PO_CTL rwflags=0x%04x ev=%d arg=" ptr_format, rwflags, (int)event,
799 (ptr_type)arg);
800
801 if (pos->fast)
802 {
803 if (!po_append_event(pos, event, rwflags, arg))
804 {
805 goto err;
806 }
807 }
808 else
809 {
810 int i;
811 for (i = 0; i < pos->n_events; ++i)
812 {
813 struct pollfd *pfdp = &pos->events[i];
814 if (pfdp->fd == event)
815 {
816 pos->args[i] = arg;
817 po_set_pollfd_events(pfdp, rwflags);
818 goto done;
819 }
820 }
821 if (!po_append_event(pos, event, rwflags, arg))
822 {
823 goto err;
824 }
825 }
826
827done:
828 return;
829
830err:
831 msg(D_EVENT_ERRORS, "Error: poll: too many I/O wait events");
832}
833
834static int
835po_wait(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
836{
837 struct po_set *pos = (struct po_set *)es;
838 int stat;
839
840 stat = poll(pos->events, pos->n_events, tv_to_ms_timeout(tv));
841
842 ASSERT(stat <= pos->n_events);
843
844 if (stat > 0)
845 {
846 int i, j = 0;
847 const struct pollfd *pfdp = pos->events;
848 for (i = 0; i < pos->n_events && j < outlen; ++i)
849 {
850 if (pfdp->revents & (POLLIN | POLLPRI | POLLERR | POLLHUP | POLLOUT))
851 {
852 out->rwflags = 0;
853 if (pfdp->revents & (POLLIN | POLLPRI | POLLERR | POLLHUP))
854 {
855 out->rwflags |= EVENT_READ;
856 }
857 if (pfdp->revents & POLLOUT)
858 {
859 out->rwflags |= EVENT_WRITE;
860 }
861 out->arg = pos->args[i];
863 "PO_WAIT[%d,%d] fd=%d rev=0x%08x rwflags=0x%04x arg=" ptr_format " %s", i, j,
864 pfdp->fd, pfdp->revents, out->rwflags, (ptr_type)out->arg,
865 pos->fast ? "" : "[scalable]");
866 ++out;
867 ++j;
868 }
869 else if (pfdp->revents)
870 {
871 msg(D_EVENT_ERRORS, "Error: poll: unknown revents=0x%04x for fd=%d",
872 (unsigned int)pfdp->revents, pfdp->fd);
873 }
874 ++pfdp;
875 }
876 return j;
877 }
878 return stat;
879}
880
881static struct event_set *
882po_init(int *maxevents, unsigned int flags)
883{
884 struct po_set *pos;
885
886 dmsg(D_EVENT_WAIT, "PO_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
887
888 ALLOC_OBJ_CLEAR(pos, struct po_set);
889
890 /* set dispatch functions */
891 pos->func.free = po_free;
892 pos->func.reset = po_reset;
893 pos->func.del = po_del;
894 pos->func.ctl = po_ctl;
895 pos->func.wait = po_wait;
896
897 if (flags & EVENT_METHOD_FAST)
898 {
899 pos->fast = true;
900 }
901
902 pos->n_events = 0;
903
904 /* Figure our event capacity */
905 ASSERT(*maxevents > 0);
906 pos->capacity = *maxevents;
907
908 /* Allocate space for pollfd structures to be passed to poll() */
909 ALLOC_ARRAY_CLEAR(pos->events, struct pollfd, pos->capacity);
910
911 /* Allocate space for event_set_return objects */
912 ALLOC_ARRAY_CLEAR(pos->args, void *, pos->capacity);
913
914 return (struct event_set *)pos;
915}
916#endif /* POLL */
917
918#if SELECT
919
920struct se_set
921{
922 struct event_set_functions func;
923 bool fast;
924 fd_set readfds;
925 fd_set writefds;
926 void **args; /* allocated to capacity size */
927 int maxfd; /* largest fd seen so far, always < capacity */
928 int capacity; /* fixed largest fd + 1 */
929};
930
931static void
932se_free(struct event_set *es)
933{
934 struct se_set *ses = (struct se_set *)es;
935 free(ses->args);
936 free(ses);
937}
938
939static void
940se_reset(struct event_set *es)
941{
942 struct se_set *ses = (struct se_set *)es;
943 int i;
944 ASSERT(ses->fast);
945
946 dmsg(D_EVENT_WAIT, "SE_RESET");
947
948 FD_ZERO(&ses->readfds);
949 FD_ZERO(&ses->writefds);
950 for (i = 0; i <= ses->maxfd; ++i)
951 {
952 ses->args[i] = NULL;
953 }
954 ses->maxfd = -1;
955}
956
957static void
958se_del(struct event_set *es, event_t event)
959{
960 struct se_set *ses = (struct se_set *)es;
961 ASSERT(!ses->fast);
962
963 dmsg(D_EVENT_WAIT, "SE_DEL ev=%d", (int)event);
964
965 if (event >= 0 && event < ses->capacity)
966 {
967 FD_CLR(event, &ses->readfds);
968 FD_CLR(event, &ses->writefds);
969 ses->args[event] = NULL;
970 }
971 else
972 {
973 msg(D_EVENT_ERRORS, "Error: select/se_del: too many I/O wait events");
974 }
975 return;
976}
977
978static void
979se_ctl(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
980{
981 struct se_set *ses = (struct se_set *)es;
982
983 dmsg(D_EVENT_WAIT, "SE_CTL rwflags=0x%04x ev=%d fast=%d cap=%d maxfd=%d arg=" ptr_format,
984 rwflags, (int)event, (int)ses->fast, ses->capacity, ses->maxfd, (ptr_type)arg);
985
986 if (event >= 0 && event < ses->capacity)
987 {
988 ses->maxfd = max_int(event, ses->maxfd);
989 ses->args[event] = arg;
990 if (ses->fast)
991 {
992 if (rwflags & EVENT_READ)
993 {
994 openvpn_fd_set(event, &ses->readfds);
995 }
996 if (rwflags & EVENT_WRITE)
997 {
998 openvpn_fd_set(event, &ses->writefds);
999 }
1000 }
1001 else
1002 {
1003 if (rwflags & EVENT_READ)
1004 {
1005 openvpn_fd_set(event, &ses->readfds);
1006 }
1007 else
1008 {
1009 FD_CLR(event, &ses->readfds);
1010 }
1011 if (rwflags & EVENT_WRITE)
1012 {
1013 openvpn_fd_set(event, &ses->writefds);
1014 }
1015 else
1016 {
1017 FD_CLR(event, &ses->writefds);
1018 }
1019 }
1020 }
1021 else
1022 {
1023 msg(D_EVENT_ERRORS, "Error: select: too many I/O wait events, fd=%d cap=%d", (int)event,
1024 ses->capacity);
1025 }
1026}
1027
1028static int
1029se_wait_return(struct se_set *ses, const fd_set *read, const fd_set *write, struct event_set_return *out,
1030 int outlen)
1031{
1032 int i, j = 0;
1033 for (i = 0; i <= ses->maxfd && j < outlen; ++i)
1034 {
1035 const bool r = FD_ISSET(i, read);
1036 const bool w = FD_ISSET(i, write);
1037 if (r || w)
1038 {
1039 out->rwflags = 0;
1040 if (r)
1041 {
1042 out->rwflags |= EVENT_READ;
1043 }
1044 if (w)
1045 {
1046 out->rwflags |= EVENT_WRITE;
1047 }
1048 out->arg = ses->args[i];
1049 dmsg(D_EVENT_WAIT, "SE_WAIT[%d,%d] rwflags=0x%04x arg=" ptr_format, i, j, out->rwflags,
1050 (ptr_type)out->arg);
1051 ++out;
1052 ++j;
1053 }
1054 }
1055 return j;
1056}
1057
1058static int
1059se_wait_fast(struct event_set *es, const struct timeval *tv, struct event_set_return *out,
1060 int outlen)
1061{
1062 struct se_set *ses = (struct se_set *)es;
1063 struct timeval tv_tmp = *tv;
1064 int stat;
1065
1066 dmsg(D_EVENT_WAIT, "SE_WAIT_FAST maxfd=%d tv=%" PRIi64 "/%ld", ses->maxfd,
1067 (int64_t)tv_tmp.tv_sec, (long)tv_tmp.tv_usec);
1068
1069 stat = select(ses->maxfd + 1, &ses->readfds, &ses->writefds, NULL, &tv_tmp);
1070
1071 if (stat > 0)
1072 {
1073 stat = se_wait_return(ses, &ses->readfds, &ses->writefds, out, outlen);
1074 }
1075
1076 return stat;
1077}
1078
1079static int
1080se_wait_scalable(struct event_set *es, const struct timeval *tv, struct event_set_return *out,
1081 int outlen)
1082{
1083 struct se_set *ses = (struct se_set *)es;
1084 struct timeval tv_tmp = *tv;
1085 fd_set read = ses->readfds;
1086 fd_set write = ses->writefds;
1087 int stat;
1088
1089 dmsg(D_EVENT_WAIT, "SE_WAIT_SCALEABLE maxfd=%d tv=%" PRIi64 "/%ld", ses->maxfd,
1090 (int64_t)tv_tmp.tv_sec, (long)tv_tmp.tv_usec);
1091
1092 stat = select(ses->maxfd + 1, &read, &write, NULL, &tv_tmp);
1093
1094 if (stat > 0)
1095 {
1096 stat = se_wait_return(ses, &read, &write, out, outlen);
1097 }
1098
1099 return stat;
1100}
1101
1102static struct event_set *
1103se_init(int *maxevents, unsigned int flags)
1104{
1105 struct se_set *ses;
1106
1107 dmsg(D_EVENT_WAIT, "SE_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
1108
1109 ALLOC_OBJ_CLEAR(ses, struct se_set);
1110
1111 /* set dispatch functions */
1112 ses->func.free = se_free;
1113 ses->func.reset = se_reset;
1114 ses->func.del = se_del;
1115 ses->func.ctl = se_ctl;
1116 ses->func.wait = se_wait_scalable;
1117
1118 if (flags & EVENT_METHOD_FAST)
1119 {
1120 ses->fast = true;
1121 ses->func.wait = se_wait_fast;
1122 }
1123
1124 /* Select needs to be passed this value + 1 */
1125 ses->maxfd = -1;
1126
1127 /* Set our event capacity */
1128 ASSERT(*maxevents > 0);
1129 *maxevents = min_int(*maxevents, SELECT_MAX_FDS);
1130 ses->capacity = SELECT_MAX_FDS;
1131
1132 /* Allocate space for event_set_return void * args */
1133 ALLOC_ARRAY_CLEAR(ses->args, void *, ses->capacity);
1134
1135 return (struct event_set *)ses;
1136}
1137#endif /* SELECT */
1138
1139#if defined(__GNUC__) || defined(__clang__)
1140#pragma GCC diagnostic pop
1141#endif
1142
1143static struct event_set *
1144event_set_init_simple(int *maxevents, unsigned int flags)
1145{
1146 struct event_set *ret = NULL;
1147#ifdef _WIN32
1148 ret = we_init(maxevents, flags);
1149#elif POLL && SELECT
1150#if 0 /* Define to 1 if EVENT_METHOD_US_TIMEOUT should cause select to be favored over poll */
1151 if (flags & EVENT_METHOD_US_TIMEOUT)
1152 {
1153 ret = se_init(maxevents, flags);
1154 }
1155#endif
1156#ifdef SELECT_PREFERRED_OVER_POLL
1157 if (!ret)
1158 {
1159 ret = se_init(maxevents, flags);
1160 }
1161 if (!ret)
1162 {
1163 ret = po_init(maxevents, flags);
1164 }
1165#else /* ifdef SELECT_PREFERRED_OVER_POLL */
1166 if (!ret)
1167 {
1168 ret = po_init(maxevents, flags);
1169 }
1170 if (!ret)
1171 {
1172 ret = se_init(maxevents, flags);
1173 }
1174#endif
1175#elif POLL
1176 ret = po_init(maxevents, flags);
1177#elif SELECT
1178 ret = se_init(maxevents, flags);
1179#else /* ifdef _WIN32 */
1180#error At least one of poll, select, or WSAWaitForMultipleEvents must be supported by the kernel
1181#endif /* ifdef _WIN32 */
1182 ASSERT(ret);
1183 return ret;
1184}
1185
1186static struct event_set *
1187event_set_init_scalable(int *maxevents, unsigned int flags)
1188{
1189 struct event_set *ret = NULL;
1190#if EPOLL
1191 ret = ep_init(maxevents, flags);
1192 if (!ret)
1193 {
1194 msg(M_WARN, "Note: sys_epoll API is unavailable, falling back to poll/select API");
1195 ret = event_set_init_simple(maxevents, flags);
1196 }
1197#else /* if EPOLL */
1198 ret = event_set_init_simple(maxevents, flags);
1199#endif
1200 ASSERT(ret);
1201 return ret;
1202}
1203
1204struct event_set *
1205event_set_init(int *maxevents, unsigned int flags)
1206{
1207 if (flags & EVENT_METHOD_FAST)
1208 {
1209 return event_set_init_simple(maxevents, flags);
1210 }
1211 else
1212 {
1213 return event_set_init_scalable(maxevents, flags);
1214 }
1215}
Buffer management functions and garbage collection.
#define ALLOC_ARRAY_CLEAR(dptr, type, n)
Allocate and zero-initialise an array of n elements of the given type.
Definition buffer.h:2077
#define ALLOC_OBJ_CLEAR(dptr, type)
Allocate and zero-initialise memory for a single object of the given type.
Definition buffer.h:2036
unsigned long ptr_type
Definition common.h:59
#define ptr_format
Definition common.h:50
#define D_EVENT_ERRORS
Definition errlevel.h:65
#define D_EVENT_WAIT
Definition errlevel.h:158
static bool we_append_event(struct we_set *wes, event_t event, unsigned int rwflags, void *arg)
Definition event.c:128
#define SELECT_MAX_FDS
Definition event.c:65
static struct event_set * event_set_init_simple(int *maxevents, unsigned int flags)
Definition event.c:1144
static void we_free(struct event_set *es)
Definition event.c:217
static void we_get_rw_indices(struct we_set *wes, event_t event, int *ri, int *wi)
Definition event.c:196
static void we_del_index(struct we_set *wes, int index)
Definition event.c:183
static int tv_to_ms_timeout(const struct timeval *tv)
Convert timeval value (which is in seconds and microseconds) to a value of milliseconds which is requ...
Definition event.c:78
static struct event_set * event_set_init_scalable(int *maxevents, unsigned int flags)
Definition event.c:1187
static void we_del(struct event_set *es, event_t event)
Definition event.c:234
static int we_wait(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
Definition event.c:393
static void we_ctl(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
Definition event.c:242
static struct event_set * we_init(int *maxevents, unsigned int flags)
Definition event.c:495
struct event_set * event_set_init(int *maxevents, unsigned int flags)
Definition event.c:1205
static void we_del_event(struct we_set *wes, event_t event)
Definition event.c:158
static void we_set_event(struct we_set *wes, int i, event_t event, unsigned int rwflags, void *arg)
Definition event.c:104
static void we_reset(struct event_set *es)
Definition event.c:226
#define EVENT_METHOD_FAST
Definition event.h:79
#define EVENT_METHOD_US_TIMEOUT
Definition event.h:78
const struct rw_handle * event_t
Definition event.h:89
#define EVENT_WRITE
Definition event.h:38
#define EVENT_READ
Definition event.h:37
void set_cloexec(socket_descriptor_t fd)
Definition fdmisc.c:87
static void openvpn_fd_set(socket_descriptor_t fd, fd_set *setp)
Definition fdmisc.h:44
static int min_int(int x, int y)
Definition integer.h:105
static int max_int(int x, int y)
Definition integer.h:92
static SERVICE_STATUS status
Definition interactive.c:52
@ write
@ read
#define CLEAR(x)
Definition basic.h:32
static bool check_debug_level(msglvl_t level)
Definition error.h:253
#define M_FATAL
Definition error.h:90
#define dmsg(flags,...)
Definition error.h:164
#define M_ERR
Definition error.h:106
#define msg(flags,...)
Definition error.h:152
#define ASSERT(x)
Definition error.h:221
#define M_WARN
Definition error.h:92
#define M_ERRNO
Definition error.h:95
static int pos(char c)
Definition base64.c:104
void(* ctl)(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
Definition event.h:109
int(* wait)(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
Definition event.h:117
void(* del)(struct event_set *es, event_t event)
Definition event.h:108
void(* reset)(struct event_set *es)
Definition event.h:107
void(* free)(struct event_set *es)
Definition event.h:106
unsigned int rwflags
Definition event.h:123
HANDLE write
Definition win32.h:83
HANDLE read
Definition win32.h:82
Definition event.c:94
struct event_set_return * esr
Definition event.c:98
struct event_set_functions func
Definition event.c:95
int capacity
Definition event.c:100
HANDLE * events
Definition event.c:97
bool fast
Definition event.c:96
int n_events
Definition event.c:99