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