xref: /freebsd/contrib/unbound/util/ub_event_pluggable.c (revision 09a53ad8f1318c5daae6cfb19d97f4f6459f0013) 
1 /*
2  * util/ub_event_pluggable.c - call registered pluggable event functions
3  *
4  * Copyright (c) 2007, NLnet Labs. All rights reserved.
5  *
6  * This software is open source.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * Redistributions of source code must retain the above copyright notice,
13  * this list of conditions and the following disclaimer.
14  *
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.
18  *
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.
22  *
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.
34  */
35 
36 /**
37  * \file
38  *
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)
42  * functions.
43  */
44 #include "config.h"
45 #include <sys/time.h>
46 #include "util/ub_event.h"
47 #include "libunbound/unbound-event.h"
48 #include "util/netevent.h"
49 #include "util/log.h"
50 #include "util/fptr_wlist.h"
51 
52 /* We define libevent structures here to hide the libevent stuff. */
53 
54 #ifdef USE_MINI_EVENT
55 #  ifdef USE_WINSOCK
56 #    include "util/winsock_event.h"
57 #  else
58 #    include "util/mini_event.h"
59 #  endif /* USE_WINSOCK */
60 #else /* USE_MINI_EVENT */
61    /* we use libevent */
62 #  ifdef HAVE_EVENT_H
63 #    include <event.h>
64 #  else
65 #    include "event2/event.h"
66 #    include "event2/event_struct.h"
67 #    include "event2/event_compat.h"
68 #  endif
69 #endif /* USE_MINI_EVENT */
70 
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))
81 
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))
88 
89 #  define UB_EV_BITS_CB(C) void my_ ## C (int fd, short bits, void *arg) \
90 	{ (C)(fd, UB_EV_BITS(bits), arg); }
91 
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)
102 
103 static void (*NATIVE_BITS_CB(void (*cb)(int, short, void*)))(int, short, void*)
104 {
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;
125 	else
126 		return NULL;
127 }
128 #else
129 #  define NATIVE_BITS(b) (b)
130 #  define NATIVE_BITS_CB(c) (c)
131 #endif
132 
133 #ifndef EVFLAG_AUTO
134 #define EVFLAG_AUTO 0
135 #endif
136 
137 struct my_event_base {
138 	struct ub_event_base super;
139 	struct event_base* base;
140 };
141 
142 struct my_event {
143 	struct ub_event super;
144 	struct event ev;
145 };
146 
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)
151 
152 const char* ub_event_get_version()
153 {
154 	return "pluggable-event"PACKAGE_VERSION;
155 }
156 
157 static void
158 my_event_add_bits(struct ub_event* ev, short bits)
159 {
160 	AS_MY_EVENT(ev)->ev.ev_events |= NATIVE_BITS(bits);
161 }
162 
163 static void
164 my_event_del_bits(struct ub_event* ev, short bits)
165 {
166 	AS_MY_EVENT(ev)->ev.ev_events &= ~NATIVE_BITS(bits);
167 }
168 
169 static void
170 my_event_set_fd(struct ub_event* ev, int fd)
171 {
172 	AS_MY_EVENT(ev)->ev.ev_fd = fd;
173 }
174 
175 static void
176 my_event_free(struct ub_event* ev)
177 {
178 	free(AS_MY_EVENT(ev));
179 }
180 
181 static int
182 my_event_add(struct ub_event* ev, struct timeval* tv)
183 {
184 	return event_add(&AS_MY_EVENT(ev)->ev, tv);
185 }
186 
187 static int
188 my_event_del(struct ub_event* ev)
189 {
190 	return event_del(&AS_MY_EVENT(ev)->ev);
191 }
192 
193 static int
194 my_timer_add(struct ub_event* ev, struct ub_event_base* base,
195 	void (*cb)(int, short, void*), void* arg, struct timeval* tv)
196 {
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)
199 		!= 0)
200 		return -1;
201 	return evtimer_add(&AS_MY_EVENT(ev)->ev, tv);
202 }
203 
204 static int
205 my_timer_del(struct ub_event* ev)
206 {
207 	return evtimer_del(&AS_MY_EVENT(ev)->ev);
208 }
209 
210 static int
211 my_signal_add(struct ub_event* ev, struct timeval* tv)
212 {
213 	return signal_add(&AS_MY_EVENT(ev)->ev, tv);
214 }
215 
216 static int
217 my_signal_del(struct ub_event* ev)
218 {
219 	return signal_del(&AS_MY_EVENT(ev)->ev);
220 }
221 
222 static void
223 my_winsock_unregister_wsaevent(struct ub_event* ev)
224 {
225 #if defined(USE_MINI_EVENT) && defined(USE_WINSOCK)
226 	winsock_unregister_wsaevent(&AS_MY_EVENT(ev)->ev);
227 	free(AS_MY_EVENT(ev));
228 #else
229 	(void)ev;
230 #endif
231 }
232 
233 static void
234 my_winsock_tcp_wouldblock(struct ub_event* ev, int eventbits)
235 {
236 #if defined(USE_MINI_EVENT) && defined(USE_WINSOCK)
237 	winsock_tcp_wouldblock(&AS_MY_EVENT(ev)->ev, NATIVE_BITS(eventbits));
238 #else
239 	(void)ev;
240 	(void)eventbits;
241 #endif
242 }
243 
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
249 };
250 
251 static void
252 my_event_base_free(struct ub_event_base* base)
253 {
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));
263 }
264 
265 static int
266 my_event_base_dispatch(struct ub_event_base* base)
267 {
268 	return event_base_dispatch(AS_MY_EVENT_BASE(base)->base);
269 }
270 
271 static int
272 my_event_base_loopexit(struct ub_event_base* base, struct timeval* tv)
273 {
274 	return event_base_loopexit(AS_MY_EVENT_BASE(base)->base, tv);
275 }
276 
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)
280 {
281 	struct my_event *my_ev = (struct my_event*)calloc(1,
282 		sizeof(struct my_event));
283 
284 	if (!my_ev)
285 		return NULL;
286 
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) {
289 		free(my_ev);
290 		return NULL;
291 	}
292 	my_ev->super.magic = UB_EVENT_MAGIC;
293 	my_ev->super.vmt = &default_event_vmt;
294 	return &my_ev->super;
295 }
296 
297 static struct ub_event*
298 my_signal_new(struct ub_event_base* base, int fd,
299 	void (*cb)(int, short, void*), void* arg)
300 {
301 	struct my_event *my_ev = (struct my_event*)calloc(1,
302 		sizeof(struct my_event));
303 
304 	if (!my_ev)
305 		return NULL;
306 
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) {
309 		free(my_ev);
310 		return NULL;
311 	}
312 	my_ev->super.magic = UB_EVENT_MAGIC;
313 	my_ev->super.vmt = &default_event_vmt;
314 	return &my_ev->super;
315 }
316 
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)
320 {
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));
324 
325 	if (!my_ev)
326 		return NULL;
327 
328 	if (!winsock_register_wsaevent(AS_MY_EVENT_BASE(base)->base,
329 		&my_ev->ev, wsaevent, cb, arg)) {
330 		free(my_ev);
331 		return NULL;
332 
333 	}
334 	my_ev->super.magic = UB_EVENT_MAGIC;
335 	my_ev->super.vmt = &default_event_vmt;
336 	return &my_ev->super;
337 #else
338 	(void)base;
339 	(void)wsaevent;
340 	(void)cb;
341 	(void)arg;
342 	return NULL;
343 #endif
344 }
345 
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
350 };
351 
352 struct ub_event_base*
353 ub_default_event_base(int sigs, time_t* time_secs, struct timeval* time_tv)
354 {
355 	struct my_event_base* my_base = (struct my_event_base*)calloc(1,
356 		sizeof(struct my_event_base));
357 
358 	if (!my_base)
359 		return NULL;
360 
361 #ifdef USE_MINI_EVENT
362 	(void)sigs;
363 	/* use mini event time-sharing feature */
364 	my_base->base = event_init(time_secs, time_tv);
365 #else
366 	(void)time_secs;
367 	(void)time_tv;
368 #  if defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)
369 	/* libev */
370 	if(sigs)
371 		my_base->base = (struct event_base*)ev_default_loop(EVFLAG_AUTO);
372 	else
373 		my_base->base = (struct event_base*)ev_loop_new(EVFLAG_AUTO);
374 #  else
375 	(void)sigs;
376 #    ifdef HAVE_EVENT_BASE_NEW
377 	my_base->base = event_base_new();
378 #    else
379 	my_base->base = event_init();
380 #    endif
381 #  endif
382 #endif
383 	if (!my_base->base) {
384 		free(my_base);
385 		return NULL;
386 	}
387 	my_base->super.magic = UB_EVENT_MAGIC;
388 	my_base->super.vmt = &default_event_base_vmt;
389 	return &my_base->super;
390 }
391 
392 struct ub_event_base*
393 ub_libevent_event_base(struct event_base* base)
394 {
395 #ifdef USE_MINI_EVENT
396 	(void)base;
397 	return NULL;
398 #else
399 	struct my_event_base* my_base = (struct my_event_base*)calloc(1,
400 		sizeof(struct my_event_base));
401 
402 	if (!my_base)
403 		return NULL;
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;
408 #endif
409 }
410 
411 struct event_base*
412 ub_libevent_get_event_base(struct ub_event_base* base)
413 {
414 #ifndef USE_MINI_EVENT
415 	if (base->vmt == &default_event_base_vmt)
416 		return AS_MY_EVENT_BASE(base)->base;
417 #else
418 	(void)base;
419 #endif
420 	return NULL;
421 }
422 
423 #if (defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)) && defined(EVBACKEND_SELECT)
424 static const char* ub_ev_backend2str_pluggable(int b)
425 {
426 	switch(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";
433 	}
434 	return "unknown";
435 }
436 #endif
437 
438 void
439 ub_get_event_sys(struct ub_event_base* ub_base, const char** n, const char** s,
440 	const char** m)
441 {
442 #ifdef USE_WINSOCK
443 	(void)ub_base;
444 	*n = "pluggable-event";
445 	*s = "winsock";
446 	*m = "WSAWaitForMultipleEvents";
447 #elif defined(USE_MINI_EVENT)
448 	(void)ub_base;
449 	*n = "pluggable-event";
450 	*s = "internal";
451 	*m = "select";
452 #else
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
456 	 * event base.
457 	 */
458 	assert(b);
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));
465 #    else
466 	*m = "not obtainable";
467 #    endif
468 #  elif defined(HAVE_EVENT_BASE_GET_METHOD)
469 	*n = "pluggable-libevent";
470 	*m = event_base_get_method(b);
471 #  else
472 	*m = "not obtainable";
473 #  endif
474 #endif
475 }
476 
477 void
478 ub_event_base_free(struct ub_event_base* base)
479 {
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);
484 	}
485 }
486 
487 int
488 ub_event_base_dispatch(struct ub_event_base* base)
489 {
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);
494 	}
495 	return -1;
496 }
497 
498 int
499 ub_event_base_loopexit(struct ub_event_base* base)
500 {
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);
505 	}
506 	return -1;
507 }
508 
509 struct ub_event*
510 ub_event_new(struct ub_event_base* base, int fd, short bits,
511 	void (*cb)(int, short, void*), void* arg)
512 {
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);
517 	}
518 	return NULL;
519 }
520 
521 struct ub_event*
522 ub_signal_new(struct ub_event_base* base, int fd,
523 	void (*cb)(int, short, void*), void* arg)
524 {
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);
529 	}
530 	return NULL;
531 }
532 
533 struct ub_event*
534 ub_winsock_register_wsaevent(struct ub_event_base* base, void* wsaevent,
535 	void (*cb)(int, short, void*), void* arg)
536 {
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);
542 	}
543 	return NULL;
544 }
545 
546 void
547 ub_event_add_bits(struct ub_event* ev, short bits)
548 {
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);
553 	}
554 }
555 
556 void
557 ub_event_del_bits(struct ub_event* ev, short bits)
558 {
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);
563 	}
564 }
565 
566 void
567 ub_event_set_fd(struct ub_event* ev, int fd)
568 {
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);
573 	}
574 }
575 
576 void
577 ub_event_free(struct ub_event* ev)
578 {
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);
583 	}
584 }
585 
586 int
587 ub_event_add(struct ub_event* ev, struct timeval* tv)
588 {
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);
593 	}
594        return -1;
595 }
596 
597 int
598 ub_event_del(struct ub_event* ev)
599 {
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);
604 	}
605 	return -1;
606 }
607 
608 int
609 ub_timer_add(struct ub_event* ev, struct ub_event_base* base,
610 	void (*cb)(int, short, void*), void* arg, struct timeval* tv)
611 {
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);
616 	}
617 	return -1;
618 }
619 
620 int
621 ub_timer_del(struct ub_event* ev)
622 {
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);
627 	}
628 	return -1;
629 }
630 
631 int
632 ub_signal_add(struct ub_event* ev, struct timeval* tv)
633 {
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);
638 	}
639 	return -1;
640 }
641 
642 int
643 ub_signal_del(struct ub_event* ev)
644 {
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);
649 	}
650 	return -1;
651 }
652 
653 void
654 ub_winsock_unregister_wsaevent(struct ub_event* ev)
655 {
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);
661 	}
662 }
663 
664 void
665 ub_winsock_tcp_wouldblock(struct ub_event* ev, int eventbits)
666 {
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);
672 	}
673 }
674 
675 void ub_comm_base_now(struct comm_base* cb)
676 {
677 	time_t *tt;
678 	struct timeval *tv;
679 
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 */
686 
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));
691 	}
692 	*tt = tv->tv_sec;
693 }
694 
695