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

   1 /*
   2     net.c -- most of the network code
   3     Copyright (C) 1998,1999,2000 Ivo Timmermans <itimmermans@bigfoot.com>,
   4                             2000 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.42 2000/10/20 19:46:57 guus Exp $
  21 */
  22
  23 #include "config.h"
  24
  25 #include <arpa/inet.h>
  26 #include <errno.h>
  27 #include <fcntl.h>
  28 #include <netdb.h>
  29 #include <netinet/in.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <sys/signal.h>
  34 #include <sys/socket.h>
  35 #include <sys/time.h>
  36 #include <sys/types.h>
  37 #include <syslog.h>
  38 #include <unistd.h>
  39
  40 #ifdef HAVE_TUNTAP
  41 #include <net/if.h>
  42 #include <linux/sockios.h>
  43 #include LINUX_IF_TUN_H
  44 #endif
  45
  46 #include <utils.h>
  47 #include <xalloc.h>
  48
  49 #include "conf.h"
  50 #include "encr.h"
  51 #include "net.h"
  52 #include "netutl.h"
  53 #include "protocol.h"
  54 #include "meta.h"
  55
  56 #include "system.h"
  57
  58 int tap_fd = -1;
  59 int taptype = 0;
  60 int total_tap_in = 0;
  61 int total_tap_out = 0;
  62 int total_socket_in = 0;
  63 int total_socket_out = 0;
  64
  65 int upstreamindex = 0;
  66 static int seconds_till_retry;
  67
  68 char *unknown = NULL;
  69
  70 /*
  71   strip off the MAC adresses of an ethernet frame
  72 */
  73 void strip_mac_addresses(vpn_packet_t *p)
  74 {
  75 cp
  76   memmove(p->data, p->data + 12, p->len -= 12);
  77 cp
  78 }
  79
  80 /*
  81   reassemble MAC addresses
  82 */
  83 void add_mac_addresses(vpn_packet_t *p)
  84 {
  85 cp
  86   memcpy(p->data + 12, p->data, p->len);
  87   p->len += 12;
  88   p->data[0] = p->data[6] = 0xfe;
  89   p->data[1] = p->data[7] = 0xfd;
  90   /* Really evil pointer stuff just below! */
  91   *((ip_t*)(&p->data[2])) = (ip_t)(htonl(myself->address));
  92   *((ip_t*)(&p->data[8])) = *((ip_t*)(&p->data[26]));
  93 cp
  94 }
  95
  96 int xsend(conn_list_t *cl, vpn_packet_t *inpkt)
  97 {
  98   vpn_packet_t outpkt;
  99   int outlen, outpad;
 100 cp
 101   outpkt.len = inpkt->len;
 102   EVP_EncryptInit(cl->cipher_pktctx, cl->cipher_pkttype, cl->cipher_pktkey, NULL);
 103   EVP_EncryptUpdate(cl->cipher_pktctx, outpkt.data, &outlen, inpkt->data, inpkt->len);
 104   EVP_EncryptFinal(cl->cipher_pktctx, outpkt.data + outlen, &outpad);
 105   outlen += outpad;
 106
 107   if(debug_lvl > 3)
 108     syslog(LOG_ERR, _("Sending packet of %d bytes to %s (%s)"),
 109            outlen, cl->name, cl->hostname);
 110
 111   total_socket_out += outlen;
 112
 113   cl->want_ping = 1;
 114
 115   if((send(cl->socket, (char *) &(outpkt.len), outlen + 2, 0)) < 0)
 116     {
 117       syslog(LOG_ERR, _("Error sending packet to %s (%s): %m"),
 118              cl->name, cl->hostname);
 119       return -1;
 120     }
 121 cp
 122   return 0;
 123 }
 124
 125 int xrecv(vpn_packet_t *inpkt)
 126 {
 127   vpn_packet_t outpkt;
 128   int outlen, outpad;
 129 cp
 130   if(debug_lvl > 3)
 131     syslog(LOG_ERR, _("Receiving packet of %d bytes"),
 132            inpkt->len);
 133
 134   outpkt.len = inpkt->len;
 135   EVP_DecryptInit(myself->cipher_pktctx, myself->cipher_pkttype, myself->cipher_pktkey, NULL);
 136   EVP_DecryptUpdate(myself->cipher_pktctx, outpkt.data, &outlen, inpkt->data, inpkt->len);
 137   /* FIXME: grok DecryptFinal
 138   EVP_DecryptFinal(myself->cipher_pktctx, outpkt.data + outlen, &outpad);
 139    */
 140
 141   add_mac_addresses(&outpkt);
 142
 143   if(write(tap_fd, outpkt.data, outpkt.len) < 0)
 144     syslog(LOG_ERR, _("Can't write to tap device: %m"));
 145   else
 146     total_tap_out += outpkt.len;
 147 cp
 148   return 0;
 149 }
 150
 151 /*
 152   add the given packet of size s to the
 153   queue q, be it the send or receive queue
 154 */
 155 void add_queue(packet_queue_t **q, void *packet, size_t s)
 156 {
 157   queue_element_t *e;
 158 cp
 159   e = xmalloc(sizeof(*e));
 160   e->packet = xmalloc(s);
 161   memcpy(e->packet, packet, s);
 162
 163   if(!*q)
 164     {
 165       *q = xmalloc(sizeof(**q));
 166       (*q)->head = (*q)->tail = NULL;
 167     }
 168
 169   e->next = NULL;                       /* We insert at the tail */
 170
 171   if((*q)->tail)                        /* Do we have a tail? */
 172     {
 173       (*q)->tail->next = e;
 174       e->prev = (*q)->tail;
 175     }
 176   else                                  /* No tail -> no head too */
 177     {
 178       (*q)->head = e;
 179       e->prev = NULL;
 180     }
 181
 182   (*q)->tail = e;
 183 cp
 184 }
 185
 186 /* Remove a queue element */
 187 void del_queue(packet_queue_t **q, queue_element_t *e)
 188 {
 189 cp
 190   free(e->packet);
 191
 192   if(e->next)                           /* There is a successor, so we are not tail */
 193     {
 194       if(e->prev)                       /* There is a predecessor, so we are not head */
 195         {
 196           e->next->prev = e->prev;
 197           e->prev->next = e->next;
 198         }
 199       else                              /* We are head */
 200         {
 201           e->next->prev = NULL;
 202           (*q)->head = e->next;
 203         }
 204     }
 205   else                                  /* We are tail (or all alone!) */
 206     {
 207       if(e->prev)                       /* We are not alone :) */
 208         {
 209           e->prev->next = NULL;
 210           (*q)->tail = e->prev;
 211         }
 212       else                              /* Adieu */
 213         {
 214           free(*q);
 215           *q = NULL;
 216         }
 217     }
 218
 219   free(e);
 220 cp
 221 }
 222
 223 /*
 224   flush a queue by calling function for
 225   each packet, and removing it when that
 226   returned a zero exit code
 227 */
 228 void flush_queue(conn_list_t *cl, packet_queue_t **pq,
 229                  int (*function)(conn_list_t*,void*))
 230 {
 231   queue_element_t *p, *next = NULL;
 232 cp
 233   for(p = (*pq)->head; p != NULL; )
 234     {
 235       next = p->next;
 236
 237       if(!function(cl, p->packet))
 238         del_queue(pq, p);
 239
 240       p = next;
 241     }
 242
 243   if(debug_lvl > 3)
 244     syslog(LOG_DEBUG, _("Queue flushed"));
 245 cp
 246 }
 247
 248 /*
 249   flush the send&recv queues
 250   void because nothing goes wrong here, packets
 251   remain in the queue if something goes wrong
 252 */
 253 void flush_queues(conn_list_t *cl)
 254 {
 255 cp
 256   if(cl->sq)
 257     {
 258       if(debug_lvl > 3)
 259         syslog(LOG_DEBUG, _("Flushing send queue for %s (%s)"),
 260                cl->name, cl->hostname);
 261       flush_queue(cl, &(cl->sq), xsend);
 262     }
 263
 264   if(cl->rq)
 265     {
 266       if(debug_lvl > 3)
 267         syslog(LOG_DEBUG, _("Flushing receive queue for %s (%s)"),
 268                cl->name, cl->hostname);
 269       flush_queue(cl, &(cl->rq), xrecv);
 270     }
 271 cp
 272 }
 273
 274 /*
 275   send a packet to the given vpn ip.
 276 */
 277 int send_packet(ip_t to, vpn_packet_t *packet)
 278 {
 279   conn_list_t *cl;
 280 cp
 281   if((cl = lookup_conn_list_ipv4(to)) == NULL)
 282     {
 283       if(debug_lvl > 3)
 284         {
 285           syslog(LOG_NOTICE, _("Trying to look up %d.%d.%d.%d in connection list failed!"),
 286                  IP_ADDR_V(to));
 287         }
 288
 289       return -1;
 290    }
 291
 292   /* If we ourselves have indirectdata flag set, we should send only to our uplink! */
 293
 294   /* FIXME - check for indirection and reprogram it The Right Way(tm) this time. */
 295
 296   if(!cl->status.dataopen)
 297     if(setup_vpn_connection(cl) < 0)
 298       {
 299         syslog(LOG_ERR, _("Could not open UDP connection to %s (%s)"),
 300                cl->name, cl->hostname);
 301         return -1;
 302       }
 303
 304   if(!cl->status.validkey)
 305     {
 306       if(debug_lvl > 3)
 307         syslog(LOG_INFO, _("No valid key known yet for %s (%s), queueing packet"),
 308                cl->name, cl->hostname);
 309       add_queue(&(cl->sq), packet, packet->len + 2);
 310       if(!cl->status.waitingforkey)
 311         send_req_key(myself, cl);                       /* Keys should be sent to the host running the tincd */
 312       return 0;
 313     }
 314
 315   if(!cl->status.active)
 316     {
 317       if(debug_lvl > 3)
 318         syslog(LOG_INFO, _("%s (%s) is not ready, queueing packet"),
 319                cl->name, cl->hostname);
 320       add_queue(&(cl->sq), packet, packet->len + 2);
 321       return 0; /* We don't want to mess up, do we? */
 322     }
 323
 324   /* can we send it? can we? can we? huh? */
 325 cp
 326   return xsend(cl, packet);
 327 }
 328
 329 /*
 330   open the local ethertap device
 331 */
 332 int setup_tap_fd(void)
 333 {
 334   int nfd;
 335   const char *tapfname;
 336   config_t const *cfg;
 337   char *envvar;
 338
 339 #ifdef HAVE_TUNTAP
 340   struct ifreq ifr;
 341 #endif
 342 cp
 343   if((cfg = get_config_val(config, tapdevice)))
 344     tapfname = cfg->data.ptr;
 345   else
 346 #ifdef HAVE_TUNTAP
 347     tapfname = "/dev/misc/net/tun";
 348 #else
 349     tapfname = "/dev/tap0";
 350 #endif
 351 cp
 352   if((nfd = open(tapfname, O_RDWR | O_NONBLOCK)) < 0)
 353     {
 354       syslog(LOG_ERR, _("Could not open %s: %m"), tapfname);
 355       return -1;
 356     }
 357 cp
 358   tap_fd = nfd;
 359
 360   taptype = 0;
 361
 362 #ifdef HAVE_TUNTAP
 363   /* Ok now check if this is an old ethertap or a new tun/tap thingie */
 364   memset(&ifr, 0, sizeof(ifr));
 365 cp
 366   ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
 367   if (netname)
 368     strncpy(ifr.ifr_name, netname, IFNAMSIZ);
 369 cp
 370   if (!ioctl(tap_fd, TUNSETIFF, (void *) &ifr))
 371   {
 372     syslog(LOG_INFO, _("%s is a new style tun/tap device"), tapfname);
 373     taptype = 1;
 374
 375     if((cfg = get_config_val(config, tapsubnet)) == NULL)
 376       syslog(LOG_INFO, _("tun/tap device will be left unconfigured"));
 377     else
 378       /* Setup inetaddr/netmask etc */;
 379   }
 380 #endif
 381
 382   /* Add name of network interface to environment (for scripts) */
 383
 384   ioctl(tap_fd, SIOCGIFNAME, (void *) &ifr);
 385   asprintf(&envvar, "IFNAME=%s", ifr.ifr_name);
 386   putenv(envvar);
 387   free(envvar);
 388
 389 cp
 390   return 0;
 391 }
 392
 393 /*
 394   set up the socket that we listen on for incoming
 395   (tcp) connections
 396 */
 397 int setup_listen_meta_socket(int port)
 398 {
 399   int nfd, flags;
 400   struct sockaddr_in a;
 401   const int one = 1;
 402   config_t const *cfg;
 403 cp
 404   if((nfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
 405     {
 406       syslog(LOG_ERR, _("Creating metasocket failed: %m"));
 407       return -1;
 408     }
 409
 410   if(setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
 411     {
 412       syslog(LOG_ERR, _("setsockopt: %m"));
 413       return -1;
 414     }
 415
 416   if(setsockopt(nfd, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof(one)))
 417     {
 418       syslog(LOG_ERR, _("setsockopt: %m"));
 419       return -1;
 420     }
 421
 422   flags = fcntl(nfd, F_GETFL);
 423   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
 424     {
 425       syslog(LOG_ERR, _("fcntl: %m"));
 426       return -1;
 427     }
 428
 429   if((cfg = get_config_val(config, interface)))
 430     {
 431       if(setsockopt(nfd, SOL_SOCKET, SO_KEEPALIVE, cfg->data.ptr, strlen(cfg->data.ptr)))
 432         {
 433           syslog(LOG_ERR, _("Unable to bind listen socket to interface %s: %m"), cfg->data.ptr);
 434           return -1;
 435         }
 436     }
 437
 438   memset(&a, 0, sizeof(a));
 439   a.sin_family = AF_INET;
 440   a.sin_port = htons(port);
 441
 442   if((cfg = get_config_val(config, interfaceip)))
 443     a.sin_addr.s_addr = htonl(cfg->data.ip->ip);
 444   else
 445     a.sin_addr.s_addr = htonl(INADDR_ANY);
 446
 447   if(bind(nfd, (struct sockaddr *)&a, sizeof(struct sockaddr)))
 448     {
 449       syslog(LOG_ERR, _("Can't bind to port %hd/tcp: %m"), port);
 450       return -1;
 451     }
 452
 453   if(listen(nfd, 3))
 454     {
 455       syslog(LOG_ERR, _("listen: %m"));
 456       return -1;
 457     }
 458 cp
 459   return nfd;
 460 }
 461
 462 /*
 463   setup the socket for incoming encrypted
 464   data (the udp part)
 465 */
 466 int setup_vpn_in_socket(int port)
 467 {
 468   int nfd, flags;
 469   struct sockaddr_in a;
 470   const int one = 1;
 471 cp
 472   if((nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
 473     {
 474       syslog(LOG_ERR, _("Creating socket failed: %m"));
 475       return -1;
 476     }
 477
 478   if(setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
 479     {
 480       syslog(LOG_ERR, _("setsockopt: %m"));
 481       return -1;
 482     }
 483
 484   flags = fcntl(nfd, F_GETFL);
 485   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
 486     {
 487       syslog(LOG_ERR, _("fcntl: %m"));
 488       return -1;
 489     }
 490
 491   memset(&a, 0, sizeof(a));
 492   a.sin_family = AF_INET;
 493   a.sin_port = htons(port);
 494   a.sin_addr.s_addr = htonl(INADDR_ANY);
 495
 496   if(bind(nfd, (struct sockaddr *)&a, sizeof(struct sockaddr)))
 497     {
 498       syslog(LOG_ERR, _("Can't bind to port %hd/udp: %m"), port);
 499       return -1;
 500     }
 501 cp
 502   return nfd;
 503 }
 504
 505 /*
 506   setup an outgoing meta (tcp) socket
 507 */
 508 int setup_outgoing_meta_socket(conn_list_t *cl)
 509 {
 510   int flags;
 511   struct sockaddr_in a;
 512   config_t const *cfg;
 513 cp
 514   if(debug_lvl > 0)
 515     syslog(LOG_INFO, _("Trying to connect to %s"), cl->hostname);
 516
 517   if((cfg = get_config_val(cl->config, port)) == NULL)
 518     cl->port = 655;
 519   else
 520     cl->port = cfg->data.val;
 521
 522   cl->meta_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 523   if(cl->meta_socket == -1)
 524     {
 525       syslog(LOG_ERR, _("Creating socket for %s port %d failed: %m"),
 526              cl->hostname, cl->port);
 527       return -1;
 528     }
 529
 530   a.sin_family = AF_INET;
 531   a.sin_port = htons(cl->port);
 532   a.sin_addr.s_addr = htonl(cl->address);
 533
 534   if(connect(cl->meta_socket, (struct sockaddr *)&a, sizeof(a)) == -1)
 535     {
 536       syslog(LOG_ERR, _("%s port %hd: %m"), cl->hostname, cl->port);
 537       return -1;
 538     }
 539
 540   flags = fcntl(cl->meta_socket, F_GETFL);
 541   if(fcntl(cl->meta_socket, F_SETFL, flags | O_NONBLOCK) < 0)
 542     {
 543       syslog(LOG_ERR, _("fcntl for %s port %d: %m"),
 544              cl->hostname, cl->port);
 545       return -1;
 546     }
 547
 548   if(debug_lvl > 0)
 549     syslog(LOG_INFO, _("Connected to %s port %hd"),
 550          cl->hostname, cl->port);
 551
 552   cl->status.meta = 1;
 553 cp
 554   return 0;
 555 }
 556
 557 /*
 558   setup an outgoing connection. It's not
 559   necessary to also open an udp socket as
 560   well, because the other host will initiate
 561   an authentication sequence during which
 562   we will do just that.
 563 */
 564 int setup_outgoing_connection(char *name)
 565 {
 566   conn_list_t *ncn;
 567   struct hostent *h;
 568   config_t *cfg;
 569 cp
 570   if(check_id(name))
 571     {
 572       syslog(LOG_ERR, _("Invalid name for outgoing connection"));
 573       return -1;
 574     }
 575
 576   ncn = new_conn_list();
 577   asprintf(&ncn->name, "%s", name);
 578
 579   if(read_host_config(ncn))
 580     {
 581       syslog(LOG_ERR, _("Error reading host configuration file for %s"));
 582       free_conn_list(ncn);
 583       return -1;
 584     }
 585
 586   if(!(cfg = get_config_val(ncn->config, address)))
 587     {
 588       syslog(LOG_ERR, _("No address specified for %s"));
 589       free_conn_list(ncn);
 590       return -1;
 591     }
 592
 593   if(!(h = gethostbyname(cfg->data.ptr)))
 594     {
 595       syslog(LOG_ERR, _("Error looking up `%s': %m"), cfg->data.ptr);
 596       free_conn_list(ncn);
 597       return -1;
 598     }
 599
 600   ncn->address = ntohl(*((ip_t*)(h->h_addr_list[0])));
 601   ncn->hostname = hostlookup(htonl(ncn->address));
 602
 603   if(setup_outgoing_meta_socket(ncn) < 0)
 604     {
 605       syslog(LOG_ERR, _("Could not set up a meta connection to %s"),
 606              ncn->hostname);
 607       free_conn_list(ncn);
 608       return -1;
 609     }
 610
 611   ncn->status.outgoing = 1;
 612   ncn->buffer = xmalloc(MAXBUFSIZE);
 613   ncn->buflen = 0;
 614   ncn->last_ping_time = time(NULL);
 615   ncn->want_ping = 0;
 616
 617   conn_list_add(ncn);
 618
 619   send_id(ncn);
 620 cp
 621   return 0;
 622 }
 623
 624 /*
 625   set up the local sockets (listen only)
 626 */
 627 int setup_myself(void)
 628 {
 629   config_t const *cfg;
 630 cp
 631   myself = new_conn_list();
 632
 633   asprintf(&myself->hostname, "MYSELF"); /* FIXME? Do hostlookup on ourselves? */
 634   myself->flags = 0;
 635   myself->protocol_version = PROT_CURRENT;
 636
 637   if(!(cfg = get_config_val(config, tincname))) /* Not acceptable */
 638     {
 639       syslog(LOG_ERR, _("Name for tinc daemon required!"));
 640       return -1;
 641     }
 642   else
 643     asprintf(&myself->name, "%s", (char*)cfg->data.val);
 644
 645   if(check_id(myself->name))
 646     {
 647       syslog(LOG_ERR, _("Invalid name for myself!"));
 648       return -1;
 649     }
 650 cp
 651   if(!(cfg = get_config_val(config, privatekey)))
 652     {
 653       syslog(LOG_ERR, _("Private key for tinc daemon required!"));
 654       return -1;
 655     }
 656   else
 657     {
 658       myself->rsa_key = RSA_new();
 659       BN_hex2bn(&myself->rsa_key->d, cfg->data.ptr);
 660       BN_hex2bn(&myself->rsa_key->e, "FFFF");
 661     }
 662
 663   if(read_host_config(myself))
 664     {
 665       syslog(LOG_ERR, _("Cannot open host configuration file for myself!"));
 666       return -1;
 667     }
 668 cp
 669   if(!(cfg = get_config_val(myself->config, publickey)))
 670     {
 671       syslog(LOG_ERR, _("Public key for tinc daemon required!"));
 672       return -1;
 673     }
 674   else
 675     {
 676       BN_hex2bn(&myself->rsa_key->n, cfg->data.ptr);
 677     }
 678 /*
 679   if(RSA_check_key(myself->rsa_key) != 1)
 680     {
 681       syslog(LOG_ERR, _("Invalid public/private keypair!"));
 682       return -1;
 683     }
 684 */
 685   if(!(cfg = get_config_val(myself->config, port)))
 686     myself->port = 655;
 687   else
 688     myself->port = cfg->data.val;
 689
 690   if((cfg = get_config_val(myself->config, indirectdata)))
 691     if(cfg->data.val == stupid_true)
 692       myself->flags |= EXPORTINDIRECTDATA;
 693
 694   if((cfg = get_config_val(myself->config, tcponly)))
 695     if(cfg->data.val == stupid_true)
 696       myself->flags |= TCPONLY;
 697
 698   if((myself->meta_socket = setup_listen_meta_socket(myself->port)) < 0)
 699     {
 700       syslog(LOG_ERR, _("Unable to set up a listening socket!"));
 701       return -1;
 702     }
 703
 704   if((myself->socket = setup_vpn_in_socket(myself->port)) < 0)
 705     {
 706       syslog(LOG_ERR, _("Unable to set up an incoming vpn data socket!"));
 707       close(myself->meta_socket);
 708       return -1;
 709     }
 710
 711   myself->status.active = 1;
 712
 713   syslog(LOG_NOTICE, _("Ready: listening on port %hd"), myself->port);
 714 cp
 715   return 0;
 716 }
 717
 718 RETSIGTYPE
 719 sigalrm_handler(int a)
 720 {
 721   config_t const *cfg;
 722 cp
 723   cfg = get_next_config_val(config, connectto, upstreamindex++);
 724
 725   if(!upstreamindex && !cfg)
 726     /* No upstream IP given, we're listen only. */
 727     return;
 728
 729   while(cfg)
 730     {
 731       if(!setup_outgoing_connection(cfg->data.ptr))   /* function returns 0 when there are no problems */
 732         {
 733           signal(SIGALRM, SIG_IGN);
 734           return;
 735         }
 736       cfg = get_next_config_val(config, connectto, upstreamindex++); /* Or else we try the next ConnectTo line */
 737     }
 738
 739   signal(SIGALRM, sigalrm_handler);
 740   upstreamindex = 0;
 741   seconds_till_retry += 5;
 742   if(seconds_till_retry > MAXTIMEOUT)    /* Don't wait more than MAXTIMEOUT seconds. */
 743     seconds_till_retry = MAXTIMEOUT;
 744   syslog(LOG_ERR, _("Still failed to connect to other, will retry in %d seconds"),
 745          seconds_till_retry);
 746   alarm(seconds_till_retry);
 747 cp
 748 }
 749
 750 /*
 751   setup all initial network connections
 752 */
 753 int setup_network_connections(void)
 754 {
 755   config_t const *cfg;
 756   char *scriptname;
 757 cp
 758   if((cfg = get_config_val(config, pingtimeout)) == NULL)
 759     timeout = 5;
 760   else
 761     timeout = cfg->data.val;
 762
 763   if(setup_tap_fd() < 0)
 764     return -1;
 765
 766   if(setup_myself() < 0)
 767     return -1;
 768
 769   /* Run tinc-up script to further initialize the tap interface */
 770
 771   asprintf(&scriptname, "%s/tinc-up", confbase);
 772
 773   if(!fork())
 774     {
 775
 776       execl(scriptname, NULL);
 777
 778       if(errno != ENOENT)
 779         syslog(LOG_WARNING, _("Error while executing %s: %m"), scriptname);
 780
 781       exit(0);
 782     }
 783
 784   free(scriptname);
 785
 786   if((cfg = get_next_config_val(config, connectto, upstreamindex++)) == NULL)
 787     /* No upstream IP given, we're listen only. */
 788     return 0;
 789
 790   while(cfg)
 791     {
 792       if(!setup_outgoing_connection(cfg->data.ptr))   /* function returns 0 when there are no problems */
 793         return 0;
 794       cfg = get_next_config_val(config, connectto, upstreamindex++); /* Or else we try the next ConnectTo line */
 795     }
 796
 797   signal(SIGALRM, sigalrm_handler);
 798   upstreamindex = 0;
 799   seconds_till_retry = MAXTIMEOUT;
 800   syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in %d seconds"), seconds_till_retry);
 801   alarm(seconds_till_retry);
 802 cp
 803   return 0;
 804 }
 805
 806 /*
 807   close all open network connections
 808 */
 809 void close_network_connections(void)
 810 {
 811   conn_list_t *p;
 812   char *scriptname;
 813 cp
 814   for(p = conn_list; p != NULL; p = p->next)
 815     {
 816       if(p->status.dataopen)
 817         {
 818           shutdown(p->socket, 0); /* No more receptions */
 819           close(p->socket);
 820         }
 821       if(p->status.meta)
 822         {
 823           send_termreq(p);
 824           shutdown(p->meta_socket, 0); /* No more receptions */
 825           close(p->meta_socket);
 826         }
 827     }
 828
 829   if(myself)
 830     if(myself->status.active)
 831       {
 832         close(myself->meta_socket);
 833         close(myself->socket);
 834       }
 835
 836   /* Execute tinc-down script right before shutting down the interface */
 837
 838   asprintf(&scriptname, "%s/tinc-down", confbase);
 839
 840   if(!fork())
 841     {
 842       execl(scriptname, NULL);
 843
 844       if(errno != ENOENT)
 845         syslog(LOG_WARNING, _("Error while executing %s: %m"), scriptname);
 846
 847       exit(0);
 848     }
 849
 850   free(scriptname);
 851
 852   close(tap_fd);
 853   destroy_conn_list();
 854
 855   syslog(LOG_NOTICE, _("Terminating"));
 856 cp
 857   return;
 858 }
 859
 860 /*
 861   create a data (udp) socket
 862 */
 863 int setup_vpn_connection(conn_list_t *cl)
 864 {
 865   int nfd, flags;
 866   struct sockaddr_in a;
 867 cp
 868   if(debug_lvl > 0)
 869     syslog(LOG_DEBUG, _("Opening UDP socket to %s"), cl->hostname);
 870
 871   nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 872   if(nfd == -1)
 873     {
 874       syslog(LOG_ERR, _("Creating UDP socket failed: %m"));
 875       return -1;
 876     }
 877
 878   a.sin_family = AF_INET;
 879   a.sin_port = htons(cl->port);
 880   a.sin_addr.s_addr = htonl(cl->address);
 881
 882   if(connect(nfd, (struct sockaddr *)&a, sizeof(a)) == -1)
 883     {
 884       syslog(LOG_ERR, _("Connecting to %s port %d failed: %m"),
 885              cl->hostname, cl->port);
 886       return -1;
 887     }
 888
 889   flags = fcntl(nfd, F_GETFL);
 890   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
 891     {
 892       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m %s (%s)"), __FILE__, __LINE__, nfd,
 893              cl->name, cl->hostname);
 894       return -1;
 895     }
 896
 897   cl->socket = nfd;
 898   cl->status.dataopen = 1;
 899 cp
 900   return 0;
 901 }
 902
 903 /*
 904   handle an incoming tcp connect call and open
 905   a connection to it.
 906 */
 907 conn_list_t *create_new_connection(int sfd)
 908 {
 909   conn_list_t *p;
 910   struct sockaddr_in ci;
 911   int len = sizeof(ci);
 912 cp
 913   p = new_conn_list();
 914
 915   if(getpeername(sfd, &ci, &len) < 0)
 916     {
 917       syslog(LOG_ERR, _("Error: getpeername: %m"));
 918       return NULL;
 919     }
 920
 921   p->name = unknown;
 922   p->address = ntohl(ci.sin_addr.s_addr);
 923   p->hostname = hostlookup(ci.sin_addr.s_addr);
 924   p->meta_socket = sfd;
 925   p->status.meta = 1;
 926   p->buffer = xmalloc(MAXBUFSIZE);
 927   p->buflen = 0;
 928   p->last_ping_time = time(NULL);
 929   p->want_ping = 0;
 930
 931   if(debug_lvl > 0)
 932     syslog(LOG_NOTICE, _("Connection from %s port %d"),
 933          p->hostname, htons(ci.sin_port));
 934
 935   p->allow_request = ID;
 936 cp
 937   return p;
 938 }
 939
 940 /*
 941   put all file descriptors in an fd_set array
 942 */
 943 void build_fdset(fd_set *fs)
 944 {
 945   conn_list_t *p;
 946 cp
 947   FD_ZERO(fs);
 948
 949   for(p = conn_list; p != NULL; p = p->next)
 950     {
 951       if(p->status.meta)
 952         FD_SET(p->meta_socket, fs);
 953       if(p->status.dataopen)
 954         FD_SET(p->socket, fs);
 955     }
 956
 957   FD_SET(myself->meta_socket, fs);
 958   FD_SET(myself->socket, fs);
 959   FD_SET(tap_fd, fs);
 960 cp
 961 }
 962
 963 /*
 964   receive incoming data from the listening
 965   udp socket and write it to the ethertap
 966   device after being decrypted
 967 */
 968 int handle_incoming_vpn_data()
 969 {
 970   vpn_packet_t pkt;
 971   int lenin;
 972   int x, l = sizeof(x);
 973 cp
 974   if(getsockopt(myself->socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
 975     {
 976       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"),
 977              __FILE__, __LINE__, myself->socket);
 978       return -1;
 979     }
 980   if(x)
 981     {
 982       syslog(LOG_ERR, _("Incoming data socket error: %s"), strerror(x));
 983       return -1;
 984     }
 985
 986   if(recvfrom(myself->socket, (char *) &(pkt.len), MTU, 0, NULL, NULL) <= 0)
 987     {
 988       syslog(LOG_ERR, _("Receiving packet failed: %m"));
 989       return -1;
 990     }
 991
 992 cp
 993   return xrecv(&pkt);
 994 }
 995
 996 /*
 997   terminate a connection and notify the other
 998   end before closing the sockets
 999 */
1000 void terminate_connection(conn_list_t *cl)
1001 {
1002   conn_list_t *p;
1003
1004 cp
1005   if(cl->status.remove)
1006     return;
1007
1008   if(debug_lvl > 0)
1009     syslog(LOG_NOTICE, _("Closing connection with %s (%s)"),
1010            cl->name, cl->hostname);
1011
1012   if(cl->socket)
1013     close(cl->socket);
1014   if(cl->status.meta)
1015     close(cl->meta_socket);
1016
1017   cl->status.remove = 1;
1018
1019   /* If this cl isn't active, don't send any DEL_HOSTs. */
1020
1021 /* FIXME: reprogram this.
1022   if(cl->status.active)
1023     notify_others(cl,NULL,send_del_host);
1024 */
1025
1026 cp
1027   /* Find all connections that were lost because they were behind cl
1028      (the connection that was dropped). */
1029   if(cl->status.meta)
1030     for(p = conn_list; p != NULL; p = p->next)
1031       {
1032         if((p->nexthop == cl) && (p != cl))
1033           {
1034             if(cl->status.active && p->status.active)
1035 /* FIXME: reprogram this
1036               notify_others(p,cl,send_del_host);
1037 */;
1038            if(cl->socket)
1039              close(cl->socket);
1040             p->status.active = 0;
1041             p->status.remove = 1;
1042           }
1043       }
1044
1045   cl->status.active = 0;
1046
1047   if(cl->status.outgoing)
1048     {
1049       signal(SIGALRM, sigalrm_handler);
1050       seconds_till_retry = 5;
1051       alarm(seconds_till_retry);
1052       syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in 5 seconds"));
1053     }
1054 cp
1055 }
1056
1057 /*
1058   Check if the other end is active.
1059   If we have sent packets, but didn't receive any,
1060   then possibly the other end is dead. We send a
1061   PING request over the meta connection. If the other
1062   end does not reply in time, we consider them dead
1063   and close the connection.
1064 */
1065 int check_dead_connections(void)
1066 {
1067   conn_list_t *p;
1068   time_t now;
1069 cp
1070   now = time(NULL);
1071   for(p = conn_list; p != NULL; p = p->next)
1072     {
1073       if(p->status.remove)
1074         continue;
1075       if(p->status.active && p->status.meta)
1076         {
1077           if(p->last_ping_time + timeout < now)
1078             {
1079               if(p->status.pinged && !p->status.got_pong)
1080                 {
1081                   if(debug_lvl > 1)
1082                     syslog(LOG_INFO, _("%s (%s) didn't respond to PING"),
1083                            p->name, p->hostname);
1084                   p->status.timeout = 1;
1085                   terminate_connection(p);
1086                 }
1087               else if(p->want_ping)
1088                 {
1089                   send_ping(p);
1090                   p->last_ping_time = now;
1091                   p->status.pinged = 1;
1092                   p->status.got_pong = 0;
1093                 }
1094             }
1095         }
1096     }
1097 cp
1098   return 0;
1099 }
1100
1101 /*
1102   accept a new tcp connect and create a
1103   new connection
1104 */
1105 int handle_new_meta_connection()
1106 {
1107   conn_list_t *ncn;
1108   struct sockaddr client;
1109   int nfd, len = sizeof(client);
1110 cp
1111   if((nfd = accept(myself->meta_socket, &client, &len)) < 0)
1112     {
1113       syslog(LOG_ERR, _("Accepting a new connection failed: %m"));
1114       return -1;
1115     }
1116
1117   if(!(ncn = create_new_connection(nfd)))
1118     {
1119       shutdown(nfd, 2);
1120       close(nfd);
1121       syslog(LOG_NOTICE, _("Closed attempted connection"));
1122       return 0;
1123     }
1124
1125   ncn->status.meta = 1;
1126   ncn->next = conn_list;
1127   conn_list = ncn;
1128 cp
1129   return 0;
1130 }
1131
1132 /*
1133   check all connections to see if anything
1134   happened on their sockets
1135 */
1136 void check_network_activity(fd_set *f)
1137 {
1138   conn_list_t *p;
1139   int x, l = sizeof(x);
1140 cp
1141   for(p = conn_list; p != NULL; p = p->next)
1142     {
1143       if(p->status.remove)
1144         continue;
1145
1146       if(p->status.dataopen)
1147         if(FD_ISSET(p->socket, f))
1148           {
1149             /*
1150               The only thing that can happen to get us here is apparently an
1151               error on this outgoing(!) UDP socket that isn't immediate (i.e.
1152               something that will not trigger an error directly on send()).
1153               I've once got here when it said `No route to host'.
1154             */
1155             getsockopt(p->socket, SOL_SOCKET, SO_ERROR, &x, &l);
1156             syslog(LOG_ERR, _("Outgoing data socket error for %s (%s): %s"),
1157                    p->name, p->hostname, strerror(x));
1158             terminate_connection(p);
1159             return;
1160           }
1161
1162       if(p->status.meta)
1163         if(FD_ISSET(p->meta_socket, f))
1164           if(receive_meta(p) < 0)
1165             {
1166               terminate_connection(p);
1167               return;
1168             }
1169     }
1170
1171   if(FD_ISSET(myself->socket, f))
1172     handle_incoming_vpn_data();
1173
1174   if(FD_ISSET(myself->meta_socket, f))
1175     handle_new_meta_connection();
1176 cp
1177 }
1178
1179 /*
1180   read, encrypt and send data that is
1181   available through the ethertap device
1182 */
1183 void handle_tap_input(void)
1184 {
1185   vpn_packet_t vp;
1186   ip_t from, to;
1187   int ether_type, lenin;
1188 cp
1189   memset(&vp, 0, sizeof(vp));
1190
1191   if(taptype = 1)
1192     {
1193       if((lenin = read(tap_fd, vp.data, MTU)) <= 0)
1194         {
1195           syslog(LOG_ERR, _("Error while reading from tapdevice: %m"));
1196           return;
1197         }
1198       vp.len = lenin;
1199     }
1200   else
1201     {
1202       if((lenin = read(tap_fd, &vp, MTU)) <= 0)
1203         {
1204           syslog(LOG_ERR, _("Error while reading from tapdevice: %m"));
1205           return;
1206         }
1207       vp.len = lenin - 2;
1208     }
1209
1210   total_tap_in += lenin;
1211
1212   ether_type = ntohs(*((unsigned short*)(&vp.data[12])));
1213   if(ether_type != 0x0800)
1214     {
1215       if(debug_lvl > 3)
1216         syslog(LOG_INFO, _("Non-IP ethernet frame %04x from %02x:%02x:%02x:%02x:%02x:%02x"), ether_type, MAC_ADDR_V(vp.data[6]));
1217       return;
1218     }
1219
1220   if(lenin < 32)
1221     {
1222       if(debug_lvl > 3)
1223         syslog(LOG_INFO, _("Dropping short packet from %02x:%02x:%02x:%02x:%02x:%02x"), MAC_ADDR_V(vp.data[6]));
1224       return;
1225     }
1226
1227   from = ntohl(*((unsigned long*)(&vp.data[26])));
1228   to = ntohl(*((unsigned long*)(&vp.data[30])));
1229
1230   send_packet(to, &vp);
1231 cp
1232 }
1233
1234 /*
1235   this is where it all happens...
1236 */
1237 void main_loop(void)
1238 {
1239   fd_set fset;
1240   struct timeval tv;
1241   int r;
1242   time_t last_ping_check;
1243 cp
1244   last_ping_check = time(NULL);
1245
1246   for(;;)
1247     {
1248       tv.tv_sec = timeout;
1249       tv.tv_usec = 0;
1250
1251       prune_conn_list();
1252       build_fdset(&fset);
1253
1254       if((r = select(FD_SETSIZE, &fset, NULL, NULL, &tv)) < 0)
1255         {
1256           if(errno != EINTR) /* because of alarm */
1257             {
1258               syslog(LOG_ERR, _("Error while waiting for input: %m"));
1259               return;
1260             }
1261         }
1262
1263       if(sighup)
1264         {
1265           sighup = 0;
1266 /* FIXME: reprogram this.
1267           if(debug_lvl > 1)
1268             syslog(LOG_INFO, _("Rereading configuration file"));
1269           close_network_connections();
1270           clear_config();
1271           if(read_config_file(&config, configfilename))
1272             {
1273               syslog(LOG_ERR, _("Unable to reread configuration file, exiting"));
1274               exit(0);
1275             }
1276           sleep(5);
1277           setup_network_connections();
1278 */
1279           continue;
1280         }
1281
1282       if(last_ping_check + timeout < time(NULL))
1283         /* Let's check if everybody is still alive */
1284         {
1285           check_dead_connections();
1286           last_ping_check = time(NULL);
1287         }
1288
1289       if(r > 0)
1290         {
1291           check_network_activity(&fset);
1292
1293           /* local tap data */
1294           if(FD_ISSET(tap_fd, &fset))
1295             handle_tap_input();
1296         }
1297     }
1298 cp
1299 }