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