git.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-2015 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 "utils.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 "xalloc.h"
  38
  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;
  46
  47 /* Purge edges and subnets of unreachable nodes. Use carefully. */
  48
  49 void purge(void) {
  50         logger(DEBUG_PROTOCOL, LOG_DEBUG, "Purging unreachable nodes");
  51
  52         /* Remove all edges and subnets owned by unreachable nodes. */
  53
  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);
  57
  58                         for splay_each(subnet_t, s, n->subnet_tree) {
  59                                 send_del_subnet(everyone, s);
  60                                 if(!strictsubnets)
  61                                         subnet_del(n, s);
  62                         }
  63
  64                         for splay_each(edge_t, e, n->edge_tree) {
  65                                 if(!tunnelserver)
  66                                         send_del_edge(everyone, e);
  67                                 edge_del(e);
  68                         }
  69                 }
  70         }
  71
  72         /* Check if anyone else claims to have an edge to an unreachable node. If not, delete node. */
  73
  74         for splay_each(node_t, n, node_tree) {
  75                 if(!n->status.reachable) {
  76                         for splay_each(edge_t, e, edge_weight_tree)
  77                                 if(e->to == n)
  78                                         return;
  79
  80                         if(!autoconnect && (!strictsubnets || !n->subnet_tree->head))
  81                                 /* in strictsubnets mode do not delete nodes with subnets */
  82                                 node_del(n);
  83                 }
  84         }
  85 }
  86
  87 /*
  88   Terminate a connection:
  89   - Mark it as inactive
  90   - Remove the edge representing this connection
  91   - Kill it with fire
  92   - Check if we need to retry making an outgoing connection
  93 */
  94 void terminate_connection(connection_t *c, bool report) {
  95         logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Closing connection with %s (%s)", c->name, c->hostname);
  96
  97         if(c->node) {
  98                 if(c->node->connection == c)
  99                         c->node->connection = NULL;
 100
 101                 if(c->edge) {
 102                         if(report && !tunnelserver)
 103                                 send_del_edge(everyone, c->edge);
 104
 105                         edge_del(c->edge);
 106                         c->edge = NULL;
 107
 108                         /* Run MST and SSSP algorithms */
 109
 110                         graph();
 111
 112                         /* If the node is not reachable anymore but we remember it had an edge to us, clean it up */
 113
 114                         if(report && !c->node->status.reachable) {
 115                                 edge_t *e;
 116                                 e = lookup_edge(c->node, myself);
 117                                 if(e) {
 118                                         if(!tunnelserver)
 119                                                 send_del_edge(everyone, e);
 120                                         edge_del(e);
 121                                 }
 122                         }
 123                 }
 124         }
 125
 126         outgoing_t *outgoing = c->outgoing;
 127         connection_del(c);
 128
 129         /* Check if this was our outgoing connection */
 130
 131         if(outgoing)
 132                 do_outgoing_connection(outgoing);
 133
 134 #ifndef HAVE_MINGW
 135         /* Clean up dead proxy processes */
 136
 137         while(waitpid(-1, NULL, WNOHANG) > 0);
 138 #endif
 139 }
 140
 141 /*
 142   Check if the other end is active.
 143   If we have sent packets, but didn't receive any,
 144   then possibly the other end is dead. We send a
 145   PING request over the meta connection. If the other
 146   end does not reply in time, we consider them dead
 147   and close the connection.
 148 */
 149 static void timeout_handler(void *data) {
 150
 151         bool close_all_connections = false;
 152
 153         /*
 154                  timeout_handler will start after 30 seconds from start of tincd
 155                  hold information about the elapsed time since last time the handler
 156                  has been run
 157         */
 158         long sleep_time = now.tv_sec - last_periodic_run_time.tv_sec;
 159         /*
 160                  It seems that finding sane default value is harder than expected
 161                  Since we send every second a UDP packet to make holepunching work
 162                  And default UDP state expire on firewalls is between 15-30 seconds
 163                  we drop all connections after 60 Seconds - UDPDiscoveryTimeout=30
 164                  by default
 165         */
 166         if (sleep_time > 2 * udp_discovery_timeout) {
 167                 logger(DEBUG_ALWAYS, LOG_ERR, "Awaking from dead after %ld seconds of sleep", sleep_time);
 168                 /*
 169                         Do not send any packets to tinc after we wake up.
 170                         The other node probably closed our connection but we still
 171                         are holding context information to them. This may happen on
 172                         laptops or any other hardware which can be suspended for some time.
 173                         Sending any data to node that wasn't expecting it will produce
 174                         annoying and misleading errors on the other side about failed signature
 175                         verification and or about missing sptps context
 176                 */
 177                 close_all_connections = true;
 178         }
 179         last_periodic_run_time = now;
 180
 181         for list_each(connection_t, c, connection_list) {
 182                 // control connections (eg. tinc ctl) do not have any timeout
 183                 if(c->status.control)
 184                         continue;
 185
 186                 if(close_all_connections) {
 187                         logger(DEBUG_ALWAYS, LOG_ERR, "Forcing connection close after sleep time %s (%s)", c->name, c->hostname);
 188                         terminate_connection(c, c->edge);
 189                         continue;
 190                 }
 191
 192                 // Bail out early if we haven't reached the ping timeout for this node yet
 193                 if(c->last_ping_time + pingtimeout > now.tv_sec)
 194                         continue;
 195
 196                 // timeout during connection establishing
 197                 if(!c->edge) {
 198                         if(c->status.connecting)
 199                                 logger(DEBUG_CONNECTIONS, LOG_WARNING, "Timeout while connecting to %s (%s)", c->name, c->hostname);
 200                         else
 201                                 logger(DEBUG_CONNECTIONS, LOG_WARNING, "Timeout from %s (%s) during authentication", c->name, c->hostname);
 202
 203                         terminate_connection(c, c->edge);
 204                         continue;
 205                 }
 206
 207                 // helps in UDP holepunching
 208                 try_tx(c->node, false);
 209
 210                 // timeout during ping
 211                 if(c->status.pinged) {
 212                         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);
 213                         terminate_connection(c, c->edge);
 214                         continue;
 215                 }
 216
 217                 // check whether we need to send a new ping
 218                 if(c->last_ping_time + pinginterval <= now.tv_sec)
 219                         send_ping(c);
 220         }
 221
 222         timeout_set(data, &(struct timeval){1, rand() % 100000});
 223 }
 224
 225 static void periodic_handler(void *data) {
 226         /* Check if there are too many contradicting ADD_EDGE and DEL_EDGE messages.
 227            This usually only happens when another node has the same Name as this node.
 228            If so, sleep for a short while to prevent a storm of contradicting messages.
 229         */
 230
 231         if(contradicting_del_edge > 100 && contradicting_add_edge > 100) {
 232                 logger(DEBUG_ALWAYS, LOG_WARNING, "Possible node with same Name as us! Sleeping %d seconds.", sleeptime);
 233                 nanosleep(&(struct timespec){sleeptime, 0}, NULL);
 234                 sleeptime *= 2;
 235                 if(sleeptime < 0)
 236                         sleeptime = 3600;
 237         } else {
 238                 sleeptime /= 2;
 239                 if(sleeptime < 10)
 240                         sleeptime = 10;
 241         }
 242
 243         contradicting_add_edge = 0;
 244         contradicting_del_edge = 0;
 245
 246         /* If AutoConnect is set, check if we need to make or break connections. */
 247
 248         if(autoconnect && node_tree->count > 1) {
 249                 /* Count number of active connections */
 250                 int nc = 0;
 251                 for list_each(connection_t, c, connection_list) {
 252                         if(c->edge)
 253                                 nc++;
 254                 }
 255
 256                 if(nc < 3) {
 257                         /* Not enough active connections, try to add one.
 258                            Choose a random node, if we don't have a connection to it,
 259                            and we are not already trying to make one, create an
 260                            outgoing connection to this node.
 261                         */
 262                         int count = 0;
 263                         for splay_each(node_t, n, node_tree) {
 264                                 if(n == myself || n->connection || !(n->status.has_address || n->status.reachable))
 265                                         continue;
 266                                 count++;
 267                         }
 268
 269                         if(!count)
 270                                 goto end;
 271
 272                         int r = rand() % count;
 273
 274                         for splay_each(node_t, n, node_tree) {
 275                                 if(n == myself || n->connection || !(n->status.has_address || n->status.reachable))
 276                                         continue;
 277
 278                                 if(r--)
 279                                         continue;
 280
 281                                 bool found = false;
 282
 283                                 for list_each(outgoing_t, outgoing, outgoing_list) {
 284                                         if(!strcmp(outgoing->name, n->name)) {
 285                                                 found = true;
 286                                                 break;
 287                                         }
 288                                 }
 289
 290                                 if(!found) {
 291                                         logger(DEBUG_CONNECTIONS, LOG_INFO, "Autoconnecting to %s", n->name);
 292                                         outgoing_t *outgoing = xzalloc(sizeof *outgoing);
 293                                         outgoing->name = xstrdup(n->name);
 294                                         list_insert_tail(outgoing_list, outgoing);
 295                                         setup_outgoing_connection(outgoing);
 296                                 }
 297
 298                                 break;
 299                         }
 300                 } else if(nc > 3) {
 301                         /* Too many active connections, try to remove one.
 302                            Choose a random outgoing connection to a node
 303                            that has at least one other connection.
 304                         */
 305                         int r = rand() % nc;
 306                         int i = 0;
 307
 308                         for list_each(connection_t, c, connection_list) {
 309                                 if(!c->edge)
 310                                         continue;
 311
 312                                 if(i++ != r)
 313                                         continue;
 314
 315                                 if(!c->outgoing || !c->node || c->node->edge_tree->count < 2)
 316                                         break;
 317
 318                                 logger(DEBUG_CONNECTIONS, LOG_INFO, "Autodisconnecting from %s", c->name);
 319                                 list_delete(outgoing_list, c->outgoing);
 320                                 c->outgoing = NULL;
 321                                 terminate_connection(c, c->edge);
 322                                 break;
 323                         }
 324                 }
 325
 326                 if(nc >= 3) {
 327                         /* If we have enough active connections,
 328                            remove any pending outgoing connections.
 329                         */
 330                         for list_each(outgoing_t, o, outgoing_list) {
 331                                 bool found = false;
 332                                 for list_each(connection_t, c, connection_list) {
 333                                         if(c->outgoing == o) {
 334                                                 found = true;
 335                                                 break;
 336                                         }
 337                                 }
 338                                 if(!found) {
 339                                         logger(DEBUG_CONNECTIONS, LOG_INFO, "Cancelled outgoing connection to %s", o->name);
 340                                         list_delete_node(outgoing_list, node);
 341                                 }
 342                         }
 343                 }
 344         }
 345
 346 end:
 347         timeout_set(data, &(struct timeval){5, rand() % 100000});
 348 }
 349
 350 void handle_meta_connection_data(connection_t *c) {
 351         if (!receive_meta(c)) {
 352                 terminate_connection(c, c->edge);
 353                 return;
 354         }
 355 }
 356
 357 #ifndef HAVE_MINGW
 358 static void sigterm_handler(void *data) {
 359         logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
 360         event_exit();
 361 }
 362
 363 static void sighup_handler(void *data) {
 364         logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
 365         reopenlogger();
 366         if(reload_configuration())
 367                 exit(1);
 368 }
 369
 370 static void sigalrm_handler(void *data) {
 371         logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
 372         retry();
 373 }
 374 #endif
 375
 376 int reload_configuration(void) {
 377         char fname[PATH_MAX];
 378
 379         /* Reread our own configuration file */
 380
 381         exit_configuration(&config_tree);
 382         init_configuration(&config_tree);
 383
 384         if(!read_server_config()) {
 385                 logger(DEBUG_ALWAYS, LOG_ERR, "Unable to reread configuration file.");
 386                 return EINVAL;
 387         }
 388
 389         read_config_options(config_tree, NULL);
 390
 391         snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, myself->name);
 392         read_config_file(config_tree, fname);
 393
 394         /* Parse some options that are allowed to be changed while tinc is running */
 395
 396         setup_myself_reloadable();
 397
 398         /* If StrictSubnet is set, expire deleted Subnets and read new ones in */
 399
 400         if(strictsubnets) {
 401                 for splay_each(subnet_t, subnet, subnet_tree)
 402                         if (subnet->owner)
 403                                 subnet->expires = 1;
 404         }
 405
 406         for splay_each(node_t, n, node_tree)
 407                 n->status.has_address = false;
 408
 409         load_all_nodes();
 410
 411         if(strictsubnets) {
 412                 for splay_each(subnet_t, subnet, subnet_tree) {
 413                         if (!subnet->owner)
 414                                 continue;
 415                         if(subnet->expires == 1) {
 416                                 send_del_subnet(everyone, subnet);
 417                                 if(subnet->owner->status.reachable)
 418                                         subnet_update(subnet->owner, subnet, false);
 419                                 subnet_del(subnet->owner, subnet);
 420                         } else if(subnet->expires == -1) {
 421                                 subnet->expires = 0;
 422                         } else {
 423                                 send_add_subnet(everyone, subnet);
 424                                 if(subnet->owner->status.reachable)
 425                                         subnet_update(subnet->owner, subnet, true);
 426                         }
 427                 }
 428         } else { /* Only read our own subnets back in */
 429                 for splay_each(subnet_t, subnet, myself->subnet_tree)
 430                         if(!subnet->expires)
 431                                 subnet->expires = 1;
 432
 433                 config_t *cfg = lookup_config(config_tree, "Subnet");
 434
 435                 while(cfg) {
 436                         subnet_t *subnet, *s2;
 437
 438                         if(!get_config_subnet(cfg, &subnet))
 439                                 continue;
 440
 441                         if((s2 = lookup_subnet(myself, subnet))) {
 442                                 if(s2->expires == 1)
 443                                         s2->expires = 0;
 444
 445                                 free_subnet(subnet);
 446                         } else {
 447                                 subnet_add(myself, subnet);
 448                                 send_add_subnet(everyone, subnet);
 449                                 subnet_update(myself, subnet, true);
 450                         }
 451
 452                         cfg = lookup_config_next(config_tree, cfg);
 453                 }
 454
 455                 for splay_each(subnet_t, subnet, myself->subnet_tree) {
 456                         if(subnet->expires == 1) {
 457                                 send_del_subnet(everyone, subnet);
 458                                 subnet_update(myself, subnet, false);
 459                                 subnet_del(myself, subnet);
 460                         }
 461                 }
 462         }
 463
 464         /* Try to make outgoing connections */
 465
 466         try_outgoing_connections();
 467
 468         /* Close connections to hosts that have a changed or deleted host config file */
 469
 470         for list_each(connection_t, c, connection_list) {
 471                 if(c->status.control)
 472                         continue;
 473
 474                 snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, c->name);
 475                 struct stat s;
 476                 if(stat(fname, &s) || s.st_mtime > last_config_check) {
 477                         logger(DEBUG_CONNECTIONS, LOG_INFO, "Host config file of %s has been changed", c->name);
 478                         terminate_connection(c, c->edge);
 479                 }
 480         }
 481
 482         last_config_check = now.tv_sec;
 483
 484         return 0;
 485 }
 486
 487 void retry(void) {
 488         /* Reset the reconnection timers for all outgoing connections */
 489         for list_each(outgoing_t, outgoing, outgoing_list) {
 490                 outgoing->timeout = 0;
 491                 if(outgoing->ev.cb)
 492                         timeout_set(&outgoing->ev, &(struct timeval){0, 0});
 493         }
 494
 495         /* Check for outgoing connections that are in progress, and reset their ping timers */
 496         for list_each(connection_t, c, connection_list) {
 497                 if(c->outgoing && !c->node)
 498                         c->last_ping_time = 0;
 499         }
 500
 501         /* Kick the ping timeout handler */
 502         timeout_set(&pingtimer, &(struct timeval){0, 0});
 503 }
 504
 505 /*
 506   this is where it all happens...
 507 */
 508 int main_loop(void) {
 509         last_periodic_run_time = now;
 510         timeout_add(&pingtimer, timeout_handler, &pingtimer, &(struct timeval){pingtimeout, rand() % 100000});
 511         timeout_add(&periodictimer, periodic_handler, &periodictimer, &(struct timeval){0, 0});
 512
 513 #ifndef HAVE_MINGW
 514         signal_t sighup = {0};
 515         signal_t sigterm = {0};
 516         signal_t sigquit = {0};
 517         signal_t sigint = {0};
 518         signal_t sigalrm = {0};
 519
 520         signal_add(&sighup, sighup_handler, &sighup, SIGHUP);
 521         signal_add(&sigterm, sigterm_handler, &sigterm, SIGTERM);
 522         signal_add(&sigquit, sigterm_handler, &sigquit, SIGQUIT);
 523         signal_add(&sigint, sigterm_handler, &sigint, SIGINT);
 524         signal_add(&sigalrm, sigalrm_handler, &sigalrm, SIGALRM);
 525 #endif
 526
 527         if(!event_loop()) {
 528                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while waiting for input: %s", sockstrerror(sockerrno));
 529                 return 1;
 530         }
 531
 532 #ifndef HAVE_MINGW
 533         signal_del(&sighup);
 534         signal_del(&sigterm);
 535         signal_del(&sigquit);
 536         signal_del(&sigint);
 537         signal_del(&sigalrm);
 538 #endif
 539
 540         timeout_del(&periodictimer);
 541         timeout_del(&pingtimer);
 542
 543         return 0;
 544 }