tinc-vpn.org Git - tinc/blob - src/net.c

   1 /*
   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>
   7
   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.
  12
  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.
  17
  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.
  21 */
  22
  23 #include "system.h"
  24
  25 #include "autoconnect.h"
  26 #include "conf.h"
  27 #include "connection.h"
  28 #include "device.h"
  29 #include "graph.h"
  30 #include "logger.h"
  31 #include "meta.h"
  32 #include "names.h"
  33 #include "net.h"
  34 #include "netutl.h"
  35 #include "protocol.h"
  36 #include "subnet.h"
  37 #include "utils.h"
  38 #include "xalloc.h"
  39
  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;
  47
  48 /* Purge edges and subnets of unreachable nodes. Use carefully. */
  49
  50 void purge(void) {
  51         logger(DEBUG_PROTOCOL, LOG_DEBUG, "Purging unreachable nodes");
  52
  53         /* Remove all edges and subnets owned by unreachable nodes. */
  54
  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);
  58
  59                         for splay_each(subnet_t, s, n->subnet_tree) {
  60                                 send_del_subnet(everyone, s);
  61                                 if(!strictsubnets)
  62                                         subnet_del(n, s);
  63                         }
  64
  65                         for splay_each(edge_t, e, n->edge_tree) {
  66                                 if(!tunnelserver)
  67                                         send_del_edge(everyone, e);
  68                                 edge_del(e);
  69                         }
  70                 }
  71         }
  72
  73         /* Check if anyone else claims to have an edge to an unreachable node. If not, delete node. */
  74
  75         for splay_each(node_t, n, node_tree) {
  76                 if(!n->status.reachable) {
  77                         for splay_each(edge_t, e, edge_weight_tree)
  78                                 if(e->to == n)
  79                                         return;
  80
  81                         if(!autoconnect && (!strictsubnets || !n->subnet_tree->head))
  82                                 /* in strictsubnets mode do not delete nodes with subnets */
  83                                 node_del(n);
  84                 }
  85         }
  86 }
  87
  88 /*
  89   Terminate a connection:
  90   - Mark it as inactive
  91   - Remove the edge representing this connection
  92   - Kill it with fire
  93   - Check if we need to retry making an outgoing connection
  94 */
  95 void terminate_connection(connection_t *c, bool report) {
  96         logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Closing connection with %s (%s)", c->name, c->hostname);
  97
  98         if(c->node) {
  99                 if(c->node->connection == c)
 100                         c->node->connection = NULL;
 101
 102                 if(c->edge) {
 103                         if(report && !tunnelserver)
 104                                 send_del_edge(everyone, c->edge);
 105
 106                         edge_del(c->edge);
 107                         c->edge = NULL;
 108
 109                         /* Run MST and SSSP algorithms */
 110
 111                         graph();
 112
 113                         /* If the node is not reachable anymore but we remember it had an edge to us, clean it up */
 114
 115                         if(report && !c->node->status.reachable) {
 116                                 edge_t *e;
 117                                 e = lookup_edge(c->node, myself);
 118                                 if(e) {
 119                                         if(!tunnelserver)
 120                                                 send_del_edge(everyone, e);
 121                                         edge_del(e);
 122                                 }
 123                         }
 124                 }
 125         }
 126
 127         outgoing_t *outgoing = c->outgoing;
 128         connection_del(c);
 129
 130         /* Check if this was our outgoing connection */
 131
 132         if(outgoing)
 133                 do_outgoing_connection(outgoing);
 134
 135 #ifndef HAVE_MINGW
 136         /* Clean up dead proxy processes */
 137
 138         while(waitpid(-1, NULL, WNOHANG) > 0);
 139 #endif
 140 }
 141
 142 /*
 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.
 149 */
 150 static void timeout_handler(void *data) {
 151
 152         bool close_all_connections = false;
 153
 154         /*
 155                  timeout_handler will start after 30 seconds from start of tincd
 156                  hold information about the elapsed time since last time the handler
 157                  has been run
 158         */
 159         long sleep_time = now.tv_sec - last_periodic_run_time.tv_sec;
 160         /*
 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
 165                  by default
 166         */
 167         if (sleep_time > 2 * udp_discovery_timeout) {
 168                 logger(DEBUG_ALWAYS, LOG_ERR, "Awaking from dead after %ld seconds of sleep", sleep_time);
 169                 /*
 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
 177                 */
 178                 close_all_connections = true;
 179         }
 180         last_periodic_run_time = now;
 181
 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)
 185                         continue;
 186
 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);
 190                         continue;
 191                 }
 192
 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)
 195                         continue;
 196
 197                 // timeout during connection establishing
 198                 if(!c->edge) {
 199                         if(c->status.connecting)
 200                                 logger(DEBUG_CONNECTIONS, LOG_WARNING, "Timeout while connecting to %s (%s)", c->name, c->hostname);
 201                         else
 202                                 logger(DEBUG_CONNECTIONS, LOG_WARNING, "Timeout from %s (%s) during authentication", c->name, c->hostname);
 203
 204                         terminate_connection(c, c->edge);
 205                         continue;
 206                 }
 207
 208                 // helps in UDP holepunching
 209                 try_tx(c->node, false);
 210
 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);
 215                         continue;
 216                 }
 217
 218                 // check whether we need to send a new ping
 219                 if(c->last_ping_time + pinginterval <= now.tv_sec)
 220                         send_ping(c);
 221         }
 222
 223         timeout_set(data, &(struct timeval){1, rand() % 100000});
 224 }
 225
 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.
 230         */
 231
 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);
 235                 sleeptime *= 2;
 236                 if(sleeptime < 0)
 237                         sleeptime = 3600;
 238         } else {
 239                 sleeptime /= 2;
 240                 if(sleeptime < 10)
 241                         sleeptime = 10;
 242         }
 243
 244         contradicting_add_edge = 0;
 245         contradicting_del_edge = 0;
 246
 247         /* If AutoConnect is set, check if we need to make or break connections. */
 248
 249         if(autoconnect && node_tree->count > 1)
 250                 do_autoconnect();
 251
 252         timeout_set(data, &(struct timeval){5, rand() % 100000});
 253 }
 254
 255 void handle_meta_connection_data(connection_t *c) {
 256         if (!receive_meta(c)) {
 257                 terminate_connection(c, c->edge);
 258                 return;
 259         }
 260 }
 261
 262 #ifndef HAVE_MINGW
 263 static void sigterm_handler(void *data) {
 264         logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
 265         event_exit();
 266 }
 267
 268 static void sighup_handler(void *data) {
 269         logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
 270         reopenlogger();
 271         if(reload_configuration())
 272                 exit(1);
 273 }
 274
 275 static void sigalrm_handler(void *data) {
 276         logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
 277         retry();
 278 }
 279 #endif
 280
 281 int reload_configuration(void) {
 282         char fname[PATH_MAX];
 283
 284         /* Reread our own configuration file */
 285
 286         exit_configuration(&config_tree);
 287         init_configuration(&config_tree);
 288
 289         if(!read_server_config()) {
 290                 logger(DEBUG_ALWAYS, LOG_ERR, "Unable to reread configuration file.");
 291                 return EINVAL;
 292         }
 293
 294         read_config_options(config_tree, NULL);
 295
 296         snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, myself->name);
 297         read_config_file(config_tree, fname);
 298
 299         /* Parse some options that are allowed to be changed while tinc is running */
 300
 301         setup_myself_reloadable();
 302
 303         /* If StrictSubnet is set, expire deleted Subnets and read new ones in */
 304
 305         if(strictsubnets) {
 306                 for splay_each(subnet_t, subnet, subnet_tree)
 307                         if (subnet->owner)
 308                                 subnet->expires = 1;
 309         }
 310
 311         for splay_each(node_t, n, node_tree)
 312                 n->status.has_address = false;
 313
 314         load_all_nodes();
 315
 316         if(strictsubnets) {
 317                 for splay_each(subnet_t, subnet, subnet_tree) {
 318                         if (!subnet->owner)
 319                                 continue;
 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) {
 326                                 subnet->expires = 0;
 327                         } else {
 328                                 send_add_subnet(everyone, subnet);
 329                                 if(subnet->owner->status.reachable)
 330                                         subnet_update(subnet->owner, subnet, true);
 331                         }
 332                 }
 333         } else { /* Only read our own subnets back in */
 334                 for splay_each(subnet_t, subnet, myself->subnet_tree)
 335                         if(!subnet->expires)
 336                                 subnet->expires = 1;
 337
 338                 config_t *cfg = lookup_config(config_tree, "Subnet");
 339
 340                 while(cfg) {
 341                         subnet_t *subnet, *s2;
 342
 343                         if(!get_config_subnet(cfg, &subnet))
 344                                 continue;
 345
 346                         if((s2 = lookup_subnet(myself, subnet))) {
 347                                 if(s2->expires == 1)
 348                                         s2->expires = 0;
 349
 350                                 free_subnet(subnet);
 351                         } else {
 352                                 subnet_add(myself, subnet);
 353                                 send_add_subnet(everyone, subnet);
 354                                 subnet_update(myself, subnet, true);
 355                         }
 356
 357                         cfg = lookup_config_next(config_tree, cfg);
 358                 }
 359
 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);
 365                         }
 366                 }
 367         }
 368
 369         /* Try to make outgoing connections */
 370
 371         try_outgoing_connections();
 372
 373         /* Close connections to hosts that have a changed or deleted host config file */
 374
 375         for list_each(connection_t, c, connection_list) {
 376                 if(c->status.control)
 377                         continue;
 378
 379                 snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, c->name);
 380                 struct stat s;
 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);
 384                 }
 385         }
 386
 387         last_config_check = now.tv_sec;
 388
 389         return 0;
 390 }
 391
 392 void retry(void) {
 393         /* Reset the reconnection timers for all outgoing connections */
 394         for list_each(outgoing_t, outgoing, outgoing_list) {
 395                 outgoing->timeout = 0;
 396                 if(outgoing->ev.cb)
 397                         timeout_set(&outgoing->ev, &(struct timeval){0, 0});
 398         }
 399
 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;
 404         }
 405
 406         /* Kick the ping timeout handler */
 407         timeout_set(&pingtimer, &(struct timeval){0, 0});
 408 }
 409
 410 /*
 411   this is where it all happens...
 412 */
 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});
 417
 418 #ifndef HAVE_MINGW
 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};
 424
 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);
 430 #endif
 431
 432         if(!event_loop()) {
 433                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while waiting for input: %s", sockstrerror(sockerrno));
 434                 return 1;
 435         }
 436
 437 #ifndef HAVE_MINGW
 438         signal_del(&sighup);
 439         signal_del(&sigterm);
 440         signal_del(&sigquit);
 441         signal_del(&sigint);
 442         signal_del(&sigalrm);
 443 #endif
 444
 445         timeout_del(&periodictimer);
 446         timeout_del(&pingtimer);
 447
 448         return 0;
 449 }