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.
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);
65 for splay_each(edge_t, e, n->edge_tree) {
67 send_del_edge(everyone, e);
73 /* Check if anyone else claims to have an edge to an unreachable node. If not, delete node. */
75 for splay_each(node_t, n, node_tree) {
76 if(!n->status.reachable) {
77 for splay_each(edge_t, e, edge_weight_tree)
81 if(!autoconnect && (!strictsubnets || !n->subnet_tree->head))
82 /* in strictsubnets mode do not delete nodes with subnets */
89 Terminate a connection:
91 - Remove the edge representing this connection
93 - Check if we need to retry making an outgoing connection
95 void terminate_connection(connection_t *c, bool report) {
96 logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Closing connection with %s (%s)", c->name, c->hostname);
99 if(c->node->connection == c)
100 c->node->connection = NULL;
103 if(report && !tunnelserver)
104 send_del_edge(everyone, c->edge);
109 /* Run MST and SSSP algorithms */
113 /* If the node is not reachable anymore but we remember it had an edge to us, clean it up */
115 if(report && !c->node->status.reachable) {
117 e = lookup_edge(c->node, myself);
120 send_del_edge(everyone, e);
127 outgoing_t *outgoing = c->outgoing;
130 /* Check if this was our outgoing connection */
133 do_outgoing_connection(outgoing);
136 /* Clean up dead proxy processes */
138 while(waitpid(-1, NULL, WNOHANG) > 0);
143 Check if the other end is active.
144 If we have sent packets, but didn't receive any,
145 then possibly the other end is dead. We send a
146 PING request over the meta connection. If the other
147 end does not reply in time, we consider them dead
148 and close the connection.
150 static void timeout_handler(void *data) {
152 bool close_all_connections = false;
155 timeout_handler will start after 30 seconds from start of tincd
156 hold information about the elapsed time since last time the handler
159 long sleep_time = now.tv_sec - last_periodic_run_time.tv_sec;
161 It seems that finding sane default value is harder than expected
162 Since we send every second a UDP packet to make holepunching work
163 And default UDP state expire on firewalls is between 15-30 seconds
164 we drop all connections after 60 Seconds - UDPDiscoveryTimeout=30
167 if (sleep_time > 2 * udp_discovery_timeout) {
168 logger(DEBUG_ALWAYS, LOG_ERR, "Awaking from dead after %ld seconds of sleep", sleep_time);
170 Do not send any packets to tinc after we wake up.
171 The other node probably closed our connection but we still
172 are holding context information to them. This may happen on
173 laptops or any other hardware which can be suspended for some time.
174 Sending any data to node that wasn't expecting it will produce
175 annoying and misleading errors on the other side about failed signature
176 verification and or about missing sptps context
178 close_all_connections = true;
180 last_periodic_run_time = now;
182 for list_each(connection_t, c, connection_list) {
183 // control connections (eg. tinc ctl) do not have any timeout
184 if(c->status.control)
187 if(close_all_connections) {
188 logger(DEBUG_ALWAYS, LOG_ERR, "Forcing connection close after sleep time %s (%s)", c->name, c->hostname);
189 terminate_connection(c, c->edge);
193 // Bail out early if we haven't reached the ping timeout for this node yet
194 if(c->last_ping_time + pingtimeout > now.tv_sec)
197 // timeout during connection establishing
199 if(c->status.connecting)
200 logger(DEBUG_CONNECTIONS, LOG_WARNING, "Timeout while connecting to %s (%s)", c->name, c->hostname);
202 logger(DEBUG_CONNECTIONS, LOG_WARNING, "Timeout from %s (%s) during authentication", c->name, c->hostname);
204 terminate_connection(c, c->edge);
208 // helps in UDP holepunching
209 try_tx(c->node, false);
211 // timeout during ping
212 if(c->status.pinged) {
213 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));
214 terminate_connection(c, c->edge);
218 // check whether we need to send a new ping
219 if(c->last_ping_time + pinginterval <= now.tv_sec)
223 timeout_set(data, &(struct timeval){1, rand() % 100000});
226 static void periodic_handler(void *data) {
227 /* Check if there are too many contradicting ADD_EDGE and DEL_EDGE messages.
228 This usually only happens when another node has the same Name as this node.
229 If so, sleep for a short while to prevent a storm of contradicting messages.
232 if(contradicting_del_edge > 100 && contradicting_add_edge > 100) {
233 logger(DEBUG_ALWAYS, LOG_WARNING, "Possible node with same Name as us! Sleeping %d seconds.", sleeptime);
234 nanosleep(&(struct timespec){sleeptime, 0}, NULL);
244 contradicting_add_edge = 0;
245 contradicting_del_edge = 0;
247 /* If AutoConnect is set, check if we need to make or break connections. */
249 if(autoconnect && node_tree->count > 1)
252 timeout_set(data, &(struct timeval){5, rand() % 100000});
255 void handle_meta_connection_data(connection_t *c) {
256 if (!receive_meta(c)) {
257 terminate_connection(c, c->edge);
263 static void sigterm_handler(void *data) {
264 logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
268 static void sighup_handler(void *data) {
269 logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
271 if(reload_configuration())
275 static void sigalrm_handler(void *data) {
276 logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
281 int reload_configuration(void) {
282 char fname[PATH_MAX];
284 /* Reread our own configuration file */
286 exit_configuration(&config_tree);
287 init_configuration(&config_tree);
289 if(!read_server_config()) {
290 logger(DEBUG_ALWAYS, LOG_ERR, "Unable to reread configuration file.");
294 read_config_options(config_tree, NULL);
296 snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, myself->name);
297 read_config_file(config_tree, fname);
299 /* Parse some options that are allowed to be changed while tinc is running */
301 setup_myself_reloadable();
303 /* If StrictSubnet is set, expire deleted Subnets and read new ones in */
306 for splay_each(subnet_t, subnet, subnet_tree)
311 for splay_each(node_t, n, node_tree)
312 n->status.has_address = false;
317 for splay_each(subnet_t, subnet, subnet_tree) {
320 if(subnet->expires == 1) {
321 send_del_subnet(everyone, subnet);
322 if(subnet->owner->status.reachable)
323 subnet_update(subnet->owner, subnet, false);
324 subnet_del(subnet->owner, subnet);
325 } else if(subnet->expires == -1) {
328 send_add_subnet(everyone, subnet);
329 if(subnet->owner->status.reachable)
330 subnet_update(subnet->owner, subnet, true);
333 } else { /* Only read our own subnets back in */
334 for splay_each(subnet_t, subnet, myself->subnet_tree)
338 config_t *cfg = lookup_config(config_tree, "Subnet");
341 subnet_t *subnet, *s2;
343 if(!get_config_subnet(cfg, &subnet))
346 if((s2 = lookup_subnet(myself, subnet))) {
352 subnet_add(myself, subnet);
353 send_add_subnet(everyone, subnet);
354 subnet_update(myself, subnet, true);
357 cfg = lookup_config_next(config_tree, cfg);
360 for splay_each(subnet_t, subnet, myself->subnet_tree) {
361 if(subnet->expires == 1) {
362 send_del_subnet(everyone, subnet);
363 subnet_update(myself, subnet, false);
364 subnet_del(myself, subnet);
369 /* Try to make outgoing connections */
371 try_outgoing_connections();
373 /* Close connections to hosts that have a changed or deleted host config file */
375 for list_each(connection_t, c, connection_list) {
376 if(c->status.control)
379 snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, c->name);
381 if(stat(fname, &s) || s.st_mtime > last_config_check) {
382 logger(DEBUG_CONNECTIONS, LOG_INFO, "Host config file of %s has been changed", c->name);
383 terminate_connection(c, c->edge);
387 last_config_check = now.tv_sec;
393 /* Reset the reconnection timers for all outgoing connections */
394 for list_each(outgoing_t, outgoing, outgoing_list) {
395 outgoing->timeout = 0;
397 timeout_set(&outgoing->ev, &(struct timeval){0, 0});
400 /* Check for outgoing connections that are in progress, and reset their ping timers */
401 for list_each(connection_t, c, connection_list) {
402 if(c->outgoing && !c->node)
403 c->last_ping_time = 0;
406 /* Kick the ping timeout handler */
407 timeout_set(&pingtimer, &(struct timeval){0, 0});
411 this is where it all happens...
413 int main_loop(void) {
414 last_periodic_run_time = now;
415 timeout_add(&pingtimer, timeout_handler, &pingtimer, &(struct timeval){pingtimeout, rand() % 100000});
416 timeout_add(&periodictimer, periodic_handler, &periodictimer, &(struct timeval){0, 0});
419 signal_t sighup = {0};
420 signal_t sigterm = {0};
421 signal_t sigquit = {0};
422 signal_t sigint = {0};
423 signal_t sigalrm = {0};
425 signal_add(&sighup, sighup_handler, &sighup, SIGHUP);
426 signal_add(&sigterm, sigterm_handler, &sigterm, SIGTERM);
427 signal_add(&sigquit, sigterm_handler, &sigquit, SIGQUIT);
428 signal_add(&sigint, sigterm_handler, &sigint, SIGINT);
429 signal_add(&sigalrm, sigalrm_handler, &sigalrm, SIGALRM);
433 logger(DEBUG_ALWAYS, LOG_ERR, "Error while waiting for input: %s", sockstrerror(sockerrno));
439 signal_del(&sigterm);
440 signal_del(&sigquit);
442 signal_del(&sigalrm);
445 timeout_del(&periodictimer);
446 timeout_del(&pingtimer);