X-Git-Url: https://tinc-vpn.org/git/browse?a=blobdiff_plain;f=src%2Fevent.c;h=5a1e4f5b7dbf49ba45ea8a2aba63985c44cc3afd;hb=refs%2Fheads%2F1.1-brainpool;hp=45961659fbd07f687c9e9cd6b9075343c592b13b;hpb=5db596c6844169f1eb5f804b72abe99d067aaa5a;p=tinc diff --git a/src/event.c b/src/event.c index 45961659..5a1e4f5b 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-2013 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,99 +12,245 @@ 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.8 2003/07/12 17:41:45 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 "config.h" - -#include -#include -#include -#include -#include -#include +#include "system.h" +#include "dropin.h" #include "event.h" +#include "net.h" +#include "utils.h" -#include "system.h" +struct timeval now; -avl_tree_t *event_tree; -extern time_t now; +static fd_set readfds; +static fd_set writefds; +static volatile bool running; -int id; +static int io_compare(const io_t *a, const io_t *b) { + return a->fd - b->fd; +} -static int event_compare(event_t *a, event_t *b) -{ - if(a->time > b->time) +static int timeout_compare(const timeout_t *a, const timeout_t *b) { + struct timeval diff; + timersub(&a->tv, &b->tv, &diff); + if(diff.tv_sec < 0) + return -1; + if(diff.tv_sec > 0) return 1; - - if(a->time < b->time) + if(diff.tv_usec < 0) return -1; + if(diff.tv_usec > 0) + return 1; + if(a < b) + return -1; + if(a > b) + return 1; + return 0; +} + +static splay_tree_t io_tree = {.compare = (splay_compare_t)io_compare}; +static splay_tree_t timeout_tree = {.compare = (splay_compare_t)timeout_compare}; + +void io_add(io_t *io, io_cb_t cb, void *data, int fd, int flags) { + if(io->cb) + return; - return a->id - b->id; + io->fd = fd; + io->cb = cb; + io->data = data; + io->node.data = io; + + io_set(io, flags); + + if(!splay_insert_node(&io_tree, &io->node)) + abort(); } -void init_events(void) -{ - cp(); +void io_set(io_t *io, int flags) { + io->flags = flags; - event_tree = avl_alloc_tree((avl_compare_t) event_compare, NULL); + 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 exit_events(void) -{ - cp(); +void io_del(io_t *io) { + if(!io->cb) + return; + + io_set(io, 0); - avl_delete_tree(event_tree); + splay_unlink_node(&io_tree, &io->node); + io->cb = NULL; } -event_t *new_event(void) -{ - cp(); +void timeout_add(timeout_t *timeout, timeout_cb_t cb, void *data, struct timeval *tv) { + timeout->cb = cb; + timeout->data = data; + timeout->node.data = timeout; - return (event_t *) xmalloc_and_zero(sizeof(event_t)); + timeout_set(timeout, tv); } -void free_event(event_t *event) -{ - cp(); +void timeout_set(timeout_t *timeout, struct timeval *tv) { + if(timerisset(&timeout->tv)) + splay_unlink_node(&timeout_tree, &timeout->node); - free(event); + if(!now.tv_sec) + gettimeofday(&now, NULL); + + timeradd(&now, tv, &timeout->tv); + + if(!splay_insert_node(&timeout_tree, &timeout->node)) + abort(); } -void event_add(event_t *event) -{ - cp(); +void timeout_del(timeout_t *timeout) { + if(!timeout->cb) + return; - event->id = ++id; - avl_insert(event_tree, event); + splay_unlink_node(&timeout_tree, &timeout->node); + timeout->cb = 0; + timeout->tv = (struct timeval){0, 0}; } -void event_del(event_t *event) -{ - cp(); +#ifndef HAVE_MINGW +static int signal_compare(const signal_t *a, const signal_t *b) { + return a->signum - b->signum; +} + +static io_t signalio; +static int pipefd[2] = {-1, -1}; +static splay_tree_t signal_tree = {.compare = (splay_compare_t)signal_compare}; + +static void signal_handler(int signum) { + unsigned char num = signum; + write(pipefd[1], &num, 1); +} + +static void signalio_handler(void *data, int flags) { + unsigned char signum; + if(read(pipefd[0], &signum, 1) != 1) + return; + + signal_t *sig = splay_search(&signal_tree, &((signal_t){.signum = signum})); + if(sig) + sig->cb(sig->data); +} - avl_delete(event_tree, event); +static void pipe_init(void) { + if(!pipe(pipefd)) + io_add(&signalio, signalio_handler, NULL, pipefd[0], IO_READ); } -event_t *get_expired_event(void) -{ - event_t *event; +void signal_add(signal_t *sig, signal_cb_t cb, void *data, int signum) { + if(sig->cb) + return; - cp(); + sig->cb = cb; + sig->data = data; + sig->signum = signum; + sig->node.data = sig; - if(event_tree->head) { - event = (event_t *) event_tree->head->data; + if(pipefd[0] == -1) + pipe_init(); - if(event->time < now) { - avl_delete(event_tree, event); - return event; + signal(sig->signum, signal_handler); + + if(!splay_insert_node(&signal_tree, &sig->node)) + abort(); +} + +void signal_del(signal_t *sig) { + if(!sig->cb) + return; + + signal(sig->signum, SIG_DFL); + + 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; + } + } + + memcpy(&readable, &readfds, sizeof readable); + memcpy(&writable, &writefds, sizeof writable); + + int fds = 0; + + if(io_tree.tail) { + io_t *last = io_tree.tail->data; + fds = last->fd + 1; + } + +#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_flush_output(void) { + for splay_each(io_t, io, &io_tree) + if(FD_ISSET(io->fd, &writefds)) + io->cb(io->data, IO_WRITE); +} + +void event_exit(void) { + running = false; }