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.2 2000/06/24 12:35:42 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 static int seconds_till_retry;
  60
  61 /* The global list of existing connections */
  62 conn_list_t *conn_list = NULL;
  63 conn_list_t *myself = NULL;
  64
  65 /*
  66   strip off the MAC adresses of an ethernet frame
  67 */
  68 void strip_mac_addresses(vpn_packet_t *p)
  69 {
  70   unsigned char tmp[MAXSIZE];
  71 cp
  72   memcpy(tmp, p->data, p->len);
  73   p->len -= 12;
  74   memcpy(p->data, &tmp[12], p->len);
  75 cp
  76 }
  77
  78 /*
  79   reassemble MAC addresses
  80 */
  81 void add_mac_addresses(vpn_packet_t *p)
  82 {
  83   unsigned char tmp[MAXSIZE];
  84 cp
  85   memcpy(&tmp[12], p->data, p->len);
  86   p->len += 12;
  87   tmp[0] = tmp[6] = 0xfe;
  88   tmp[1] = tmp[7] = 0xfd;
  89   *((ip_t*)(&tmp[2])) = (ip_t)(htonl(myself->vpn_ip));
  90   *((ip_t*)(&tmp[8])) = *((ip_t*)(&tmp[26]));
  91   memcpy(p->data, &tmp[0], p->len);
  92 cp
  93 }
  94
  95 int xsend(conn_list_t *cl, void *packet)
  96 {
  97   int r;
  98   real_packet_t rp;
  99 cp
 100   do_encrypt((vpn_packet_t*)packet, &rp, cl->key);
 101   rp.from = htonl(myself->vpn_ip);
 102   rp.data.len = htons(rp.data.len);
 103   rp.len = htons(rp.len);
 104
 105   if(debug_lvl > 3)
 106     syslog(LOG_ERR, _("Sent %d bytes to %lx"), ntohs(rp.len), cl->vpn_ip);
 107
 108   if((r = send(cl->socket, (char*)&rp, ntohs(rp.len), 0)) < 0)
 109     {
 110       syslog(LOG_ERR, _("Error sending data: %m"));
 111       return -1;
 112     }
 113
 114   total_socket_out += r;
 115
 116   cl->want_ping = 1;
 117 cp
 118   return 0;
 119 }
 120
 121 int xrecv(conn_list_t *cl, void *packet)
 122 {
 123   vpn_packet_t vp;
 124   int lenin;
 125 cp
 126   do_decrypt((real_packet_t*)packet, &vp, cl->key);
 127   add_mac_addresses(&vp);
 128
 129   if((lenin = write(tap_fd, &vp, vp.len + sizeof(vp.len))) < 0)
 130     syslog(LOG_ERR, _("Can't write to tap device: %m"));
 131   else
 132     total_tap_out += lenin;
 133
 134   cl->want_ping = 0;
 135   cl->last_ping_time = time(NULL);
 136 cp
 137   return 0;
 138 }
 139
 140 /*
 141   add the given packet of size s to the
 142   queue q, be it the send or receive queue
 143 */
 144 void add_queue(packet_queue_t **q, void *packet, size_t s)
 145 {
 146   queue_element_t *e;
 147 cp
 148   if(debug_lvl > 3)
 149     syslog(LOG_DEBUG, _("packet to queue: %d"), s);
 150
 151   e = xmalloc(sizeof(*e));
 152   e->packet = xmalloc(s);
 153   memcpy(e->packet, packet, s);
 154
 155   if(!*q)
 156     {
 157       *q = xmalloc(sizeof(**q));
 158       (*q)->head = (*q)->tail = NULL;
 159     }
 160
 161   e->next = NULL;                       /* We insert at the tail */
 162
 163   if((*q)->tail)                        /* Do we have a tail? */
 164     {
 165       (*q)->tail->next = e;
 166       e->prev = (*q)->tail;
 167     }
 168   else                                  /* No tail -> no head too */
 169     {
 170       (*q)->head = e;
 171       e->prev = NULL;
 172     }
 173
 174   (*q)->tail = e;
 175 cp
 176 }
 177
 178 /* Remove a queue element */
 179 void del_queue(packet_queue_t **q, queue_element_t *e)
 180 {
 181 cp
 182   free(e->packet);
 183
 184   if(e->next)                           /* There is a successor, so we are not tail */
 185     {
 186       if(e->prev)                       /* There is a predecessor, so we are not head */
 187         {
 188           e->next->prev = e->prev;
 189           e->prev->next = e->next;
 190         }
 191       else                              /* We are head */
 192         {
 193           e->next->prev = NULL;
 194           (*q)->head = e->next;
 195         }
 196     }
 197   else                                  /* We are tail (or all alone!) */
 198     {
 199       if(e->prev)                       /* We are not alone :) */
 200         {
 201           e->prev->next = NULL;
 202           (*q)->tail = e->prev;
 203         }
 204       else                              /* Adieu */
 205         {
 206           free(*q);
 207           *q = NULL;
 208         }
 209     }
 210
 211   free(e);
 212 cp
 213 }
 214
 215 /*
 216   flush a queue by calling function for
 217   each packet, and removing it when that
 218   returned a zero exit code
 219 */
 220 void flush_queue(conn_list_t *cl, packet_queue_t **pq,
 221                  int (*function)(conn_list_t*,void*))
 222 {
 223   queue_element_t *p, *next = NULL;
 224 cp
 225   for(p = (*pq)->head; p != NULL; )
 226     {
 227       next = p->next;
 228
 229       if(!function(cl, p->packet))
 230         del_queue(pq, p);
 231
 232       p = next;
 233     }
 234
 235   if(debug_lvl > 3)
 236     syslog(LOG_DEBUG, _("queue flushed"));
 237 cp
 238 }
 239
 240 /*
 241   flush the send&recv queues
 242   void because nothing goes wrong here, packets
 243   remain in the queue if something goes wrong
 244 */
 245 void flush_queues(conn_list_t *cl)
 246 {
 247 cp
 248   if(cl->sq)
 249     {
 250       if(debug_lvl > 1)
 251         syslog(LOG_DEBUG, _("Flushing send queue for " IP_ADDR_S),
 252                IP_ADDR_V(cl->vpn_ip));
 253       flush_queue(cl, &(cl->sq), xsend);
 254     }
 255
 256   if(cl->rq)
 257     {
 258       if(debug_lvl > 1)
 259         syslog(LOG_DEBUG, _("Flushing receive queue for " IP_ADDR_S),
 260                IP_ADDR_V(cl->vpn_ip));
 261       flush_queue(cl, &(cl->rq), xrecv);
 262     }
 263 cp
 264 }
 265
 266 /*
 267   send a packet to the given vpn ip.
 268 */
 269 int send_packet(ip_t to, vpn_packet_t *packet)
 270 {
 271   conn_list_t *cl;
 272 cp
 273   if((cl = lookup_conn(to)) == NULL)
 274     {
 275       if(debug_lvl > 2)
 276         {
 277           syslog(LOG_NOTICE, _("trying to look up " IP_ADDR_S " in connection list failed."),
 278                  IP_ADDR_V(to));
 279         }
 280
 281       /* Is this really necessary? If we can't find "to", then neither should any uplink. (GS) */
 282
 283       return -1;
 284
 285       for(cl = conn_list; cl != NULL && !cl->status.outgoing; cl = cl->next);
 286       if(!cl)
 287         { /* No open outgoing connection has been found. */
 288           if(debug_lvl > 2)
 289             syslog(LOG_NOTICE, _("There is no remote host I can send this packet to."));
 290           return -1;
 291         }
 292     }
 293
 294   /* If we ourselves have indirectdata flag set, we should send only to our uplink! */
 295
 296   if(myself->flags & EXPORTINDIRECTDATA)
 297     {
 298       for(cl = conn_list; cl != NULL && !cl->status.outgoing; cl = cl->next);
 299       if(!cl)
 300         { /* No open outgoing connection has been found. */
 301           if(debug_lvl > 2)
 302             syslog(LOG_NOTICE, _("There is no remote host I can send this packet to."));
 303           return -1;
 304         }
 305     }
 306   else
 307
 308   /* If indirectdata flag is set for the destination we just looked up,
 309    * then real_ip is actually the vpn_ip of the gateway tincd
 310    * it is behind.
 311    */
 312
 313   if(cl->flags & INDIRECTDATA)
 314     {
 315       if((cl = lookup_conn(cl->vpn_ip)) == NULL)
 316         {
 317           if(debug_lvl > 2)
 318             {
 319               syslog(LOG_NOTICE, _("indirect look up " IP_ADDR_S " in connection list failed."),
 320                      IP_ADDR_V(to));
 321             }
 322
 323           /* Gateway tincd dead? Should we kill it? (GS) */
 324
 325           return -1;
 326         }
 327       if(cl->flags & INDIRECTDATA)  /* This should not happen */
 328         if(debug_lvl > 1)
 329           {
 330             syslog(LOG_NOTICE, _("double indirection for " IP_ADDR_S),
 331                    IP_ADDR_V(to));
 332           }
 333         return -1;
 334     }
 335
 336   if(my_key_expiry <= time(NULL))
 337     regenerate_keys();
 338
 339   if(!cl->status.dataopen)
 340     if(setup_vpn_connection(cl) < 0)
 341       return -1;
 342
 343   if(!cl->status.validkey)
 344     {
 345       add_queue(&(cl->sq), packet, packet->len + 2);
 346       if(!cl->status.waitingforkey)
 347         send_key_request(cl->vpn_ip);                   /* Keys should be sent to the host running the tincd */
 348       return 0;
 349     }
 350
 351   if(!cl->status.active)
 352     {
 353       add_queue(&(cl->sq), packet, packet->len + 2);
 354       if(debug_lvl > 1)
 355         syslog(LOG_INFO, _(IP_ADDR_S " is not ready, queueing packet."), IP_ADDR_V(cl->vpn_ip));
 356       return 0; /* We don't want to mess up, do we? */
 357     }
 358
 359   /* can we send it? can we? can we? huh? */
 360 cp
 361   return xsend(cl, packet);
 362 }
 363
 364 /*
 365   open the local ethertap device
 366 */
 367 int setup_tap_fd(void)
 368 {
 369   int nfd;
 370   const char *tapfname;
 371   config_t const *cfg;
 372 cp
 373   if((cfg = get_config_val(tapdevice)) == NULL)
 374     tapfname = "/dev/tap0";
 375   else
 376     tapfname = cfg->data.ptr;
 377
 378   if((nfd = open(tapfname, O_RDWR | O_NONBLOCK)) < 0)
 379     {
 380       syslog(LOG_ERR, _("Could not open %s: %m"), tapfname);
 381       return -1;
 382     }
 383
 384   tap_fd = nfd;
 385 cp
 386   return 0;
 387 }
 388
 389 /*
 390   set up the socket that we listen on for incoming
 391   (tcp) connections
 392 */
 393 int setup_listen_meta_socket(int port)
 394 {
 395   int nfd, flags;
 396   struct sockaddr_in a;
 397   const int one = 1;
 398 cp
 399   if((nfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
 400     {
 401       syslog(LOG_ERR, _("Creating metasocket failed: %m"));
 402       return -1;
 403     }
 404
 405   if(setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
 406     {
 407       syslog(LOG_ERR, _("setsockopt: %m"));
 408       return -1;
 409     }
 410
 411   flags = fcntl(nfd, F_GETFL);
 412   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
 413     {
 414       syslog(LOG_ERR, _("fcntl: %m"));
 415       return -1;
 416     }
 417
 418   memset(&a, 0, sizeof(a));
 419   a.sin_family = AF_INET;
 420   a.sin_port = htons(port);
 421   a.sin_addr.s_addr = htonl(INADDR_ANY);
 422
 423   if(bind(nfd, (struct sockaddr *)&a, sizeof(struct sockaddr)))
 424     {
 425       syslog(LOG_ERR, _("Can't bind to port %hd/tcp: %m"), port);
 426       return -1;
 427     }
 428
 429   if(listen(nfd, 3))
 430     {
 431       syslog(LOG_ERR, _("listen: %m"));
 432       return -1;
 433     }
 434 cp
 435   return nfd;
 436 }
 437
 438 /*
 439   setup the socket for incoming encrypted
 440   data (the udp part)
 441 */
 442 int setup_vpn_in_socket(int port)
 443 {
 444   int nfd, flags;
 445   struct sockaddr_in a;
 446   const int one = 1;
 447 cp
 448   if((nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
 449     {
 450       syslog(LOG_ERR, _("Creating socket failed: %m"));
 451       return -1;
 452     }
 453
 454   if(setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
 455     {
 456       syslog(LOG_ERR, _("setsockopt: %m"));
 457       return -1;
 458     }
 459
 460   flags = fcntl(nfd, F_GETFL);
 461   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
 462     {
 463       syslog(LOG_ERR, _("fcntl: %m"));
 464       return -1;
 465     }
 466
 467   memset(&a, 0, sizeof(a));
 468   a.sin_family = AF_INET;
 469   a.sin_port = htons(port);
 470   a.sin_addr.s_addr = htonl(INADDR_ANY);
 471
 472   if(bind(nfd, (struct sockaddr *)&a, sizeof(struct sockaddr)))
 473     {
 474       syslog(LOG_ERR, _("Can't bind to port %hd/udp: %m"), port);
 475       return -1;
 476     }
 477 cp
 478   return nfd;
 479 }
 480
 481 /*
 482   setup an outgoing meta (tcp) socket
 483 */
 484 int setup_outgoing_meta_socket(conn_list_t *cl)
 485 {
 486   int flags;
 487   struct sockaddr_in a;
 488   config_t const *cfg;
 489 cp
 490   if((cfg = get_config_val(upstreamport)) == NULL)
 491     cl->port = 655;
 492   else
 493     cl->port = cfg->data.val;
 494
 495   cl->meta_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 496   if(cl->meta_socket == -1)
 497     {
 498       syslog(LOG_ERR, _("Creating socket failed: %m"));
 499       return -1;
 500     }
 501
 502   a.sin_family = AF_INET;
 503   a.sin_port = htons(cl->port);
 504   a.sin_addr.s_addr = htonl(cl->real_ip);
 505
 506   if(connect(cl->meta_socket, (struct sockaddr *)&a, sizeof(a)) == -1)
 507     {
 508       syslog(LOG_ERR, _(IP_ADDR_S ":%d: %m"), IP_ADDR_V(cl->real_ip), cl->port);
 509       return -1;
 510     }
 511
 512   flags = fcntl(cl->meta_socket, F_GETFL);
 513   if(fcntl(cl->meta_socket, F_SETFL, flags | O_NONBLOCK) < 0)
 514     {
 515       syslog(LOG_ERR, _("fcntl: %m"));
 516       return -1;
 517     }
 518
 519   cl->hostname = hostlookup(htonl(cl->real_ip));
 520
 521   syslog(LOG_INFO, _("Connected to %s:%hd"), cl->hostname, cl->port);
 522 cp
 523   return 0;
 524 }
 525
 526 /*
 527   setup an outgoing connection. It's not
 528   necessary to also open an udp socket as
 529   well, because the other host will initiate
 530   an authentication sequence during which
 531   we will do just that.
 532 */
 533 int setup_outgoing_connection(ip_t ip)
 534 {
 535   conn_list_t *ncn;
 536 cp
 537   ncn = new_conn_list();
 538   ncn->real_ip = ip;
 539
 540   if(setup_outgoing_meta_socket(ncn) < 0)
 541     {
 542       syslog(LOG_ERR, _("Could not set up a meta connection."));
 543       free_conn_element(ncn);
 544       return -1;
 545     }
 546
 547   ncn->status.meta = 1;
 548   ncn->status.outgoing = 1;
 549   ncn->next = conn_list;
 550   conn_list = ncn;
 551 cp
 552   return 0;
 553 }
 554
 555 /*
 556   set up the local sockets (listen only)
 557 */
 558 int setup_myself(void)
 559 {
 560   config_t const *cfg;
 561 cp
 562   myself = new_conn_list();
 563
 564   if(!(cfg = get_config_val(myvpnip)))
 565     {
 566       syslog(LOG_ERR, _("No value for my VPN IP given"));
 567       return -1;
 568     }
 569
 570   myself->vpn_ip = cfg->data.ip->ip;
 571   myself->vpn_mask = cfg->data.ip->mask;
 572   myself->flags = 0;
 573
 574   if(!(cfg = get_config_val(listenport)))
 575     myself->port = 655;
 576   else
 577     myself->port = cfg->data.val;
 578
 579   if(cfg = get_config_val(indirectdata))
 580     if(cfg->data.val)
 581       myself->flags |= EXPORTINDIRECTDATA;
 582
 583   if((myself->meta_socket = setup_listen_meta_socket(myself->port)) < 0)
 584     {
 585       syslog(LOG_ERR, _("Unable to set up a listening socket"));
 586       return -1;
 587     }
 588
 589   if((myself->socket = setup_vpn_in_socket(myself->port)) < 0)
 590     {
 591       syslog(LOG_ERR, _("Unable to set up an incoming vpn data socket"));
 592       close(myself->meta_socket);
 593       return -1;
 594     }
 595
 596   myself->status.active = 1;
 597
 598   syslog(LOG_NOTICE, _("Ready: listening on port %d."), myself->port);
 599 cp
 600   return 0;
 601 }
 602
 603 RETSIGTYPE
 604 sigalrm_handler(int a)
 605 {
 606   config_t const *cfg;
 607 cp
 608   cfg = get_config_val(upstreamip);
 609
 610   if(!setup_outgoing_connection(cfg->data.ip->ip))
 611     {
 612       signal(SIGALRM, SIG_IGN);
 613     }
 614   else
 615     {
 616       signal(SIGALRM, sigalrm_handler);
 617       seconds_till_retry += 5;
 618       if(seconds_till_retry>300)    /* Don't wait more than 5 minutes. */
 619         seconds_till_retry = 300;
 620       alarm(seconds_till_retry);
 621       syslog(LOG_ERR, _("Still failed to connect to other. Will retry in %d seconds."),
 622              seconds_till_retry);
 623     }
 624 cp
 625 }
 626
 627 /*
 628   setup all initial network connections
 629 */
 630 int setup_network_connections(void)
 631 {
 632   config_t const *cfg;
 633 cp
 634   if((cfg = get_config_val(pingtimeout)) == NULL)
 635     timeout = 5;
 636   else
 637     timeout = cfg->data.val;
 638
 639   if(setup_tap_fd() < 0)
 640     return -1;
 641
 642   if(setup_myself() < 0)
 643     return -1;
 644
 645   if((cfg = get_config_val(upstreamip)) == NULL)
 646     /* No upstream IP given, we're listen only. */
 647     return 0;
 648
 649   if(setup_outgoing_connection(cfg->data.ip->ip))
 650     {
 651       signal(SIGALRM, sigalrm_handler);
 652       seconds_till_retry = 300;
 653       alarm(seconds_till_retry);
 654       syslog(LOG_NOTICE, _("Try to re-establish outgoing connection in 5 minutes."));
 655     }
 656 cp
 657   return 0;
 658 }
 659
 660 /*
 661   close all open network connections
 662 */
 663 void close_network_connections(void)
 664 {
 665   conn_list_t *p;
 666 cp
 667   for(p = conn_list; p != NULL; p = p->next)
 668     {
 669       if(p->status.dataopen)
 670         {
 671           shutdown(p->socket, 0); /* No more receptions */
 672           close(p->socket);
 673         }
 674       if(p->status.meta)
 675         {
 676           send_termreq(p);
 677           shutdown(p->meta_socket, 0); /* No more receptions */
 678           close(p->meta_socket);
 679         }
 680     }
 681
 682   if(myself)
 683     if(myself->status.active)
 684       {
 685         close(myself->meta_socket);
 686         close(myself->socket);
 687       }
 688
 689   close(tap_fd);
 690   destroy_conn_list();
 691
 692   syslog(LOG_NOTICE, _("Terminating."));
 693 cp
 694   return;
 695 }
 696
 697 /*
 698   create a data (udp) socket
 699 */
 700 int setup_vpn_connection(conn_list_t *cl)
 701 {
 702   int nfd, flags;
 703   struct sockaddr_in a;
 704 cp
 705   if(debug_lvl > 1)
 706     syslog(LOG_DEBUG, _("Opening UDP socket to " IP_ADDR_S), IP_ADDR_V(cl->real_ip));
 707
 708   nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 709   if(nfd == -1)
 710     {
 711       syslog(LOG_ERR, _("Creating data socket failed: %m"));
 712       return -1;
 713     }
 714
 715   a.sin_family = AF_INET;
 716   a.sin_port = htons(cl->port);
 717   a.sin_addr.s_addr = htonl(cl->real_ip);
 718
 719   if(connect(nfd, (struct sockaddr *)&a, sizeof(a)) == -1)
 720     {
 721       syslog(LOG_ERR, _("Connecting to " IP_ADDR_S ":%d failed: %m"),
 722              IP_ADDR_V(cl->real_ip), cl->port);
 723       return -1;
 724     }
 725
 726   flags = fcntl(nfd, F_GETFL);
 727   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
 728     {
 729       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, nfd);
 730       return -1;
 731     }
 732
 733   cl->socket = nfd;
 734   cl->status.dataopen = 1;
 735 cp
 736   return 0;
 737 }
 738
 739 /*
 740   handle an incoming tcp connect call and open
 741   a connection to it.
 742 */
 743 conn_list_t *create_new_connection(int sfd)
 744 {
 745   conn_list_t *p;
 746   struct sockaddr_in ci;
 747   int len = sizeof(ci);
 748 cp
 749   p = new_conn_list();
 750
 751   if(getpeername(sfd, &ci, &len) < 0)
 752     {
 753       syslog(LOG_ERR, _("Error: getpeername: %m"));
 754       return NULL;
 755     }
 756
 757   p->hostname = hostlookup(ci.sin_addr.s_addr);
 758   p->real_ip = ntohl(ci.sin_addr.s_addr);
 759   p->meta_socket = sfd;
 760   p->status.meta = 1;
 761   p->buflen = 0;
 762   p->last_ping_time = time(NULL);
 763   p->want_ping = 0;
 764
 765   syslog(LOG_NOTICE, _("Connection from %s:%d"), p->hostname, htons(ci.sin_port));
 766
 767   if(send_basic_info(p) < 0)
 768     {
 769       free(p);
 770       return NULL;
 771     }
 772 cp
 773   return p;
 774 }
 775
 776 /*
 777   put all file descriptors in an fd_set array
 778 */
 779 void build_fdset(fd_set *fs)
 780 {
 781   conn_list_t *p;
 782 cp
 783   FD_ZERO(fs);
 784
 785   for(p = conn_list; p != NULL; p = p->next)
 786     {
 787       if(p->status.meta)
 788         FD_SET(p->meta_socket, fs);
 789       if(p->status.dataopen)
 790         FD_SET(p->socket, fs);
 791     }
 792
 793   FD_SET(myself->meta_socket, fs);
 794   FD_SET(myself->socket, fs);
 795   FD_SET(tap_fd, fs);
 796 cp
 797 }
 798
 799 /*
 800   receive incoming data from the listening
 801   udp socket and write it to the ethertap
 802   device after being decrypted
 803 */
 804 int handle_incoming_vpn_data(conn_list_t *cl)
 805 {
 806   real_packet_t rp;
 807   int lenin;
 808   int x, l = sizeof(x);
 809   conn_list_t *f;
 810 cp
 811   if(getsockopt(cl->socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
 812     {
 813       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, cl->socket);
 814       return -1;
 815     }
 816   if(x)
 817     {
 818       syslog(LOG_ERR, _("Incoming data socket error: %s"), sys_errlist[x]);
 819       return -1;
 820     }
 821
 822   rp.len = -1;
 823   lenin = recvfrom(cl->socket, &rp, MTU, 0, NULL, NULL);
 824   if(lenin <= 0)
 825     {
 826       syslog(LOG_ERR, _("Receiving data failed: %m"));
 827       return -1;
 828     }
 829   total_socket_in += lenin;
 830
 831   rp.data.len = ntohs(rp.data.len);
 832   rp.len = ntohs(rp.len);
 833   rp.from = ntohl(rp.from);
 834
 835   if(rp.len >= 0)
 836     {
 837       f = lookup_conn(rp.from);
 838       if(debug_lvl > 3)
 839         syslog(LOG_DEBUG, _("packet from " IP_ADDR_S " (len %d)"),
 840                IP_ADDR_V(rp.from), rp.len);
 841       if(!f)
 842         {
 843           syslog(LOG_ERR, _("Got packet from unknown source " IP_ADDR_S),
 844                  IP_ADDR_V(rp.from));
 845           return -1;
 846         }
 847
 848       if(f->status.validkey)
 849         xrecv(f, &rp);
 850       else
 851         {
 852           add_queue(&(f->rq), &rp, rp.len);
 853           if(!cl->status.waitingforkey)
 854             send_key_request(rp.from);
 855         }
 856
 857       if(my_key_expiry <= time(NULL))
 858         regenerate_keys();
 859     }
 860 cp
 861   return 0;
 862 }
 863
 864 /*
 865   terminate a connection and notify the other
 866   end before closing the sockets
 867 */
 868 void terminate_connection(conn_list_t *cl)
 869 {
 870   conn_list_t *p, *q;
 871
 872 cp
 873   if(cl->status.remove)
 874     return;
 875
 876   if(debug_lvl > 0)
 877     syslog(LOG_NOTICE, _("Closing connection with %s."), cl->hostname);
 878
 879   if(cl->status.timeout)
 880     send_timeout(cl);
 881   else if(!cl->status.termreq)
 882     send_termreq(cl);
 883
 884   close(cl->socket);
 885   if(cl->status.meta)
 886     close(cl->meta_socket);
 887
 888   if(cl->status.outgoing)
 889     {
 890       signal(SIGALRM, sigalrm_handler);
 891       seconds_till_retry = 5;
 892       alarm(seconds_till_retry);
 893       syslog(LOG_NOTICE, _("Try to re-establish outgoing connection in 5 seconds."));
 894     }
 895
 896   cl->status.active = 0;
 897   cl->status.remove = 1;
 898
 899 cp
 900   /* Find all connections that were lost because they were behind cl
 901      (the connection that was dropped). */
 902   for(p = conn_list; p != NULL; p = p->next)
 903     if(p->nexthop == cl)
 904       {
 905         p->status.active = 0;
 906         p->status.remove = 1;
 907       }
 908
 909 cp
 910   /* Then send a notification about all these connections to all hosts
 911      that are still connected to us. */
 912   for(p = conn_list; p != NULL; p = p->next)
 913     if(!p->status.remove && p->status.meta)
 914       for(q = conn_list; q != NULL; q = q->next)
 915         if(q->status.remove)
 916           send_del_host(p, q);
 917
 918 cp
 919 }
 920
 921 /*
 922   Check if the other end is active.
 923   If we have sent packets, but didn't receive any,
 924   then possibly the other end is dead. We send a
 925   PING request over the meta connection. If the other
 926   end does not reply in time, we consider them dead
 927   and close the connection.
 928 */
 929 int check_dead_connections(void)
 930 {
 931   conn_list_t *p;
 932   time_t now;
 933 cp
 934   now = time(NULL);
 935   for(p = conn_list; p != NULL; p = p->next)
 936     {
 937       if(p->status.remove)
 938         continue;
 939       if(p->status.active && p->status.meta)
 940         {
 941           if(p->last_ping_time + timeout < now)
 942             {
 943               if(p->status.pinged && !p->status.got_pong)
 944                 {
 945                   syslog(LOG_INFO, _("%s (" IP_ADDR_S ") didn't respond to ping"),
 946                          p->hostname, IP_ADDR_V(p->vpn_ip));
 947                   p->status.timeout = 1;
 948                   terminate_connection(p);
 949                 }
 950               else if(p->want_ping)
 951                 {
 952                   send_ping(p);
 953                   p->last_ping_time = now;
 954                   p->status.pinged = 1;
 955                   p->status.got_pong = 0;
 956                 }
 957             }
 958         }
 959     }
 960 cp
 961   return 0;
 962 }
 963
 964 /*
 965   accept a new tcp connect and create a
 966   new connection
 967 */
 968 int handle_new_meta_connection(conn_list_t *cl)
 969 {
 970   conn_list_t *ncn;
 971   struct sockaddr client;
 972   int nfd, len = sizeof(client);
 973 cp
 974   if((nfd = accept(cl->meta_socket, &client, &len)) < 0)
 975     {
 976       syslog(LOG_ERR, _("Accepting a new connection failed: %m"));
 977       return -1;
 978     }
 979
 980   if((ncn = create_new_connection(nfd)) == NULL)
 981     {
 982       shutdown(nfd, 2);
 983       close(nfd);
 984       syslog(LOG_NOTICE, _("Closed attempted connection."));
 985       return 0;
 986     }
 987
 988   ncn->status.meta = 1;
 989   ncn->next = conn_list;
 990   conn_list = ncn;
 991 cp
 992   return 0;
 993 }
 994
 995 /*
 996   dispatch any incoming meta requests
 997 */
 998 int handle_incoming_meta_data(conn_list_t *cl)
 999 {
1000   int x, l = sizeof(x);
1001   int request, oldlen, i;
1002   int lenin = 0;
1003 cp
1004   if(getsockopt(cl->meta_socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
1005     {
1006       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, cl->meta_socket);
1007       return -1;
1008     }
1009   if(x)
1010     {
1011       syslog(LOG_ERR, _("Metadata socket error: %s"), sys_errlist[x]);
1012       return -1;
1013     }
1014
1015   if(cl->buflen >= MAXBUFSIZE)
1016     {
1017       syslog(LOG_ERR, _("Metadata read buffer overflow."));
1018       return -1;
1019     }
1020
1021   lenin = read(cl->meta_socket, cl->buffer, MAXBUFSIZE-cl->buflen);
1022
1023   if(lenin<=0)
1024     {
1025       syslog(LOG_ERR, _("Metadata socket read error: %m"));
1026       return -1;
1027     }
1028
1029   oldlen = cl->buflen;
1030   cl->buflen += lenin;
1031
1032   for(;;)
1033     {
1034       cl->reqlen = 0;
1035
1036       for(i = oldlen; i < cl->buflen; i++)
1037         {
1038           if(cl->buffer[i] == '\n')
1039             {
1040               cl->buffer[i] = 0;  /* replace end-of-line by end-of-string so we can use sscanf */
1041               cl->reqlen = i + 1;
1042               break;
1043             }
1044         }
1045
1046       if(cl->reqlen)
1047         {
1048           if(sscanf(cl->buffer, "%d", &request) == 1)
1049             {
1050               if((request < 0) || (request > 255) || (request_handlers[request] == NULL))
1051                 {
1052                   syslog(LOG_ERR, _("Unknown request: %s"), cl->buffer);
1053                   return -1;
1054                 }
1055
1056               if(debug_lvl > 3)
1057                 syslog(LOG_DEBUG, _("Got request: %s"), cl->buffer);
1058
1059               if(request_handlers[request](cl))  /* Something went wrong. Probably scriptkiddies. Terminate. */
1060                 {
1061                   syslog(LOG_ERR, _("Error while processing request from " IP_ADDR_S), IP_ADDR_V(cl->real_ip));
1062                   return -1;
1063                 }
1064             }
1065           else
1066             {
1067               syslog(LOG_ERR, _("Bogus data received."));
1068               return -1;
1069             }
1070
1071           cl->buflen -= cl->reqlen;
1072           memmove(cl->buffer, cl->buffer + cl->reqlen, cl->buflen);
1073           oldlen = 0;
1074         }
1075       else
1076         {
1077           break;
1078         }
1079     }
1080
1081   cl->last_ping_time = time(NULL);
1082   cl->want_ping = 0;
1083 cp
1084   return 0;
1085 }
1086
1087 /*
1088   check all connections to see if anything
1089   happened on their sockets
1090 */
1091 void check_network_activity(fd_set *f)
1092 {
1093   conn_list_t *p;
1094   int x, l = sizeof(x);
1095 cp
1096   for(p = conn_list; p != NULL; p = p->next)
1097     {
1098       if(p->status.remove)
1099         continue;
1100
1101       if(p->status.dataopen)
1102         if(FD_ISSET(p->socket, f))
1103           {
1104             /*
1105               The only thing that can happen to get us here is apparently an
1106               error on this outgoing(!) UDP socket that isn't immediate (i.e.
1107               something that will not trigger an error directly on send()).
1108               I've once got here when it said `No route to host'.
1109             */
1110             getsockopt(p->socket, SOL_SOCKET, SO_ERROR, &x, &l);
1111             syslog(LOG_ERR, _("Outgoing data socket error: %s"), sys_errlist[x]);
1112             terminate_connection(p);
1113             return;
1114           }
1115
1116       if(p->status.meta)
1117         if(FD_ISSET(p->meta_socket, f))
1118           if(handle_incoming_meta_data(p) < 0)
1119             {
1120               terminate_connection(p);
1121               return;
1122             }
1123     }
1124
1125   if(FD_ISSET(myself->socket, f))
1126     handle_incoming_vpn_data(myself);
1127
1128   if(FD_ISSET(myself->meta_socket, f))
1129     handle_new_meta_connection(myself);
1130 cp
1131 }
1132
1133 /*
1134   read, encrypt and send data that is
1135   available through the ethertap device
1136 */
1137 void handle_tap_input(void)
1138 {
1139   vpn_packet_t vp;
1140   ip_t from, to;
1141   int ether_type, lenin;
1142 cp
1143   memset(&vp, 0, sizeof(vp));
1144   if((lenin = read(tap_fd, &vp, MTU)) <= 0)
1145     {
1146       syslog(LOG_ERR, _("Error while reading from tapdevice: %m"));
1147       return;
1148     }
1149
1150   total_tap_in += lenin;
1151
1152   ether_type = ntohs(*((unsigned short*)(&vp.data[12])));
1153   if(ether_type != 0x0800)
1154     {
1155       if(debug_lvl > 0)
1156         syslog(LOG_INFO, _("Non-IP ethernet frame %04x from " MAC_ADDR_S),
1157                ether_type, MAC_ADDR_V(vp.data[6]));
1158       return;
1159     }
1160
1161   if(lenin < 32)
1162     {
1163       if(debug_lvl > 0)
1164         syslog(LOG_INFO, _("Dropping short packet"));
1165       return;
1166     }
1167
1168   from = ntohl(*((unsigned long*)(&vp.data[26])));
1169   to = ntohl(*((unsigned long*)(&vp.data[30])));
1170
1171   if(debug_lvl > 3)
1172     syslog(LOG_DEBUG, _("An IP packet (%04x) for " IP_ADDR_S " from " IP_ADDR_S),
1173            ether_type, IP_ADDR_V(to), IP_ADDR_V(from));
1174   if(debug_lvl > 4)
1175     syslog(LOG_DEBUG, _(MAC_ADDR_S " to " MAC_ADDR_S),
1176            MAC_ADDR_V(vp.data[0]), MAC_ADDR_V(vp.data[6]));
1177
1178   vp.len = (length_t)lenin - 2;
1179
1180   strip_mac_addresses(&vp);
1181
1182   send_packet(to, &vp);
1183 cp
1184 }
1185
1186 /*
1187   this is where it all happens...
1188 */
1189 void main_loop(void)
1190 {
1191   fd_set fset;
1192   struct timeval tv;
1193   int r;
1194   time_t last_ping_check;
1195 cp
1196   last_ping_check = time(NULL);
1197
1198   for(;;)
1199     {
1200       tv.tv_sec = timeout;
1201       tv.tv_usec = 0;
1202
1203       prune_conn_list();
1204       build_fdset(&fset);
1205
1206       if((r = select(FD_SETSIZE, &fset, NULL, NULL, &tv)) < 0)
1207         {
1208           if(errno == EINTR) /* because of alarm */
1209             continue;
1210           syslog(LOG_ERR, _("Error while waiting for input: %m"));
1211           return;
1212         }
1213
1214       if(last_ping_check + timeout < time(NULL))
1215         /* Let's check if everybody is still alive */
1216         {
1217           check_dead_connections();
1218           last_ping_check = time(NULL);
1219           continue;
1220         }
1221
1222       check_network_activity(&fset);
1223
1224       /* local tap data */
1225       if(FD_ISSET(tap_fd, &fset))
1226         handle_tap_input();
1227     }
1228 cp
1229 }