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.12 2000/06/28 10:11:10 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 " IP_ADDR_S " (%s)"),
 108            ntohs(rp.len), IP_ADDR_V(cl->vpn_ip), cl->hostname);
 109
 110   if((r = send(cl->socket, (char*)&rp, ntohs(rp.len), 0)) < 0)
 111     {
 112       syslog(LOG_ERR, _("Error sending packet to " IP_ADDR_S " (%s): %m"),
 113              IP_ADDR_V(cl->vpn_ip), cl->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 " IP_ADDR_S " (%s)"),
 134            ((real_packet_t*)packet)->len, IP_ADDR_V(cl->vpn_ip), cl->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 " IP_ADDR_S),
 256                IP_ADDR_V(cl->vpn_ip));
 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 " IP_ADDR_S),
 264                IP_ADDR_V(cl->vpn_ip));
 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 " IP_ADDR_S " 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 " IP_ADDR_S " via " IP_ADDR_S),
 321                IP_ADDR_V(cl->vpn_ip), IP_ADDR_V(cl->real_ip));
 322       if((cl = lookup_conn(cl->real_ip)) == NULL)
 323         {
 324           if(debug_lvl > 3)
 325               syslog(LOG_NOTICE, _("Indirect look up " IP_ADDR_S " 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 " IP_ADDR_S),
 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 " IP_ADDR_S " (%s)"), IP_ADDR_V(cl->vpn_ip), cl->hostname);
 348         return -1;
 349       }
 350
 351   if(!cl->status.validkey)
 352     {
 353       if(debug_lvl > 3)
 354         syslog(LOG_INFO, _(IP_ADDR_S " (%s) has no valid key, queueing packet"), IP_ADDR_V(cl->vpn_ip), cl->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, _(IP_ADDR_S " (%s) is not ready, queueing packet"), IP_ADDR_V(cl->vpn_ip), cl->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->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, _(IP_ADDR_S ":%d: %m"), IP_ADDR_V(cl->real_ip), 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 " IP_ADDR_S ":%hd"),
 533          IP_ADDR_V(cl->real_ip), 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->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->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->hostname = hostlookup(htonl(myself->vpn_ip));
 586   myself->vpn_mask = cfg->data.ip->mask;
 587   myself->flags = 0;
 588
 589   if(!(cfg = get_config_val(listenport)))
 590     myself->port = 655;
 591   else
 592     myself->port = cfg->data.val;
 593
 594   if(cfg = get_config_val(indirectdata))
 595     if(cfg->data.val == stupid_true)
 596       myself->flags |= EXPORTINDIRECTDATA;
 597
 598   if((myself->meta_socket = setup_listen_meta_socket(myself->port)) < 0)
 599     {
 600       syslog(LOG_ERR, _("Unable to set up a listening socket"));
 601       return -1;
 602     }
 603
 604   if((myself->socket = setup_vpn_in_socket(myself->port)) < 0)
 605     {
 606       syslog(LOG_ERR, _("Unable to set up an incoming vpn data socket"));
 607       close(myself->meta_socket);
 608       return -1;
 609     }
 610
 611   myself->status.active = 1;
 612
 613   syslog(LOG_NOTICE, _("Ready: listening on port %d"), myself->port);
 614 cp
 615   return 0;
 616 }
 617
 618 RETSIGTYPE
 619 sigalrm_handler(int a)
 620 {
 621   config_t const *cfg;
 622 cp
 623   cfg = get_next_config_val(upstreamip, upstreamindex++);
 624
 625   while(cfg)
 626     {
 627       if(!setup_outgoing_connection(cfg->data.ip->ip))   /* function returns 0 when there are no problems */
 628         {
 629           signal(SIGALRM, SIG_IGN);
 630           return;
 631         }
 632       cfg = get_next_config_val(upstreamip, upstreamindex++); /* Or else we try the next ConnectTo line */
 633     }
 634
 635   signal(SIGALRM, sigalrm_handler);
 636   upstreamindex = 0;
 637   seconds_till_retry += 5;
 638   if(seconds_till_retry>300)    /* Don't wait more than 5 minutes. */
 639     seconds_till_retry = 300;
 640   alarm(seconds_till_retry);
 641   syslog(LOG_ERR, _("Still failed to connect to other, will retry in %d seconds"),
 642          seconds_till_retry);
 643 cp
 644 }
 645
 646 /*
 647   setup all initial network connections
 648 */
 649 int setup_network_connections(void)
 650 {
 651   config_t const *cfg;
 652 cp
 653   if((cfg = get_config_val(pingtimeout)) == NULL)
 654     timeout = 5;
 655   else
 656     timeout = cfg->data.val;
 657
 658   if(setup_tap_fd() < 0)
 659     return -1;
 660
 661   if(setup_myself() < 0)
 662     return -1;
 663
 664   if((cfg = get_next_config_val(upstreamip, upstreamindex++)) == NULL)
 665     /* No upstream IP given, we're listen only. */
 666     return 0;
 667
 668   while(cfg)
 669     {
 670       if(!setup_outgoing_connection(cfg->data.ip->ip))   /* function returns 0 when there are no problems */
 671         return 0;
 672       cfg = get_next_config_val(upstreamip, upstreamindex++); /* Or else we try the next ConnectTo line */
 673     }
 674
 675   signal(SIGALRM, sigalrm_handler);
 676   upstreamindex = 0;
 677   seconds_till_retry = 300;
 678   alarm(seconds_till_retry);
 679   syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in 5 minutes"));
 680 cp
 681   return 0;
 682 }
 683
 684 /*
 685   close all open network connections
 686 */
 687 void close_network_connections(void)
 688 {
 689   conn_list_t *p;
 690 cp
 691   for(p = conn_list; p != NULL; p = p->next)
 692     {
 693       if(p->status.dataopen)
 694         {
 695           shutdown(p->socket, 0); /* No more receptions */
 696           close(p->socket);
 697         }
 698       if(p->status.meta)
 699         {
 700           send_termreq(p);
 701           shutdown(p->meta_socket, 0); /* No more receptions */
 702           close(p->meta_socket);
 703         }
 704     }
 705
 706   if(myself)
 707     if(myself->status.active)
 708       {
 709         close(myself->meta_socket);
 710         close(myself->socket);
 711       }
 712
 713   close(tap_fd);
 714   destroy_conn_list();
 715
 716   syslog(LOG_NOTICE, _("Terminating"));
 717 cp
 718   return;
 719 }
 720
 721 /*
 722   create a data (udp) socket
 723 */
 724 int setup_vpn_connection(conn_list_t *cl)
 725 {
 726   int nfd, flags;
 727   struct sockaddr_in a;
 728 cp
 729   if(debug_lvl > 0)
 730     syslog(LOG_DEBUG, _("Opening UDP socket to %s"), cl->hostname);
 731
 732   nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 733   if(nfd == -1)
 734     {
 735       syslog(LOG_ERR, _("Creating UDP socket failed: %m"));
 736       return -1;
 737     }
 738
 739   a.sin_family = AF_INET;
 740   a.sin_port = htons(cl->port);
 741   a.sin_addr.s_addr = htonl(cl->real_ip);
 742
 743   if(connect(nfd, (struct sockaddr *)&a, sizeof(a)) == -1)
 744     {
 745       syslog(LOG_ERR, _("Connecting to %s port %d failed: %m"),
 746              cl->hostname, cl->port);
 747       return -1;
 748     }
 749
 750   flags = fcntl(nfd, F_GETFL);
 751   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
 752     {
 753       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, nfd);
 754       return -1;
 755     }
 756
 757   cl->socket = nfd;
 758   cl->status.dataopen = 1;
 759 cp
 760   return 0;
 761 }
 762
 763 /*
 764   handle an incoming tcp connect call and open
 765   a connection to it.
 766 */
 767 conn_list_t *create_new_connection(int sfd)
 768 {
 769   conn_list_t *p;
 770   struct sockaddr_in ci;
 771   int len = sizeof(ci);
 772 cp
 773   p = new_conn_list();
 774
 775   if(getpeername(sfd, &ci, &len) < 0)
 776     {
 777       syslog(LOG_ERR, _("Error: getpeername: %m"));
 778       return NULL;
 779     }
 780
 781   p->real_ip = ntohl(ci.sin_addr.s_addr);
 782   p->hostname = hostlookup(ci.sin_addr.s_addr);
 783   p->meta_socket = sfd;
 784   p->status.meta = 1;
 785   p->buflen = 0;
 786   p->last_ping_time = time(NULL);
 787   p->want_ping = 0;
 788
 789   if(debug_lvl > 0)
 790     syslog(LOG_NOTICE, _("Connection from %s port %d"),
 791          p->hostname, htons(ci.sin_port));
 792
 793   if(send_basic_info(p) < 0)
 794     {
 795       free(p);
 796       return NULL;
 797     }
 798 cp
 799   return p;
 800 }
 801
 802 /*
 803   put all file descriptors in an fd_set array
 804 */
 805 void build_fdset(fd_set *fs)
 806 {
 807   conn_list_t *p;
 808 cp
 809   FD_ZERO(fs);
 810
 811   for(p = conn_list; p != NULL; p = p->next)
 812     {
 813       if(p->status.meta)
 814         FD_SET(p->meta_socket, fs);
 815       if(p->status.dataopen)
 816         FD_SET(p->socket, fs);
 817     }
 818
 819   FD_SET(myself->meta_socket, fs);
 820   FD_SET(myself->socket, fs);
 821   FD_SET(tap_fd, fs);
 822 cp
 823 }
 824
 825 /*
 826   receive incoming data from the listening
 827   udp socket and write it to the ethertap
 828   device after being decrypted
 829 */
 830 int handle_incoming_vpn_data(conn_list_t *cl)
 831 {
 832   real_packet_t rp;
 833   int lenin;
 834   int x, l = sizeof(x);
 835   conn_list_t *f;
 836 cp
 837   if(getsockopt(cl->socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
 838     {
 839       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, cl->socket);
 840       return -1;
 841     }
 842   if(x)
 843     {
 844       syslog(LOG_ERR, _("Incoming data socket error: %s"), sys_errlist[x]);
 845       return -1;
 846     }
 847
 848   rp.len = -1;
 849   lenin = recvfrom(cl->socket, &rp, MTU, 0, NULL, NULL);
 850   if(lenin <= 0)
 851     {
 852       syslog(LOG_ERR, _("Receiving packet from %s failed: %m"), cl->hostname);
 853       return -1;
 854     }
 855   total_socket_in += lenin;
 856
 857   rp.data.len = ntohs(rp.data.len);
 858   rp.len = ntohs(rp.len);
 859   rp.from = ntohl(rp.from);
 860
 861   if(rp.len >= 0)
 862     {
 863       f = lookup_conn(rp.from);
 864       if(!f)
 865         {
 866           syslog(LOG_ERR, _("Got packet from " IP_ADDR_S " (%s) with unknown origin " IP_ADDR_S "?"),
 867                  IP_ADDR_V(cl->vpn_ip), cl->hostname, IP_ADDR_V(rp.from));
 868           return -1;
 869         }
 870
 871       if(f->status.validkey)
 872         xrecv(f, &rp);
 873       else
 874         {
 875           add_queue(&(f->rq), &rp, rp.len);
 876           if(!cl->status.waitingforkey)
 877             send_key_request(rp.from);
 878         }
 879
 880       if(my_key_expiry <= time(NULL))
 881         regenerate_keys();
 882     }
 883 cp
 884   return 0;
 885 }
 886
 887 /*
 888   terminate a connection and notify the other
 889   end before closing the sockets
 890 */
 891 void terminate_connection(conn_list_t *cl)
 892 {
 893   conn_list_t *p, *q;
 894
 895 cp
 896   if(cl->status.remove)
 897     return;
 898
 899   if(debug_lvl > 0)
 900     syslog(LOG_NOTICE, _("Closing connection with " IP_ADDR_S " (%s)"),
 901            IP_ADDR_V(cl->vpn_ip), cl->hostname);
 902
 903   if(cl->status.timeout)
 904     send_timeout(cl);
 905   else if(!cl->status.termreq)
 906     send_termreq(cl);
 907
 908   close(cl->socket);
 909   if(cl->status.meta)
 910     close(cl->meta_socket);
 911
 912   if(cl->status.outgoing)
 913     {
 914       signal(SIGALRM, sigalrm_handler);
 915       seconds_till_retry = 5;
 916       alarm(seconds_till_retry);
 917       syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in 5 seconds"));
 918     }
 919
 920   cl->status.remove = 1;
 921
 922   /* If this cl isn't active, don't send any DEL_HOSTs and don't bother
 923      checking for other lost connections. */
 924   if(!cl->status.active)
 925     return;
 926
 927   cl->status.active = 0;
 928
 929 cp
 930   /* Find all connections that were lost because they were behind cl
 931      (the connection that was dropped). */
 932   for(p = conn_list; p != NULL; p = p->next)
 933     if(p->nexthop == cl)
 934       {
 935         p->status.active = 0;
 936         p->status.remove = 1;
 937       }
 938
 939 cp
 940   /* Then send a notification about all these connections to all hosts
 941      that are still connected to us. */
 942   for(p = conn_list; p != NULL; p = p->next)
 943     if(p->status.active && p->status.meta)
 944       for(q = conn_list; q != NULL; q = q->next)
 945         if(q->status.remove)
 946           send_del_host(p, q);
 947
 948 cp
 949 }
 950
 951 /*
 952   Check if the other end is active.
 953   If we have sent packets, but didn't receive any,
 954   then possibly the other end is dead. We send a
 955   PING request over the meta connection. If the other
 956   end does not reply in time, we consider them dead
 957   and close the connection.
 958 */
 959 int check_dead_connections(void)
 960 {
 961   conn_list_t *p;
 962   time_t now;
 963 cp
 964   now = time(NULL);
 965   for(p = conn_list; p != NULL; p = p->next)
 966     {
 967       if(p->status.remove)
 968         continue;
 969       if(p->status.active && p->status.meta)
 970         {
 971           if(p->last_ping_time + timeout < now)
 972             {
 973               if(p->status.pinged && !p->status.got_pong)
 974                 {
 975                   if(debug_lvl > 1)
 976                     syslog(LOG_INFO, _(IP_ADDR_S " (%s) didn't respond to ping"),
 977                            IP_ADDR_V(p->vpn_ip), p->hostname);
 978                   p->status.timeout = 1;
 979                   terminate_connection(p);
 980                 }
 981               else if(p->want_ping)
 982                 {
 983                   send_ping(p);
 984                   p->last_ping_time = now;
 985                   p->status.pinged = 1;
 986                   p->status.got_pong = 0;
 987                 }
 988             }
 989         }
 990     }
 991 cp
 992   return 0;
 993 }
 994
 995 /*
 996   accept a new tcp connect and create a
 997   new connection
 998 */
 999 int handle_new_meta_connection(conn_list_t *cl)
1000 {
1001   conn_list_t *ncn;
1002   struct sockaddr client;
1003   int nfd, len = sizeof(client);
1004 cp
1005   if((nfd = accept(cl->meta_socket, &client, &len)) < 0)
1006     {
1007       syslog(LOG_ERR, _("Accepting a new connection failed: %m"));
1008       return -1;
1009     }
1010
1011   if((ncn = create_new_connection(nfd)) == NULL)
1012     {
1013       shutdown(nfd, 2);
1014       close(nfd);
1015       syslog(LOG_NOTICE, _("Closed attempted connection"));
1016       return 0;
1017     }
1018
1019   ncn->status.meta = 1;
1020   ncn->next = conn_list;
1021   conn_list = ncn;
1022 cp
1023   return 0;
1024 }
1025
1026 /*
1027   dispatch any incoming meta requests
1028 */
1029 int handle_incoming_meta_data(conn_list_t *cl)
1030 {
1031   int x, l = sizeof(x);
1032   int request, oldlen, i;
1033   int lenin = 0;
1034 cp
1035   if(getsockopt(cl->meta_socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
1036     {
1037       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, cl->meta_socket);
1038       return -1;
1039     }
1040   if(x)
1041     {
1042       syslog(LOG_ERR, _("Metadata socket error: %s"), sys_errlist[x]);
1043       return -1;
1044     }
1045
1046   if(cl->buflen >= MAXBUFSIZE)
1047     {
1048       syslog(LOG_ERR, _("Metadata read buffer overflow!"));
1049       return -1;
1050     }
1051
1052   lenin = read(cl->meta_socket, cl->buffer, MAXBUFSIZE-cl->buflen);
1053
1054   if(lenin<=0)
1055     {
1056       if(errno==EINTR)
1057         return 0;
1058       syslog(LOG_ERR, _("Metadata socket read error: %m"));
1059       return -1;
1060     }
1061
1062   oldlen = cl->buflen;
1063   cl->buflen += lenin;
1064
1065   for(;;)
1066     {
1067       cl->reqlen = 0;
1068
1069       for(i = oldlen; i < cl->buflen; i++)
1070         {
1071           if(cl->buffer[i] == '\n')
1072             {
1073               cl->buffer[i] = 0;  /* replace end-of-line by end-of-string so we can use sscanf */
1074               cl->reqlen = i + 1;
1075               break;
1076             }
1077         }
1078
1079       if(cl->reqlen)
1080         {
1081           if(debug_lvl > 2)
1082             syslog(LOG_DEBUG, _("Got request from " IP_ADDR_S " (%s): %s"),
1083                          IP_ADDR_V(cl->vpn_ip), cl->hostname, cl->buffer);
1084           if(sscanf(cl->buffer, "%d", &request) == 1)
1085             {
1086               if((request < 0) || (request > 255) || (request_handlers[request] == NULL))
1087                 {
1088                   syslog(LOG_ERR, _("Unknown request from " IP_ADDR_S " (%s)"),
1089                          IP_ADDR_V(cl->vpn_ip), cl->hostname);
1090                   return -1;
1091                 }
1092
1093               if(request_handlers[request](cl))  /* Something went wrong. Probably scriptkiddies. Terminate. */
1094                 {
1095                   syslog(LOG_ERR, _("Error while processing request from " IP_ADDR_S " (%s)"),
1096                          IP_ADDR_V(cl->vpn_ip), cl->hostname);
1097                   return -1;
1098                 }
1099             }
1100           else
1101             {
1102               syslog(LOG_ERR, _("Bogus data received from " IP_ADDR_S " (%s)"),
1103                          IP_ADDR_V(cl->vpn_ip), cl->hostname);
1104               return -1;
1105             }
1106
1107           cl->buflen -= cl->reqlen;
1108           memmove(cl->buffer, cl->buffer + cl->reqlen, cl->buflen);
1109           oldlen = 0;
1110         }
1111       else
1112         {
1113           break;
1114         }
1115     }
1116
1117   cl->last_ping_time = time(NULL);
1118   cl->want_ping = 0;
1119 cp
1120   return 0;
1121 }
1122
1123 /*
1124   check all connections to see if anything
1125   happened on their sockets
1126 */
1127 void check_network_activity(fd_set *f)
1128 {
1129   conn_list_t *p;
1130   int x, l = sizeof(x);
1131 cp
1132   for(p = conn_list; p != NULL; p = p->next)
1133     {
1134       if(p->status.remove)
1135         continue;
1136
1137       if(p->status.dataopen)
1138         if(FD_ISSET(p->socket, f))
1139           {
1140             /*
1141               The only thing that can happen to get us here is apparently an
1142               error on this outgoing(!) UDP socket that isn't immediate (i.e.
1143               something that will not trigger an error directly on send()).
1144               I've once got here when it said `No route to host'.
1145             */
1146             getsockopt(p->socket, SOL_SOCKET, SO_ERROR, &x, &l);
1147             syslog(LOG_ERR, _("Outgoing data socket error: %s"), 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             continue;
1239           syslog(LOG_ERR, _("Error while waiting for input: %m"));
1240           return;
1241         }
1242
1243       if(last_ping_check + timeout < time(NULL))
1244         /* Let's check if everybody is still alive */
1245         {
1246           check_dead_connections();
1247           last_ping_check = time(NULL);
1248           continue;
1249         }
1250
1251       check_network_activity(&fset);
1252
1253       /* local tap data */
1254       if(FD_ISSET(tap_fd, &fset))
1255         handle_tap_input();
1256     }
1257 cp
1258 }