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.13 2000/06/29 13:04: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>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(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   close(cl->socket);
 911   if(cl->status.meta)
 912     close(cl->meta_socket);
 913
 914   if(cl->status.outgoing)
 915     {
 916       signal(SIGALRM, sigalrm_handler);
 917       seconds_till_retry = 5;
 918       alarm(seconds_till_retry);
 919       syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in 5 seconds"));
 920     }
 921
 922   cl->status.remove = 1;
 923
 924   /* If this cl isn't active, don't send any DEL_HOSTs and don't bother
 925      checking for other lost connections. */
 926   if(!cl->status.active)
 927     return;
 928
 929   cl->status.active = 0;
 930
 931 cp
 932   /* Find all connections that were lost because they were behind cl
 933      (the connection that was dropped). */
 934   for(p = conn_list; p != NULL; p = p->next)
 935     if(p->nexthop == cl)
 936       {
 937         p->status.active = 0;
 938         p->status.remove = 1;
 939       }
 940
 941 cp
 942   /* Then send a notification about all these connections to all hosts
 943      that are still connected to us. */
 944   for(p = conn_list; p != NULL; p = p->next)
 945     if(p->status.active && p->status.meta)
 946       for(q = conn_list; q != NULL; q = q->next)
 947         if(q->status.remove)
 948           send_del_host(p, q);
 949
 950 cp
 951 }
 952
 953 /*
 954   Check if the other end is active.
 955   If we have sent packets, but didn't receive any,
 956   then possibly the other end is dead. We send a
 957   PING request over the meta connection. If the other
 958   end does not reply in time, we consider them dead
 959   and close the connection.
 960 */
 961 int check_dead_connections(void)
 962 {
 963   conn_list_t *p;
 964   time_t now;
 965 cp
 966   now = time(NULL);
 967   for(p = conn_list; p != NULL; p = p->next)
 968     {
 969       if(p->status.remove)
 970         continue;
 971       if(p->status.active && p->status.meta)
 972         {
 973           if(p->last_ping_time + timeout < now)
 974             {
 975               if(p->status.pinged && !p->status.got_pong)
 976                 {
 977                   if(debug_lvl > 1)
 978                     syslog(LOG_INFO, _("%s (%s) didn't respond to PING"),
 979                            p->vpn_hostname, p->real_hostname);
 980                   p->status.timeout = 1;
 981                   terminate_connection(p);
 982                 }
 983               else if(p->want_ping)
 984                 {
 985                   send_ping(p);
 986                   p->last_ping_time = now;
 987                   p->status.pinged = 1;
 988                   p->status.got_pong = 0;
 989                 }
 990             }
 991         }
 992     }
 993 cp
 994   return 0;
 995 }
 996
 997 /*
 998   accept a new tcp connect and create a
 999   new connection
1000 */
1001 int handle_new_meta_connection(conn_list_t *cl)
1002 {
1003   conn_list_t *ncn;
1004   struct sockaddr client;
1005   int nfd, len = sizeof(client);
1006 cp
1007   if((nfd = accept(cl->meta_socket, &client, &len)) < 0)
1008     {
1009       syslog(LOG_ERR, _("Accepting a new connection failed: %m"));
1010       return -1;
1011     }
1012
1013   if((ncn = create_new_connection(nfd)) == NULL)
1014     {
1015       shutdown(nfd, 2);
1016       close(nfd);
1017       syslog(LOG_NOTICE, _("Closed attempted connection"));
1018       return 0;
1019     }
1020
1021   ncn->status.meta = 1;
1022   ncn->next = conn_list;
1023   conn_list = ncn;
1024 cp
1025   return 0;
1026 }
1027
1028 /*
1029   dispatch any incoming meta requests
1030 */
1031 int handle_incoming_meta_data(conn_list_t *cl)
1032 {
1033   int x, l = sizeof(x);
1034   int request, oldlen, i;
1035   int lenin = 0;
1036 cp
1037   if(getsockopt(cl->meta_socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
1038     {
1039       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, cl->meta_socket);
1040       return -1;
1041     }
1042   if(x)
1043     {
1044       syslog(LOG_ERR, _("Metadata socket error: %s"), sys_errlist[x]);
1045       return -1;
1046     }
1047
1048   if(cl->buflen >= MAXBUFSIZE)
1049     {
1050       syslog(LOG_ERR, _("Metadata read buffer overflow!"));
1051       return -1;
1052     }
1053
1054   lenin = read(cl->meta_socket, cl->buffer, MAXBUFSIZE-cl->buflen);
1055
1056   if(lenin<=0)
1057     {
1058       if(errno==EINTR)
1059         return 0;
1060       syslog(LOG_ERR, _("Metadata socket read error: %m"));
1061       return -1;
1062     }
1063
1064   oldlen = cl->buflen;
1065   cl->buflen += lenin;
1066
1067   for(;;)
1068     {
1069       cl->reqlen = 0;
1070
1071       for(i = oldlen; i < cl->buflen; i++)
1072         {
1073           if(cl->buffer[i] == '\n')
1074             {
1075               cl->buffer[i] = 0;  /* replace end-of-line by end-of-string so we can use sscanf */
1076               cl->reqlen = i + 1;
1077               break;
1078             }
1079         }
1080
1081       if(cl->reqlen)
1082         {
1083           if(debug_lvl > 2)
1084             syslog(LOG_DEBUG, _("Got request from %s (%s): %s"),
1085                          cl->vpn_hostname, cl->real_hostname, cl->buffer);
1086           if(sscanf(cl->buffer, "%d", &request) == 1)
1087             {
1088               if((request < 0) || (request > 255) || (request_handlers[request] == NULL))
1089                 {
1090                   syslog(LOG_ERR, _("Unknown request from %s (%s)"),
1091                          cl->vpn_hostname, cl->real_hostname);
1092                   return -1;
1093                 }
1094
1095               if(request_handlers[request](cl))  /* Something went wrong. Probably scriptkiddies. Terminate. */
1096                 {
1097                   syslog(LOG_ERR, _("Error while processing request from %s (%s)"),
1098                          cl->vpn_hostname, cl->real_hostname);
1099                   return -1;
1100                 }
1101             }
1102           else
1103             {
1104               syslog(LOG_ERR, _("Bogus data received from %s (%s)"),
1105                          cl->vpn_hostname, cl->real_hostname);
1106               return -1;
1107             }
1108
1109           cl->buflen -= cl->reqlen;
1110           memmove(cl->buffer, cl->buffer + cl->reqlen, cl->buflen);
1111           oldlen = 0;
1112         }
1113       else
1114         {
1115           break;
1116         }
1117     }
1118
1119   cl->last_ping_time = time(NULL);
1120   cl->want_ping = 0;
1121 cp
1122   return 0;
1123 }
1124
1125 /*
1126   check all connections to see if anything
1127   happened on their sockets
1128 */
1129 void check_network_activity(fd_set *f)
1130 {
1131   conn_list_t *p;
1132   int x, l = sizeof(x);
1133 cp
1134   for(p = conn_list; p != NULL; p = p->next)
1135     {
1136       if(p->status.remove)
1137         continue;
1138
1139       if(p->status.dataopen)
1140         if(FD_ISSET(p->socket, f))
1141           {
1142             /*
1143               The only thing that can happen to get us here is apparently an
1144               error on this outgoing(!) UDP socket that isn't immediate (i.e.
1145               something that will not trigger an error directly on send()).
1146               I've once got here when it said `No route to host'.
1147             */
1148             getsockopt(p->socket, SOL_SOCKET, SO_ERROR, &x, &l);
1149             syslog(LOG_ERR, _("Outgoing data socket error: %s"), sys_errlist[x]);
1150             terminate_connection(p);
1151             return;
1152           }
1153
1154       if(p->status.meta)
1155         if(FD_ISSET(p->meta_socket, f))
1156           if(handle_incoming_meta_data(p) < 0)
1157             {
1158               terminate_connection(p);
1159               return;
1160             }
1161     }
1162
1163   if(FD_ISSET(myself->socket, f))
1164     handle_incoming_vpn_data(myself);
1165
1166   if(FD_ISSET(myself->meta_socket, f))
1167     handle_new_meta_connection(myself);
1168 cp
1169 }
1170
1171 /*
1172   read, encrypt and send data that is
1173   available through the ethertap device
1174 */
1175 void handle_tap_input(void)
1176 {
1177   vpn_packet_t vp;
1178   ip_t from, to;
1179   int ether_type, lenin;
1180 cp
1181   memset(&vp, 0, sizeof(vp));
1182   if((lenin = read(tap_fd, &vp, MTU)) <= 0)
1183     {
1184       syslog(LOG_ERR, _("Error while reading from tapdevice: %m"));
1185       return;
1186     }
1187
1188   total_tap_in += lenin;
1189
1190   ether_type = ntohs(*((unsigned short*)(&vp.data[12])));
1191   if(ether_type != 0x0800)
1192     {
1193       if(debug_lvl > 3)
1194         syslog(LOG_INFO, _("Non-IP ethernet frame %04x from " MAC_ADDR_S),
1195                ether_type, MAC_ADDR_V(vp.data[6]));
1196       return;
1197     }
1198
1199   if(lenin < 32)
1200     {
1201       if(debug_lvl > 3)
1202         syslog(LOG_INFO, _("Dropping short packet"));
1203       return;
1204     }
1205
1206   from = ntohl(*((unsigned long*)(&vp.data[26])));
1207   to = ntohl(*((unsigned long*)(&vp.data[30])));
1208
1209   vp.len = (length_t)lenin - 2;
1210
1211   strip_mac_addresses(&vp);
1212
1213   send_packet(to, &vp);
1214 cp
1215 }
1216
1217 /*
1218   this is where it all happens...
1219 */
1220 void main_loop(void)
1221 {
1222   fd_set fset;
1223   struct timeval tv;
1224   int r;
1225   time_t last_ping_check;
1226 cp
1227   last_ping_check = time(NULL);
1228
1229   for(;;)
1230     {
1231       tv.tv_sec = timeout;
1232       tv.tv_usec = 0;
1233
1234       prune_conn_list();
1235       build_fdset(&fset);
1236
1237       if((r = select(FD_SETSIZE, &fset, NULL, NULL, &tv)) < 0)
1238         {
1239           if(errno == EINTR) /* because of alarm */
1240             continue;
1241           syslog(LOG_ERR, _("Error while waiting for input: %m"));
1242           return;
1243         }
1244
1245       if(last_ping_check + timeout < time(NULL))
1246         /* Let's check if everybody is still alive */
1247         {
1248           check_dead_connections();
1249           last_ping_check = time(NULL);
1250           continue;
1251         }
1252
1253       check_network_activity(&fset);
1254
1255       /* local tap data */
1256       if(FD_ISSET(tap_fd, &fset))
1257         handle_tap_input();
1258     }
1259 cp
1260 }