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-2025 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=%d", 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=%d", 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#ifdef ENABLE_DEBUG
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 /*
414 * First poll our event list with 0 timeout
415 */
416 status = WSAWaitForMultipleEvents((DWORD)wes->n_events, wes->events, FALSE, (DWORD)0, FALSE);
417
418 /*
419 * If at least one event is already set, we must
420 * individually poll the whole list.
421 */
422 if (status >= WSA_WAIT_EVENT_0 && status < WSA_WAIT_EVENT_0 + (DWORD)wes->n_events)
423 {
424 int i;
425 int j = 0;
426 for (i = 0; i < wes->n_events; ++i)
427 {
428 if (j >= outlen)
429 {
430 break;
431 }
432 if (WaitForSingleObject(wes->events[i], 0) == WAIT_OBJECT_0)
433 {
434 *out = wes->esr[i];
435 dmsg(D_EVENT_WAIT, "WE_WAIT leave [%d,%d] rwflags=0x%04x arg=" ptr_format, i, j,
436 out->rwflags, (ptr_type)out->arg);
437 ++j;
438 ++out;
439 }
440 }
441 return j;
442 }
443 else
444 {
445 /*
446 * If caller specified timeout > 0, we know at this point
447 * that no events are set, so wait only for the first event
448 * (or timeout) and return at most one event_set_return object.
449 *
450 * If caller specified timeout == 0, the second call to
451 * WSAWaitForMultipleEvents would be redundant -- just
452 * return 0 indicating timeout.
453 */
454 if (timeout > 0)
455 {
456 status = WSAWaitForMultipleEvents((DWORD)wes->n_events, wes->events, FALSE,
457 (DWORD)timeout, FALSE);
458 }
459
460 if (outlen >= 1 && status >= WSA_WAIT_EVENT_0
461 && status < WSA_WAIT_EVENT_0 + (DWORD)wes->n_events)
462 {
463 *out = wes->esr[status - WSA_WAIT_EVENT_0];
464 dmsg(D_EVENT_WAIT, "WE_WAIT leave rwflags=0x%04x arg=" ptr_format, out->rwflags,
465 (ptr_type)out->arg);
466 return 1;
467 }
468 else if (status == WSA_WAIT_TIMEOUT)
469 {
470 return 0;
471 }
472 else
473 {
474 return -1;
475 }
476 }
477}
478
479static struct event_set *
480we_init(int *maxevents, unsigned int flags)
481{
482 struct we_set *wes;
483
484 dmsg(D_EVENT_WAIT, "WE_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
485
486 ALLOC_OBJ_CLEAR(wes, struct we_set);
487
488 /* set dispatch functions */
489 wes->func.free = we_free;
490 wes->func.reset = we_reset;
491 wes->func.del = we_del;
492 wes->func.ctl = we_ctl;
493 wes->func.wait = we_wait;
494
495 if (flags & EVENT_METHOD_FAST)
496 {
497 wes->fast = true;
498 }
499 wes->n_events = 0;
500
501 /* Figure our event capacity */
502 ASSERT(*maxevents > 0);
503 wes->capacity = min_int(*maxevents * 2, WSA_MAXIMUM_WAIT_EVENTS);
504 *maxevents = min_int(*maxevents, WSA_MAXIMUM_WAIT_EVENTS);
505
506 /* Allocate space for Win32 event handles */
507 ALLOC_ARRAY_CLEAR(wes->events, HANDLE, wes->capacity);
508
509 /* Allocate space for event_set_return objects */
511
512 dmsg(D_EVENT_WAIT, "WE_INIT maxevents=%d capacity=%d", *maxevents, wes->capacity);
513
514 return (struct event_set *)wes;
515}
516
517#endif /* _WIN32 */
518
519#if EPOLL
520
521struct ep_set
522{
523 struct event_set_functions func;
524 bool fast;
525 int epfd;
526 int maxevents;
527 struct epoll_event *events;
528};
529
530static void
531ep_free(struct event_set *es)
532{
533 struct ep_set *eps = (struct ep_set *)es;
534 close(eps->epfd);
535 free(eps->events);
536 free(eps);
537}
538
539static void
540ep_reset(struct event_set *es)
541{
542 const struct ep_set *eps = (struct ep_set *)es;
543 ASSERT(eps->fast);
544}
545
546static void
547ep_del(struct event_set *es, event_t event)
548{
549 struct epoll_event ev;
550 struct ep_set *eps = (struct ep_set *)es;
551
552 dmsg(D_EVENT_WAIT, "EP_DEL ev=%d", (int)event);
553
554 ASSERT(!eps->fast);
555 CLEAR(ev);
556 if (epoll_ctl(eps->epfd, EPOLL_CTL_DEL, event, &ev) < 0)
557 {
558 msg(M_WARN | M_ERRNO, "EVENT: epoll_ctl EPOLL_CTL_DEL failed, sd=%d", (int)event);
559 }
560}
561
562static void
563ep_ctl(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
564{
565 struct ep_set *eps = (struct ep_set *)es;
566 struct epoll_event ev;
567
568 CLEAR(ev);
569
570 ev.data.ptr = arg;
571 if (rwflags & EVENT_READ)
572 {
573 ev.events |= EPOLLIN;
574 }
575 if (rwflags & EVENT_WRITE)
576 {
577 ev.events |= EPOLLOUT;
578 }
579
580 dmsg(D_EVENT_WAIT, "EP_CTL fd=%d rwflags=0x%04x ev=0x%08x arg=" ptr_format, (int)event, rwflags,
581 (unsigned int)ev.events, (ptr_type)ev.data.ptr);
582
583 if (epoll_ctl(eps->epfd, EPOLL_CTL_MOD, event, &ev) < 0)
584 {
585 if (errno == ENOENT)
586 {
587 if (epoll_ctl(eps->epfd, EPOLL_CTL_ADD, event, &ev) < 0)
588 {
589 msg(M_ERR, "EVENT: epoll_ctl EPOLL_CTL_ADD failed, sd=%d", (int)event);
590 }
591 }
592 else
593 {
594 msg(M_ERR, "EVENT: epoll_ctl EPOLL_CTL_MOD failed, sd=%d", (int)event);
595 }
596 }
597}
598
599static int
600ep_wait(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
601{
602 struct ep_set *eps = (struct ep_set *)es;
603 int stat;
604
605 if (outlen > eps->maxevents)
606 {
607 outlen = eps->maxevents;
608 }
609
610 stat = epoll_wait(eps->epfd, eps->events, outlen, tv_to_ms_timeout(tv));
611 ASSERT(stat <= outlen);
612
613 if (stat > 0)
614 {
615 int i;
616 const struct epoll_event *ev = eps->events;
617 struct event_set_return *esr = out;
618 for (i = 0; i < stat; ++i)
619 {
620 esr->rwflags = 0;
621 if (ev->events & (EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP))
622 {
623 esr->rwflags |= EVENT_READ;
624 }
625 if (ev->events & EPOLLOUT)
626 {
627 esr->rwflags |= EVENT_WRITE;
628 }
629 esr->arg = ev->data.ptr;
630 dmsg(D_EVENT_WAIT, "EP_WAIT[%d] rwflags=0x%04x ev=0x%08x arg=" ptr_format, i,
631 esr->rwflags, ev->events, (ptr_type)ev->data.ptr);
632 ++ev;
633 ++esr;
634 }
635 }
636 return stat;
637}
638
639static struct event_set *
640ep_init(int *maxevents, unsigned int flags)
641{
642 struct ep_set *eps;
643 int fd;
644
645 dmsg(D_EVENT_WAIT, "EP_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
646
647 /* open epoll file descriptor */
648 fd = epoll_create(*maxevents);
649 if (fd < 0)
650 {
651 return NULL;
652 }
653
654 set_cloexec(fd);
655
656 ALLOC_OBJ_CLEAR(eps, struct ep_set);
657
658 /* set dispatch functions */
659 eps->func.free = ep_free;
660 eps->func.reset = ep_reset;
661 eps->func.del = ep_del;
662 eps->func.ctl = ep_ctl;
663 eps->func.wait = ep_wait;
664
665 /* fast method ("sort of") corresponds to epoll one-shot */
666 if (flags & EVENT_METHOD_FAST)
667 {
668 eps->fast = true;
669 }
670
671 /* allocate space for epoll_wait return */
672 ASSERT(*maxevents > 0);
673 eps->maxevents = *maxevents;
674 ALLOC_ARRAY_CLEAR(eps->events, struct epoll_event, eps->maxevents);
675
676 /* set epoll control fd */
677 eps->epfd = fd;
678
679 return (struct event_set *)eps;
680}
681#endif /* EPOLL */
682
683#if POLL
684
685struct po_set
686{
687 struct event_set_functions func;
688 bool fast;
689 struct pollfd *events;
690 void **args;
691 int n_events;
692 int capacity;
693};
694
695static void
696po_free(struct event_set *es)
697{
698 struct po_set *pos = (struct po_set *)es;
699 free(pos->events);
700 free(pos->args);
701 free(pos);
702}
703
704static void
705po_reset(struct event_set *es)
706{
707 struct po_set *pos = (struct po_set *)es;
708 ASSERT(pos->fast);
709 pos->n_events = 0;
710}
711
712static void
713po_del(struct event_set *es, event_t event)
714{
715 struct po_set *pos = (struct po_set *)es;
716 int i;
717
718 dmsg(D_EVENT_WAIT, "PO_DEL ev=%d", (int)event);
719
720 ASSERT(!pos->fast);
721 for (i = 0; i < pos->n_events; ++i)
722 {
723 if (pos->events[i].fd == event)
724 {
725 int j;
726 for (j = i; j < pos->n_events - 1; ++j)
727 {
728 pos->events[j] = pos->events[j + 1];
729 pos->args[j] = pos->args[j + 1];
730 }
731 --pos->n_events;
732 break;
733 }
734 }
735}
736
737static inline void
738po_set_pollfd_events(struct pollfd *pfdp, unsigned int rwflags)
739{
740 pfdp->events = 0;
741 if (rwflags & EVENT_WRITE)
742 {
743 pfdp->events |= POLLOUT;
744 }
745 if (rwflags & EVENT_READ)
746 {
747 pfdp->events |= (POLLIN | POLLPRI);
748 }
749}
750
751static inline bool
752po_append_event(struct po_set *pos, event_t event, unsigned int rwflags, void *arg)
753{
754 if (pos->n_events < pos->capacity)
755 {
756 struct pollfd *pfdp = &pos->events[pos->n_events];
757 pfdp->fd = event;
758 pos->args[pos->n_events] = arg;
759 po_set_pollfd_events(pfdp, rwflags);
760 ++pos->n_events;
761 return true;
762 }
763 else
764 {
765 return false;
766 }
767}
768
769static void
770po_ctl(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
771{
772 struct po_set *pos = (struct po_set *)es;
773
774 dmsg(D_EVENT_WAIT, "PO_CTL rwflags=0x%04x ev=%d arg=" ptr_format, rwflags, (int)event,
775 (ptr_type)arg);
776
777 if (pos->fast)
778 {
779 if (!po_append_event(pos, event, rwflags, arg))
780 {
781 goto err;
782 }
783 }
784 else
785 {
786 int i;
787 for (i = 0; i < pos->n_events; ++i)
788 {
789 struct pollfd *pfdp = &pos->events[i];
790 if (pfdp->fd == event)
791 {
792 pos->args[i] = arg;
793 po_set_pollfd_events(pfdp, rwflags);
794 goto done;
795 }
796 }
797 if (!po_append_event(pos, event, rwflags, arg))
798 {
799 goto err;
800 }
801 }
802
803done:
804 return;
805
806err:
807 msg(D_EVENT_ERRORS, "Error: poll: too many I/O wait events");
808}
809
810static int
811po_wait(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
812{
813 struct po_set *pos = (struct po_set *)es;
814 int stat;
815
816 stat = poll(pos->events, pos->n_events, tv_to_ms_timeout(tv));
817
818 ASSERT(stat <= pos->n_events);
819
820 if (stat > 0)
821 {
822 int i, j = 0;
823 const struct pollfd *pfdp = pos->events;
824 for (i = 0; i < pos->n_events && j < outlen; ++i)
825 {
826 if (pfdp->revents & (POLLIN | POLLPRI | POLLERR | POLLHUP | POLLOUT))
827 {
828 out->rwflags = 0;
829 if (pfdp->revents & (POLLIN | POLLPRI | POLLERR | POLLHUP))
830 {
831 out->rwflags |= EVENT_READ;
832 }
833 if (pfdp->revents & POLLOUT)
834 {
835 out->rwflags |= EVENT_WRITE;
836 }
837 out->arg = pos->args[i];
839 "PO_WAIT[%d,%d] fd=%d rev=0x%08x rwflags=0x%04x arg=" ptr_format " %s", i, j,
840 pfdp->fd, pfdp->revents, out->rwflags, (ptr_type)out->arg,
841 pos->fast ? "" : "[scalable]");
842 ++out;
843 ++j;
844 }
845 else if (pfdp->revents)
846 {
847 msg(D_EVENT_ERRORS, "Error: poll: unknown revents=0x%04x for fd=%d",
848 (unsigned int)pfdp->revents, pfdp->fd);
849 }
850 ++pfdp;
851 }
852 return j;
853 }
854 return stat;
855}
856
857static struct event_set *
858po_init(int *maxevents, unsigned int flags)
859{
860 struct po_set *pos;
861
862 dmsg(D_EVENT_WAIT, "PO_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
863
864 ALLOC_OBJ_CLEAR(pos, struct po_set);
865
866 /* set dispatch functions */
867 pos->func.free = po_free;
868 pos->func.reset = po_reset;
869 pos->func.del = po_del;
870 pos->func.ctl = po_ctl;
871 pos->func.wait = po_wait;
872
873 if (flags & EVENT_METHOD_FAST)
874 {
875 pos->fast = true;
876 }
877
878 pos->n_events = 0;
879
880 /* Figure our event capacity */
881 ASSERT(*maxevents > 0);
882 pos->capacity = *maxevents;
883
884 /* Allocate space for pollfd structures to be passed to poll() */
885 ALLOC_ARRAY_CLEAR(pos->events, struct pollfd, pos->capacity);
886
887 /* Allocate space for event_set_return objects */
888 ALLOC_ARRAY_CLEAR(pos->args, void *, pos->capacity);
889
890 return (struct event_set *)pos;
891}
892#endif /* POLL */
893
894#if SELECT
895
896struct se_set
897{
898 struct event_set_functions func;
899 bool fast;
900 fd_set readfds;
901 fd_set writefds;
902 void **args; /* allocated to capacity size */
903 int maxfd; /* largest fd seen so far, always < capacity */
904 int capacity; /* fixed largest fd + 1 */
905};
906
907static void
908se_free(struct event_set *es)
909{
910 struct se_set *ses = (struct se_set *)es;
911 free(ses->args);
912 free(ses);
913}
914
915static void
916se_reset(struct event_set *es)
917{
918 struct se_set *ses = (struct se_set *)es;
919 int i;
920 ASSERT(ses->fast);
921
922 dmsg(D_EVENT_WAIT, "SE_RESET");
923
924 FD_ZERO(&ses->readfds);
925 FD_ZERO(&ses->writefds);
926 for (i = 0; i <= ses->maxfd; ++i)
927 {
928 ses->args[i] = NULL;
929 }
930 ses->maxfd = -1;
931}
932
933static void
934se_del(struct event_set *es, event_t event)
935{
936 struct se_set *ses = (struct se_set *)es;
937 ASSERT(!ses->fast);
938
939 dmsg(D_EVENT_WAIT, "SE_DEL ev=%d", (int)event);
940
941 if (event >= 0 && event < ses->capacity)
942 {
943 FD_CLR(event, &ses->readfds);
944 FD_CLR(event, &ses->writefds);
945 ses->args[event] = NULL;
946 }
947 else
948 {
949 msg(D_EVENT_ERRORS, "Error: select/se_del: too many I/O wait events");
950 }
951 return;
952}
953
954static void
955se_ctl(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
956{
957 struct se_set *ses = (struct se_set *)es;
958
959 dmsg(D_EVENT_WAIT, "SE_CTL rwflags=0x%04x ev=%d fast=%d cap=%d maxfd=%d arg=" ptr_format,
960 rwflags, (int)event, (int)ses->fast, ses->capacity, ses->maxfd, (ptr_type)arg);
961
962 if (event >= 0 && event < ses->capacity)
963 {
964 ses->maxfd = max_int(event, ses->maxfd);
965 ses->args[event] = arg;
966 if (ses->fast)
967 {
968 if (rwflags & EVENT_READ)
969 {
970 openvpn_fd_set(event, &ses->readfds);
971 }
972 if (rwflags & EVENT_WRITE)
973 {
974 openvpn_fd_set(event, &ses->writefds);
975 }
976 }
977 else
978 {
979 if (rwflags & EVENT_READ)
980 {
981 openvpn_fd_set(event, &ses->readfds);
982 }
983 else
984 {
985 FD_CLR(event, &ses->readfds);
986 }
987 if (rwflags & EVENT_WRITE)
988 {
989 openvpn_fd_set(event, &ses->writefds);
990 }
991 else
992 {
993 FD_CLR(event, &ses->writefds);
994 }
995 }
996 }
997 else
998 {
999 msg(D_EVENT_ERRORS, "Error: select: too many I/O wait events, fd=%d cap=%d", (int)event,
1000 ses->capacity);
1001 }
1002}
1003
1004static int
1005se_wait_return(struct se_set *ses, fd_set *read, fd_set *write, struct event_set_return *out,
1006 int outlen)
1007{
1008 int i, j = 0;
1009 for (i = 0; i <= ses->maxfd && j < outlen; ++i)
1010 {
1011 const bool r = FD_ISSET(i, read);
1012 const bool w = FD_ISSET(i, write);
1013 if (r || w)
1014 {
1015 out->rwflags = 0;
1016 if (r)
1017 {
1018 out->rwflags |= EVENT_READ;
1019 }
1020 if (w)
1021 {
1022 out->rwflags |= EVENT_WRITE;
1023 }
1024 out->arg = ses->args[i];
1025 dmsg(D_EVENT_WAIT, "SE_WAIT[%d,%d] rwflags=0x%04x arg=" ptr_format, i, j, out->rwflags,
1026 (ptr_type)out->arg);
1027 ++out;
1028 ++j;
1029 }
1030 }
1031 return j;
1032}
1033
1034static int
1035se_wait_fast(struct event_set *es, const struct timeval *tv, struct event_set_return *out,
1036 int outlen)
1037{
1038 struct se_set *ses = (struct se_set *)es;
1039 struct timeval tv_tmp = *tv;
1040 int stat;
1041
1042 dmsg(D_EVENT_WAIT, "SE_WAIT_FAST maxfd=%d tv=%" PRIi64 "/%ld", ses->maxfd,
1043 (int64_t)tv_tmp.tv_sec, (long)tv_tmp.tv_usec);
1044
1045 stat = select(ses->maxfd + 1, &ses->readfds, &ses->writefds, NULL, &tv_tmp);
1046
1047 if (stat > 0)
1048 {
1049 stat = se_wait_return(ses, &ses->readfds, &ses->writefds, out, outlen);
1050 }
1051
1052 return stat;
1053}
1054
1055static int
1056se_wait_scalable(struct event_set *es, const struct timeval *tv, struct event_set_return *out,
1057 int outlen)
1058{
1059 struct se_set *ses = (struct se_set *)es;
1060 struct timeval tv_tmp = *tv;
1061 fd_set read = ses->readfds;
1062 fd_set write = ses->writefds;
1063 int stat;
1064
1065 dmsg(D_EVENT_WAIT, "SE_WAIT_SCALEABLE maxfd=%d tv=%" PRIi64 "/%ld", ses->maxfd,
1066 (int64_t)tv_tmp.tv_sec, (long)tv_tmp.tv_usec);
1067
1068 stat = select(ses->maxfd + 1, &read, &write, NULL, &tv_tmp);
1069
1070 if (stat > 0)
1071 {
1072 stat = se_wait_return(ses, &read, &write, out, outlen);
1073 }
1074
1075 return stat;
1076}
1077
1078static struct event_set *
1079se_init(int *maxevents, unsigned int flags)
1080{
1081 struct se_set *ses;
1082
1083 dmsg(D_EVENT_WAIT, "SE_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
1084
1085 ALLOC_OBJ_CLEAR(ses, struct se_set);
1086
1087 /* set dispatch functions */
1088 ses->func.free = se_free;
1089 ses->func.reset = se_reset;
1090 ses->func.del = se_del;
1091 ses->func.ctl = se_ctl;
1092 ses->func.wait = se_wait_scalable;
1093
1094 if (flags & EVENT_METHOD_FAST)
1095 {
1096 ses->fast = true;
1097 ses->func.wait = se_wait_fast;
1098 }
1099
1100 /* Select needs to be passed this value + 1 */
1101 ses->maxfd = -1;
1102
1103 /* Set our event capacity */
1104 ASSERT(*maxevents > 0);
1105 *maxevents = min_int(*maxevents, SELECT_MAX_FDS);
1106 ses->capacity = SELECT_MAX_FDS;
1107
1108 /* Allocate space for event_set_return void * args */
1109 ALLOC_ARRAY_CLEAR(ses->args, void *, ses->capacity);
1110
1111 return (struct event_set *)ses;
1112}
1113#endif /* SELECT */
1114
1115static struct event_set *
1116event_set_init_simple(int *maxevents, unsigned int flags)
1117{
1118 struct event_set *ret = NULL;
1119#ifdef _WIN32
1120 ret = we_init(maxevents, flags);
1121#elif POLL && SELECT
1122#if 0 /* Define to 1 if EVENT_METHOD_US_TIMEOUT should cause select to be favored over poll */
1123 if (flags & EVENT_METHOD_US_TIMEOUT)
1124 {
1125 ret = se_init(maxevents, flags);
1126 }
1127#endif
1128#ifdef SELECT_PREFERRED_OVER_POLL
1129 if (!ret)
1130 {
1131 ret = se_init(maxevents, flags);
1132 }
1133 if (!ret)
1134 {
1135 ret = po_init(maxevents, flags);
1136 }
1137#else /* ifdef SELECT_PREFERRED_OVER_POLL */
1138 if (!ret)
1139 {
1140 ret = po_init(maxevents, flags);
1141 }
1142 if (!ret)
1143 {
1144 ret = se_init(maxevents, flags);
1145 }
1146#endif
1147#elif POLL
1148 ret = po_init(maxevents, flags);
1149#elif SELECT
1150 ret = se_init(maxevents, flags);
1151#else /* ifdef _WIN32 */
1152#error At least one of poll, select, or WSAWaitForMultipleEvents must be supported by the kernel
1153#endif /* ifdef _WIN32 */
1154 ASSERT(ret);
1155 return ret;
1156}
1157
1158static struct event_set *
1159event_set_init_scalable(int *maxevents, unsigned int flags)
1160{
1161 struct event_set *ret = NULL;
1162#if EPOLL
1163 ret = ep_init(maxevents, flags);
1164 if (!ret)
1165 {
1166 msg(M_WARN, "Note: sys_epoll API is unavailable, falling back to poll/select API");
1167 ret = event_set_init_simple(maxevents, flags);
1168 }
1169#else /* if EPOLL */
1170 ret = event_set_init_simple(maxevents, flags);
1171#endif
1172 ASSERT(ret);
1173 return ret;
1174}
1175
1176struct event_set *
1177event_set_init(int *maxevents, unsigned int flags)
1178{
1179 if (flags & EVENT_METHOD_FAST)
1180 {
1181 return event_set_init_simple(maxevents, flags);
1182 }
1183 else
1184 {
1185 return event_set_init_scalable(maxevents, flags);
1186 }
1187}
#define ALLOC_ARRAY_CLEAR(dptr, type, n)
Definition buffer.h:1058
#define ALLOC_OBJ_CLEAR(dptr, type)
Definition buffer.h:1042
unsigned long ptr_type
Definition common.h:57
#define ptr_format
Definition common.h:48
#define D_EVENT_ERRORS
Definition errlevel.h:65
#define D_EVENT_WAIT
Definition errlevel.h:161
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:1116
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:1159
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:480
struct event_set * event_set_init(int *maxevents, unsigned int flags)
Definition event.c:1177
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:82
#define EVENT_METHOD_US_TIMEOUT
Definition event.h:81
#define EVENT_WRITE
Definition event.h:39
#define EVENT_READ
Definition event.h:38
void set_cloexec(socket_descriptor_t fd)
Definition fdmisc.c:78
static void openvpn_fd_set(socket_descriptor_t fd, fd_set *setp)
Definition fdmisc.h:39
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:51
@ write
@ read
#define CLEAR(x)
Definition basic.h:32
static bool check_debug_level(msglvl_t level)
Definition error.h:259
#define M_FATAL
Definition error.h:90
#define dmsg(flags,...)
Definition error.h:172
#define M_ERR
Definition error.h:106
#define msg(flags,...)
Definition error.h:152
#define ASSERT(x)
Definition error.h:219
#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:112
int(* wait)(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
Definition event.h:120
void(* del)(struct event_set *es, event_t event)
Definition event.h:111
void(* reset)(struct event_set *es)
Definition event.h:110
void(* free)(struct event_set *es)
Definition event.h:109
unsigned int rwflags
Definition event.h:126
HANDLE write
Definition win32.h:82
HANDLE read
Definition win32.h:81
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
struct env_set * es