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