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.15 2000/06/29 19:47:03 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>300)    /* Don't wait more than 5 minutes. */
 640     seconds_till_retry = 300;
 641   alarm(seconds_till_retry);
 642   syslog(LOG_ERR, _("Still failed to connect to other, will retry in %d seconds"),
 643          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 = 300;
 679   alarm(seconds_till_retry);
 680   syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in 5 minutes"));
 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->vpn_hostname = _("unknown");
 783   p->real_ip = ntohl(ci.sin_addr.s_addr);
 784   p->real_hostname = hostlookup(ci.sin_addr.s_addr);
 785   p->meta_socket = sfd;
 786   p->status.meta = 1;
 787   p->buflen = 0;
 788   p->last_ping_time = time(NULL);
 789   p->want_ping = 0;
 790
 791   if(debug_lvl > 0)
 792     syslog(LOG_NOTICE, _("Connection from %s port %d"),
 793          p->real_hostname, htons(ci.sin_port));
 794
 795   if(send_basic_info(p) < 0)
 796     {
 797       free_conn_element(p);
 798       return NULL;
 799     }
 800 cp
 801   return p;
 802 }
 803
 804 /*
 805   put all file descriptors in an fd_set array
 806 */
 807 void build_fdset(fd_set *fs)
 808 {
 809   conn_list_t *p;
 810 cp
 811   FD_ZERO(fs);
 812
 813   for(p = conn_list; p != NULL; p = p->next)
 814     {
 815       if(p->status.meta)
 816         FD_SET(p->meta_socket, fs);
 817       if(p->status.dataopen)
 818         FD_SET(p->socket, fs);
 819     }
 820
 821   FD_SET(myself->meta_socket, fs);
 822   FD_SET(myself->socket, fs);
 823   FD_SET(tap_fd, fs);
 824 cp
 825 }
 826
 827 /*
 828   receive incoming data from the listening
 829   udp socket and write it to the ethertap
 830   device after being decrypted
 831 */
 832 int handle_incoming_vpn_data(conn_list_t *cl)
 833 {
 834   real_packet_t rp;
 835   int lenin;
 836   int x, l = sizeof(x);
 837   conn_list_t *f;
 838 cp
 839   if(getsockopt(cl->socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
 840     {
 841       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, cl->socket);
 842       return -1;
 843     }
 844   if(x)
 845     {
 846       syslog(LOG_ERR, _("Incoming data socket error: %s"), sys_errlist[x]);
 847       return -1;
 848     }
 849
 850   rp.len = -1;
 851   lenin = recvfrom(cl->socket, &rp, MTU, 0, NULL, NULL);
 852   if(lenin <= 0)
 853     {
 854       syslog(LOG_ERR, _("Receiving packet from %s failed: %m"), cl->real_hostname);
 855       return -1;
 856     }
 857   total_socket_in += lenin;
 858
 859   rp.data.len = ntohs(rp.data.len);
 860   rp.len = ntohs(rp.len);
 861   rp.from = ntohl(rp.from);
 862
 863   if(rp.len >= 0)
 864     {
 865       f = lookup_conn(rp.from);
 866       if(!f)
 867         {
 868           syslog(LOG_ERR, _("Got packet from %s (%s) with unknown origin %d.%d.%d.%d?"),
 869                  cl->vpn_hostname, cl->real_hostname, IP_ADDR_V(rp.from));
 870           return -1;
 871         }
 872
 873       if(f->status.validkey)
 874         xrecv(f, &rp);
 875       else
 876         {
 877           add_queue(&(f->rq), &rp, rp.len);
 878           if(!cl->status.waitingforkey)
 879             send_key_request(rp.from);
 880         }
 881
 882       if(my_key_expiry <= time(NULL))
 883         regenerate_keys();
 884     }
 885 cp
 886   return 0;
 887 }
 888
 889 /*
 890   terminate a connection and notify the other
 891   end before closing the sockets
 892 */
 893 void terminate_connection(conn_list_t *cl)
 894 {
 895   conn_list_t *p, *q;
 896
 897 cp
 898   if(cl->status.remove)
 899     return;
 900
 901   if(debug_lvl > 0)
 902     syslog(LOG_NOTICE, _("Closing connection with %s (%s)"),
 903            cl->vpn_hostname, cl->real_hostname);
 904
 905   if(cl->status.timeout)
 906     send_timeout(cl);
 907 /*  else if(!cl->status.termreq)
 908     send_termreq(cl);
 909  */
 910
 911   if(cl->socket)
 912     close(cl->socket);
 913   if(cl->status.meta)
 914     close(cl->meta_socket);
 915
 916   cl->status.remove = 1;
 917
 918   /* If this cl isn't active, don't send any DEL_HOSTs. */
 919   if(cl->status.active)
 920     notify_others(cl,NULL,send_del_host);
 921
 922 cp
 923   /* Find all connections that were lost because they were behind cl
 924      (the connection that was dropped). */
 925   if(cl->status.meta)
 926     for(p = conn_list; p != NULL; p = p->next)
 927       {
 928         if((p->nexthop == cl) && (p != cl))
 929           {
 930             if(cl->status.active && p->status.active)
 931               notify_others(p,cl,send_del_host);
 932            if(cl->socket)
 933              close(cl->socket);
 934             p->status.active = 0;
 935             p->status.remove = 1;
 936           }
 937       }
 938
 939   cl->status.active = 0;
 940
 941   if(cl->status.outgoing)
 942     {
 943       signal(SIGALRM, sigalrm_handler);
 944       seconds_till_retry = 5;
 945       alarm(seconds_till_retry);
 946       syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in 5 seconds"));
 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, _("%s (%s) didn't respond to PING"),
 977                            p->vpn_hostname, p->real_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)))
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 %s (%s): %s"),
1083                          cl->vpn_hostname, cl->real_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 %s (%s)"),
1089                          cl->vpn_hostname, cl->real_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 %s (%s)"),
1096                          cl->vpn_hostname, cl->real_hostname);
1097                   return -1;
1098                 }
1099             }
1100           else
1101             {
1102               syslog(LOG_ERR, _("Bogus data received from %s (%s)"),
1103                          cl->vpn_hostname, cl->real_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 for %s (%s): %s"),
1148                    p->vpn_hostname, p->real_hostname, sys_errlist[x]);
1149             terminate_connection(p);
1150             return;
1151           }
1152
1153       if(p->status.meta)
1154         if(FD_ISSET(p->meta_socket, f))
1155           if(handle_incoming_meta_data(p) < 0)
1156             {
1157               terminate_connection(p);
1158               return;
1159             }
1160     }
1161
1162   if(FD_ISSET(myself->socket, f))
1163     handle_incoming_vpn_data(myself);
1164
1165   if(FD_ISSET(myself->meta_socket, f))
1166     handle_new_meta_connection(myself);
1167 cp
1168 }
1169
1170 /*
1171   read, encrypt and send data that is
1172   available through the ethertap device
1173 */
1174 void handle_tap_input(void)
1175 {
1176   vpn_packet_t vp;
1177   ip_t from, to;
1178   int ether_type, lenin;
1179 cp
1180   memset(&vp, 0, sizeof(vp));
1181   if((lenin = read(tap_fd, &vp, MTU)) <= 0)
1182     {
1183       syslog(LOG_ERR, _("Error while reading from tapdevice: %m"));
1184       return;
1185     }
1186
1187   total_tap_in += lenin;
1188
1189   ether_type = ntohs(*((unsigned short*)(&vp.data[12])));
1190   if(ether_type != 0x0800)
1191     {
1192       if(debug_lvl > 3)
1193         syslog(LOG_INFO, _("Non-IP ethernet frame %04x from " MAC_ADDR_S),
1194                ether_type, MAC_ADDR_V(vp.data[6]));
1195       return;
1196     }
1197
1198   if(lenin < 32)
1199     {
1200       if(debug_lvl > 3)
1201         syslog(LOG_INFO, _("Dropping short packet"));
1202       return;
1203     }
1204
1205   from = ntohl(*((unsigned long*)(&vp.data[26])));
1206   to = ntohl(*((unsigned long*)(&vp.data[30])));
1207
1208   vp.len = (length_t)lenin - 2;
1209
1210   strip_mac_addresses(&vp);
1211
1212   send_packet(to, &vp);
1213 cp
1214 }
1215
1216 /*
1217   this is where it all happens...
1218 */
1219 void main_loop(void)
1220 {
1221   fd_set fset;
1222   struct timeval tv;
1223   int r;
1224   time_t last_ping_check;
1225 cp
1226   last_ping_check = time(NULL);
1227
1228   for(;;)
1229     {
1230       tv.tv_sec = timeout;
1231       tv.tv_usec = 0;
1232
1233       prune_conn_list();
1234       build_fdset(&fset);
1235
1236       if((r = select(FD_SETSIZE, &fset, NULL, NULL, &tv)) < 0)
1237         {
1238           if(errno != EINTR) /* because of alarm */
1239             {
1240               syslog(LOG_ERR, _("Error while waiting for input: %m"));
1241               return;
1242             }
1243         }
1244
1245       if(sighup)
1246         {
1247           close_network_connections();
1248           clear_config();
1249           if(read_config_file(configfilename))
1250             {
1251               syslog(LOG_ERR, _("Unable to reread configuration file, exitting"));
1252               exit(0);
1253             }
1254           if(setup_network_connections())
1255             {
1256               syslog(LOG_ERR, _("Unable to restart, exitting"));
1257               exit(0);
1258             }
1259           sighup = 0;
1260           continue;
1261         }
1262
1263       if(last_ping_check + timeout < time(NULL))
1264         /* Let's check if everybody is still alive */
1265         {
1266           check_dead_connections();
1267           last_ping_check = time(NULL);
1268           continue;
1269         }
1270
1271       check_network_activity(&fset);
1272
1273       /* local tap data */
1274       if(FD_ISSET(tap_fd, &fset))
1275         handle_tap_input();
1276     }
1277 cp
1278 }