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