1 /* 2 * mini_event.c - implementation of part of libevent api, portably. 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 /** 38 * \file 39 * fake libevent implementation. Less broad in functionality, and only 40 * supports select(2). 41 */ 42 43 #include "config.h" 44 #include "util/mini_event.h" 45 #ifdef HAVE_TIME_H 46 #include <time.h> 47 #endif 48 #include <sys/time.h> 49 50 #if defined(USE_MINI_EVENT) && !defined(USE_WINSOCK) 51 #include <signal.h> 52 #include "util/fptr_wlist.h" 53 54 /** compare events in tree, based on timevalue, ptr for uniqueness */ 55 int mini_ev_cmp(const void* a, const void* b) 56 { 57 const struct event *e = (const struct event*)a; 58 const struct event *f = (const struct event*)b; 59 if(e->ev_timeout.tv_sec < f->ev_timeout.tv_sec) 60 return -1; 61 if(e->ev_timeout.tv_sec > f->ev_timeout.tv_sec) 62 return 1; 63 if(e->ev_timeout.tv_usec < f->ev_timeout.tv_usec) 64 return -1; 65 if(e->ev_timeout.tv_usec > f->ev_timeout.tv_usec) 66 return 1; 67 if(e < f) 68 return -1; 69 if(e > f) 70 return 1; 71 return 0; 72 } 73 74 /** set time */ 75 static int 76 settime(struct event_base* base) 77 { 78 if(gettimeofday(base->time_tv, NULL) < 0) { 79 return -1; 80 } 81 #ifndef S_SPLINT_S 82 *base->time_secs = (time_t)base->time_tv->tv_sec; 83 #endif 84 return 0; 85 } 86 87 /** create event base */ 88 void *event_init(time_t* time_secs, struct timeval* time_tv) 89 { 90 struct event_base* base = (struct event_base*)malloc( 91 sizeof(struct event_base)); 92 if(!base) 93 return NULL; 94 memset(base, 0, sizeof(*base)); 95 base->time_secs = time_secs; 96 base->time_tv = time_tv; 97 if(settime(base) < 0) { 98 event_base_free(base); 99 return NULL; 100 } 101 base->times = rbtree_create(mini_ev_cmp); 102 if(!base->times) { 103 event_base_free(base); 104 return NULL; 105 } 106 base->capfd = MAX_FDS; 107 #ifdef FD_SETSIZE 108 if((int)FD_SETSIZE < base->capfd) 109 base->capfd = (int)FD_SETSIZE; 110 #endif 111 base->fds = (struct event**)calloc((size_t)base->capfd, 112 sizeof(struct event*)); 113 if(!base->fds) { 114 event_base_free(base); 115 return NULL; 116 } 117 base->signals = (struct event**)calloc(MAX_SIG, sizeof(struct event*)); 118 if(!base->signals) { 119 event_base_free(base); 120 return NULL; 121 } 122 #ifndef S_SPLINT_S 123 FD_ZERO(&base->reads); 124 FD_ZERO(&base->writes); 125 #endif 126 return base; 127 } 128 129 /** get version */ 130 const char *event_get_version(void) 131 { 132 return "mini-event-"PACKAGE_VERSION; 133 } 134 135 /** get polling method, select */ 136 const char *event_get_method(void) 137 { 138 return "select"; 139 } 140 141 /** call timeouts handlers, and return how long to wait for next one or -1 */ 142 static void handle_timeouts(struct event_base* base, struct timeval* now, 143 struct timeval* wait) 144 { 145 struct event* p; 146 #ifndef S_SPLINT_S 147 wait->tv_sec = (time_t)-1; 148 #endif 149 150 while((rbnode_type*)(p = (struct event*)rbtree_first(base->times)) 151 !=RBTREE_NULL) { 152 #ifndef S_SPLINT_S 153 if(p->ev_timeout.tv_sec > now->tv_sec || 154 (p->ev_timeout.tv_sec==now->tv_sec && 155 p->ev_timeout.tv_usec > now->tv_usec)) { 156 /* there is a next larger timeout. wait for it */ 157 wait->tv_sec = p->ev_timeout.tv_sec - now->tv_sec; 158 if(now->tv_usec > p->ev_timeout.tv_usec) { 159 wait->tv_sec--; 160 wait->tv_usec = 1000000 - (now->tv_usec - 161 p->ev_timeout.tv_usec); 162 } else { 163 wait->tv_usec = p->ev_timeout.tv_usec 164 - now->tv_usec; 165 } 166 return; 167 } 168 #endif 169 /* event times out, remove it */ 170 (void)rbtree_delete(base->times, p); 171 p->ev_events &= ~EV_TIMEOUT; 172 fptr_ok(fptr_whitelist_event(p->ev_callback)); 173 (*p->ev_callback)(p->ev_fd, EV_TIMEOUT, p->ev_arg); 174 } 175 } 176 177 /** call select and callbacks for that */ 178 static int handle_select(struct event_base* base, struct timeval* wait) 179 { 180 fd_set r, w; 181 int ret, i; 182 183 #ifndef S_SPLINT_S 184 if(wait->tv_sec==(time_t)-1) 185 wait = NULL; 186 #endif 187 memmove(&r, &base->reads, sizeof(fd_set)); 188 memmove(&w, &base->writes, sizeof(fd_set)); 189 memmove(&base->ready, &base->content, sizeof(fd_set)); 190 191 if((ret = select(base->maxfd+1, &r, &w, NULL, wait)) == -1) { 192 ret = errno; 193 if(settime(base) < 0) 194 return -1; 195 errno = ret; 196 if(ret == EAGAIN || ret == EINTR) 197 return 0; 198 return -1; 199 } 200 if(settime(base) < 0) 201 return -1; 202 203 for(i=0; i<base->maxfd+1; i++) { 204 short bits = 0; 205 if(!base->fds[i] || !(FD_ISSET(i, &base->ready))) { 206 continue; 207 } 208 if(FD_ISSET(i, &r)) { 209 bits |= EV_READ; 210 ret--; 211 } 212 if(FD_ISSET(i, &w)) { 213 bits |= EV_WRITE; 214 ret--; 215 } 216 bits &= base->fds[i]->ev_events; 217 if(bits) { 218 fptr_ok(fptr_whitelist_event( 219 base->fds[i]->ev_callback)); 220 (*base->fds[i]->ev_callback)(base->fds[i]->ev_fd, 221 bits, base->fds[i]->ev_arg); 222 if(ret==0) 223 break; 224 } 225 } 226 return 0; 227 } 228 229 /** run select in a loop */ 230 int event_base_dispatch(struct event_base* base) 231 { 232 struct timeval wait; 233 if(settime(base) < 0) 234 return -1; 235 while(!base->need_to_exit) 236 { 237 /* see if timeouts need handling */ 238 handle_timeouts(base, base->time_tv, &wait); 239 if(base->need_to_exit) 240 return 0; 241 /* do select */ 242 if(handle_select(base, &wait) < 0) { 243 if(base->need_to_exit) 244 return 0; 245 return -1; 246 } 247 } 248 return 0; 249 } 250 251 /** exit that loop */ 252 int event_base_loopexit(struct event_base* base, 253 struct timeval* ATTR_UNUSED(tv)) 254 { 255 base->need_to_exit = 1; 256 return 0; 257 } 258 259 /* free event base, free events yourself */ 260 void event_base_free(struct event_base* base) 261 { 262 if(!base) 263 return; 264 free(base->times); 265 free(base->fds); 266 free(base->signals); 267 free(base); 268 } 269 270 /** set content of event */ 271 void event_set(struct event* ev, int fd, short bits, 272 void (*cb)(int, short, void *), void* arg) 273 { 274 ev->node.key = ev; 275 ev->ev_fd = fd; 276 ev->ev_events = bits; 277 ev->ev_callback = cb; 278 fptr_ok(fptr_whitelist_event(ev->ev_callback)); 279 ev->ev_arg = arg; 280 ev->added = 0; 281 } 282 283 /* add event to a base */ 284 int event_base_set(struct event_base* base, struct event* ev) 285 { 286 ev->ev_base = base; 287 ev->added = 0; 288 return 0; 289 } 290 291 /* add event to make it active, you may not change it with event_set anymore */ 292 int event_add(struct event* ev, struct timeval* tv) 293 { 294 if(ev->added) 295 event_del(ev); 296 if(ev->ev_fd != -1 && ev->ev_fd >= ev->ev_base->capfd) 297 return -1; 298 if( (ev->ev_events&(EV_READ|EV_WRITE)) && ev->ev_fd != -1) { 299 ev->ev_base->fds[ev->ev_fd] = ev; 300 if(ev->ev_events&EV_READ) { 301 FD_SET(FD_SET_T ev->ev_fd, &ev->ev_base->reads); 302 } 303 if(ev->ev_events&EV_WRITE) { 304 FD_SET(FD_SET_T ev->ev_fd, &ev->ev_base->writes); 305 } 306 FD_SET(FD_SET_T ev->ev_fd, &ev->ev_base->content); 307 FD_CLR(FD_SET_T ev->ev_fd, &ev->ev_base->ready); 308 if(ev->ev_fd > ev->ev_base->maxfd) 309 ev->ev_base->maxfd = ev->ev_fd; 310 } 311 if(tv && (ev->ev_events&EV_TIMEOUT)) { 312 #ifndef S_SPLINT_S 313 struct timeval *now = ev->ev_base->time_tv; 314 ev->ev_timeout.tv_sec = tv->tv_sec + now->tv_sec; 315 ev->ev_timeout.tv_usec = tv->tv_usec + now->tv_usec; 316 while(ev->ev_timeout.tv_usec >= 1000000) { 317 ev->ev_timeout.tv_usec -= 1000000; 318 ev->ev_timeout.tv_sec++; 319 } 320 #endif 321 (void)rbtree_insert(ev->ev_base->times, &ev->node); 322 } 323 ev->added = 1; 324 return 0; 325 } 326 327 /* remove event, you may change it again */ 328 int event_del(struct event* ev) 329 { 330 if(ev->ev_fd != -1 && ev->ev_fd >= ev->ev_base->capfd) 331 return -1; 332 if((ev->ev_events&EV_TIMEOUT)) 333 (void)rbtree_delete(ev->ev_base->times, &ev->node); 334 if((ev->ev_events&(EV_READ|EV_WRITE)) && ev->ev_fd != -1) { 335 ev->ev_base->fds[ev->ev_fd] = NULL; 336 FD_CLR(FD_SET_T ev->ev_fd, &ev->ev_base->reads); 337 FD_CLR(FD_SET_T ev->ev_fd, &ev->ev_base->writes); 338 FD_CLR(FD_SET_T ev->ev_fd, &ev->ev_base->ready); 339 FD_CLR(FD_SET_T ev->ev_fd, &ev->ev_base->content); 340 } 341 ev->added = 0; 342 return 0; 343 } 344 345 /** which base gets to handle signals */ 346 static struct event_base* signal_base = NULL; 347 /** signal handler */ 348 static RETSIGTYPE sigh(int sig) 349 { 350 struct event* ev; 351 if(!signal_base || sig < 0 || sig >= MAX_SIG) 352 return; 353 ev = signal_base->signals[sig]; 354 if(!ev) 355 return; 356 fptr_ok(fptr_whitelist_event(ev->ev_callback)); 357 (*ev->ev_callback)(sig, EV_SIGNAL, ev->ev_arg); 358 } 359 360 /** install signal handler */ 361 int signal_add(struct event* ev, struct timeval* ATTR_UNUSED(tv)) 362 { 363 if(ev->ev_fd == -1 || ev->ev_fd >= MAX_SIG) 364 return -1; 365 signal_base = ev->ev_base; 366 ev->ev_base->signals[ev->ev_fd] = ev; 367 ev->added = 1; 368 if(signal(ev->ev_fd, sigh) == SIG_ERR) { 369 return -1; 370 } 371 return 0; 372 } 373 374 /** remove signal handler */ 375 int signal_del(struct event* ev) 376 { 377 if(ev->ev_fd == -1 || ev->ev_fd >= MAX_SIG) 378 return -1; 379 ev->ev_base->signals[ev->ev_fd] = NULL; 380 ev->added = 0; 381 return 0; 382 } 383 384 #else /* USE_MINI_EVENT */ 385 #ifndef USE_WINSOCK 386 int mini_ev_cmp(const void* ATTR_UNUSED(a), const void* ATTR_UNUSED(b)) 387 { 388 return 0; 389 } 390 #endif /* not USE_WINSOCK */ 391 #endif /* USE_MINI_EVENT */ 392