2 net.c -- most of the network code
3 Copyright (C) 1998-2005 Ivo Timmermans,
4 2000-2017 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.
25 #include "autoconnect.h"
27 #include "connection.h"
40 int contradicting_add_edge = 0;
41 int contradicting_del_edge = 0;
42 static int sleeptime = 10;
43 time_t last_config_check = 0;
44 static timeout_t pingtimer;
45 static timeout_t periodictimer;
46 static struct timeval last_periodic_run_time;
48 /* Purge edges and subnets of unreachable nodes. Use carefully. */
51 logger(DEBUG_PROTOCOL, LOG_DEBUG, "Purging unreachable nodes");
53 /* Remove all edges and subnets owned by unreachable nodes. */
55 for splay_each(node_t, n, node_tree) {
56 if(!n->status.reachable) {
57 logger(DEBUG_SCARY_THINGS, LOG_DEBUG, "Purging node %s (%s)", n->name, n->hostname);
59 for splay_each(subnet_t, s, n->subnet_tree) {
60 send_del_subnet(everyone, s);
67 for splay_each(edge_t, e, n->edge_tree) {
69 send_del_edge(everyone, e);
77 /* Check if anyone else claims to have an edge to an unreachable node. If not, delete node. */
79 for splay_each(node_t, n, node_tree) {
80 if(!n->status.reachable) {
81 for splay_each(edge_t, e, edge_weight_tree)
86 if(!autoconnect && (!strictsubnets || !n->subnet_tree->head))
87 /* in strictsubnets mode do not delete nodes with subnets */
96 Terminate a connection:
98 - Remove the edge representing this connection
100 - Check if we need to retry making an outgoing connection
102 void terminate_connection(connection_t *c, bool report) {
103 logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Closing connection with %s (%s)", c->name, c->hostname);
106 if(c->node->connection == c) {
107 c->node->connection = NULL;
111 if(report && !tunnelserver) {
112 send_del_edge(everyone, c->edge);
118 /* Run MST and SSSP algorithms */
122 /* If the node is not reachable anymore but we remember it had an edge to us, clean it up */
124 if(report && !c->node->status.reachable) {
126 e = lookup_edge(c->node, myself);
130 send_del_edge(everyone, e);
139 outgoing_t *outgoing = c->outgoing;
142 /* Check if this was our outgoing connection */
145 do_outgoing_connection(outgoing);
149 /* Clean up dead proxy processes */
151 while(waitpid(-1, NULL, WNOHANG) > 0);
157 Check if the other end is active.
158 If we have sent packets, but didn't receive any,
159 then possibly the other end is dead. We send a
160 PING request over the meta connection. If the other
161 end does not reply in time, we consider them dead
162 and close the connection.
164 static void timeout_handler(void *data) {
166 bool close_all_connections = false;
169 timeout_handler will start after 30 seconds from start of tincd
170 hold information about the elapsed time since last time the handler
173 long sleep_time = now.tv_sec - last_periodic_run_time.tv_sec;
176 It seems that finding sane default value is harder than expected
177 Since we send every second a UDP packet to make holepunching work
178 And default UDP state expire on firewalls is between 15-30 seconds
179 we drop all connections after 60 Seconds - UDPDiscoveryTimeout=30
182 if(sleep_time > 2 * udp_discovery_timeout) {
183 logger(DEBUG_ALWAYS, LOG_ERR, "Awaking from dead after %ld seconds of sleep", sleep_time);
185 Do not send any packets to tinc after we wake up.
186 The other node probably closed our connection but we still
187 are holding context information to them. This may happen on
188 laptops or any other hardware which can be suspended for some time.
189 Sending any data to node that wasn't expecting it will produce
190 annoying and misleading errors on the other side about failed signature
191 verification and or about missing sptps context
193 close_all_connections = true;
196 last_periodic_run_time = now;
198 for list_each(connection_t, c, connection_list) {
199 // control connections (eg. tinc ctl) do not have any timeout
200 if(c->status.control) {
204 if(close_all_connections) {
205 logger(DEBUG_ALWAYS, LOG_ERR, "Forcing connection close after sleep time %s (%s)", c->name, c->hostname);
206 terminate_connection(c, c->edge);
210 // Bail out early if we haven't reached the ping timeout for this node yet
211 if(c->last_ping_time + pingtimeout > now.tv_sec) {
215 // timeout during connection establishing
217 if(c->status.connecting) {
218 logger(DEBUG_CONNECTIONS, LOG_WARNING, "Timeout while connecting to %s (%s)", c->name, c->hostname);
220 logger(DEBUG_CONNECTIONS, LOG_WARNING, "Timeout from %s (%s) during authentication", c->name, c->hostname);
223 terminate_connection(c, c->edge);
227 // helps in UDP holepunching
228 try_tx(c->node, false);
230 // timeout during ping
231 if(c->status.pinged) {
232 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));
233 terminate_connection(c, c->edge);
237 // check whether we need to send a new ping
238 if(c->last_ping_time + pinginterval <= now.tv_sec) {
243 timeout_set(data, &(struct timeval) {
248 static void periodic_handler(void *data) {
249 /* Check if there are too many contradicting ADD_EDGE and DEL_EDGE messages.
250 This usually only happens when another node has the same Name as this node.
251 If so, sleep for a short while to prevent a storm of contradicting messages.
254 if(contradicting_del_edge > 100 && contradicting_add_edge > 100) {
255 logger(DEBUG_ALWAYS, LOG_WARNING, "Possible node with same Name as us! Sleeping %d seconds.", sleeptime);
256 nanosleep(&(struct timespec) {
272 contradicting_add_edge = 0;
273 contradicting_del_edge = 0;
275 /* If AutoConnect is set, check if we need to make or break connections. */
277 if(autoconnect && node_tree->count > 1) {
281 timeout_set(data, &(struct timeval) {
286 void handle_meta_connection_data(connection_t *c) {
287 if(!receive_meta(c)) {
288 terminate_connection(c, c->edge);
294 static void sigterm_handler(void *data) {
295 logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
299 static void sighup_handler(void *data) {
300 logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
303 if(reload_configuration()) {
308 static void sigalrm_handler(void *data) {
309 logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
314 int reload_configuration(void) {
315 char fname[PATH_MAX];
317 /* Reread our own configuration file */
319 exit_configuration(&config_tree);
320 init_configuration(&config_tree);
322 if(!read_server_config()) {
323 logger(DEBUG_ALWAYS, LOG_ERR, "Unable to reread configuration file.");
327 read_config_options(config_tree, NULL);
329 snprintf(fname, sizeof(fname), "%s" SLASH "hosts" SLASH "%s", confbase, myself->name);
330 read_config_file(config_tree, fname, true);
332 /* Parse some options that are allowed to be changed while tinc is running */
334 setup_myself_reloadable();
336 /* If StrictSubnet is set, expire deleted Subnets and read new ones in */
339 for splay_each(subnet_t, subnet, subnet_tree)
345 for splay_each(node_t, n, node_tree) {
346 n->status.has_address = false;
352 for splay_each(subnet_t, subnet, subnet_tree) {
357 if(subnet->expires == 1) {
358 send_del_subnet(everyone, subnet);
360 if(subnet->owner->status.reachable) {
361 subnet_update(subnet->owner, subnet, false);
364 subnet_del(subnet->owner, subnet);
365 } else if(subnet->expires == -1) {
368 send_add_subnet(everyone, subnet);
370 if(subnet->owner->status.reachable) {
371 subnet_update(subnet->owner, subnet, true);
375 } else { /* Only read our own subnets back in */
376 for splay_each(subnet_t, subnet, myself->subnet_tree)
377 if(!subnet->expires) {
381 config_t *cfg = lookup_config(config_tree, "Subnet");
384 subnet_t *subnet, *s2;
386 if(!get_config_subnet(cfg, &subnet)) {
390 if((s2 = lookup_subnet(myself, subnet))) {
391 if(s2->expires == 1) {
397 subnet_add(myself, subnet);
398 send_add_subnet(everyone, subnet);
399 subnet_update(myself, subnet, true);
402 cfg = lookup_config_next(config_tree, cfg);
405 for splay_each(subnet_t, subnet, myself->subnet_tree) {
406 if(subnet->expires == 1) {
407 send_del_subnet(everyone, subnet);
408 subnet_update(myself, subnet, false);
409 subnet_del(myself, subnet);
414 /* Try to make outgoing connections */
416 try_outgoing_connections();
418 /* Close connections to hosts that have a changed or deleted host config file */
420 for list_each(connection_t, c, connection_list) {
421 if(c->status.control) {
425 snprintf(fname, sizeof(fname), "%s" SLASH "hosts" SLASH "%s", confbase, c->name);
428 if(stat(fname, &s) || s.st_mtime > last_config_check) {
429 logger(DEBUG_CONNECTIONS, LOG_INFO, "Host config file of %s has been changed", c->name);
430 terminate_connection(c, c->edge);
434 last_config_check = now.tv_sec;
440 /* Reset the reconnection timers for all outgoing connections */
441 for list_each(outgoing_t, outgoing, outgoing_list) {
442 outgoing->timeout = 0;
445 timeout_set(&outgoing->ev, &(struct timeval) {
450 /* Check for outgoing connections that are in progress, and reset their ping timers */
451 for list_each(connection_t, c, connection_list) {
452 if(c->outgoing && !c->node) {
453 c->last_ping_time = 0;
457 /* Kick the ping timeout handler */
458 timeout_set(&pingtimer, &(struct timeval) {
464 this is where it all happens...
466 int main_loop(void) {
467 last_periodic_run_time = now;
468 timeout_add(&pingtimer, timeout_handler, &pingtimer, &(struct timeval) {
469 pingtimeout, rand() % 100000
471 timeout_add(&periodictimer, periodic_handler, &periodictimer, &(struct timeval) {
476 signal_t sighup = {0};
477 signal_t sigterm = {0};
478 signal_t sigquit = {0};
479 signal_t sigint = {0};
480 signal_t sigalrm = {0};
482 signal_add(&sighup, sighup_handler, &sighup, SIGHUP);
483 signal_add(&sigterm, sigterm_handler, &sigterm, SIGTERM);
484 signal_add(&sigquit, sigterm_handler, &sigquit, SIGQUIT);
485 signal_add(&sigint, sigterm_handler, &sigint, SIGINT);
486 signal_add(&sigalrm, sigalrm_handler, &sigalrm, SIGALRM);
490 logger(DEBUG_ALWAYS, LOG_ERR, "Error while waiting for input: %s", sockstrerror(sockerrno));
496 signal_del(&sigterm);
497 signal_del(&sigquit);
499 signal_del(&sigalrm);
502 timeout_del(&periodictimer);
503 timeout_del(&pingtimer);