Remove global variables from the event loop code.

Everything is now in a struct event_loop_t, which is now also in
meshlink_handle_t.  To make the transition easier, there is a temporary global
event_loop_t *loop.

diff --git a/src/connection.c b/src/connection.c
index 3db7a2711ba62b8b8f293e93cbc1074d5228eb5b..0a7662dbafd4b8c1bcf952da84d32eac96494ddc 100644 (file)
--- a/src/connection.c
+++ b/src/connection.c
@@ -54,7 +54,7 @@ void free_connection(connection_t *c) {
        buffer_clear(&c->inbuf);
        buffer_clear(&c->outbuf);
 
-       io_del(&c->io);
+       io_del(&mesh->loop, &c->io);
 
        if(c->socket > 0)
                closesocket(c->socket);

diff --git a/src/event.c b/src/event.c
index e4917589750a53e48cf8a563502b7563ed90a86a..065f1b5eaf5a52710f8c9412ddccd03b656e8f90 100644 (file)
--- a/src/event.c
+++ b/src/event.c
@@ -22,14 +22,13 @@
 #include "dropin.h"
 #include "event.h"
 #include "net.h"
+#include "splay_tree.h"
 #include "utils.h"
+#include "xalloc.h"
 
+event_loop_t *loop;
 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;
 }
