www.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 && c->node->connection == c)
  98                 c->node->connection = NULL;
  99
 100         if(c->edge) {
 101                 if(report && !tunnelserver)
 102                         send_del_edge(everyone, c->edge);
 103
 104                 edge_del(c->edge);
 105                 c->edge = NULL;
 106
 107                 /* Run MST and SSSP algorithms */
 108
 109                 graph();
 110
 111                 /* If the node is not reachable anymore but we remember it had an edge to us, clean it up */
 112
 113                 if(report && !c->node->status.reachable) {
 114                         edge_t *e;
 115                         e = lookup_edge(c->node, myself);
 116                         if(e) {
 117                                 if(!tunnelserver)
 118                                         send_del_edge(everyone, e);
 119                                 edge_del(e);
 120                         }
 121                 }
 122         }
 123
 124         outgoing_t *outgoing = c->outgoing;
 125         connection_del(c);
 126
 127         /* Check if this was our outgoing connection */
 128
 129         if(outgoing)
 130                 do_outgoing_connection(outgoing);
 131
 132 #ifndef HAVE_MINGW
 133         /* Clean up dead proxy processes */
 134
 135         while(waitpid(-1, NULL, WNOHANG) > 0);
 136 #endif
 137 }
 138
 139 /*
 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.
 146 */
 147 static void timeout_handler(void *data) {
 148
 149         bool close_all_connections = false;
 150
 151         /*
 152                  timeout_hanlder will start after 30 seconds from start of tincd
 153                  hold information about the elapsed time since last time the handler
 154                  has been run
 155         */
 156         long sleep_time = now.tv_sec - last_periodic_run_time.tv_sec;
 157         /*
 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
 162                  by default
 163         */
 164         if (sleep_time > 2 * udp_discovery_timeout) {
 165                 logger(DEBUG_ALWAYS, LOG_ERR, "Awaking from dead after %ld seconds of sleep", sleep_time);
 166                 /*
 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
 174                 */
 175                 close_all_connections = true;
 176         }
 177         last_periodic_run_time = now;
 178
 179         for list_each(connection_t, c, connection_list) {
 180                 if(c->status.control)
 181                         continue;
 182
 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);
 186                         continue;
 187                 }
 188
 189                 if(c->last_ping_time + pingtimeout <= now.tv_sec) {
 190                         if(c->edge) {
 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) {
 195                                         send_ping(c);
 196                                         continue;
 197                                 } else {
 198                                         continue;
 199                                 }
 200                         } else {
 201                                 if(c->status.connecting)
 202                                         logger(DEBUG_CONNECTIONS, LOG_WARNING, "Timeout while connecting to %s (%s)", c->name, c->hostname);
 203                                 else
 204                                         logger(DEBUG_CONNECTIONS, LOG_WARNING, "Timeout from %s (%s) during authentication", c->name, c->hostname);
 205                         }
 206                         terminate_connection(c, c->edge);
 207                 }
 208
 209         }
 210
 211         timeout_set(data, &(struct timeval){1, rand() % 100000});
 212 }
 213
 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.
 218         */
 219
 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);
 223                 sleeptime *= 2;
 224                 if(sleeptime < 0)
 225                         sleeptime = 3600;
 226         } else {
 227                 sleeptime /= 2;
 228                 if(sleeptime < 10)
 229                         sleeptime = 10;
 230         }
 231
 232         contradicting_add_edge = 0;
 233         contradicting_del_edge = 0;
 234
 235         /* If AutoConnect is set, check if we need to make or break connections. */
 236
 237         if(autoconnect && node_tree->count > 1) {
 238                 /* Count number of active connections */
 239                 int nc = 0;
 240                 for list_each(connection_t, c, connection_list) {
 241                         if(c->edge)
 242                                 nc++;
 243                 }
 244
 245                 if(nc < 3) {
 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.
 250                         */
 251                         int count = 0;
 252                         for splay_each(node_t, n, node_tree) {
 253                                 if(n == myself || n->connection || !(n->status.has_address || n->status.reachable))
 254                                         continue;
 255                                 count++;
 256                         }
 257
 258                         if(!count)
 259                                 goto end;
 260
 261                         int r = rand() % count;
 262
 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
 267                                 if(r--)
 268                                         continue;
 269
 270                                 bool found = false;
 271
 272                                 for list_each(outgoing_t, outgoing, outgoing_list) {
 273                                         if(!strcmp(outgoing->name, n->name)) {
 274                                                 found = true;
 275                                                 break;
 276                                         }
 277                                 }
 278
 279                                 if(!found) {
 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);
 285                                 }
 286
 287                                 break;
 288                         }
 289                 } else if(nc > 3) {
 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.
 293                         */
 294                         int r = rand() % nc;
 295                         int i = 0;
 296
 297                         for list_each(connection_t, c, connection_list) {
 298                                 if(!c->edge)
 299                                         continue;
 300
 301                                 if(i++ != r)
 302                                         continue;
 303
 304                                 if(!c->outgoing || !c->node || c->node->edge_tree->count < 2)
 305                                         break;
 306
 307                                 logger(DEBUG_CONNECTIONS, LOG_INFO, "Autodisconnecting from %s", c->name);
 308                                 list_delete(outgoing_list, c->outgoing);
 309                                 c->outgoing = NULL;
 310                                 terminate_connection(c, c->edge);
 311                                 break;
 312                         }
 313                 }
 314
 315                 if(nc >= 3) {
 316                         /* If we have enough active connections,
 317                            remove any pending outgoing connections.
 318                         */
 319                         for list_each(outgoing_t, o, outgoing_list) {
 320                                 bool found = false;
 321                                 for list_each(connection_t, c, connection_list) {
 322                                         if(c->outgoing == o) {
 323                                                 found = true;
 324                                                 break;
 325                                         }
 326                                 }
 327                                 if(!found) {
 328                                         logger(DEBUG_CONNECTIONS, LOG_INFO, "Cancelled outgoing connection to %s", o->name);
 329                                         list_delete_node(outgoing_list, node);
 330                                 }
 331                         }
 332                 }
 333         }
 334
 335 end:
 336         timeout_set(data, &(struct timeval){5, rand() % 100000});
 337 }
 338
 339 void handle_meta_connection_data(connection_t *c) {
 340         if (!receive_meta(c)) {
 341                 terminate_connection(c, c->edge);
 342                 return;
 343         }
 344 }
 345
 346 #ifndef HAVE_MINGW
 347 static void sigterm_handler(void *data) {
 348         logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
 349         event_exit();
 350 }
 351
 352 static void sighup_handler(void *data) {
 353         logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
 354         reopenlogger();
 355         if(reload_configuration())
 356                 exit(1);
 357 }
 358
 359 static void sigalrm_handler(void *data) {
 360         logger(DEBUG_ALWAYS, LOG_NOTICE, "Got %s signal", strsignal(((signal_t *)data)->signum));
 361         retry();
 362 }
 363 #endif
 364
 365 int reload_configuration(void) {
 366         char fname[PATH_MAX];
 367
 368         /* Reread our own configuration file */
 369
 370         exit_configuration(&config_tree);
 371         init_configuration(&config_tree);
 372
 373         if(!read_server_config()) {
 374                 logger(DEBUG_ALWAYS, LOG_ERR, "Unable to reread configuration file.");
 375                 return EINVAL;
 376         }
 377
 378         read_config_options(config_tree, NULL);
 379
 380         snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, myself->name);
 381         read_config_file(config_tree, fname);
 382
 383         /* Parse some options that are allowed to be changed while tinc is running */
 384
 385         setup_myself_reloadable();
 386
 387         /* If StrictSubnet is set, expire deleted Subnets and read new ones in */
 388
 389         if(strictsubnets) {
 390                 for splay_each(subnet_t, subnet, subnet_tree)
 391                         if (subnet->owner)
 392                                 subnet->expires = 1;
 393         }
 394
 395         for splay_each(node_t, n, node_tree)
 396                 n->status.has_address = false;
 397
 398         load_all_nodes();
 399
 400         if(strictsubnets) {
 401                 for splay_each(subnet_t, subnet, subnet_tree) {
 402                         if (!subnet->owner)
 403                                 continue;
 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) {
 410                                 subnet->expires = 0;
 411                         } else {
 412                                 send_add_subnet(everyone, subnet);
 413                                 if(subnet->owner->status.reachable)
 414                                         subnet_update(subnet->owner, subnet, true);
 415                         }
 416                 }
 417         } else { /* Only read our own subnets back in */
 418                 for splay_each(subnet_t, subnet, myself->subnet_tree)
 419                         if(!subnet->expires)
 420                                 subnet->expires = 1;
 421
 422                 config_t *cfg = lookup_config(config_tree, "Subnet");
 423
 424                 while(cfg) {
 425                         subnet_t *subnet, *s2;
 426
 427                         if(!get_config_subnet(cfg, &subnet))
 428                                 continue;
 429
 430                         if((s2 = lookup_subnet(myself, subnet))) {
 431                                 if(s2->expires == 1)
 432                                         s2->expires = 0;
 433
 434                                 free_subnet(subnet);
 435                         } else {
 436                                 subnet_add(myself, subnet);
 437                                 send_add_subnet(everyone, subnet);
 438                                 subnet_update(myself, subnet, true);
 439                         }
 440
 441                         cfg = lookup_config_next(config_tree, cfg);
 442                 }
 443
 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);
 449                         }
 450                 }
 451         }
 452
 453         /* Try to make outgoing connections */
 454
 455         try_outgoing_connections();
 456
 457         /* Close connections to hosts that have a changed or deleted host config file */
 458
 459         for list_each(connection_t, c, connection_list) {
 460                 if(c->status.control)
 461                         continue;
 462
 463                 snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, c->name);
 464                 struct stat s;
 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);
 468                 }
 469         }
 470
 471         last_config_check = now.tv_sec;
 472
 473         return 0;
 474 }
 475
 476 void retry(void) {
 477         /* Reset the reconnection timers for all outgoing connections */
 478         for list_each(outgoing_t, outgoing, outgoing_list) {
 479                 outgoing->timeout = 0;
 480                 if(outgoing->ev.cb)
 481                         timeout_set(&outgoing->ev, &(struct timeval){0, 0});
 482         }
 483
 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;
 488         }
 489
 490         /* Kick the ping timeout handler */
 491         timeout_set(&pingtimer, &(struct timeval){0, 0});
 492 }
 493
 494 /*
 495   this is where it all happens...
 496 */
 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});
 501
 502 #ifndef HAVE_MINGW
 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};
 508
 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);
 514 #endif
 515
 516         if(!event_loop()) {
 517                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while waiting for input: %s", sockstrerror(sockerrno));
 518                 return 1;
 519         }
 520
 521 #ifndef HAVE_MINGW
 522         signal_del(&sighup);
 523         signal_del(&sigterm);
 524         signal_del(&sigquit);
 525         signal_del(&sigint);
 526         signal_del(&sigalrm);
 527 #endif
 528
 529         timeout_del(&periodictimer);
 530         timeout_del(&pingtimer);
 531
 532         return 0;
 533 }