-/*
- check all connections to see if anything
- happened on their sockets
-*/
-void check_network_activity(fd_set *f)
-{
- connection_t *c;
- avl_node_t *node;
- int result, i;
- int len = sizeof(result);
- vpn_packet_t packet;
- cp();
- if(FD_ISSET(device_fd, f))
- {
- if(!read_packet(&packet))
- route_outgoing(&packet);
- }
-
- for(node = connection_tree->head; node; node = node->next)
- {
- c = (connection_t *)node->data;
-
- if(c->status.remove)
- continue;
-
- if(FD_ISSET(c->socket, f))
- {
- if(c->status.connecting)
- {
- c->status.connecting = 0;
- getsockopt(c->socket, SOL_SOCKET, SO_ERROR, &result, &len);
- if(!result)
- finish_connecting(c);
- else
- {
- if(debug_lvl >= DEBUG_CONNECTIONS)
- syslog(LOG_DEBUG, _("Error while connecting to %s (%s): %s"), c->name, c->hostname, strerror(result));
- close(c->socket);
- do_outgoing_connection(c);
- continue;
- }
- }
- if(receive_meta(c) < 0)
- {
- terminate_connection(c, c->status.active);
- continue;
- }
- }
- }
-
- for(i = 0; i < listen_sockets; i++)
- {
- if(FD_ISSET(listen_socket[i].udp, f))
- handle_incoming_vpn_data(listen_socket[i].udp);
- if(FD_ISSET(listen_socket[i].tcp, f))
- handle_new_meta_connection(listen_socket[i].tcp);
- }
- cp();
+/// Utility function to establish connections based on condition check
+/** The function iterates over all nodes, but skips those that do
+ * not pass the condition check.
+ *
+ * The condition check function is passed
+ * a pointer to a random number r between 0 and rand_modulo, a pointer to the
+ * current node index i, and the node pointer n. This function should return true
+ * if a connection attempt to the node should be made.
+ *
+ * @param mesh A pointer to the mesh structure
+ * @param rand_modulo Random index is selected between 0 and rand_modulo
+ * @cond_check A function pointer. This function should return true
+ * if a connection attempt to the node should be made
+ */
+static void cond_add_connection(meshlink_handle_t *mesh, int rand_modulo, bool (*cond_check)(int*, int*, node_t*)) {
+ int r = rand() % rand_modulo;
+ int i = 0;
+
+ for splay_each(node_t, n, mesh->nodes) {
+ /* skip nodes that do not pass condition check */
+ if(!(*cond_check)(&i, &r, n))
+ continue;
+
+ /* check if there is already a connection attempt to this node */
+ bool found = false;
+ for list_each(outgoing_t, outgoing, mesh->outgoings) {
+ if(!strcmp(outgoing->name, n->name)) {
+ found = true;
+ break;
+ }
+ }
+
+ if(!found) {
+ //TODO: if the node is blacklisted the connection will not happen, but
+ //the user will read this debug message "Autoconnecting to %s" that is misleading
+ logger(DEBUG_CONNECTIONS, LOG_INFO, "Autoconnecting to %s", n->name);
+ outgoing_t *outgoing = xzalloc(sizeof *outgoing);
+ outgoing->name = xstrdup(n->name);
+ list_insert_tail(mesh->outgoings, outgoing);
+ setup_outgoing_connection(mesh, outgoing);
+ }
+ break;
+ }
+}
+
+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});