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