Remove reload_configuration().

[meshlink] / src / net.c

diff --git a/src/net.c b/src/net.c
index a2cc3ed7d84d3b3f0ea6bf9083c9af86925722fa..61cb1538de42236ee2727ff537b5034df6f4b752 100644 (file)
--- a/src/net.c
+++ b/src/net.c
@@ -105,7 +105,7 @@ void terminate_connection(connection_t *c, bool report) {
        /* Check if this was our outgoing connection */
 
        if(outgoing)
-               do_outgoing_connection(outgoing);
+               do_outgoing_connection(mesh, outgoing);
 
 #ifndef HAVE_MINGW
        /* Clean up dead proxy processes */
@@ -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 + mesh->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 + mesh->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){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.
@@ -208,7 +208,7 @@ static void periodic_handler(void *data) {
                                        outgoing_t *outgoing = xzalloc(sizeof *outgoing);
                                        outgoing->name = xstrdup(n->name);
                                        list_insert_tail(mesh->outgoings, outgoing);
-                                       setup_outgoing_connection(outgoing);
+                                       setup_outgoing_connection(mesh, outgoing);
                                }
                                break;
                        }
@@ -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) {
@@ -268,54 +268,12 @@ void handle_meta_connection_data(connection_t *c) {
        }
 }
 
-int reload_configuration(void) {
-       char *fname = NULL;
-
-       /* Reread our own configuration file */
-
-       exit_configuration(&mesh->config);
-       init_configuration(&mesh->config);
-
-       if(!read_server_config()) {
-               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);
-
-       /* Parse some options that are allowed to be changed while tinc is running */
-
-       setup_myself_reloadable();
-
-       /* Try to make outgoing connections */
-
-       try_outgoing_connections();
-
-       /* 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);
-               struct stat s;
-               if(stat(fname, &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;
-
-       return 0;
-}
-
 void retry(void) {
        /* Reset the reconnection timers for all outgoing connections */
        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 +283,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;
 }