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