X-Git-Url: https://tinc-vpn.org/git/browse?a=blobdiff_plain;f=src%2Fevent.c;h=6827dc048c4b6135a1fa42fbabd1bce63af22406;hb=6bc5d626a8726fc23365ee705761a3c666a08ad4;hp=4d6431cb4a526bd7cf75f5cb1373f779492247a5;hpb=6c5f3d8b74ffea1522a727ef189a5ba65a939e07;p=tinc diff --git a/src/event.c b/src/event.c index 4d6431cb..6827dc04 100644 --- a/src/event.c +++ b/src/event.c @@ -1,7 +1,6 @@ /* - event.c -- event queue - Copyright (C) 2002-2003 Guus Sliepen , - 2002-2003 Ivo Timmermans + event.c -- I/O, timeout and signal event handling + Copyright (C) 2012 Guus Sliepen This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -13,93 +12,225 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - - $Id: event.c,v 1.1.4.11 2003/08/28 21:05:10 guus Exp $ + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "system.h" -#include "avl_tree.h" #include "event.h" +#include "net.h" #include "utils.h" -#include "xalloc.h" -avl_tree_t *event_tree; -extern time_t now; +struct timeval now; + +static fd_set readfds; +static fd_set writefds; +static volatile bool running; + +static int io_compare(const io_t *a, const io_t *b) { + return a->fd - b->fd; +} + +static int timeout_compare(const timeout_t *a, const timeout_t *b) { + struct timeval diff; + timersub(&a->tv, &b->tv, &diff); + return diff.tv_sec ?: diff.tv_usec; +} + +static int signal_compare(const signal_t *a, const signal_t *b) { + return a->signum - b->signum; +} + +static splay_tree_t io_tree = {.compare = (splay_compare_t)io_compare}; +static splay_tree_t timeout_tree = {.compare = (splay_compare_t)timeout_compare}; +static splay_tree_t signal_tree = {.compare = (splay_compare_t)signal_compare}; + +void io_add(io_t *io, io_cb_t cb, void *data, int fd, int flags) { + if(io->cb) + return; + + io->fd = fd; + io->cb = cb; + io->data = data; + io->node.data = io; + + io_set(io, flags); + + splay_insert_node(&io_tree, &io->node); +} + +void io_set(io_t *io, int flags) { + io->flags = flags; + + if(flags & IO_READ) + FD_SET(io->fd, &readfds); + else + FD_CLR(io->fd, &readfds); + + if(flags & IO_WRITE) + FD_SET(io->fd, &writefds); + else + FD_CLR(io->fd, &writefds); +} + +void io_del(io_t *io) { + if(!io->cb) + return; + + io_set(io, 0); -int id; + splay_unlink_node(&io_tree, &io->node); + io->cb = NULL; +} -static int event_compare(const event_t *a, const event_t *b) -{ - if(a->time > b->time) - return 1; +void timeout_add(timeout_t *timeout, timeout_cb_t cb, void *data, struct timeval *tv) { + if(timeout->cb) + return; - if(a->time < b->time) - return -1; + timeout->cb = cb; + timeout->data = data; + timeout->node.data = timeout; - return a->id - b->id; + timeout_set(timeout, tv); } -void init_events(void) -{ - cp(); +void timeout_set(timeout_t *timeout, struct timeval *tv) { + if(timeout->tv.tv_sec) + splay_unlink_node(&timeout_tree, &timeout->node); + + if(!now.tv_sec) + gettimeofday(&now, NULL); + + timeradd(&now, tv, &timeout->tv); - event_tree = avl_alloc_tree((avl_compare_t) event_compare, NULL); + splay_insert_node(&timeout_tree, &timeout->node); } -void exit_events(void) -{ - cp(); +void timeout_del(timeout_t *timeout) { + if(!timeout->cb) + return; - avl_delete_tree(event_tree); + splay_unlink_node(&timeout_tree, &timeout->node); + timeout->cb = NULL; } -event_t *new_event(void) -{ - cp(); +#ifndef HAVE_MINGW +static io_t signalio; +static int pipefd[2] = {-1, -1}; - return xmalloc_and_zero(sizeof(event_t)); +static void signal_handler(int signum) { + unsigned char num = signum; + write(pipefd[1], &num, 1); } -void free_event(event_t *event) -{ - cp(); +static void signalio_handler(void *data, int flags) { + unsigned char signum; + if(read(pipefd[0], &signum, 1) != 1) + return; - free(event); + signal_t *sig = splay_search(&signal_tree, &((signal_t){.signum = signum})); + if(sig) + sig->cb(sig->data); } -void event_add(event_t *event) -{ - cp(); +static void pipe_init(void) { + if(!pipe(pipefd)) + io_add(&signalio, signalio_handler, NULL, pipefd[0], IO_READ); +} + +void signal_add(signal_t *sig, signal_cb_t cb, void *data, int signum) { + if(sig->cb) + return; + + sig->cb = cb; + sig->data = data; + sig->signum = signum; + sig->node.data = sig; + + if(pipefd[0] == -1) + pipe_init(); - event->id = ++id; - avl_insert(event_tree, event); + signal(sig->signum, signal_handler); + + splay_insert_node(&signal_tree, &sig->node); } -void event_del(event_t *event) -{ - cp(); +void signal_del(signal_t *sig) { + if(!sig->cb) + return; + + signal(sig->signum, SIG_DFL); - avl_delete(event_tree, event); + splay_unlink_node(&signal_tree, &sig->node); + sig->cb = NULL; } +#endif + +bool event_loop(void) { + running = true; + + fd_set readable; + fd_set writable; + + while(running) { + gettimeofday(&now, NULL); + struct timeval diff, *tv = NULL; + + while(timeout_tree.head) { + timeout_t *timeout = timeout_tree.head->data; + timersub(&timeout->tv, &now, &diff); + + if(diff.tv_sec <= 0) { + timeout->cb(timeout->data); + if(timercmp(&timeout->tv, &now, <)) + timeout_del(timeout); + } else { + tv = &diff; + break; + } + } -event_t *get_expired_event(void) -{ - event_t *event; + memcpy(&readable, &readfds, sizeof readable); + memcpy(&writable, &writefds, sizeof writable); - cp(); + int fds = 0; - if(event_tree->head) { - event = event_tree->head->data; + if(io_tree.tail) { + io_t *last = io_tree.tail->data; + fds = last->fd + 1; + } - if(event->time < now) { - avl_delete(event_tree, event); - return event; +#ifdef HAVE_MINGW + LeaveCriticalSection(&mutex); +#endif + int n = select(fds, &readable, &writable, NULL, tv); +#ifdef HAVE_MINGW + EnterCriticalSection(&mutex); +#endif + + if(n < 0) { + if(sockwouldblock(errno)) + continue; + else + return false; + } + + if(!n) + continue; + + for splay_each(io_t, io, &io_tree) { + if(FD_ISSET(io->fd, &writable)) + io->cb(io->data, IO_WRITE); + else if(FD_ISSET(io->fd, &readable)) + io->cb(io->data, IO_READ); } } - return NULL; + return true; +} + +void event_exit(void) { + running = false; }