2 net.c -- most of the network code
3 Copyright (C) 1998-2005 Ivo Timmermans,
4 2000-2015 Guus Sliepen <guus@tinc-vpn.org>
5 2006 Scott Lamb <slamb@slamb.org>
6 2011 Loïc Grenié <loic.grenie@gmail.com>
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
27 #include "connection.h"
39 int contradicting_add_edge = 0;
40 int contradicting_del_edge = 0;
41 static int sleeptime = 10;
42 time_t last_config_check = 0;
43 static timeout_t pingtimer;
44 static timeout_t periodictimer;
45 static struct timeval last_periodic_run_time;
47 /* Purge edges and subnets of unreachable nodes. Use carefully. */
50 logger(DEBUG_PROTOCOL, LOG_DEBUG, "Purging unreachable nodes");
52 /* Remove all edges and subnets owned by unreachable nodes. */
54 for splay_each(node_t, n, node_tree) {
55 if(!n->status.reachable) {
56 logger(DEBUG_SCARY_THINGS, LOG_DEBUG, "Purging node %s (%s)", n->name, n->hostname);
58 for splay_each(subnet_t, s, n->subnet_tree) {
59 send_del_subnet(everyone, s);
64 for splay_each(edge_t, e, n->edge_tree) {
66 send_del_edge(everyone, e);
72 /* Check if anyone else claims to have an edge to an unreachable node. If not, delete node. */
74 for splay_each(node_t, n, node_tree) {
75 if(!n->status.reachable) {
76 for splay_each(edge_t, e, edge_weight_tree)
80 if(!autoconnect && (!strictsubnets || !n->subnet_tree->head))
81 /* in strictsubnets mode do not delete nodes with subnets */
88 Terminate a connection:
90 - Remove the edge representing this connection
92 - Check if we need to retry making an outgoing connection
94 void terminate_connection(connection_t *c, bool report) {
95 logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Closing connection with %s (%s)", c->name, c->hostname);
97 if(c->node && c->node->connection == c)
98 c->node->connection = NULL;
101 if(report && !tunnelserver)
102 send_del_edge(everyone, c->edge);
107 /* Run MST and SSSP algorithms */
111 /* If the node is not reachable anymore but we remember it had an edge to us, clean it up */
113 if(report && !c->node->status.reachable) {
115 e = lookup_edge(c->node, myself);
118 send_del_edge(everyone, e);
124 outgoing_t *outgoing = c->outgoing;
127 /* Check if this was our outgoing connection */
130 do_outgoing_connection(outgoing);
133 /* Clean up dead proxy processes */
135 while(waitpid(-1, NULL, WNOHANG) > 0);
140 Check if the other end is active.
141 If we have sent packets, but didn't receive any,
142 then possibly the other end is dead. We send a
143 PING request over the meta connection. If the other
144 end does not reply in time, we consider them dead
145 and close the connection.
147 static void timeout_handler(void *data) {
149 bool close_all_connections = false;
152 timeout_hanlder will start after 30 seconds from start of tincd
153 hold information about the elapsed time since last time the handler
156 long sleep_time = now.tv_sec - last_periodic_run_time.tv_sec;
158 It seems that finding sane default value is harder than expected
159 Since we send every second a UDP packet to make holepunching work
160 And default UDP state expire on firewalls is between 15-30 seconds
161 we drop all connections after 60 Seconds - UDPDiscoveryTimeout=30
164 if (sleep_time > 2 * udp_discovery_timeout) {
165 logger(DEBUG_ALWAYS, LOG_ERR, "Awaking from dead after %ld seconds of sleep", sleep_time);
167 Do not send any packets to tinc after we wake up.
168 The other node probably closed our connection but we still
169 are holding context information to them. This may happen on
170 laptops or any other hardware which can be suspended for some time.
171 Sending any data to node that wasn't expecting it will produce
172 annoying and misleading errors on the other side about failed signature
173 verification and or about missing sptps context
175 close_all_connections = true;
177 last_periodic_run_time = now;
179 for list_each(connection_t, c, connection_list) {
180 if(c->status.control)
183 if(close_all_connections) {
184 logger(DEBUG_ALWAYS, LOG_ERR, "Forcing connection close after sleep time %s (%s)", c->name, c->hostname);
185 terminate_connection(c, c->edge);
189 if(c->last_ping_time + pingtimeout <= now.tv_sec) {
191 try_tx(c->node, false);
192 if(c->status.pinged) {
193 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));
194 } else if(c->last_ping_time + pinginterval <= now.tv_sec) {
201 if(c->status.connecting)
202 logger(DEBUG_CONNECTIONS, LOG_WARNING, "Timeout while connecting to %s (%s)", c->name, c->hostname);
204 logger(DEBUG_CONNECTIONS, LOG_WARNING, "Timeout from %s (%s) during authentication", c->name, c->hostname);
206 terminate_connection(c, c->edge);
211 timeout_set(data, &(struct timeval){1, rand() % 100000});
214 static void periodic_handler(void *data) {
215 /* Check if there are too many contradicting ADD_EDGE and DEL_EDGE messages.
216 This usually only happens when another node has the same Name as this node.
217 If so, sleep for a short while to prevent a storm of contradicting messages.
220 if(contradicting_del_edge > 100 && contradicting_add_edge > 100) {
221 logger(DEBUG_ALWAYS, LOG_WARNING, "Possible node with same Name as us! Sleeping %d seconds.", sleeptime);
222 nanosleep(&(struct timespec){sleeptime, 0}, NULL);
232 contradicting_add_edge = 0;
233 contradicting_del_edge = 0;
235 /* If AutoConnect is set, check if we need to make or break connections. */
237 if(autoconnect && node_tree->count > 1) {
238 /* Count number of active connections */
240 for list_each(connection_t, c, connection_list) {
246 /* Not enough active connections, try to add one.
247 Choose a random node, if we don't have a connection to it,
248 and we are not already trying to make one, create an
249 outgoing connection to this node.
252 for splay_each(node_t, n, node_tree) {
253 if(n == myself || n->connection || !(n->status.has_address || n->status.reachable))
261 int r = rand() % count;
263 for splay_each(node_t, n, node_tree) {
264 if(n == myself || n->connection || !(n->status.has_address || n->status.reachable))
272 for list_each(outgoing_t, outgoing, outgoing_list) {
273 if(!strcmp(outgoing->name, n->name)) {
280 logger(DEBUG_CONNECTIONS, LOG_INFO, "Autoconnecting to %s", n->name);
281 outgoing_t *outgoing = xzalloc(sizeof *outgoing);
282 outgoing->name = xstrdup(n->name);
283 list_insert_tail(outgoing_list, outgoing);
284 setup_outgoing_connection(outgoing);
290 /* Too many active connections, try to remove one.
291 Choose a random outgoing connection to a node
292 that has at least one other connection.
297 for list_each(connection_t, c, connection_list) {
304 if(!c->outgoing || !c->node || c->node->edge_tree->count < 2)
307 logger(DEBUG_CONNECTIONS, LOG_INFO, "Autodisconnecting from %s", c->name);
308 list_delete(outgoing_list, c->outgoing);
310 terminate_connection(c, c->edge);
316 /* If we have enough active connections,
317 remove any pending outgoing connections.
319 for list_each(outgoing_t, o, outgoing_list) {
321 for list_each(connection_t, c, connection_list) {
322 if(c->outgoing == o) {
328 logger(DEBUG_CONNECTIONS, LOG_INFO, "Cancelled outgoing connection to %s", o->name);
329 list_delete_node(outgoing_list, node);
336 timeout_set(data, &(struct timeval){5, rand() % 100000});
339 void handle_meta_connection_data(connection_t *c) {
340 if (!receive_meta(c)) {
341 terminate_connection(c, c->edge);
347 static void sigterm_handler(void *data) {
348 logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
352 static void sighup_handler(void *data) {
353 logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
355 if(reload_configuration())
359 static void sigalrm_handler(void *data) {
360 logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
365 int reload_configuration(void) {
366 char fname[PATH_MAX];
368 /* Reread our own configuration file */
370 exit_configuration(&config_tree);
371 init_configuration(&config_tree);
373 if(!read_server_config()) {
374 logger(DEBUG_ALWAYS, LOG_ERR, "Unable to reread configuration file.");
378 read_config_options(config_tree, NULL);
380 snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, myself->name);
381 read_config_file(config_tree, fname);
383 /* Parse some options that are allowed to be changed while tinc is running */
385 setup_myself_reloadable();
387 /* If StrictSubnet is set, expire deleted Subnets and read new ones in */
390 for splay_each(subnet_t, subnet, subnet_tree)
395 for splay_each(node_t, n, node_tree)
396 n->status.has_address = false;
401 for splay_each(subnet_t, subnet, subnet_tree) {
404 if(subnet->expires == 1) {
405 send_del_subnet(everyone, subnet);
406 if(subnet->owner->status.reachable)
407 subnet_update(subnet->owner, subnet, false);
408 subnet_del(subnet->owner, subnet);
409 } else if(subnet->expires == -1) {
412 send_add_subnet(everyone, subnet);
413 if(subnet->owner->status.reachable)
414 subnet_update(subnet->owner, subnet, true);
417 } else { /* Only read our own subnets back in */
418 for splay_each(subnet_t, subnet, myself->subnet_tree)
422 config_t *cfg = lookup_config(config_tree, "Subnet");
425 subnet_t *subnet, *s2;
427 if(!get_config_subnet(cfg, &subnet))
430 if((s2 = lookup_subnet(myself, subnet))) {
436 subnet_add(myself, subnet);
437 send_add_subnet(everyone, subnet);
438 subnet_update(myself, subnet, true);
441 cfg = lookup_config_next(config_tree, cfg);
444 for splay_each(subnet_t, subnet, myself->subnet_tree) {
445 if(subnet->expires == 1) {
446 send_del_subnet(everyone, subnet);
447 subnet_update(myself, subnet, false);
448 subnet_del(myself, subnet);
453 /* Try to make outgoing connections */
455 try_outgoing_connections();
457 /* Close connections to hosts that have a changed or deleted host config file */
459 for list_each(connection_t, c, connection_list) {
460 if(c->status.control)
463 snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, c->name);
465 if(stat(fname, &s) || s.st_mtime > last_config_check) {
466 logger(DEBUG_CONNECTIONS, LOG_INFO, "Host config file of %s has been changed", c->name);
467 terminate_connection(c, c->edge);
471 last_config_check = now.tv_sec;
477 /* Reset the reconnection timers for all outgoing connections */
478 for list_each(outgoing_t, outgoing, outgoing_list) {
479 outgoing->timeout = 0;
481 timeout_set(&outgoing->ev, &(struct timeval){0, 0});
484 /* Check for outgoing connections that are in progress, and reset their ping timers */
485 for list_each(connection_t, c, connection_list) {
486 if(c->outgoing && !c->node)
487 c->last_ping_time = 0;
490 /* Kick the ping timeout handler */
491 timeout_set(&pingtimer, &(struct timeval){0, 0});
495 this is where it all happens...
497 int main_loop(void) {
498 last_periodic_run_time = now;
499 timeout_add(&pingtimer, timeout_handler, &pingtimer, &(struct timeval){pingtimeout, rand() % 100000});
500 timeout_add(&periodictimer, periodic_handler, &periodictimer, &(struct timeval){0, 0});
503 signal_t sighup = {0};
504 signal_t sigterm = {0};
505 signal_t sigquit = {0};
506 signal_t sigint = {0};
507 signal_t sigalrm = {0};
509 signal_add(&sighup, sighup_handler, &sighup, SIGHUP);
510 signal_add(&sigterm, sigterm_handler, &sigterm, SIGTERM);
511 signal_add(&sigquit, sigterm_handler, &sigquit, SIGQUIT);
512 signal_add(&sigint, sigterm_handler, &sigint, SIGINT);
513 signal_add(&sigalrm, sigalrm_handler, &sigalrm, SIGALRM);
517 logger(DEBUG_ALWAYS, LOG_ERR, "Error while waiting for input: %s", sockstrerror(sockerrno));
523 signal_del(&sigterm);
524 signal_del(&sigquit);
526 signal_del(&sigalrm);
529 timeout_del(&periodictimer);
530 timeout_del(&pingtimer);