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