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

   1 /*
   2     net.c -- most of the network code
   3     Copyright (C) 1998-2001 Ivo Timmermans <itimmermans@bigfoot.com>,
   4                   2000,2001 Guus Sliepen <guus@sliepen.warande.net>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20     $Id: net.c,v 1.35.4.146 2001/11/03 21:21:04 guus Exp $
  21 */
  22
  23 #include "config.h"
  24
  25 #include <errno.h>
  26 #include <fcntl.h>
  27 #include <netdb.h>
  28 #include <netinet/in.h>
  29 #ifdef HAVE_LINUX
  30  #include <netinet/ip.h>
  31  #include <netinet/tcp.h>
  32 #endif
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <sys/signal.h>
  37 #include <sys/time.h>
  38 #include <sys/types.h>
  39 #include <syslog.h>
  40 #include <unistd.h>
  41 #include <sys/ioctl.h>
  42 /* SunOS really wants sys/socket.h BEFORE net/if.h,
  43    and FreeBSD wants these lines below the rest. */
  44 #include <arpa/inet.h>
  45 #include <sys/socket.h>
  46 #include <net/if.h>
  47
  48 #include <openssl/rand.h>
  49 #include <openssl/evp.h>
  50 #include <openssl/pem.h>
  51
  52 #ifndef HAVE_RAND_PSEUDO_BYTES
  53 #define RAND_pseudo_bytes RAND_bytes
  54 #endif
  55
  56 #include <utils.h>
  57 #include <xalloc.h>
  58 #include <avl_tree.h>
  59 #include <list.h>
  60
  61 #include "conf.h"
  62 #include "connection.h"
  63 #include "meta.h"
  64 #include "net.h"
  65 #include "netutl.h"
  66 #include "process.h"
  67 #include "protocol.h"
  68 #include "subnet.h"
  69 #include "process.h"
  70 #include "route.h"
  71 #include "device.h"
  72
  73 #include "system.h"
  74
  75 int maxtimeout = 900;
  76 int seconds_till_retry = 5;
  77
  78 int tcp_socket = -1;
  79 int udp_socket = -1;
  80
  81 int keylifetime = 0;
  82 int keyexpires = 0;
  83
  84 int do_prune = 0;
  85
  86 /* VPN packet I/O */
  87
  88 void receive_udppacket(node_t *n, vpn_packet_t *inpkt)
  89 {
  90   vpn_packet_t outpkt;
  91   int outlen, outpad;
  92   EVP_CIPHER_CTX ctx;
  93 cp
  94   /* Decrypt the packet */
  95
  96   EVP_DecryptInit(&ctx, myself->cipher, myself->key, myself->key + myself->cipher->key_len);
  97   EVP_DecryptUpdate(&ctx, outpkt.salt, &outlen, inpkt->salt, inpkt->len);
  98   EVP_DecryptFinal(&ctx, outpkt.salt + outlen, &outpad);
  99   outlen += outpad;
 100   outpkt.len = outlen - sizeof(outpkt.salt);
 101
 102   receive_packet(n, &outpkt);
 103 cp
 104 }
 105
 106 void receive_tcppacket(connection_t *c, char *buffer, int len)
 107 {
 108   vpn_packet_t outpkt;
 109 cp
 110   outpkt.len = len;
 111   memcpy(outpkt.data, buffer, len);
 112
 113   receive_packet(c->node, &outpkt);
 114 cp
 115 }
 116
 117 void receive_packet(node_t *n, vpn_packet_t *packet)
 118 {
 119 cp
 120   if(debug_lvl >= DEBUG_TRAFFIC)
 121     syslog(LOG_DEBUG, _("Received packet of %d bytes from %s (%s)"), packet->len, n->name, n->hostname);
 122
 123   route_incoming(n, packet);
 124 cp
 125 }
 126
 127 void send_udppacket(node_t *n, vpn_packet_t *inpkt)
 128 {
 129   vpn_packet_t outpkt;
 130   int outlen, outpad;
 131   EVP_CIPHER_CTX ctx;
 132   struct sockaddr_in to;
 133   socklen_t tolen = sizeof(to);
 134   vpn_packet_t *copy;
 135 cp
 136   if(!n->status.validkey)
 137     {
 138       if(debug_lvl >= DEBUG_TRAFFIC)
 139         syslog(LOG_INFO, _("No valid key known yet for %s (%s), queueing packet"),
 140                n->name, n->hostname);
 141
 142       /* Since packet is on the stack of handle_tap_input(),
 143          we have to make a copy of it first. */
 144
 145       copy = xmalloc(sizeof(vpn_packet_t));
 146       memcpy(copy, inpkt, sizeof(vpn_packet_t));
 147
 148       list_insert_tail(n->queue, copy);
 149
 150       if(!n->status.waitingforkey)
 151         send_req_key(n->nexthop->connection, myself, n);
 152       return;
 153     }
 154
 155   /* Encrypt the packet. */
 156
 157   RAND_pseudo_bytes(inpkt->salt, sizeof(inpkt->salt));
 158
 159   EVP_EncryptInit(&ctx, n->cipher, n->key, n->key + n->cipher->key_len);
 160   EVP_EncryptUpdate(&ctx, outpkt.salt, &outlen, inpkt->salt, inpkt->len + sizeof(inpkt->salt));
 161   EVP_EncryptFinal(&ctx, outpkt.salt + outlen, &outpad);
 162   outlen += outpad;
 163
 164   to.sin_family = AF_INET;
 165   to.sin_addr.s_addr = htonl(n->address);
 166   to.sin_port = htons(n->port);
 167
 168   if((sendto(udp_socket, (char *) outpkt.salt, outlen, 0, (const struct sockaddr *)&to, tolen)) < 0)
 169     {
 170       syslog(LOG_ERR, _("Error sending packet to %s (%s): %m"),
 171              n->name, n->hostname);
 172       return;
 173     }
 174 cp
 175 }
 176
 177 /*
 178   send a packet to the given vpn ip.
 179 */
 180 void send_packet(node_t *n, vpn_packet_t *packet)
 181 {
 182 cp
 183   if(debug_lvl >= DEBUG_TRAFFIC)
 184     syslog(LOG_ERR, _("Sending packet of %d bytes to %s (%s)"),
 185            packet->len, n->name, n->hostname);
 186
 187   if(n == myself)
 188     {
 189       if(debug_lvl >= DEBUG_TRAFFIC)
 190         {
 191           syslog(LOG_NOTICE, _("Packet is looping back to us!"));
 192         }
 193
 194       return;
 195     }
 196
 197   if(n->via != n && debug_lvl >= DEBUG_TRAFFIC)
 198     syslog(LOG_ERR, _("Sending packet to %s via %s (%s)"),
 199            n->name, n->via->name, n->via->hostname);
 200
 201   if((myself->options | n->via->options) & OPTION_TCPONLY)
 202     {
 203       if(send_tcppacket(n->via->connection, packet))
 204         terminate_connection(n->via->connection, 1);
 205     }
 206   else
 207     send_udppacket(n->via, packet);
 208 }
 209
 210 /* Broadcast a packet to all active direct connections */
 211
 212 void broadcast_packet(node_t *from, vpn_packet_t *packet)
 213 {
 214   avl_node_t *node;
 215   connection_t *c;
 216 cp
 217   if(debug_lvl >= DEBUG_TRAFFIC)
 218     syslog(LOG_INFO, _("Broadcasting packet of %d bytes from %s (%s)"),
 219            packet->len, from->name, from->hostname);
 220
 221   for(node = connection_tree->head; node; node = node->next)
 222     {
 223       c = (connection_t *)node->data;
 224       if(c->status.active && c != from->nexthop->connection)
 225         send_packet(c->node, packet);
 226     }
 227 cp
 228 }
 229
 230 void flush_queue(node_t *n)
 231 {
 232   list_node_t *node, *next;
 233 cp
 234   if(debug_lvl >= DEBUG_TRAFFIC)
 235     syslog(LOG_INFO, _("Flushing queue for %s (%s)"), n->name, n->hostname);
 236
 237   for(node = n->queue->head; node; node = next)
 238     {
 239       next = node->next;
 240       send_udppacket(n, (vpn_packet_t *)node->data);
 241       list_delete_node(n->queue, node);
 242     }
 243 cp
 244 }
 245
 246 /* Setup sockets */
 247
 248 int setup_listen_socket(int port)
 249 {
 250   int nfd, flags;
 251   struct sockaddr_in a;
 252   int option;
 253   char *interface;
 254   char *address;
 255   ip_mask_t *ipmask;
 256 cp
 257   if((nfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
 258     {
 259       syslog(LOG_ERR, _("Creating metasocket failed: %m"));
 260       return -1;
 261     }
 262
 263   flags = fcntl(nfd, F_GETFL);
 264   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
 265     {
 266       close(nfd);
 267       syslog(LOG_ERR, _("System call `%s' failed: %m"),
 268              "fcntl");
 269       return -1;
 270     }
 271
 272   /* Optimize TCP settings */
 273
 274   option = 1;
 275   setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option));
 276   setsockopt(nfd, SOL_SOCKET, SO_KEEPALIVE, &option, sizeof(option));
 277 #ifdef HAVE_LINUX
 278   setsockopt(nfd, SOL_TCP, TCP_NODELAY, &option, sizeof(option));
 279
 280   option = IPTOS_LOWDELAY;
 281   setsockopt(nfd, SOL_IP, IP_TOS, &option, sizeof(option));
 282
 283   if(get_config_string(lookup_config(config_tree, "BindToInterface"), &interface))
 284     if(setsockopt(nfd, SOL_SOCKET, SO_BINDTODEVICE, interface, strlen(interface)))
 285       {
 286         close(nfd);
 287         syslog(LOG_ERR, _("Can't bind to interface %s: %m"), interface);
 288         return -1;
 289       }
 290 #endif
 291
 292   memset(&a, 0, sizeof(a));
 293   a.sin_family = AF_INET;
 294   a.sin_addr.s_addr = htonl(INADDR_ANY);
 295   a.sin_port = htons(port);
 296
 297   if(get_config_string(lookup_config(config_tree, "BindToAddress"), &address))
 298     {
 299       ipmask = strtoip(address);
 300       if(ipmask)
 301       {
 302         a.sin_addr.s_addr = htonl(ipmask->address);
 303         free(ipmask);
 304       }
 305     }
 306
 307   if(bind(nfd, (struct sockaddr *)&a, sizeof(struct sockaddr)))
 308     {
 309       close(nfd);
 310       syslog(LOG_ERR, _("Can't bind to port %hd/tcp: %m"), port);
 311       return -1;
 312     }
 313
 314   if(listen(nfd, 3))
 315     {
 316       close(nfd);
 317       syslog(LOG_ERR, _("System call `%s' failed: %m"),
 318              "listen");
 319       return -1;
 320     }
 321 cp
 322   return nfd;
 323 }
 324
 325 int setup_vpn_in_socket(int port)
 326 {
 327   int nfd, flags;
 328   struct sockaddr_in a;
 329   const int one = 1;
 330 cp
 331   if((nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
 332     {
 333       close(nfd);
 334       syslog(LOG_ERR, _("Creating socket failed: %m"));
 335       return -1;
 336     }
 337
 338   setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
 339
 340   flags = fcntl(nfd, F_GETFL);
 341   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
 342     {
 343       close(nfd);
 344       syslog(LOG_ERR, _("System call `%s' failed: %m"),
 345              "fcntl");
 346       return -1;
 347     }
 348
 349   memset(&a, 0, sizeof(a));
 350   a.sin_family = AF_INET;
 351   a.sin_port = htons(port);
 352   a.sin_addr.s_addr = htonl(INADDR_ANY);
 353
 354   if(bind(nfd, (struct sockaddr *)&a, sizeof(struct sockaddr)))
 355     {
 356       close(nfd);
 357       syslog(LOG_ERR, _("Can't bind to port %hd/udp: %m"), port);
 358       return -1;
 359     }
 360 cp
 361   return nfd;
 362 }
 363
 364 int setup_outgoing_socket(connection_t *c)
 365 {
 366   int flags;
 367   struct sockaddr_in a;
 368 cp
 369   if(debug_lvl >= DEBUG_CONNECTIONS)
 370     syslog(LOG_INFO, _("Trying to connect to %s (%s)"), c->name, c->hostname);
 371
 372   c->socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 373
 374   if(c->socket == -1)
 375     {
 376       syslog(LOG_ERR, _("Creating socket for %s port %d failed: %m"),
 377              c->hostname, c->port);
 378       return -1;
 379     }
 380
 381   /* Bind first to get a fix on our source port???
 382
 383   a.sin_family = AF_INET;
 384   a.sin_port = htons(0);
 385   a.sin_addr.s_addr = htonl(INADDR_ANY);
 386
 387   if(bind(c->socket, (struct sockaddr *)&a, sizeof(struct sockaddr)))
 388     {
 389       close(c->socket);
 390       syslog(LOG_ERR, _("System call `%s' failed: %m"), "bind");
 391       return -1;
 392     }
 393
 394   */
 395
 396   /* Optimize TCP settings?
 397
 398   option = 1;
 399   setsockopt(c->socket, SOL_SOCKET, SO_KEEPALIVE, &option, sizeof(option));
 400 #ifdef HAVE_LINUX
 401   setsockopt(c->socket, SOL_TCP, TCP_NODELAY, &option, sizeof(option));
 402
 403   option = IPTOS_LOWDELAY;
 404   setsockopt(c->socket, SOL_IP, IP_TOS, &option, sizeof(option));
 405 #endif
 406
 407   */
 408
 409   /* Connect */
 410
 411   a.sin_family = AF_INET;
 412   a.sin_port = htons(c->port);
 413   a.sin_addr.s_addr = htonl(c->address);
 414
 415   if(connect(c->socket, (struct sockaddr *)&a, sizeof(a)) == -1)
 416     {
 417       close(c->socket);
 418       syslog(LOG_ERR, _("%s port %hd: %m"), c->hostname, c->port);
 419       return -1;
 420     }
 421
 422   flags = fcntl(c->socket, F_GETFL);
 423
 424   if(fcntl(c->socket, F_SETFL, flags | O_NONBLOCK) < 0)
 425     {
 426       close(c->socket);
 427       syslog(LOG_ERR, _("fcntl for %s port %d: %m"),
 428              c->hostname, c->port);
 429       return -1;
 430     }
 431
 432   if(debug_lvl >= DEBUG_CONNECTIONS)
 433     syslog(LOG_INFO, _("Connected to %s port %hd"),
 434          c->hostname, c->port);
 435 cp
 436   return 0;
 437 }
 438
 439 int setup_outgoing_connection(char *name)
 440 {
 441   connection_t *c;
 442   node_t *n;
 443   struct hostent *h;
 444 cp
 445   n = lookup_node(name);
 446
 447   if(n)
 448     if(n->connection)
 449       {
 450         if(debug_lvl >= DEBUG_CONNECTIONS)
 451           syslog(LOG_INFO, _("Already connected to %s"), name);
 452         return 0;
 453       }
 454
 455   c = new_connection();
 456   c->name = xstrdup(name);
 457
 458   init_configuration(&c->config_tree);
 459   read_connection_config(c);
 460
 461   if(!get_config_string(lookup_config(c->config_tree, "Address"), &c->hostname))
 462     {
 463       syslog(LOG_ERR, _("No address specified for %s"), c->name);
 464       free_connection(c);
 465       return -1;
 466     }
 467
 468   if(!get_config_port(lookup_config(c->config_tree, "Port"), &c->port))
 469     {
 470       syslog(LOG_ERR, _("No port specified for %s"), c->name);
 471       free_connection(c);
 472       return -1;
 473     }
 474
 475   if(!(h = gethostbyname(c->hostname)))
 476     {
 477       syslog(LOG_ERR, _("Error looking up `%s': %m"), c->hostname);
 478       free_connection(c);
 479       return -1;
 480     }
 481
 482   c->address = ntohl(*((ipv4_t*)(h->h_addr_list[0])));
 483   c->hostname = hostlookup(htonl(c->address));
 484
 485   if(setup_outgoing_socket(c) < 0)
 486     {
 487       syslog(LOG_ERR, _("Could not set up a meta connection to %s (%s)"),
 488              c->name, c->hostname);
 489       free_connection(c);
 490       return -1;
 491     }
 492
 493   c->status.outgoing = 1;
 494   c->last_ping_time = time(NULL);
 495
 496   connection_add(c);
 497
 498   send_id(c);
 499 cp
 500   return 0;
 501 }
 502
 503 int read_rsa_public_key(connection_t *c)
 504 {
 505   FILE *fp;
 506   char *fname;
 507   char *key;
 508 cp
 509   if(!c->rsa_key)
 510     c->rsa_key = RSA_new();
 511
 512   /* First, check for simple PublicKey statement */
 513
 514   if(get_config_string(lookup_config(c->config_tree, "PublicKey"), &key))
 515     {
 516       BN_hex2bn(&c->rsa_key->n, key);
 517       BN_hex2bn(&c->rsa_key->e, "FFFF");
 518       return 0;
 519     }
 520
 521   /* Else, check for PublicKeyFile statement and read it */
 522
 523   if(get_config_string(lookup_config(c->config_tree, "PublicKeyFile"), &fname))
 524     {
 525       if(is_safe_path(fname))
 526         {
 527           if((fp = fopen(fname, "r")) == NULL)
 528             {
 529               syslog(LOG_ERR, _("Error reading RSA public key file `%s': %m"),
 530                      fname);
 531               return -1;
 532             }
 533           c->rsa_key = PEM_read_RSAPublicKey(fp, &c->rsa_key, NULL, NULL);
 534           fclose(fp);
 535           if(!c->rsa_key)
 536             {
 537               syslog(LOG_ERR, _("Reading RSA public key file `%s' failed: %m"),
 538                      fname);
 539               return -1;
 540             }
 541           return 0;
 542         }
 543       else
 544         return -1;
 545     }
 546
 547   /* Else, check if a harnessed public key is in the config file */
 548
 549   asprintf(&fname, "%s/hosts/%s", confbase, c->name);
 550   if((fp = fopen(fname, "r")))
 551     {
 552       c->rsa_key = PEM_read_RSAPublicKey(fp, NULL, NULL, NULL);
 553       fclose(fp);
 554     }
 555
 556   free(fname);
 557
 558   if(c->rsa_key)
 559     return 0;
 560   else
 561     {
 562       syslog(LOG_ERR, _("No public key for %s specified!"), c->name);
 563       return -1;
 564     }
 565 }
 566
 567 int read_rsa_private_key(void)
 568 {
 569   FILE *fp;
 570   char *fname, *key;
 571 cp
 572   if(get_config_string(lookup_config(config_tree, "PrivateKey"), &key))
 573     {
 574       myself->connection->rsa_key = RSA_new();
 575       BN_hex2bn(&myself->connection->rsa_key->d, key);
 576       BN_hex2bn(&myself->connection->rsa_key->e, "FFFF");
 577     }
 578   else if(get_config_string(lookup_config(config_tree, "PrivateKeyFile"), &fname))
 579     {
 580       if((fp = fopen(fname, "r")) == NULL)
 581         {
 582           syslog(LOG_ERR, _("Error reading RSA private key file `%s': %m"),
 583                  fname);
 584           return -1;
 585         }
 586       myself->connection->rsa_key = PEM_read_RSAPrivateKey(fp, NULL, NULL, NULL);
 587       fclose(fp);
 588       if(!myself->connection->rsa_key)
 589         {
 590           syslog(LOG_ERR, _("Reading RSA private key file `%s' failed: %m"),
 591                  fname);
 592           return -1;
 593         }
 594     }
 595   else
 596     {
 597       syslog(LOG_ERR, _("No private key for tinc daemon specified!"));
 598       return -1;
 599     }
 600 cp
 601   return 0;
 602 }
 603
 604 /*
 605   Configure node_t myself and set up the local sockets (listen only)
 606 */
 607 int setup_myself(void)
 608 {
 609   config_t *cfg;
 610   subnet_t *subnet;
 611   char *name, *mode;
 612   int choice;
 613 cp
 614   myself = new_node();
 615   myself->connection = new_connection();
 616   init_configuration(&myself->connection->config_tree);
 617
 618   asprintf(&myself->hostname, _("MYSELF"));
 619   asprintf(&myself->connection->hostname, _("MYSELF"));
 620
 621   myself->connection->options = 0;
 622   myself->connection->protocol_version = PROT_CURRENT;
 623
 624   if(!get_config_string(lookup_config(config_tree, "Name"), &name)) /* Not acceptable */
 625     {
 626       syslog(LOG_ERR, _("Name for tinc daemon required!"));
 627       return -1;
 628     }
 629
 630   if(check_id(name))
 631     {
 632       syslog(LOG_ERR, _("Invalid name for myself!"));
 633       free(name);
 634       return -1;
 635     }
 636
 637   myself->name = name;
 638   myself->connection->name = xstrdup(name);
 639
 640 cp
 641   if(read_rsa_private_key())
 642     return -1;
 643
 644   if(read_connection_config(myself->connection))
 645     {
 646       syslog(LOG_ERR, _("Cannot open host configuration file for myself!"));
 647       return -1;
 648     }
 649
 650   if(read_rsa_public_key(myself->connection))
 651     return -1;
 652 cp
 653
 654 /*
 655   if(RSA_check_key(rsa_key) != 1)
 656     {
 657       syslog(LOG_ERR, _("Invalid public/private keypair!"));
 658       return -1;
 659     }
 660 */
 661   if(!get_config_port(lookup_config(myself->connection->config_tree, "Port"), &myself->port))
 662     myself->port = 655;
 663
 664   myself->connection->port = myself->port;
 665
 666 /* Read in all the subnets specified in the host configuration file */
 667
 668   cfg = lookup_config(myself->connection->config_tree, "Subnet");
 669
 670   while(cfg)
 671     {
 672       if(!get_config_subnet(cfg, &subnet))
 673         return -1;
 674
 675       subnet_add(myself, subnet);
 676
 677       cfg = lookup_config_next(myself->connection->config_tree, cfg);
 678     }
 679
 680 cp
 681   /* Check some options */
 682
 683   if(get_config_bool(lookup_config(config_tree, "IndirectData"), &choice))
 684     if(choice)
 685       myself->options |= OPTION_INDIRECT;
 686
 687   if(get_config_bool(lookup_config(config_tree, "TCPOnly"), &choice))
 688     if(choice)
 689       myself->options |= OPTION_TCPONLY;
 690
 691   if(get_config_bool(lookup_config(myself->connection->config_tree, "IndirectData"), &choice))
 692     if(choice)
 693       myself->options |= OPTION_INDIRECT;
 694
 695   if(get_config_bool(lookup_config(myself->connection->config_tree, "TCPOnly"), &choice))
 696     if(choice)
 697       myself->options |= OPTION_TCPONLY;
 698
 699   if(myself->options & OPTION_TCPONLY)
 700     myself->options |= OPTION_INDIRECT;
 701
 702   if(get_config_string(lookup_config(config_tree, "Mode"), &mode))
 703     {
 704       if(!strcasecmp(mode, "router"))
 705         routing_mode = RMODE_ROUTER;
 706       else if (!strcasecmp(mode, "switch"))
 707         routing_mode = RMODE_SWITCH;
 708       else if (!strcasecmp(mode, "hub"))
 709         routing_mode = RMODE_HUB;
 710       else
 711         {
 712           syslog(LOG_ERR, _("Invalid routing mode!"));
 713           return -1;
 714         }
 715     }
 716   else
 717     routing_mode = RMODE_ROUTER;
 718
 719 cp
 720   /* Open sockets */
 721
 722   if((tcp_socket = setup_listen_socket(myself->port)) < 0)
 723     {
 724       syslog(LOG_ERR, _("Unable to set up a listening TCP socket!"));
 725       return -1;
 726     }
 727
 728   if((udp_socket = setup_vpn_in_socket(myself->port)) < 0)
 729     {
 730       syslog(LOG_ERR, _("Unable to set up a listening UDP socket!"));
 731       return -1;
 732     }
 733 cp
 734   /* Generate packet encryption key */
 735
 736   myself->cipher = EVP_bf_cbc();
 737
 738   myself->keylength = myself->cipher->key_len + myself->cipher->iv_len;
 739
 740   myself->key = (char *)xmalloc(myself->keylength);
 741   RAND_pseudo_bytes(myself->key, myself->keylength);
 742
 743   if(!get_config_int(lookup_config(config_tree, "KeyExpire"), &keylifetime))
 744     keylifetime = 3600;
 745
 746   keyexpires = time(NULL) + keylifetime;
 747 cp
 748   /* Done */
 749
 750   myself->nexthop = myself;
 751   myself->via = myself;
 752   myself->status.active = 1;
 753   node_add(myself);
 754
 755   syslog(LOG_NOTICE, _("Ready: listening on port %hd"), myself->port);
 756 cp
 757   return 0;
 758 }
 759
 760 /*
 761   setup all initial network connections
 762 */
 763 int setup_network_connections(void)
 764 {
 765 cp
 766   init_connections();
 767   init_subnets();
 768   init_nodes();
 769   init_edges();
 770
 771   if(get_config_int(lookup_config(config_tree, "PingTimeout"), &timeout))
 772     {
 773       if(timeout < 1)
 774         {
 775           timeout = 86400;
 776         }
 777     }
 778   else
 779     timeout = 60;
 780
 781   if(setup_device() < 0)
 782     return -1;
 783
 784   /* Run tinc-up script to further initialize the tap interface */
 785   execute_script("tinc-up");
 786
 787   if(setup_myself() < 0)
 788     return -1;
 789
 790   signal(SIGALRM, try_outgoing_connections);
 791   alarm(5);
 792 cp
 793   return 0;
 794 }
 795
 796 /*
 797   close all open network connections
 798 */
 799 void close_network_connections(void)
 800 {
 801   avl_node_t *node, *next;
 802   connection_t *c;
 803 cp
 804   for(node = connection_tree->head; node; node = next)
 805     {
 806       next = node->next;
 807       c = (connection_t *)node->data;
 808       c->status.outgoing = 0;
 809       terminate_connection(c, 0);
 810     }
 811
 812   terminate_connection(myself->connection, 0);
 813
 814 //  destroy_trees();
 815   exit_edges();
 816   exit_subnets();
 817   exit_nodes();
 818   exit_connections();
 819
 820   execute_script("tinc-down");
 821
 822   close_device();
 823 cp
 824   return;
 825 }
 826
 827 /*
 828   handle an incoming tcp connect call and open
 829   a connection to it.
 830 */
 831 connection_t *create_new_connection(int sfd)
 832 {
 833   connection_t *c;
 834   struct sockaddr_in ci;
 835   int len = sizeof(ci);
 836 cp
 837   c = new_connection();
 838
 839   if(getpeername(sfd, (struct sockaddr *) &ci, (socklen_t *) &len) < 0)
 840     {
 841       syslog(LOG_ERR, _("System call `%s' failed: %m"),
 842              "getpeername");
 843       close(sfd);
 844       return NULL;
 845     }
 846
 847   c->address = ntohl(ci.sin_addr.s_addr);
 848   c->hostname = hostlookup(ci.sin_addr.s_addr);
 849   c->port = htons(ci.sin_port);
 850   c->socket = sfd;
 851   c->last_ping_time = time(NULL);
 852
 853   if(debug_lvl >= DEBUG_CONNECTIONS)
 854     syslog(LOG_NOTICE, _("Connection from %s port %d"),
 855          c->hostname, c->port);
 856
 857   c->allow_request = ID;
 858 cp
 859   return c;
 860 }
 861
 862 /*
 863   put all file descriptors in an fd_set array
 864 */
 865 void build_fdset(fd_set *fs)
 866 {
 867   avl_node_t *node;
 868   connection_t *c;
 869 cp
 870   FD_ZERO(fs);
 871
 872   for(node = connection_tree->head; node; node = node->next)
 873     {
 874       c = (connection_t *)node->data;
 875       FD_SET(c->socket, fs);
 876     }
 877
 878   FD_SET(tcp_socket, fs);
 879   FD_SET(udp_socket, fs);
 880   FD_SET(device_fd, fs);
 881 cp
 882 }
 883
 884 /*
 885   receive incoming data from the listening
 886   udp socket and write it to the ethertap
 887   device after being decrypted
 888 */
 889 void handle_incoming_vpn_data(void)
 890 {
 891   vpn_packet_t pkt;
 892   int x, l = sizeof(x);
 893   struct sockaddr_in from;
 894   socklen_t fromlen = sizeof(from);
 895   node_t *n;
 896 cp
 897   if(getsockopt(udp_socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
 898     {
 899       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"),
 900              __FILE__, __LINE__, udp_socket);
 901       return;
 902     }
 903   if(x)
 904     {
 905       syslog(LOG_ERR, _("Incoming data socket error: %s"), strerror(x));
 906       return;
 907     }
 908
 909   if((pkt.len = recvfrom(udp_socket, (char *) pkt.salt, MTU, 0, (struct sockaddr *)&from, &fromlen)) <= 0)
 910     {
 911       syslog(LOG_ERR, _("Receiving packet failed: %m"));
 912       return;
 913     }
 914
 915   n = lookup_node_udp(ntohl(from.sin_addr.s_addr), ntohs(from.sin_port));
 916
 917   if(!n)
 918     {
 919       syslog(LOG_WARNING, _("Received UDP packet on port %hd from unknown source %x:%hd"), myself->port, ntohl(from.sin_addr.s_addr), ntohs(from.sin_port));
 920       return;
 921     }
 922 /*
 923   if(n->connection)
 924     n->connection->last_ping_time = time(NULL);
 925 */
 926   receive_udppacket(n, &pkt);
 927 cp
 928 }
 929
 930 /*
 931   Terminate a connection:
 932   - Close the socket
 933   - Remove associated edge and tell other connections about it if report = 1
 934   - Check if we need to retry making an outgoing connection
 935   - Deactivate the host
 936 */
 937 void terminate_connection(connection_t *c, int report)
 938 {
 939   avl_node_t *node;
 940   connection_t *other;
 941 cp
 942   if(c->status.remove)
 943     return;
 944
 945   if(debug_lvl >= DEBUG_CONNECTIONS)
 946     syslog(LOG_NOTICE, _("Closing connection with %s (%s)"),
 947            c->name, c->hostname);
 948
 949   c->status.remove = 1;
 950
 951   if(c->socket)
 952     close(c->socket);
 953
 954   if(c->edge)
 955     {
 956       if(report)
 957         {
 958           for(node = connection_tree->head; node; node = node->next)
 959             {
 960               other = (connection_t *)node->data;
 961               if(other->status.active && other != c)
 962                 send_del_edge(other, c->edge);
 963             }
 964         }
 965
 966       edge_del(c->edge);
 967     }
 968
 969   /* Check if this was our outgoing connection */
 970
 971   if(c->status.outgoing)
 972     {
 973       c->status.outgoing = 0;
 974       signal(SIGALRM, try_outgoing_connections);
 975       alarm(seconds_till_retry);
 976       syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in %d seconds"), seconds_till_retry);
 977     }
 978
 979   /* Deactivate */
 980
 981   c->status.active = 0;
 982   if(c->node)
 983     c->node->connection = NULL;
 984   do_prune = 1;
 985 cp
 986 }
 987
 988 /*
 989   Check if the other end is active.
 990   If we have sent packets, but didn't receive any,
 991   then possibly the other end is dead. We send a
 992   PING request over the meta connection. If the other
 993   end does not reply in time, we consider them dead
 994   and close the connection.
 995 */
 996 void check_dead_connections(void)
 997 {
 998   time_t now;
 999   avl_node_t *node, *next;
1000   connection_t *c;
1001 cp
1002   now = time(NULL);
1003
1004   for(node = connection_tree->head; node; node = next)
1005     {
1006       next = node->next;
1007       c = (connection_t *)node->data;
1008       if(c->last_ping_time + timeout < now)
1009         {
1010           if(c->status.active)
1011             {
1012               if(c->status.pinged)
1013                 {
1014                   if(debug_lvl >= DEBUG_PROTOCOL)
1015                     syslog(LOG_INFO, _("%s (%s) didn't respond to PING"),
1016                            c->name, c->hostname);
1017                   c->status.timeout = 1;
1018                   terminate_connection(c, 1);
1019                 }
1020               else
1021                 {
1022                   send_ping(c);
1023                 }
1024             }
1025           else
1026             {
1027               if(debug_lvl >= DEBUG_CONNECTIONS)
1028                 syslog(LOG_WARNING, _("Timeout from %s (%s) during authentication"),
1029                        c->name, c->hostname);
1030               terminate_connection(c, 0);
1031             }
1032         }
1033     }
1034 cp
1035 }
1036
1037 /*
1038   accept a new tcp connect and create a
1039   new connection
1040 */
1041 int handle_new_meta_connection()
1042 {
1043   connection_t *new;
1044   struct sockaddr client;
1045   int fd, len = sizeof(client);
1046 cp
1047   if((fd = accept(tcp_socket, &client, &len)) < 0)
1048     {
1049       syslog(LOG_ERR, _("Accepting a new connection failed: %m"));
1050       return -1;
1051     }
1052
1053   if(!(new = create_new_connection(fd)))
1054     {
1055       shutdown(fd, 2);
1056       close(fd);
1057       syslog(LOG_NOTICE, _("Closed attempted connection"));
1058       return 0;
1059     }
1060
1061   connection_add(new);
1062
1063   send_id(new);
1064 cp
1065   return 0;
1066 }
1067
1068 void randomized_alarm(int seconds)
1069 {
1070   unsigned char r;
1071   RAND_pseudo_bytes(&r, 1);
1072   alarm((seconds * (int)r) / 128 + 1);
1073 }
1074
1075 /* This function is severely fucked up.
1076    We want to redesign it so the following rules apply:
1077
1078    - Try all ConnectTo's in a row:
1079      - if a connect() fails, try next one immediately,
1080      - if it works, wait 5 seconds or so.
1081    - If none of them were succesful, increase delay and retry.
1082    - If all were succesful, don't try anymore.
1083 */
1084
1085 RETSIGTYPE
1086 try_outgoing_connections(int a)
1087 {
1088   static config_t *cfg = NULL;
1089   static int retry = 0;
1090   char *name;
1091 cp
1092   if(!cfg)
1093     cfg = lookup_config(config_tree, "ConnectTo");
1094
1095   if(!cfg)
1096     return;
1097
1098   while(cfg)
1099     {
1100       get_config_string(cfg, &name);
1101       cfg = lookup_config_next(config_tree, cfg);  /* Next time skip to next ConnectTo line */
1102
1103       if(check_id(name))
1104         {
1105           syslog(LOG_ERR, _("Invalid name for outgoing connection in %s line %d"), cfg->file, cfg->line);
1106           continue;
1107         }
1108
1109       if(setup_outgoing_connection(name))   /* function returns 0 when there are no problems */
1110         retry = 1;
1111
1112     }
1113
1114   get_config_int(lookup_config(config_tree, "MaxTimeout"), &maxtimeout);
1115
1116   if(retry)
1117     {
1118       seconds_till_retry += 5;
1119       if(seconds_till_retry > maxtimeout)    /* Don't wait more than MAXTIMEOUT seconds. */
1120         seconds_till_retry = maxtimeout;
1121
1122       syslog(LOG_ERR, _("Failed to setup all outgoing connections, will retry in %d seconds"),
1123         seconds_till_retry);
1124
1125       /* Randomize timeout to avoid global synchronisation effects */
1126       randomized_alarm(seconds_till_retry);
1127     }
1128   else
1129     {
1130       seconds_till_retry = 5;
1131     }
1132 cp
1133 }
1134
1135 /*
1136   check all connections to see if anything
1137   happened on their sockets
1138 */
1139 void check_network_activity(fd_set *f)
1140 {
1141   connection_t *c;
1142   avl_node_t *node;
1143 cp
1144   if(FD_ISSET(udp_socket, f))
1145     handle_incoming_vpn_data();
1146
1147   for(node = connection_tree->head; node; node = node->next)
1148     {
1149       c = (connection_t *)node->data;
1150
1151       if(c->status.remove)
1152         return;
1153
1154       if(FD_ISSET(c->socket, f))
1155         if(receive_meta(c) < 0)
1156           {
1157             terminate_connection(c, c->status.active);
1158             return;
1159           }
1160     }
1161
1162   if(FD_ISSET(tcp_socket, f))
1163     handle_new_meta_connection();
1164 cp
1165 }
1166
1167 void prune_connections(void)
1168 {
1169   connection_t *c;
1170   avl_node_t *node, *next;
1171 cp
1172   for(node = connection_tree->head; node; node = next)
1173     {
1174       next = node->next;
1175       c = (connection_t *)node->data;
1176
1177       if(c->status.remove)
1178         connection_del(c);
1179     }
1180 cp
1181 }
1182
1183 /*
1184   this is where it all happens...
1185 */
1186 void main_loop(void)
1187 {
1188   fd_set fset;
1189   struct timeval tv;
1190   int r;
1191   time_t last_ping_check;
1192   int t;
1193   vpn_packet_t packet;
1194 cp
1195   last_ping_check = time(NULL);
1196
1197   for(;;)
1198     {
1199       tv.tv_sec = timeout;
1200       tv.tv_usec = 0;
1201
1202       if(do_prune)
1203         {
1204           prune_connections();
1205           do_prune = 0;
1206         }
1207
1208       build_fdset(&fset);
1209
1210       if((r = select(FD_SETSIZE, &fset, NULL, NULL, &tv)) < 0)
1211         {
1212           if(errno != EINTR) /* because of alarm */
1213             {
1214               syslog(LOG_ERR, _("Error while waiting for input: %m"));
1215               return;
1216             }
1217         }
1218
1219       if(sighup)
1220         {
1221           syslog(LOG_INFO, _("Rereading configuration file and restarting in 5 seconds"));
1222           sighup = 0;
1223           close_network_connections();
1224           exit_configuration(&config_tree);
1225
1226           if(read_server_config())
1227             {
1228               syslog(LOG_ERR, _("Unable to reread configuration file, exiting"));
1229               exit(1);
1230             }
1231
1232           sleep(5);
1233
1234           if(setup_network_connections())
1235             return;
1236
1237           continue;
1238         }
1239
1240       t = time(NULL);
1241
1242       /* Let's check if everybody is still alive */
1243
1244       if(last_ping_check + timeout < t)
1245         {
1246           check_dead_connections();
1247           last_ping_check = time(NULL);
1248
1249           /* Should we regenerate our key? */
1250
1251           if(keyexpires < t)
1252             {
1253               if(debug_lvl >= DEBUG_STATUS)
1254                 syslog(LOG_INFO, _("Regenerating symmetric key"));
1255
1256               RAND_pseudo_bytes(myself->key, myself->keylength);
1257               send_key_changed(myself->connection, myself);
1258               keyexpires = time(NULL) + keylifetime;
1259             }
1260         }
1261
1262       if(r > 0)
1263         {
1264           check_network_activity(&fset);
1265
1266           /* local tap data */
1267           if(FD_ISSET(device_fd, &fset))
1268             {
1269               if(read_packet(&packet))
1270                 return;
1271               else
1272                 route_outgoing(&packet);
1273             }
1274         }
1275     }
1276 cp
1277 }