@@ -52,10 +51,7 @@ static int timeout_compare(const timeout_t *a, const timeout_t *b) {
        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) {
+void io_add(event_loop_t *loop, io_t *io, io_cb_t cb, void *data, int fd, int flags) {
        if(io->cb)
                return;
 
@@ -64,96 +60,86 @@ void io_add(io_t *io, io_cb_t cb, void *data, int fd, int flags) {
        io->data = data;
        io->node.data = io;
 
-       io_set(io, flags);
+       io_set(loop, io, flags);
 
-       if(!splay_insert_node(&io_tree, &io->node))
+       if(!splay_insert_node(&loop->ios, &io->node))
                abort();
 }
 
-void io_set(io_t *io, int flags) {
+void io_set(event_loop_t *loop, io_t *io, int flags) {
        io->flags = flags;
 
        if(flags & IO_READ)
-               FD_SET(io->fd, &readfds);
+               FD_SET(io->fd, &loop->readfds);
        else
-               FD_CLR(io->fd, &readfds);
+               FD_CLR(io->fd, &loop->readfds);
 
        if(flags & IO_WRITE)
-               FD_SET(io->fd, &writefds);
+               FD_SET(io->fd, &loop->writefds);
        else
-               FD_CLR(io->fd, &writefds);
+               FD_CLR(io->fd, &loop->writefds);
 }
 
-void io_del(io_t *io) {
+void io_del(event_loop_t *loop, io_t *io) {
        if(!io->cb)
                return;
 
-       io_set(io, 0);
+       io_set(loop, io, 0);
 
-       splay_unlink_node(&io_tree, &io->node);
+       splay_unlink_node(&loop->ios, &io->node);
        io->cb = NULL;
 }
 
-void timeout_add(timeout_t *timeout, timeout_cb_t cb, void *data, struct timeval *tv) {
+void timeout_add(event_loop_t *loop, timeout_t *timeout, timeout_cb_t cb, void *data, struct timeval *tv) {
        timeout->cb = cb;
        timeout->data = data;
        timeout->node.data = timeout;
 
-       timeout_set(timeout, tv);
+       timeout_set(loop, timeout, tv);
 }
 
-void timeout_set(timeout_t *timeout, struct timeval *tv) {
+void timeout_set(event_loop_t *loop, timeout_t *timeout, struct timeval *tv) {
        if(timerisset(&timeout->tv))
-               splay_unlink_node(&timeout_tree, &timeout->node);
+               splay_unlink_node(&loop->timeouts, &timeout->node);
 
-       if(!now.tv_sec)
-               gettimeofday(&now, NULL);
+       if(!loop->now.tv_sec)
+               gettimeofday(&loop->now, NULL);
 
-       timeradd(&now, tv, &timeout->tv);
+       timeradd(&loop->now, tv, &timeout->tv);
 
-       if(!splay_insert_node(&timeout_tree, &timeout->node))
+       if(!splay_insert_node(&loop->timeouts, &timeout->node))
                abort();
 }
 
-void timeout_del(timeout_t *timeout) {
+void timeout_del(event_loop_t *loop, timeout_t *timeout) {
        if(!timeout->cb)
                return;
 
-       splay_unlink_node(&timeout_tree, &timeout->node);
+       splay_unlink_node(&loop->timeouts, &timeout->node);
        timeout->cb = 0;
        timeout->tv = (struct timeval){0, 0};
 }
 
-#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);
+       return (int)a->signum - (int)b->signum;
 }
 
-static void signalio_handler(void *data, int flags) {
+static void signalio_handler(event_loop_t *loop, void *data, int flags) {
        unsigned char signum;
-       if(read(pipefd[0], &signum, 1) != 1)
+       if(read(loop->pipefd[0], &signum, 1) != 1)
                return;
 
-       signal_t *sig = splay_search(&signal_tree, &((signal_t){.signum = signum}));
+       signal_t *sig = splay_search(&loop->signals, &((signal_t){.signum = signum}));
        if(sig)
-               sig->cb(sig->data);
+               sig->cb(loop, sig->data);
 }
 
-static void pipe_init(void) {
-       if(!pipe(pipefd))
-               io_add(&signalio, signalio_handler, NULL, pipefd[0], IO_READ);
+static void pipe_init(event_loop_t *loop) {
+       if(!pipe(loop->pipefd))
+               io_add(loop, &loop->signalio, signalio_handler, NULL, loop->pipefd[0], IO_READ);
 }
 
-void signal_add(signal_t *sig, signal_cb_t cb, void *data, int signum) {
+void signal_add(event_loop_t *loop, signal_t *sig, signal_cb_t cb, void *data, uint8_t signum) {
        if(sig->cb)
                return;
 
@@ -162,67 +148,57 @@ void signal_add(signal_t *sig, signal_cb_t cb, void *data, int signum) {
        sig->signum = signum;
        sig->node.data = sig;
 
-       if(pipefd[0] == -1)
-               pipe_init();
-
-       signal(sig->signum, signal_handler);
+       if(loop->pipefd[0] == -1)
+               pipe_init(loop);
 
-       if(!splay_insert_node(&signal_tree, &sig->node))
+       if(!splay_insert_node(&loop->signals, &sig->node))
                abort();
 }
 
-void signal_del(signal_t *sig) {
+void signal_del(event_loop_t *loop, signal_t *sig) {
        if(!sig->cb)
                return;
 
-       signal(sig->signum, SIG_DFL);
-
-       splay_unlink_node(&signal_tree, &sig->node);
+       splay_unlink_node(&loop->signals, &sig->node);
        sig->cb = NULL;
 }
-#endif
 
-bool event_loop(void) {
-       running = true;
+bool event_loop_run(event_loop_t *loop) {
+       loop->running = true;
 
        fd_set readable;
        fd_set writable;
 
-       while(running) {
-               gettimeofday(&now, NULL);
+       while(loop->running) {
+               gettimeofday(&loop->now, NULL);
+               now = loop->now;
                struct timeval diff, *tv = NULL;
 
-               while(timeout_tree.head) {
-                       timeout_t *timeout = timeout_tree.head->data;
-                       timersub(&timeout->tv, &now, &diff);
+               while(loop->timeouts.head) {
+                       timeout_t *timeout = loop->timeouts.head->data;
+                       timersub(&timeout->tv, &loop->now, &diff);
 
                        if(diff.tv_sec < 0) {
-                               timeout->cb(timeout->data);
-                               if(timercmp(&timeout->tv, &now, <))
-                                       timeout_del(timeout);
+                               timeout->cb(loop, timeout->data);
+                               if(timercmp(&timeout->tv, &loop->now, <))
+                                       timeout_del(loop, timeout);
                        } else {
                                tv = &diff;
                                break;
                        }
                }
 
-               memcpy(&readable, &readfds, sizeof readable);
-               memcpy(&writable, &writefds, sizeof writable);
+               memcpy(&readable, &loop->readfds, sizeof readable);
+               memcpy(&writable, &loop->writefds, sizeof writable);
 
                int fds = 0;
 
-               if(io_tree.tail) {
-                       io_t *last = io_tree.tail->data;
+               if(loop->ios.tail) {
+                       io_t *last = loop->ios.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))
@@ -234,23 +210,40 @@ bool event_loop(void) {
                if(!n)
                        continue;
 
-               for splay_each(io_t, io, &io_tree) {
+               for splay_each(io_t, io, &loop->ios) {
                        if(FD_ISSET(io->fd, &writable))
-                               io->cb(io->data, IO_WRITE);
+                               io->cb(loop, io->data, IO_WRITE);
                        else if(FD_ISSET(io->fd, &readable))
-                               io->cb(io->data, IO_READ);
+                               io->cb(loop, io->data, IO_READ);
                }
        }
 
        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_flush_output(event_loop_t *loop) {
+       for splay_each(io_t, io, &loop->ios)
+               if(FD_ISSET(io->fd, &loop->writefds))
+                       io->cb(loop, io->data, IO_WRITE);
+}
+
+void event_loop_stop(event_loop_t *loop) {
+       loop->running = false;
+}
+
+void event_loop_init(event_loop_t *loop) {
+       loop->ios.compare = (splay_compare_t)io_compare;
+       loop->timeouts.compare = (splay_compare_t)timeout_compare;
+       loop->signals.compare = (splay_compare_t)signal_compare;
+       loop->pipefd[0] = -1;
+       loop->pipefd[1] = -1;
 }
 
-void event_exit(void) {
-       running = false;
+void event_loop_exit(event_loop_t *loop) {
+       for splay_each(io_t, io, &loop->ios)
+               splay_free_node(&loop->ios, node);
+       for splay_each(timeout_t, timeout, &loop->timeouts)
+               splay_free_node(&loop->timeouts, node);
+       for splay_each(signal_t, signal, &loop->signals)
+               splay_free_node(&loop->signals, node);
 }

diff --git a/src/event.h b/src/event.h
index 7d52a174fa874f8b460a5645e6cb234495685393..3d49fe2d9b825e74e41d9c581b3b4891fd993290 100644 (file)
--- a/src/event.h
+++ b/src/event.h
@@ -25,9 +25,11 @@
 #define IO_READ 1
 #define IO_WRITE 2
 
-typedef void (*io_cb_t)(void *data, int flags);
-typedef void (*timeout_cb_t)(void *data);
-typedef void (*signal_cb_t)(void *data);
+typedef struct event_loop_t event_loop_t;
+
+typedef void (*io_cb_t)(event_loop_t *loop, void *data, int flags);
+typedef void (*timeout_cb_t)(event_loop_t *loop, void *data);
+typedef void (*signal_cb_t)(event_loop_t *loop, void *data);
 
 typedef struct io_t {
        int fd;
@@ -51,21 +53,42 @@ typedef struct signal_t {
        struct splay_node_t node;
 } signal_t;
 
+struct event_loop_t {
+       fd_set readfds;
+       fd_set writefds;
+
+       volatile bool running;
+       struct timeval now;
+       
+       splay_tree_t ios;
+       splay_tree_t timeouts;
+       splay_tree_t signals;
+
+       io_t signalio;
+       int pipefd[2];
+
+       void *data;
+};
+
+extern event_loop_t *loop;
 extern struct timeval now;
 
-extern void io_add(io_t *io, io_cb_t cb, void *data, int fd, int flags);
-extern void io_del(io_t *io);
-extern void io_set(io_t *io, int flags);
+extern void io_add(event_loop_t *loop, io_t *io, io_cb_t cb, void *data, int fd, int flags);
+extern void io_del(event_loop_t *loop, io_t *io);
+extern void io_set(event_loop_t *loop, io_t *io, int flags);
 
-extern void timeout_add(timeout_t *timeout, timeout_cb_t cb, void *data, struct timeval *tv);
-extern void timeout_del(timeout_t *timeout);
-extern void timeout_set(timeout_t *timeout, struct timeval *tv);
+extern void timeout_add(event_loop_t *loop, timeout_t *timeout, timeout_cb_t cb, void *data, struct timeval *tv);
+extern void timeout_del(event_loop_t *loop, timeout_t *timeout);
+extern void timeout_set(event_loop_t *loop, timeout_t *timeout, struct timeval *tv);
 
-extern void signal_add(signal_t *sig, signal_cb_t cb, void *data, int signum);
-extern void signal_del(signal_t *sig);
+extern void signal_add(event_loop_t *loop, signal_t *sig, signal_cb_t cb, void *data, uint8_t signum);
+extern void signal_trigger(event_loop_t *loop, signal_t *sig);
+extern void signal_del(event_loop_t *loop, signal_t *sig);
 
-extern bool event_loop(void);
-extern void event_flush_output(void);
-extern void event_exit(void);
+extern void event_loop_init(event_loop_t *loop);
+extern void event_loop_exit(event_loop_t *loop);
+extern bool event_loop_run(event_loop_t *loop);
+extern void event_loop_flush_output(event_loop_t *loop);
+extern void event_loop_stop(event_loop_t *loop);
 
 #endif

diff --git a/src/graph.c b/src/graph.c
index 60d3b02ff3ceb6d6e0625638d4b905e990ac5db8..017e10dc4ba6fd17f0aad6bf901b0d3d31d4ce2d 100644 (file)
--- a/src/graph.c
+++ b/src/graph.c
@@ -221,7 +221,7 @@ static void check_reachability(void) {
                        n->minmtu = 0;
                        n->mtuprobes = 0;
 
-                       timeout_del(&n->mtutimeout);
+                       timeout_del(&mesh->loop, &n->mtutimeout);
 
                        //TODO: callback to application to inform of this node going up/down
 

diff --git a/src/meshlink.c b/src/meshlink.c
index 4abacb1433afd18b35c2027d7aef64af1ad932a6..460256551ee7198ff2e83fc4fb9db7507d4e7d74 100644 (file)
--- a/src/meshlink.c
+++ b/src/meshlink.c
@@ -43,6 +43,7 @@ const char *meshlink_strerror(meshlink_errno_t errno) {
 // TODO: hack, remove once all global variables are gone.
 static void set_mesh(meshlink_handle_t *localmesh) {
        mesh = localmesh;
+       loop = &mesh->loop;
 }
 
 static bool ecdsa_keygen(meshlink_handle_t *mesh) {
@@ -212,6 +213,7 @@ meshlink_handle_t *meshlink_open(const char *confbase, const char *name) {
        meshlink_handle_t *mesh = xzalloc(sizeof *mesh);
        mesh->confbase = xstrdup(confbase);
        mesh->name = xstrdup(name);
+       event_loop_init(&mesh->loop);
        set_mesh(mesh);
 
        // TODO: should be set by a function.
@@ -288,7 +290,7 @@ void meshlink_close(meshlink_handle_t *mesh) {
        logger(DEBUG_ALWAYS, LOG_NOTICE, "Terminating");
 
        exit_configuration(&mesh->config);
-
+       event_loop_exit(&mesh->loop);
 }
 
 void meshlink_set_receive_cb(meshlink_handle_t *mesh, meshlink_receive_cb_t cb) {

diff --git a/src/meshlink_internal.h b/src/meshlink_internal.h
index 00f68e46f75ef959187942390e2000f3373e6026..db69e6fd99c6a3612e06064c7c969523258bad05 100644 (file)
--- a/src/meshlink_internal.h
+++ b/src/meshlink_internal.h
@@ -57,6 +57,7 @@ struct meshlink_handle {
        meshlink_log_level_t log_level;
 
        pthread_t thread;
+       event_loop_t loop;
        listen_socket_t listen_socket[MAXSOCKETS];
        int listen_sockets;
 

diff --git a/src/meta.c b/src/meta.c
index 14342608518aac02ee8c06cfe16d572e2935750a..ccf333dbe012e65c7026b4ec8bce855f0682e05c 100644 (file)
--- a/src/meta.c
+++ b/src/meta.c
@@ -37,7 +37,7 @@ bool send_meta_sptps(void *handle, uint8_t type, const char *buffer, size_t leng
        }
 
        buffer_add(&c->outbuf, buffer, length);
-       io_set(&c->io, IO_READ | IO_WRITE);
+       io_set(&mesh->loop, &c->io, IO_READ | IO_WRITE);
 
        return true;
 }
@@ -53,7 +53,7 @@ bool send_meta(connection_t *c, const char *buffer, int length) {
 
        if(c->allow_request == ID) {
                buffer_add(&c->outbuf, buffer, length);
-               io_set(&c->io, IO_READ | IO_WRITE);
+               io_set(&mesh->loop, &c->io, IO_READ | IO_WRITE);
                return true;
        }
 

diff --git a/src/net.c b/src/net.c
index dacf52c334a19395dfbaafc88e850ec91ad0e06d..12f2f33d7c48e921ced4558ef77b3e423dd5dee9 100644 (file)
--- a/src/net.c
+++ b/src/net.c
@@ -122,7 +122,7 @@ void terminate_connection(connection_t *c, bool report) {
   end does not reply in time, we consider them dead
   and close the connection.
 */
-static void timeout_handler(void *data) {
+static void timeout_handler(event_loop_t *loop, void *data) {
        for list_each(connection_t, c, mesh->connections) {
                if(c->last_ping_time + mesh->pingtimeout <= now.tv_sec) {
                        if(c->status.active) {
@@ -144,10 +144,10 @@ static void timeout_handler(void *data) {
                }
        }
 
-       timeout_set(data, &(struct timeval){mesh->pingtimeout, rand() % 100000});
+       timeout_set(&mesh->loop, data, &(struct timeval){mesh->pingtimeout, rand() % 100000});
 }
 
-static void periodic_handler(void *data) {
+static void periodic_handler(event_loop_t *loop, void *data) {
        /* Check if there are too many contradicting ADD_EDGE and DEL_EDGE messages.
           This usually only happens when another node has the same Name as this node.
           If so, sleep for a short while to prevent a storm of contradicting messages.
@@ -258,7 +258,7 @@ static void periodic_handler(void *data) {
                }
        }
 
-       timeout_set(data, &(struct timeval){5, rand() % 100000});
+       timeout_set(&mesh->loop, data, &(struct timeval){5, rand() % 100000});
 }
 
 void handle_meta_connection_data(connection_t *c) {
@@ -313,7 +313,7 @@ void retry(void) {
        for list_each(outgoing_t, outgoing, mesh->outgoings) {
                outgoing->timeout = 0;
                if(outgoing->ev.cb)
-                       timeout_set(&outgoing->ev, &(struct timeval){0, 0});
+                       timeout_set(&mesh->loop, &outgoing->ev, &(struct timeval){0, 0});
        }
 
        /* Check for outgoing connections that are in progress, and reset their ping timers */
@@ -323,23 +323,23 @@ void retry(void) {
        }
 
        /* Kick the ping timeout handler */
-       timeout_set(&mesh->pingtimer, &(struct timeval){0, 0});
+       timeout_set(&mesh->loop, &mesh->pingtimer, &(struct timeval){0, 0});
 }
 
 /*
   this is where it all happens...
 */
 int main_loop(void) {
-       timeout_add(&mesh->pingtimer, timeout_handler, &mesh->pingtimer, &(struct timeval){mesh->pingtimeout, rand() % 100000});
-       timeout_add(&mesh->periodictimer, periodic_handler, &mesh->periodictimer, &(struct timeval){mesh->pingtimeout, rand() % 100000});
+       timeout_add(&mesh->loop, &mesh->pingtimer, timeout_handler, &mesh->pingtimer, &(struct timeval){mesh->pingtimeout, rand() % 100000});
+       timeout_add(&mesh->loop, &mesh->periodictimer, periodic_handler, &mesh->periodictimer, &(struct timeval){mesh->pingtimeout, rand() % 100000});
 
-       if(!event_loop()) {
+       if(!event_loop_run(&mesh->loop)) {
                logger(DEBUG_ALWAYS, LOG_ERR, "Error while waiting for input: %s", strerror(errno));
                return 1;
        }
 
-       timeout_del(&mesh->periodictimer);
-       timeout_del(&mesh->pingtimer);
+       timeout_del(&mesh->loop, &mesh->periodictimer);
+       timeout_del(&mesh->loop, &mesh->pingtimer);
 
        return 0;
 }

diff --git a/src/net.h b/src/net.h
index 33d273593cf3a2e917e9cd804e086f37748d1c8b..2e38477815719805d2ea4d06129c5a5b265fdda0 100644 (file)
--- a/src/net.h
+++ b/src/net.h
@@ -82,10 +82,10 @@ extern int autoconnect;
 #include "node.h"
 
 extern void retry_outgoing(outgoing_t *);
-extern void handle_incoming_vpn_data(void *, int);
+extern void handle_incoming_vpn_data(struct event_loop_t *loop, void *, int);
 extern void finish_connecting(struct connection_t *);
 extern bool do_outgoing_connection(struct outgoing_t *);
-extern void handle_new_meta_connection(void *, int);
+extern void handle_new_meta_connection(struct event_loop_t *loop, void *, int);
 extern int setup_listen_socket(const sockaddr_t *);
 extern int setup_vpn_in_socket(const sockaddr_t *);
 extern bool send_sptps_data(void *handle, uint8_t type, const char *data, size_t len);
@@ -104,7 +104,6 @@ extern void terminate_connection(struct connection_t *, bool);
 extern bool node_read_ecdsa_public_key(struct node_t *);
 extern bool read_ecdsa_public_key(struct connection_t *);
 extern void send_mtu_probe(struct node_t *);
-extern void handle_device_data(void *, int);
 extern void handle_meta_connection_data(struct connection_t *);
 extern void regenerate_key(void);
 extern void purge(void);

diff --git a/src/net_packet.c b/src/net_packet.c
index 281fd973c7fddba951bb12f1ddb0b1ea996e4427..63d6e4eaf6f2f7aad8ec3593cd617fd1ef1e983a 100644 (file)
--- a/src/net_packet.c
+++ b/src/net_packet.c
@@ -60,7 +60,7 @@ unsigned replaywin = 16;
 
 */
 
-static void send_mtu_probe_handler(void *data) {
+static void send_mtu_probe_handler(event_loop_t *loop, void *data) {
        node_t *n = data;
        int timeout = 1;
 
@@ -153,12 +153,12 @@ static void send_mtu_probe_handler(void *data) {
        n->prev_received = n->received;
 
 end:
-       timeout_set(&n->mtutimeout, &(struct timeval){timeout, rand() % 100000});
+       timeout_set(&mesh->loop, &n->mtutimeout, &(struct timeval){timeout, rand() % 100000});
 }
 
 void send_mtu_probe(node_t *n) {
-       timeout_add(&n->mtutimeout, send_mtu_probe_handler, n, &(struct timeval){1, 0});
-       send_mtu_probe_handler(n);
+       timeout_add(&mesh->loop, &n->mtutimeout, send_mtu_probe_handler, n, &(struct timeval){1, 0});
+       send_mtu_probe_handler(&mesh->loop, n);
 }
 
 static void mtu_probe_h(node_t *n, vpn_packet_t *packet, uint16_t len) {
@@ -623,7 +623,7 @@ static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
        return n;
 }
 
-void handle_incoming_vpn_data(void *data, int flags) {
+void handle_incoming_vpn_data(event_loop_t *loop, void *data, int flags) {
        listen_socket_t *ls = data;
        vpn_packet_t pkt;
        char *hostname;

diff --git a/src/net_setup.c b/src/net_setup.c
index 7fa7b98e975e56dbf7d91f7af290098dee4b569e..896df4327269c73bd9696a891ecbca3c65d054c7 100644 (file)
--- a/src/net_setup.c
+++ b/src/net_setup.c
@@ -243,8 +243,8 @@ static bool add_listen_address(char *address, bool bindto) {
                        continue;
                }
 
-               io_add(&mesh->listen_socket[mesh->listen_sockets].tcp, handle_new_meta_connection, &mesh->listen_socket[mesh->listen_sockets], tcp_fd, IO_READ);
-               io_add(&mesh->listen_socket[mesh->listen_sockets].udp, handle_incoming_vpn_data, &mesh->listen_socket[mesh->listen_sockets], udp_fd, IO_READ);
+               io_add(&mesh->loop, &mesh->listen_socket[mesh->listen_sockets].tcp, handle_new_meta_connection, &mesh->listen_socket[mesh->listen_sockets], tcp_fd, IO_READ);
+               io_add(&mesh->loop, &mesh->listen_socket[mesh->listen_sockets].udp, handle_incoming_vpn_data, &mesh->listen_socket[mesh->listen_sockets], udp_fd, IO_READ);
 
                if(mesh->debug_level >= DEBUG_CONNECTIONS) {
                        char *hostname = sockaddr2hostname((sockaddr_t *) aip->ai_addr);
@@ -397,8 +397,8 @@ void close_network_connections(void) {
        }
 
        for(int i = 0; i < mesh->listen_sockets; i++) {
-               io_del(&mesh->listen_socket[i].tcp);
-               io_del(&mesh->listen_socket[i].udp);
+               io_del(&mesh->loop, &mesh->listen_socket[i].tcp);
+               io_del(&mesh->loop, &mesh->listen_socket[i].udp);
                close(mesh->listen_socket[i].tcp.fd);
                close(mesh->listen_socket[i].udp.fd);
        }

diff --git a/src/net_socket.c b/src/net_socket.c
index 7f87d9c42056fbc9ddd40b812762e59473d9a45d..589c4caa9b5424bb3113d61b6b59e0b124313e55 100644 (file)
--- a/src/net_socket.c
+++ b/src/net_socket.c
@@ -232,7 +232,7 @@ int setup_vpn_in_socket(const sockaddr_t *sa) {
        return nfd;
 } /* int setup_vpn_in_socket */
 
-static void retry_outgoing_handler(void *data) {
+static void retry_outgoing_handler(event_loop_t *loop, void *data) {
        setup_outgoing_connection(data);
 }
 
@@ -242,7 +242,7 @@ void retry_outgoing(outgoing_t *outgoing) {
        if(outgoing->timeout > mesh->maxtimeout)
                outgoing->timeout = mesh->maxtimeout;
 
-       timeout_add(&outgoing->ev, retry_outgoing_handler, outgoing, &(struct timeval){outgoing->timeout, rand() % 100000});
+       timeout_add(&mesh->loop, &outgoing->ev, retry_outgoing_handler, outgoing, &(struct timeval){outgoing->timeout, rand() % 100000});
 
        logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Trying to re-establish outgoing connection in %d seconds", outgoing->timeout);
 }
@@ -323,10 +323,10 @@ static void handle_meta_write(connection_t *c) {
 
        buffer_read(&c->outbuf, outlen);
        if(!c->outbuf.len)
-               io_set(&c->io, IO_READ);
+               io_set(&mesh->loop, &c->io, IO_READ);
 }
 
-static void handle_meta_io(void *data, int flags) {
+static void handle_meta_io(event_loop_t *loop, void *data, int flags) {
        connection_t *c = data;
 
        if(c->status.connecting) {
@@ -464,7 +464,7 @@ begin:
 
        connection_add(c);
 
-       io_add(&c->io, handle_meta_io, c, c->socket, IO_READ|IO_WRITE);
+       io_add(&mesh->loop, &c->io, handle_meta_io, c, c->socket, IO_READ|IO_WRITE);
 
        return true;
 }
@@ -503,7 +503,7 @@ static struct addrinfo *get_known_addresses(node_t *n) {
 }
 
 void setup_outgoing_connection(outgoing_t *outgoing) {
-       timeout_del(&outgoing->ev);
+       timeout_del(&mesh->loop, &outgoing->ev);
 
        node_t *n = lookup_node(outgoing->name);
 
@@ -534,7 +534,7 @@ void setup_outgoing_connection(outgoing_t *outgoing) {
   accept a new tcp connect and create a
   new connection
 */
-void handle_new_meta_connection(void *data, int flags) {
+void handle_new_meta_connection(event_loop_t *loop, void *data, int flags) {
        listen_socket_t *l = data;
        connection_t *c;
        sockaddr_t sa;
@@ -612,7 +612,7 @@ void handle_new_meta_connection(void *data, int flags) {
 
        logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Connection from %s", c->hostname);
 
-       io_add(&c->io, handle_meta_io, c, c->socket, IO_READ);
+       io_add(&mesh->loop, &c->io, handle_meta_io, c, c->socket, IO_READ);
 
        configure_tcp(c);
 
@@ -623,7 +623,7 @@ void handle_new_meta_connection(void *data, int flags) {
 }
 
 static void free_outgoing(outgoing_t *outgoing) {
-       timeout_del(&outgoing->ev);
+       timeout_del(&mesh->loop, &outgoing->ev);
 
        if(outgoing->ai)
                freeaddrinfo(outgoing->ai);

diff --git a/src/node.c b/src/node.c
index 3068c9fbbac4693c168ed6f0014e058f2af3584c..54887a3bcda12eef09667edf8a3a9cbdca0025d2 100644 (file)
--- a/src/node.c
+++ b/src/node.c
@@ -65,7 +65,7 @@ void free_node(node_t *n) {
        ecdsa_free(n->ecdsa);
        sptps_stop(&n->sptps);
 
-       timeout_del(&n->mtutimeout);
+       timeout_del(&mesh->loop, &n->mtutimeout);
 
        if(n->hostname)
                free(n->hostname);

diff --git a/src/protocol.c b/src/protocol.c
index 3e6db47e05c154409dc5107ffd034150e62978f2..f8b827d60ca8277ef1b77fe6ac28a2a9720e6f9a 100644 (file)
--- a/src/protocol.c
+++ b/src/protocol.c
@@ -163,7 +163,7 @@ static void free_past_request(past_request_t *r) {
 
 static timeout_t past_request_timeout;
 
-static void age_past_requests(void *data) {
+static void age_past_requests(event_loop_t *loop, void *data) {
        int left = 0, deleted = 0;
 
        for splay_each(past_request_t, p, past_request_tree) {
@@ -177,7 +177,7 @@ static void age_past_requests(void *data) {
                logger(DEBUG_SCARY_THINGS, LOG_DEBUG, "Aging past requests: deleted %d, left %d", deleted, left);
 
        if(left)
-               timeout_set(&past_request_timeout, &(struct timeval){10, rand() % 100000});
+               timeout_set(&mesh->loop, &past_request_timeout, &(struct timeval){10, rand() % 100000});
 }
 
 bool seen_request(const char *request) {
@@ -193,7 +193,7 @@ bool seen_request(const char *request) {
                new->request = xstrdup(request);
                new->firstseen = now.tv_sec;
                splay_insert(past_request_tree, new);
-               timeout_add(&past_request_timeout, age_past_requests, NULL, &(struct timeval){10, rand() % 100000});
+               timeout_add(&mesh->loop, &past_request_timeout, age_past_requests, NULL, &(struct timeval){10, rand() % 100000});
                return false;
        }
 }
@@ -205,5 +205,5 @@ void init_requests(void) {
 void exit_requests(void) {
        splay_delete_tree(past_request_tree);
 
-       timeout_del(&past_request_timeout);
+       timeout_del(&mesh->loop, &past_request_timeout);
 }