Stop using global variable mesh in net_setup.[ch].

[meshlink] / src / net.c

diff --git a/src/net.c b/src/net.c
index 294014231b1b04f0f556c11d826b57f45596414f..d271a3466c08bbd721873bcddbfe0bfb711391c8 100644 (file)
--- a/src/net.c
+++ b/src/net.c
@@ -122,13 +122,13 @@ 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 + pingtimeout <= now.tv_sec) {
+               if(c->last_ping_time + mesh->pingtimeout <= mesh->loop.now.tv_sec) {
                        if(c->status.active) {
                                if(c->status.pinged) {
-                                       logger(DEBUG_CONNECTIONS, LOG_INFO, "%s (%s) didn't respond to PING in %ld seconds", c->name, c->hostname, (long)now.tv_sec - c->last_ping_time);
-                               } else if(c->last_ping_time + pinginterval <= now.tv_sec) {
+                                       logger(DEBUG_CONNECTIONS, LOG_INFO, "%s (%s) didn't respond to PING in %ld seconds", c->name, c->hostname, (long)mesh->loop.now.tv_sec - c->last_ping_time);
+                               } else if(c->last_ping_time + mesh->pinginterval <= mesh->loop.now.tv_sec) {
                                        send_ping(c);
                                        continue;
                                } else {
@@ -144,10 +144,10 @@ static void timeout_handler(void *data) {
                }
        }
 
-       timeout_set(data, &(struct timeval){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) {
@@ -269,25 +269,24 @@ void handle_meta_connection_data(connection_t *c) {
 }
 
 int reload_configuration(void) {
-       char *fname = NULL;
+       char filename[PATH_MAX];
 
        /* Reread our own configuration file */
 
        exit_configuration(&mesh->config);
        init_configuration(&mesh->config);
 
-       if(!read_server_config()) {
+       if(!read_server_config(mesh)) {
                logger(DEBUG_ALWAYS, LOG_ERR, "Unable to reread configuration file.");
                return EINVAL;
        }
 
-       xasprintf(&fname, "%s" SLASH "hosts" SLASH "%s", mesh->confbase, mesh->self->name);
-       read_config_file(mesh->config, fname);
-       free(fname);
+       snprintf(filename, PATH_MAX,"%s" SLASH "hosts" SLASH "%s", mesh->confbase, mesh->self->name);
+       read_config_file(mesh->config, filename);
 
        /* Parse some options that are allowed to be changed while tinc is running */
 
-       setup_myself_reloadable();
+       setup_myself_reloadable(mesh);
 
        /* Try to make outgoing connections */
 
@@ -296,16 +295,15 @@ int reload_configuration(void) {
        /* Close connections to hosts that have a changed or deleted host config file */
 
        for list_each(connection_t, c, mesh->connections) {
-               xasprintf(&fname, "%s" SLASH "hosts" SLASH "%s", mesh->confbase, c->name);
+               snprintf(filename, PATH_MAX,"%s" SLASH "hosts" SLASH "%s", mesh->confbase, c->name);
                struct stat s;
-               if(stat(fname, &s) || s.st_mtime > mesh->last_config_check) {
+               if(stat(filename, &s) || s.st_mtime > mesh->last_config_check) {
                        logger(DEBUG_CONNECTIONS, LOG_INFO, "Host config file of %s has been changed", c->name);
                        terminate_connection(c, c->status.active);
                }
-               free(fname);
        }
 
-       mesh->last_config_check = now.tv_sec;
+       mesh->last_config_check = mesh->loop.now.tv_sec;
 
        return 0;
 }
@@ -315,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 */
@@ -325,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){pingtimeout, rand() % 100000});
-       timeout_add(&mesh->periodictimer, periodic_handler, &mesh->periodictimer, &(struct timeval){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;
 }