2 * util/ub_event_pluggable.c - call registered pluggable event functions
4 * Copyright (c) 2007, NLnet Labs. All rights reserved.
6 * This software is open source.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
12 * Redistributions of source code must retain the above copyright notice,
13 * this list of conditions and the following disclaimer.
15 * Redistributions in binary form must reproduce the above copyright notice,
16 * this list of conditions and the following disclaimer in the documentation
17 * and/or other materials provided with the distribution.
19 * Neither the name of the NLNET LABS nor the names of its contributors may
20 * be used to endorse or promote products derived from this software without
21 * specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
29 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
30 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 * This file contains an implementation for the indirection layer for pluggable
40 * events that calls the registered pluggable event loop. It also defines a
41 * default pluggable event loop based on the default libevent (compatibility)
46 #include "util/ub_event.h"
47 #include "libunbound/unbound-event.h"
48 #include "util/netevent.h"
50 #include "util/fptr_wlist.h"
52 /* We define libevent structures here to hide the libevent stuff. */
56 # include "util/winsock_event.h"
58 # include "util/mini_event.h"
59 # endif /* USE_WINSOCK */
60 #else /* USE_MINI_EVENT */
65 # include "event2/event.h"
66 # include "event2/event_struct.h"
67 # include "event2/event_compat.h"
69 #endif /* USE_MINI_EVENT */
71 #if UB_EV_TIMEOUT != EV_TIMEOUT || UB_EV_READ != EV_READ || \
72 UB_EV_WRITE != EV_WRITE || UB_EV_SIGNAL != EV_SIGNAL || \
73 UB_EV_PERSIST != EV_PERSIST
74 /* Only necessary for libev */
75 # define NATIVE_BITS(b) ( \
76 (((b) & UB_EV_TIMEOUT) ? EV_TIMEOUT : 0) \
77 | (((b) & UB_EV_READ ) ? EV_READ : 0) \
78 | (((b) & UB_EV_WRITE ) ? EV_WRITE : 0) \
79 | (((b) & UB_EV_SIGNAL ) ? EV_SIGNAL : 0) \
80 | (((b) & UB_EV_PERSIST) ? EV_PERSIST : 0))
82 # define UB_EV_BITS(b) ( \
83 (((b) & EV_TIMEOUT) ? UB_EV_TIMEOUT : 0) \
84 | (((b) & EV_READ ) ? UB_EV_READ : 0) \
85 | (((b) & EV_WRITE ) ? UB_EV_WRITE : 0) \
86 | (((b) & EV_SIGNAL ) ? UB_EV_SIGNAL : 0) \
87 | (((b) & EV_PERSIST) ? UB_EV_PERSIST : 0))
89 # define UB_EV_BITS_CB(C) void my_ ## C (int fd, short bits, void *arg) \
90 { (C)(fd, UB_EV_BITS(bits), arg); }
92 UB_EV_BITS_CB(comm_point_udp_callback);
93 UB_EV_BITS_CB(comm_point_udp_ancil_callback)
94 UB_EV_BITS_CB(comm_point_tcp_accept_callback)
95 UB_EV_BITS_CB(comm_point_tcp_handle_callback)
96 UB_EV_BITS_CB(comm_timer_callback)
97 UB_EV_BITS_CB(comm_signal_callback)
98 UB_EV_BITS_CB(comm_point_local_handle_callback)
99 UB_EV_BITS_CB(comm_point_raw_handle_callback)
100 UB_EV_BITS_CB(tube_handle_signal)
101 UB_EV_BITS_CB(comm_base_handle_slow_accept)
103 static void (*NATIVE_BITS_CB(void (*cb)(int, short, void*)))(int, short, void*)
105 if(cb == comm_point_udp_callback)
106 return my_comm_point_udp_callback;
107 else if(cb == comm_point_udp_ancil_callback)
108 return my_comm_point_udp_ancil_callback;
109 else if(cb == comm_point_tcp_accept_callback)
110 return my_comm_point_tcp_accept_callback;
111 else if(cb == comm_point_tcp_handle_callback)
112 return my_comm_point_tcp_handle_callback;
113 else if(cb == comm_timer_callback)
114 return my_comm_timer_callback;
115 else if(cb == comm_signal_callback)
116 return my_comm_signal_callback;
117 else if(cb == comm_point_local_handle_callback)
118 return my_comm_point_local_handle_callback;
119 else if(cb == comm_point_raw_handle_callback)
120 return my_comm_point_raw_handle_callback;
121 else if(cb == tube_handle_signal)
122 return my_tube_handle_signal;
123 else if(cb == comm_base_handle_slow_accept)
124 return my_comm_base_handle_slow_accept;
129 # define NATIVE_BITS(b) (b)
130 # define NATIVE_BITS_CB(c) (c)
134 #define EVFLAG_AUTO 0
137 struct my_event_base {
138 struct ub_event_base super;
139 struct event_base* base;
143 struct ub_event super;
147 #define AS_MY_EVENT_BASE(x) \
148 (((union {struct ub_event_base* a; struct my_event_base* b;})x).b)
149 #define AS_MY_EVENT(x) \
150 (((union {struct ub_event* a; struct my_event* b;})x).b)
152 const char* ub_event_get_version()
154 return "pluggable-event"PACKAGE_VERSION;
158 my_event_add_bits(struct ub_event* ev, short bits)
160 AS_MY_EVENT(ev)->ev.ev_events |= NATIVE_BITS(bits);
164 my_event_del_bits(struct ub_event* ev, short bits)
166 AS_MY_EVENT(ev)->ev.ev_events &= ~NATIVE_BITS(bits);
170 my_event_set_fd(struct ub_event* ev, int fd)
172 AS_MY_EVENT(ev)->ev.ev_fd = fd;
176 my_event_free(struct ub_event* ev)
178 free(AS_MY_EVENT(ev));
182 my_event_add(struct ub_event* ev, struct timeval* tv)
184 return event_add(&AS_MY_EVENT(ev)->ev, tv);
188 my_event_del(struct ub_event* ev)
190 return event_del(&AS_MY_EVENT(ev)->ev);
194 my_timer_add(struct ub_event* ev, struct ub_event_base* base,
195 void (*cb)(int, short, void*), void* arg, struct timeval* tv)
197 event_set(&AS_MY_EVENT(ev)->ev, -1, EV_TIMEOUT,NATIVE_BITS_CB(cb),arg);
198 if (event_base_set(AS_MY_EVENT_BASE(base)->base, &AS_MY_EVENT(ev)->ev)
201 return evtimer_add(&AS_MY_EVENT(ev)->ev, tv);
205 my_timer_del(struct ub_event* ev)
207 return evtimer_del(&AS_MY_EVENT(ev)->ev);
211 my_signal_add(struct ub_event* ev, struct timeval* tv)
213 return signal_add(&AS_MY_EVENT(ev)->ev, tv);
217 my_signal_del(struct ub_event* ev)
219 return signal_del(&AS_MY_EVENT(ev)->ev);
223 my_winsock_unregister_wsaevent(struct ub_event* ev)
225 #if defined(USE_MINI_EVENT) && defined(USE_WINSOCK)
226 winsock_unregister_wsaevent(&AS_MY_EVENT(ev)->ev);
227 free(AS_MY_EVENT(ev));
234 my_winsock_tcp_wouldblock(struct ub_event* ev, int eventbits)
236 #if defined(USE_MINI_EVENT) && defined(USE_WINSOCK)
237 winsock_tcp_wouldblock(&AS_MY_EVENT(ev)->ev, NATIVE_BITS(eventbits));
244 static struct ub_event_vmt default_event_vmt = {
245 my_event_add_bits, my_event_del_bits, my_event_set_fd,
246 my_event_free, my_event_add, my_event_del,
247 my_timer_add, my_timer_del, my_signal_add, my_signal_del,
248 my_winsock_unregister_wsaevent, my_winsock_tcp_wouldblock
252 my_event_base_free(struct ub_event_base* base)
254 #ifdef USE_MINI_EVENT
255 event_base_free(AS_MY_EVENT_BASE(base)->base);
256 #elif defined(HAVE_EVENT_BASE_FREE) && defined(HAVE_EVENT_BASE_ONCE)
257 /* only libevent 1.2+ has it, but in 1.2 it is broken -
258 assertion fails on signal handling ev that is not deleted
259 in libevent 1.3c (event_base_once appears) this is fixed. */
260 event_base_free(AS_MY_EVENT_BASE(base)->base);
261 #endif /* HAVE_EVENT_BASE_FREE and HAVE_EVENT_BASE_ONCE */
262 free(AS_MY_EVENT_BASE(base));
266 my_event_base_dispatch(struct ub_event_base* base)
268 return event_base_dispatch(AS_MY_EVENT_BASE(base)->base);
272 my_event_base_loopexit(struct ub_event_base* base, struct timeval* tv)
274 return event_base_loopexit(AS_MY_EVENT_BASE(base)->base, tv);
277 static struct ub_event*
278 my_event_new(struct ub_event_base* base, int fd, short bits,
279 void (*cb)(int, short, void*), void* arg)
281 struct my_event *my_ev = (struct my_event*)calloc(1,
282 sizeof(struct my_event));
287 event_set(&my_ev->ev, fd, NATIVE_BITS(bits), NATIVE_BITS_CB(cb), arg);
288 if (event_base_set(AS_MY_EVENT_BASE(base)->base, &my_ev->ev) != 0) {
292 my_ev->super.magic = UB_EVENT_MAGIC;
293 my_ev->super.vmt = &default_event_vmt;
294 return &my_ev->super;
297 static struct ub_event*
298 my_signal_new(struct ub_event_base* base, int fd,
299 void (*cb)(int, short, void*), void* arg)
301 struct my_event *my_ev = (struct my_event*)calloc(1,
302 sizeof(struct my_event));
307 signal_set(&my_ev->ev, fd, NATIVE_BITS_CB(cb), arg);
308 if (event_base_set(AS_MY_EVENT_BASE(base)->base, &my_ev->ev) != 0) {
312 my_ev->super.magic = UB_EVENT_MAGIC;
313 my_ev->super.vmt = &default_event_vmt;
314 return &my_ev->super;
317 static struct ub_event*
318 my_winsock_register_wsaevent(struct ub_event_base* base, void* wsaevent,
319 void (*cb)(int, short, void*), void* arg)
321 #if defined(USE_MINI_EVENT) && defined(USE_WINSOCK)
322 struct my_event *my_ev = (struct my_event*)calloc(1,
323 sizeof(struct my_event));
328 if (!winsock_register_wsaevent(AS_MY_EVENT_BASE(base)->base,
329 &my_ev->ev, wsaevent, cb, arg)) {
334 my_ev->super.magic = UB_EVENT_MAGIC;
335 my_ev->super.vmt = &default_event_vmt;
336 return &my_ev->super;
346 static struct ub_event_base_vmt default_event_base_vmt = {
347 my_event_base_free, my_event_base_dispatch,
348 my_event_base_loopexit, my_event_new, my_signal_new,
349 my_winsock_register_wsaevent
352 struct ub_event_base*
353 ub_default_event_base(int sigs, time_t* time_secs, struct timeval* time_tv)
355 struct my_event_base* my_base = (struct my_event_base*)calloc(1,
356 sizeof(struct my_event_base));
361 #ifdef USE_MINI_EVENT
363 /* use mini event time-sharing feature */
364 my_base->base = event_init(time_secs, time_tv);
368 # if defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)
371 my_base->base = (struct event_base*)ev_default_loop(EVFLAG_AUTO);
373 my_base->base = (struct event_base*)ev_loop_new(EVFLAG_AUTO);
376 # ifdef HAVE_EVENT_BASE_NEW
377 my_base->base = event_base_new();
379 my_base->base = event_init();
383 if (!my_base->base) {
387 my_base->super.magic = UB_EVENT_MAGIC;
388 my_base->super.vmt = &default_event_base_vmt;
389 return &my_base->super;
392 struct ub_event_base*
393 ub_libevent_event_base(struct event_base* base)
395 #ifdef USE_MINI_EVENT
399 struct my_event_base* my_base = (struct my_event_base*)calloc(1,
400 sizeof(struct my_event_base));
404 my_base->super.magic = UB_EVENT_MAGIC;
405 my_base->super.vmt = &default_event_base_vmt;
406 my_base->base = base;
407 return &my_base->super;
412 ub_libevent_get_event_base(struct ub_event_base* base)
414 #ifndef USE_MINI_EVENT
415 if (base->vmt == &default_event_base_vmt)
416 return AS_MY_EVENT_BASE(base)->base;
423 #if (defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)) && defined(EVBACKEND_SELECT)
424 static const char* ub_ev_backend2str_pluggable(int b)
427 case EVBACKEND_SELECT: return "select";
428 case EVBACKEND_POLL: return "poll";
429 case EVBACKEND_EPOLL: return "epoll";
430 case EVBACKEND_KQUEUE: return "kqueue";
431 case EVBACKEND_DEVPOLL: return "devpoll";
432 case EVBACKEND_PORT: return "evport";
439 ub_get_event_sys(struct ub_event_base* ub_base, const char** n, const char** s,
444 *n = "pluggable-event";
446 *m = "WSAWaitForMultipleEvents";
447 #elif defined(USE_MINI_EVENT)
449 *n = "pluggable-event";
453 struct event_base* b = ub_libevent_get_event_base(ub_base);
454 /* This function is only called from comm_base_create, so
455 * ub_base is guaranteed to exist and to be the default
459 *n = "pluggable-event";
460 *s = event_get_version();
461 # if defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)
462 *n = "pluggable-libev";
463 # ifdef EVBACKEND_SELECT
464 *m = ub_ev_backend2str_pluggable(ev_backend((struct ev_loop*)b));
466 *m = "not obtainable";
468 # elif defined(HAVE_EVENT_BASE_GET_METHOD)
469 *n = "pluggable-libevent";
470 *m = event_base_get_method(b);
472 *m = "not obtainable";
478 ub_event_base_free(struct ub_event_base* base)
480 if (base && base->magic == UB_EVENT_MAGIC) {
481 fptr_ok(base->vmt != &default_event_base_vmt ||
482 base->vmt->free == my_event_base_free);
483 (*base->vmt->free)(base);
488 ub_event_base_dispatch(struct ub_event_base* base)
490 if (base->magic == UB_EVENT_MAGIC) {
491 fptr_ok(base->vmt != &default_event_base_vmt ||
492 base->vmt->dispatch == my_event_base_dispatch);
493 return (*base->vmt->dispatch)(base);
499 ub_event_base_loopexit(struct ub_event_base* base)
501 if (base->magic == UB_EVENT_MAGIC) {
502 fptr_ok(base->vmt != &default_event_base_vmt ||
503 base->vmt->loopexit == my_event_base_loopexit);
504 return (*base->vmt->loopexit)(base, NULL);
510 ub_event_new(struct ub_event_base* base, int fd, short bits,
511 void (*cb)(int, short, void*), void* arg)
513 if (base->magic == UB_EVENT_MAGIC) {
514 fptr_ok(base->vmt != &default_event_base_vmt ||
515 base->vmt->new_event == my_event_new);
516 return (*base->vmt->new_event)(base, fd, bits, cb, arg);
522 ub_signal_new(struct ub_event_base* base, int fd,
523 void (*cb)(int, short, void*), void* arg)
525 if (base->magic == UB_EVENT_MAGIC) {
526 fptr_ok(base->vmt != &default_event_base_vmt ||
527 base->vmt->new_signal == my_signal_new);
528 return (*base->vmt->new_signal)(base, fd, cb, arg);
534 ub_winsock_register_wsaevent(struct ub_event_base* base, void* wsaevent,
535 void (*cb)(int, short, void*), void* arg)
537 if (base->magic == UB_EVENT_MAGIC) {
538 fptr_ok(base->vmt != &default_event_base_vmt ||
539 base->vmt->winsock_register_wsaevent ==
540 my_winsock_register_wsaevent);
541 return (*base->vmt->winsock_register_wsaevent)(base, wsaevent, cb, arg);
547 ub_event_add_bits(struct ub_event* ev, short bits)
549 if (ev->magic == UB_EVENT_MAGIC) {
550 fptr_ok(ev->vmt != &default_event_vmt ||
551 ev->vmt->add_bits == my_event_add_bits);
552 (*ev->vmt->add_bits)(ev, bits);
557 ub_event_del_bits(struct ub_event* ev, short bits)
559 if (ev->magic == UB_EVENT_MAGIC) {
560 fptr_ok(ev->vmt != &default_event_vmt ||
561 ev->vmt->del_bits == my_event_del_bits);
562 (*ev->vmt->del_bits)(ev, bits);
567 ub_event_set_fd(struct ub_event* ev, int fd)
569 if (ev->magic == UB_EVENT_MAGIC) {
570 fptr_ok(ev->vmt != &default_event_vmt ||
571 ev->vmt->set_fd == my_event_set_fd);
572 (*ev->vmt->set_fd)(ev, fd);
577 ub_event_free(struct ub_event* ev)
579 if (ev && ev->magic == UB_EVENT_MAGIC) {
580 fptr_ok(ev->vmt != &default_event_vmt ||
581 ev->vmt->free == my_event_free);
582 (*ev->vmt->free)(ev);
587 ub_event_add(struct ub_event* ev, struct timeval* tv)
589 if (ev->magic == UB_EVENT_MAGIC) {
590 fptr_ok(ev->vmt != &default_event_vmt ||
591 ev->vmt->add == my_event_add);
592 return (*ev->vmt->add)(ev, tv);
598 ub_event_del(struct ub_event* ev)
600 if (ev->magic == UB_EVENT_MAGIC) {
601 fptr_ok(ev->vmt != &default_event_vmt ||
602 ev->vmt->del == my_event_del);
603 return (*ev->vmt->del)(ev);
609 ub_timer_add(struct ub_event* ev, struct ub_event_base* base,
610 void (*cb)(int, short, void*), void* arg, struct timeval* tv)
612 if (ev->magic == UB_EVENT_MAGIC) {
613 fptr_ok(ev->vmt != &default_event_vmt ||
614 ev->vmt->add_timer == my_timer_add);
615 return (*ev->vmt->add_timer)(ev, base, cb, arg, tv);
621 ub_timer_del(struct ub_event* ev)
623 if (ev->magic == UB_EVENT_MAGIC) {
624 fptr_ok(ev->vmt != &default_event_vmt ||
625 ev->vmt->del_timer == my_timer_del);
626 return (*ev->vmt->del_timer)(ev);
632 ub_signal_add(struct ub_event* ev, struct timeval* tv)
634 if (ev->magic == UB_EVENT_MAGIC) {
635 fptr_ok(ev->vmt != &default_event_vmt ||
636 ev->vmt->add_signal == my_signal_add);
637 return (*ev->vmt->add_signal)(ev, tv);
643 ub_signal_del(struct ub_event* ev)
645 if (ev->magic == UB_EVENT_MAGIC) {
646 fptr_ok(ev->vmt != &default_event_vmt ||
647 ev->vmt->del_signal == my_signal_del);
648 return (*ev->vmt->del_signal)(ev);
654 ub_winsock_unregister_wsaevent(struct ub_event* ev)
656 if (ev->magic == UB_EVENT_MAGIC) {
657 fptr_ok(ev->vmt != &default_event_vmt ||
658 ev->vmt->winsock_unregister_wsaevent ==
659 my_winsock_unregister_wsaevent);
660 (*ev->vmt->winsock_unregister_wsaevent)(ev);
665 ub_winsock_tcp_wouldblock(struct ub_event* ev, int eventbits)
667 if (ev->magic == UB_EVENT_MAGIC) {
668 fptr_ok(ev->vmt != &default_event_vmt ||
669 ev->vmt->winsock_tcp_wouldblock ==
670 my_winsock_tcp_wouldblock);
671 (*ev->vmt->winsock_tcp_wouldblock)(ev, eventbits);
675 void ub_comm_base_now(struct comm_base* cb)
680 #ifdef USE_MINI_EVENT
681 /** minievent updates the time when it blocks. */
682 if (comm_base_internal(cb)->magic == UB_EVENT_MAGIC &&
683 comm_base_internal(cb)->vmt == &default_event_base_vmt)
684 return; /* Actually using mini event, so do not set time */
685 #endif /* USE_MINI_EVENT */
687 /** fillup the time values in the event base */
688 comm_base_timept(cb, &tt, &tv);
689 if(gettimeofday(tv, NULL) < 0) {
690 log_err("gettimeofday: %s", strerror(errno));