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