www.tinc-vpn.org Git - tinc/blob - src/net.c

   1 /*
   2     net.c -- most of the network code
   3     Copyright (C) 1998,1999,2000 Ivo Timmermans <itimmermans@bigfoot.com>,
   4                             2000 Guus Sliepen <guus@sliepen.warande.net>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20     $Id: net.c,v 1.35.4.18 2000/06/30 21:03:51 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   if(debug_lvl > 0)
 535     syslog(LOG_INFO, _("Connected to %s port %hd"),
 536          cl->real_hostname, cl->port);
 537 cp
 538   return 0;
 539 }
 540
 541 /*
 542   setup an outgoing connection. It's not
 543   necessary to also open an udp socket as
 544   well, because the other host will initiate
 545   an authentication sequence during which
 546   we will do just that.
 547 */
 548 int setup_outgoing_connection(ip_t ip)
 549 {
 550   conn_list_t *ncn;
 551 cp
 552   ncn = new_conn_list();
 553   ncn->real_ip = ip;
 554   ncn->real_hostname = hostlookup(htonl(ip));
 555
 556   if(setup_outgoing_meta_socket(ncn) < 0)
 557     {
 558       syslog(LOG_ERR, _("Could not set up a meta connection to %s"),
 559              ncn->real_hostname);
 560       free_conn_element(ncn);
 561       return -1;
 562     }
 563
 564   ncn->status.meta = 1;
 565   ncn->status.outgoing = 1;
 566   ncn->next = conn_list;
 567   conn_list = ncn;
 568 cp
 569   return 0;
 570 }
 571
 572 /*
 573   set up the local sockets (listen only)
 574 */
 575 int setup_myself(void)
 576 {
 577   config_t const *cfg;
 578 cp
 579   myself = new_conn_list();
 580
 581   if(!(cfg = get_config_val(myvpnip)))
 582     {
 583       syslog(LOG_ERR, _("No value for my VPN IP given"));
 584       return -1;
 585     }
 586
 587   myself->vpn_ip = cfg->data.ip->ip;
 588   myself->vpn_hostname = hostlookup(htonl(myself->vpn_ip));
 589   myself->real_hostname = hostlookup(htonl(myself->vpn_ip));
 590   myself->vpn_mask = cfg->data.ip->mask;
 591   myself->flags = 0;
 592
 593   if(!(cfg = get_config_val(listenport)))
 594     myself->port = 655;
 595   else
 596     myself->port = cfg->data.val;
 597
 598   if(cfg = get_config_val(indirectdata))
 599     if(cfg->data.val == stupid_true)
 600       myself->flags |= EXPORTINDIRECTDATA;
 601
 602   if((myself->meta_socket = setup_listen_meta_socket(myself->port)) < 0)
 603     {
 604       syslog(LOG_ERR, _("Unable to set up a listening socket"));
 605       return -1;
 606     }
 607
 608   if((myself->socket = setup_vpn_in_socket(myself->port)) < 0)
 609     {
 610       syslog(LOG_ERR, _("Unable to set up an incoming vpn data socket"));
 611       close(myself->meta_socket);
 612       return -1;
 613     }
 614
 615   myself->status.active = 1;
 616
 617   syslog(LOG_NOTICE, _("Ready: listening on port %hd"), myself->port);
 618 cp
 619   return 0;
 620 }
 621
 622 RETSIGTYPE
 623 sigalrm_handler(int a)
 624 {
 625   config_t const *cfg;
 626 cp
 627   cfg = get_next_config_val(upstreamip, upstreamindex++);
 628
 629   while(cfg)
 630     {
 631       if(!setup_outgoing_connection(cfg->data.ip->ip))   /* function returns 0 when there are no problems */
 632         {
 633           signal(SIGALRM, SIG_IGN);
 634           return;
 635         }
 636       cfg = get_next_config_val(upstreamip, upstreamindex++); /* Or else we try the next ConnectTo line */
 637     }
 638
 639   signal(SIGALRM, sigalrm_handler);
 640   upstreamindex = 0;
 641   seconds_till_retry += 5;
 642   if(seconds_till_retry > MAXTIMEOUT)    /* Don't wait more than MAXTIMEOUT seconds. */
 643     seconds_till_retry = MAXTIMEOUT;
 644   syslog(LOG_ERR, _("Still failed to connect to other, will retry in %d seconds"),
 645          seconds_till_retry);
 646   alarm(seconds_till_retry);
 647 cp
 648 }
 649
 650 /*
 651   setup all initial network connections
 652 */
 653 int setup_network_connections(void)
 654 {
 655   config_t const *cfg;
 656 cp
 657   if((cfg = get_config_val(pingtimeout)) == NULL)
 658     timeout = 5;
 659   else
 660     timeout = cfg->data.val;
 661
 662   if(setup_tap_fd() < 0)
 663     return -1;
 664
 665   if(setup_myself() < 0)
 666     return -1;
 667
 668   if((cfg = get_next_config_val(upstreamip, upstreamindex++)) == NULL)
 669     /* No upstream IP given, we're listen only. */
 670     return 0;
 671
 672   while(cfg)
 673     {
 674       if(!setup_outgoing_connection(cfg->data.ip->ip))   /* function returns 0 when there are no problems */
 675         return 0;
 676       cfg = get_next_config_val(upstreamip, upstreamindex++); /* Or else we try the next ConnectTo line */
 677     }
 678
 679   signal(SIGALRM, sigalrm_handler);
 680   upstreamindex = 0;
 681   seconds_till_retry = MAXTIMEOUT;
 682   syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in %d seconds"), seconds_till_retry);
 683   alarm(seconds_till_retry);
 684 cp
 685   return 0;
 686 }
 687
 688 /*
 689   close all open network connections
 690 */
 691 void close_network_connections(void)
 692 {
 693   conn_list_t *p;
 694 cp
 695   for(p = conn_list; p != NULL; p = p->next)
 696     {
 697       if(p->status.dataopen)
 698         {
 699           shutdown(p->socket, 0); /* No more receptions */
 700           close(p->socket);
 701         }
 702       if(p->status.meta)
 703         {
 704           send_termreq(p);
 705           shutdown(p->meta_socket, 0); /* No more receptions */
 706           close(p->meta_socket);
 707         }
 708     }
 709
 710   if(myself)
 711     if(myself->status.active)
 712       {
 713         close(myself->meta_socket);
 714         close(myself->socket);
 715       }
 716
 717   close(tap_fd);
 718   destroy_conn_list();
 719
 720   syslog(LOG_NOTICE, _("Terminating"));
 721 cp
 722   return;
 723 }
 724
 725 /*
 726   create a data (udp) socket
 727 */
 728 int setup_vpn_connection(conn_list_t *cl)
 729 {
 730   int nfd, flags;
 731   struct sockaddr_in a;
 732 cp
 733   if(debug_lvl > 0)
 734     syslog(LOG_DEBUG, _("Opening UDP socket to %s"), cl->real_hostname);
 735
 736   nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 737   if(nfd == -1)
 738     {
 739       syslog(LOG_ERR, _("Creating UDP socket failed: %m"));
 740       return -1;
 741     }
 742
 743   a.sin_family = AF_INET;
 744   a.sin_port = htons(cl->port);
 745   a.sin_addr.s_addr = htonl(cl->real_ip);
 746
 747   if(connect(nfd, (struct sockaddr *)&a, sizeof(a)) == -1)
 748     {
 749       syslog(LOG_ERR, _("Connecting to %s port %d failed: %m"),
 750              cl->real_hostname, cl->port);
 751       return -1;
 752     }
 753
 754   flags = fcntl(nfd, F_GETFL);
 755   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
 756     {
 757       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m %s (%s)"), __FILE__, __LINE__, nfd,
 758              cl->vpn_hostname, cl->real_hostname);
 759       return -1;
 760     }
 761
 762   cl->socket = nfd;
 763   cl->status.dataopen = 1;
 764 cp
 765   return 0;
 766 }
 767
 768 /*
 769   handle an incoming tcp connect call and open
 770   a connection to it.
 771 */
 772 conn_list_t *create_new_connection(int sfd)
 773 {
 774   conn_list_t *p;
 775   struct sockaddr_in ci;
 776   int len = sizeof(ci);
 777 cp
 778   p = new_conn_list();
 779
 780   if(getpeername(sfd, &ci, &len) < 0)
 781     {
 782       syslog(LOG_ERR, _("Error: getpeername: %m"));
 783       return NULL;
 784     }
 785
 786   p->real_ip = ntohl(ci.sin_addr.s_addr);
 787   p->real_hostname = hostlookup(ci.sin_addr.s_addr);
 788   p->meta_socket = sfd;
 789   p->status.meta = 1;
 790   p->buflen = 0;
 791   p->last_ping_time = time(NULL);
 792   p->want_ping = 0;
 793
 794   if(debug_lvl > 0)
 795     syslog(LOG_NOTICE, _("Connection from %s port %d"),
 796          p->real_hostname, htons(ci.sin_port));
 797
 798   if(send_basic_info(p) < 0)
 799     {
 800       free_conn_element(p);
 801       return NULL;
 802     }
 803 cp
 804   return p;
 805 }
 806
 807 /*
 808   put all file descriptors in an fd_set array
 809 */
 810 void build_fdset(fd_set *fs)
 811 {
 812   conn_list_t *p;
 813 cp
 814   FD_ZERO(fs);
 815
 816   for(p = conn_list; p != NULL; p = p->next)
 817     {
 818       if(p->status.meta)
 819         FD_SET(p->meta_socket, fs);
 820       if(p->status.dataopen)
 821         FD_SET(p->socket, fs);
 822     }
 823
 824   FD_SET(myself->meta_socket, fs);
 825   FD_SET(myself->socket, fs);
 826   FD_SET(tap_fd, fs);
 827 cp
 828 }
 829
 830 /*
 831   receive incoming data from the listening
 832   udp socket and write it to the ethertap
 833   device after being decrypted
 834 */
 835 int handle_incoming_vpn_data(conn_list_t *cl)
 836 {
 837   real_packet_t rp;
 838   int lenin;
 839   int x, l = sizeof(x);
 840   conn_list_t *f;
 841 cp
 842   if(getsockopt(cl->socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
 843     {
 844       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m %s (%s)"), __FILE__, __LINE__, cl->socket,
 845              cl->vpn_hostname, cl->real_hostname);
 846       return -1;
 847     }
 848   if(x)
 849     {
 850       syslog(LOG_ERR, _("Incoming data socket error for %s (%s): %s"),
 851              cl->vpn_hostname, cl->real_hostname, sys_errlist[x]);
 852       return -1;
 853     }
 854
 855   rp.len = -1;
 856   lenin = recvfrom(cl->socket, &rp, MTU, 0, NULL, NULL);
 857   if(lenin <= 0)
 858     {
 859       syslog(LOG_ERR, _("Receiving packet from %s (%s) failed: %m"), cl->vpn_hostname, cl->real_hostname);
 860       return -1;
 861     }
 862   total_socket_in += lenin;
 863
 864   rp.data.len = ntohs(rp.data.len);
 865   rp.len = ntohs(rp.len);
 866   rp.from = ntohl(rp.from);
 867
 868   if(rp.len >= 0)
 869     {
 870       f = lookup_conn(rp.from);
 871       if(!f)
 872         {
 873           syslog(LOG_ERR, _("Got packet from %s (%s) with unknown origin %d.%d.%d.%d?"),
 874                  cl->vpn_hostname, cl->real_hostname, IP_ADDR_V(rp.from));
 875           return -1;
 876         }
 877
 878       if(f->status.validkey)
 879         xrecv(f, &rp);
 880       else
 881         {
 882           add_queue(&(f->rq), &rp, rp.len);
 883           if(!cl->status.waitingforkey)
 884             send_key_request(rp.from);
 885         }
 886
 887       if(my_key_expiry <= time(NULL))
 888         regenerate_keys();
 889     }
 890 cp
 891   return 0;
 892 }
 893
 894 /*
 895   terminate a connection and notify the other
 896   end before closing the sockets
 897 */
 898 void terminate_connection(conn_list_t *cl)
 899 {
 900   conn_list_t *p, *q;
 901
 902 cp
 903   if(cl->status.remove)
 904     return;
 905
 906   if(debug_lvl > 0)
 907     syslog(LOG_NOTICE, _("Closing connection with %s (%s)"),
 908            cl->vpn_hostname, cl->real_hostname);
 909
 910   if(cl->status.timeout)
 911     send_timeout(cl);
 912 /*  else if(!cl->status.termreq)
 913     send_termreq(cl);
 914  */
 915
 916   if(cl->socket)
 917     close(cl->socket);
 918   if(cl->status.meta)
 919     close(cl->meta_socket);
 920
 921   cl->status.remove = 1;
 922
 923   /* If this cl isn't active, don't send any DEL_HOSTs. */
 924   if(cl->status.active)
 925     notify_others(cl,NULL,send_del_host);
 926
 927 cp
 928   /* Find all connections that were lost because they were behind cl
 929      (the connection that was dropped). */
 930   if(cl->status.meta)
 931     for(p = conn_list; p != NULL; p = p->next)
 932       {
 933         if((p->nexthop == cl) && (p != cl))
 934           {
 935             if(cl->status.active && p->status.active)
 936               notify_others(p,cl,send_del_host);
 937            if(cl->socket)
 938              close(cl->socket);
 939             p->status.active = 0;
 940             p->status.remove = 1;
 941           }
 942       }
 943
 944   cl->status.active = 0;
 945
 946   if(cl->status.outgoing)
 947     {
 948       signal(SIGALRM, sigalrm_handler);
 949       seconds_till_retry = 5;
 950       alarm(seconds_till_retry);
 951       syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in 5 seconds"));
 952     }
 953 cp
 954 }
 955
 956 /*
 957   Check if the other end is active.
 958   If we have sent packets, but didn't receive any,
 959   then possibly the other end is dead. We send a
 960   PING request over the meta connection. If the other
 961   end does not reply in time, we consider them dead
 962   and close the connection.
 963 */
 964 int check_dead_connections(void)
 965 {
 966   conn_list_t *p;
 967   time_t now;
 968 cp
 969   now = time(NULL);
 970   for(p = conn_list; p != NULL; p = p->next)
 971     {
 972       if(p->status.remove)
 973         continue;
 974       if(p->status.active && p->status.meta)
 975         {
 976           if(p->last_ping_time + timeout < now)
 977             {
 978               if(p->status.pinged && !p->status.got_pong)
 979                 {
 980                   if(debug_lvl > 1)
 981                     syslog(LOG_INFO, _("%s (%s) didn't respond to PING"),
 982                            p->vpn_hostname, p->real_hostname);
 983                   p->status.timeout = 1;
 984                   terminate_connection(p);
 985                 }
 986               else if(p->want_ping)
 987                 {
 988                   send_ping(p);
 989                   p->last_ping_time = now;
 990                   p->status.pinged = 1;
 991                   p->status.got_pong = 0;
 992                 }
 993             }
 994         }
 995     }
 996 cp
 997   return 0;
 998 }
 999
1000 /*
1001   accept a new tcp connect and create a
1002   new connection
1003 */
1004 int handle_new_meta_connection(conn_list_t *cl)
1005 {
1006   conn_list_t *ncn;
1007   struct sockaddr client;
1008   int nfd, len = sizeof(client);
1009 cp
1010   if((nfd = accept(cl->meta_socket, &client, &len)) < 0)
1011     {
1012       syslog(LOG_ERR, _("Accepting a new connection failed: %m"));
1013       return -1;
1014     }
1015
1016   if(!(ncn = create_new_connection(nfd)))
1017     {
1018       shutdown(nfd, 2);
1019       close(nfd);
1020       syslog(LOG_NOTICE, _("Closed attempted connection"));
1021       return 0;
1022     }
1023
1024   ncn->status.meta = 1;
1025   ncn->next = conn_list;
1026   conn_list = ncn;
1027 cp
1028   return 0;
1029 }
1030
1031 /*
1032   dispatch any incoming meta requests
1033 */
1034 int handle_incoming_meta_data(conn_list_t *cl)
1035 {
1036   int x, l = sizeof(x);
1037   int request, oldlen, i;
1038   int lenin = 0;
1039 cp
1040   if(getsockopt(cl->meta_socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
1041     {
1042       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m %s (%s)"), __FILE__, __LINE__, cl->meta_socket,
1043              cl->vpn_hostname, cl->real_hostname);
1044       return -1;
1045     }
1046   if(x)
1047     {
1048       syslog(LOG_ERR, _("Metadata socket error for %s (%s): %s"),
1049              cl->vpn_hostname, cl->real_hostname, sys_errlist[x]);
1050       return -1;
1051     }
1052
1053   if(cl->buflen >= MAXBUFSIZE)
1054     {
1055       syslog(LOG_ERR, _("Metadata read buffer overflow!"));
1056       return -1;
1057     }
1058
1059   lenin = read(cl->meta_socket, cl->buffer, MAXBUFSIZE-cl->buflen);
1060
1061   if(lenin<=0)
1062     {
1063       if(errno==EINTR)
1064         return 0;
1065       if(errno==0)
1066         if(debug_lvl>0)
1067           syslog(LOG_NOTICE, _("Connection closed by %s (%s)"),
1068                  cl->vpn_hostname, cl->real_hostname);
1069       else
1070         syslog(LOG_ERR, _("Metadata socket read error for %s (%s): %m"),
1071                cl->vpn_hostname, cl->real_hostname);
1072       return -1;
1073     }
1074
1075   oldlen = cl->buflen;
1076   cl->buflen += lenin;
1077
1078   for(;;)
1079     {
1080       cl->reqlen = 0;
1081
1082       for(i = oldlen; i < cl->buflen; i++)
1083         {
1084           if(cl->buffer[i] == '\n')
1085             {
1086               cl->buffer[i] = 0;  /* replace end-of-line by end-of-string so we can use sscanf */
1087               cl->reqlen = i + 1;
1088               break;
1089             }
1090         }
1091
1092       if(cl->reqlen)
1093         {
1094           if(debug_lvl > 2)
1095             syslog(LOG_DEBUG, _("Got request from %s (%s): %s"),
1096                          cl->vpn_hostname, cl->real_hostname, cl->buffer);
1097           if(sscanf(cl->buffer, "%d", &request) == 1)
1098             {
1099               if((request < 0) || (request > 255) || (request_handlers[request] == NULL))
1100                 {
1101                   syslog(LOG_ERR, _("Unknown request from %s (%s)"),
1102                          cl->vpn_hostname, cl->real_hostname);
1103                   return -1;
1104                 }
1105
1106               if(request_handlers[request](cl))  /* Something went wrong. Probably scriptkiddies. Terminate. */
1107                 {
1108                   syslog(LOG_ERR, _("Error while processing request from %s (%s)"),
1109                          cl->vpn_hostname, cl->real_hostname);
1110                   return -1;
1111                 }
1112             }
1113           else
1114             {
1115               syslog(LOG_ERR, _("Bogus data received from %s (%s)"),
1116                          cl->vpn_hostname, cl->real_hostname);
1117               return -1;
1118             }
1119
1120           cl->buflen -= cl->reqlen;
1121           memmove(cl->buffer, cl->buffer + cl->reqlen, cl->buflen);
1122           oldlen = 0;
1123         }
1124       else
1125         {
1126           break;
1127         }
1128     }
1129
1130   cl->last_ping_time = time(NULL);
1131   cl->want_ping = 0;
1132 cp
1133   return 0;
1134 }
1135
1136 /*
1137   check all connections to see if anything
1138   happened on their sockets
1139 */
1140 void check_network_activity(fd_set *f)
1141 {
1142   conn_list_t *p;
1143   int x, l = sizeof(x);
1144 cp
1145   for(p = conn_list; p != NULL; p = p->next)
1146     {
1147       if(p->status.remove)
1148         continue;
1149
1150       if(p->status.dataopen)
1151         if(FD_ISSET(p->socket, f))
1152           {
1153             /*
1154               The only thing that can happen to get us here is apparently an
1155               error on this outgoing(!) UDP socket that isn't immediate (i.e.
1156               something that will not trigger an error directly on send()).
1157               I've once got here when it said `No route to host'.
1158             */
1159             getsockopt(p->socket, SOL_SOCKET, SO_ERROR, &x, &l);
1160             syslog(LOG_ERR, _("Outgoing data socket error for %s (%s): %s"),
1161                    p->vpn_hostname, p->real_hostname, sys_errlist[x]);
1162             terminate_connection(p);
1163             return;
1164           }
1165
1166       if(p->status.meta)
1167         if(FD_ISSET(p->meta_socket, f))
1168           if(handle_incoming_meta_data(p) < 0)
1169             {
1170               terminate_connection(p);
1171               return;
1172             }
1173     }
1174
1175   if(FD_ISSET(myself->socket, f))
1176     handle_incoming_vpn_data(myself);
1177
1178   if(FD_ISSET(myself->meta_socket, f))
1179     handle_new_meta_connection(myself);
1180 cp
1181 }
1182
1183 /*
1184   read, encrypt and send data that is
1185   available through the ethertap device
1186 */
1187 void handle_tap_input(void)
1188 {
1189   vpn_packet_t vp;
1190   ip_t from, to;
1191   int ether_type, lenin;
1192 cp
1193   memset(&vp, 0, sizeof(vp));
1194   if((lenin = read(tap_fd, &vp, MTU)) <= 0)
1195     {
1196       syslog(LOG_ERR, _("Error while reading from tapdevice: %m"));
1197       return;
1198     }
1199
1200   total_tap_in += lenin;
1201
1202   ether_type = ntohs(*((unsigned short*)(&vp.data[12])));
1203   if(ether_type != 0x0800)
1204     {
1205       if(debug_lvl > 3)
1206         syslog(LOG_INFO, _("Non-IP ethernet frame %04x from " MAC_ADDR_S),
1207                ether_type, MAC_ADDR_V(vp.data[6]));
1208       return;
1209     }
1210
1211   if(lenin < 32)
1212     {
1213       if(debug_lvl > 3)
1214         syslog(LOG_INFO, _("Dropping short packet"));
1215       return;
1216     }
1217
1218   from = ntohl(*((unsigned long*)(&vp.data[26])));
1219   to = ntohl(*((unsigned long*)(&vp.data[30])));
1220
1221   vp.len = (length_t)lenin - 2;
1222
1223   strip_mac_addresses(&vp);
1224
1225   send_packet(to, &vp);
1226 cp
1227 }
1228
1229 /*
1230   this is where it all happens...
1231 */
1232 void main_loop(void)
1233 {
1234   fd_set fset;
1235   struct timeval tv;
1236   int r;
1237   time_t last_ping_check;
1238 cp
1239   last_ping_check = time(NULL);
1240
1241   for(;;)
1242     {
1243       tv.tv_sec = timeout;
1244       tv.tv_usec = 0;
1245
1246       prune_conn_list();
1247       build_fdset(&fset);
1248
1249       if((r = select(FD_SETSIZE, &fset, NULL, NULL, &tv)) < 0)
1250         {
1251           if(errno != EINTR) /* because of alarm */
1252             {
1253               syslog(LOG_ERR, _("Error while waiting for input: %m"));
1254               return;
1255             }
1256         }
1257
1258       if(sighup)
1259         {
1260           sighup = 0;
1261           close_network_connections();
1262           clear_config();
1263           if(read_config_file(configfilename))
1264             {
1265               syslog(LOG_ERR, _("Unable to reread configuration file, exiting"));
1266               exit(0);
1267             }
1268           sleep(5);
1269           setup_network_connections();
1270           continue;
1271         }
1272
1273       if(last_ping_check + timeout < time(NULL))
1274         /* Let's check if everybody is still alive */
1275         {
1276           check_dead_connections();
1277           last_ping_check = time(NULL);
1278         }
1279
1280       if(r > 0)
1281         {
1282           check_network_activity(&fset);
1283
1284           /* local tap data */
1285           if(FD_ISSET(tap_fd, &fset))
1286             handle_tap_input();
1287         }
1288     }
1289 cp
1290 }