+static bool found_random_node(int *i, int *r, node_t *n) {
+ if((*i)++ != *r)
+ return false;
+
+ if(n->connection)
+ return false;
+
+ return true;
+}
+
+static bool found_random_unreachable_node(int *i, int *r, node_t *n) {
+ if(n->status.reachable)
+ return false;
+
+ if((*i)++ != *r)
+ return false;
+
+ if(n->connection)
+ return false;
+
+ return true;
+}
+
+static void periodic_handler(event_loop_t *loop, void *data) {
+ meshlink_handle_t *mesh = loop->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.
+ */
+
+ if(mesh->contradicting_del_edge > 100 && mesh->contradicting_add_edge > 100) {
+ logger(DEBUG_ALWAYS, LOG_WARNING, "Possible node with same Name as us! Sleeping %d seconds.", mesh->sleeptime);
+ usleep(mesh->sleeptime * 1000000LL);
+ mesh->sleeptime *= 2;
+ if(mesh->sleeptime < 0)
+ mesh->sleeptime = 3600;
+ } else {
+ mesh->sleeptime /= 2;
+ if(mesh->sleeptime < 10)
+ mesh->sleeptime = 10;
+ }
+
+ mesh->contradicting_add_edge = 0;
+ mesh->contradicting_del_edge = 0;
+
+ /* If AutoConnect is set, check if we need to make or break connections. */
+
+ if(autoconnect && mesh->nodes->count > 1) {
+ /* Count number of active connections */
+ int nc = 0;
+ for list_each(connection_t, c, mesh->connections) {
+ if(c->status.active)
+ nc++;
+ }
+
+ /* Count number of unreachable nodes */
+ int num_unreachable = 0;
+ for splay_each(node_t, n, mesh->nodes) {
+ if(!n->status.reachable)
+ num_unreachable++;
+ }
+
+ if(nc < autoconnect) {
+ /* Not enough active connections, try to add one.
+ Choose a random node, if we don't have a connection to it,
+ and we are not already trying to make one, create an
+ outgoing connection to this node.
+ */
+ cond_add_connection(mesh, mesh->nodes->count, &found_random_node);
+ } else if(num_unreachable > 0) {
+ /* Min number of connections established. Now try
+ to connect to some unreachable nodes to attempt
+ to heal possible partitions.
+ */
+ cond_add_connection(mesh, num_unreachable, &found_random_unreachable_node);
+ }
+
+ if(nc > autoconnect) {
+ /* Too many active connections, try to remove one.
+ Choose a random outgoing connection to a node
+ that has at least one other connection.
+ */
+ int r = rand() % nc;
+ int i = 0;
+
+ for list_each(connection_t, c, mesh->connections) {
+ if(!c->status.active)
+ continue;
+
+ if(i++ != r)
+ continue;
+
+ if(!c->outgoing || !c->node || c->node->edge_tree->count < 2)
+ break;
+
+ logger(DEBUG_CONNECTIONS, LOG_INFO, "Autodisconnecting from %s", c->name);
+ list_delete(mesh->outgoings, c->outgoing);
+ c->outgoing = NULL;
+ terminate_connection(mesh, c, c->status.active);
+ break;
+ }
+ }
+
+ if(nc >= autoconnect) {
+ /* If we have enough active connections,
+ remove any pending outgoing connections.
+ Do not remove pending connections to unreachable
+ nodes.
+ */
+ node_t *o_node = NULL;
+ for list_each(outgoing_t, o, mesh->outgoings) {
+ o_node = lookup_node(mesh, o->name);
+ /* o_node is NULL if it is not part of the graph yet */
+ if(!o_node || !o_node->status.reachable)
+ continue;
+
+ bool found = false;
+ for list_each(connection_t, c, mesh->connections) {
+ if(c->outgoing == o) {
+ found = true;
+ break;
+ }
+ }
+ if(!found) {
+ logger(DEBUG_CONNECTIONS, LOG_INFO, "Cancelled outgoing connection to %s", o->name);
+ /* The node variable is leaked in from using the list_each macro.
+ The o variable could be used, but using node directly
+ is more efficient.
+ */
+ list_delete_node(mesh->outgoings, node);
+ }
+ }
+ }
+ }
+
+ timeout_set(&mesh->loop, data, &(struct timeval){5, rand() % 100000});
+}
+
+void handle_meta_connection_data(meshlink_handle_t *mesh, connection_t *c) {
+ if (!receive_meta(mesh, c)) {
+ terminate_connection(mesh, c, c->status.active);
+ return;
+ }
+}
+
+void retry(meshlink_handle_t *mesh) {
+ /* 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(&mesh->loop, &outgoing->ev, &(struct timeval){0, 0});
+ }
+
+ /* Check for outgoing connections that are in progress, and reset their ping timers */
+ for list_each(connection_t, c, mesh->connections) {
+ if(c->outgoing && !c->node)
+ c->last_ping_time = 0;
+ }
+
+ /* Kick the ping timeout handler */
+ timeout_set(&mesh->loop, &mesh->pingtimer, &(struct timeval){0, 0});