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