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.4 2000/06/25 16:01:11 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 > 3)
 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 > 3)
 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 > 3)
 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 > 3)
 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 > 3)
 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 > 3)
 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 > 3)
 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 > 3)
 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   syslog(LOG_INFO, _("Connected to " IP_ADDR_S ":%hd"),
 520          IP_ADDR_V(cl->real_ip), cl->port);
 521 cp
 522   return 0;
 523 }
 524
 525 /*
 526   setup an outgoing connection. It's not
 527   necessary to also open an udp socket as
 528   well, because the other host will initiate
 529   an authentication sequence during which
 530   we will do just that.
 531 */
 532 int setup_outgoing_connection(ip_t ip)
 533 {
 534   conn_list_t *ncn;
 535 cp
 536   ncn = new_conn_list();
 537   ncn->real_ip = ip;
 538
 539   if(setup_outgoing_meta_socket(ncn) < 0)
 540     {
 541       syslog(LOG_ERR, _("Could not set up a meta connection!"));
 542       free_conn_element(ncn);
 543       return -1;
 544     }
 545
 546   ncn->status.meta = 1;
 547   ncn->status.outgoing = 1;
 548   ncn->next = conn_list;
 549   conn_list = ncn;
 550 cp
 551   return 0;
 552 }
 553
 554 /*
 555   set up the local sockets (listen only)
 556 */
 557 int setup_myself(void)
 558 {
 559   config_t const *cfg;
 560 cp
 561   myself = new_conn_list();
 562
 563   if(!(cfg = get_config_val(myvpnip)))
 564     {
 565       syslog(LOG_ERR, _("No value for my VPN IP given"));
 566       return -1;
 567     }
 568
 569   myself->vpn_ip = cfg->data.ip->ip;
 570   myself->vpn_mask = cfg->data.ip->mask;
 571   myself->flags = 0;
 572
 573   if(!(cfg = get_config_val(listenport)))
 574     myself->port = 655;
 575   else
 576     myself->port = cfg->data.val;
 577
 578   if(cfg = get_config_val(indirectdata))
 579     if(cfg->data.val)
 580       myself->flags |= EXPORTINDIRECTDATA;
 581
 582   if((myself->meta_socket = setup_listen_meta_socket(myself->port)) < 0)
 583     {
 584       syslog(LOG_ERR, _("Unable to set up a listening socket"));
 585       return -1;
 586     }
 587
 588   if((myself->socket = setup_vpn_in_socket(myself->port)) < 0)
 589     {
 590       syslog(LOG_ERR, _("Unable to set up an incoming vpn data socket"));
 591       close(myself->meta_socket);
 592       return -1;
 593     }
 594
 595   myself->status.active = 1;
 596
 597   syslog(LOG_NOTICE, _("Ready: listening on port %d"), myself->port);
 598 cp
 599   return 0;
 600 }
 601
 602 RETSIGTYPE
 603 sigalrm_handler(int a)
 604 {
 605   config_t const *cfg;
 606 cp
 607   cfg = get_config_val(upstreamip);
 608
 609   if(!setup_outgoing_connection(cfg->data.ip->ip))
 610     {
 611       signal(SIGALRM, SIG_IGN);
 612     }
 613   else
 614     {
 615       signal(SIGALRM, sigalrm_handler);
 616       seconds_till_retry += 5;
 617       if(seconds_till_retry>300)    /* Don't wait more than 5 minutes. */
 618         seconds_till_retry = 300;
 619       alarm(seconds_till_retry);
 620       syslog(LOG_ERR, _("Still failed to connect to other, will retry in %d seconds"),
 621              seconds_till_retry);
 622     }
 623 cp
 624 }
 625
 626 /*
 627   setup all initial network connections
 628 */
 629 int setup_network_connections(void)
 630 {
 631   config_t const *cfg;
 632 cp
 633   if((cfg = get_config_val(pingtimeout)) == NULL)
 634     timeout = 5;
 635   else
 636     timeout = cfg->data.val;
 637
 638   if(setup_tap_fd() < 0)
 639     return -1;
 640
 641   if(setup_myself() < 0)
 642     return -1;
 643
 644   if((cfg = get_config_val(upstreamip)) == NULL)
 645     /* No upstream IP given, we're listen only. */
 646     return 0;
 647
 648   if(setup_outgoing_connection(cfg->data.ip->ip))
 649     {
 650       signal(SIGALRM, sigalrm_handler);
 651       seconds_till_retry = 300;
 652       alarm(seconds_till_retry);
 653       syslog(LOG_NOTICE, _("Trying to re-establish outgoing connection in 5 minutes"));
 654     }
 655 cp
 656   return 0;
 657 }
 658
 659 /*
 660   close all open network connections
 661 */
 662 void close_network_connections(void)
 663 {
 664   conn_list_t *p;
 665 cp
 666   for(p = conn_list; p != NULL; p = p->next)
 667     {
 668       if(p->status.dataopen)
 669         {
 670           shutdown(p->socket, 0); /* No more receptions */
 671           close(p->socket);
 672         }
 673       if(p->status.meta)
 674         {
 675           send_termreq(p);
 676           shutdown(p->meta_socket, 0); /* No more receptions */
 677           close(p->meta_socket);
 678         }
 679     }
 680
 681   if(myself)
 682     if(myself->status.active)
 683       {
 684         close(myself->meta_socket);
 685         close(myself->socket);
 686       }
 687
 688   close(tap_fd);
 689   destroy_conn_list();
 690
 691   syslog(LOG_NOTICE, _("Terminating"));
 692 cp
 693   return;
 694 }
 695
 696 /*
 697   create a data (udp) socket
 698 */
 699 int setup_vpn_connection(conn_list_t *cl)
 700 {
 701   int nfd, flags;
 702   struct sockaddr_in a;
 703 cp
 704   if(debug_lvl > 0)
 705     syslog(LOG_DEBUG, _("Opening UDP socket to " IP_ADDR_S), IP_ADDR_V(cl->real_ip));
 706
 707   nfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 708   if(nfd == -1)
 709     {
 710       syslog(LOG_ERR, _("Creating data socket failed: %m"));
 711       return -1;
 712     }
 713
 714   a.sin_family = AF_INET;
 715   a.sin_port = htons(cl->port);
 716   a.sin_addr.s_addr = htonl(cl->real_ip);
 717
 718   if(connect(nfd, (struct sockaddr *)&a, sizeof(a)) == -1)
 719     {
 720       syslog(LOG_ERR, _("Connecting to " IP_ADDR_S ":%d failed: %m"),
 721              IP_ADDR_V(cl->real_ip), cl->port);
 722       return -1;
 723     }
 724
 725   flags = fcntl(nfd, F_GETFL);
 726   if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0)
 727     {
 728       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, nfd);
 729       return -1;
 730     }
 731
 732   cl->socket = nfd;
 733   cl->status.dataopen = 1;
 734 cp
 735   return 0;
 736 }
 737
 738 /*
 739   handle an incoming tcp connect call and open
 740   a connection to it.
 741 */
 742 conn_list_t *create_new_connection(int sfd)
 743 {
 744   conn_list_t *p;
 745   struct sockaddr_in ci;
 746   int len = sizeof(ci);
 747 cp
 748   p = new_conn_list();
 749
 750   if(getpeername(sfd, &ci, &len) < 0)
 751     {
 752       syslog(LOG_ERR, _("Error: getpeername: %m"));
 753       return NULL;
 754     }
 755
 756   p->real_ip = ntohl(ci.sin_addr.s_addr);
 757   p->meta_socket = sfd;
 758   p->status.meta = 1;
 759   p->buflen = 0;
 760   p->last_ping_time = time(NULL);
 761   p->want_ping = 0;
 762
 763   syslog(LOG_NOTICE, _("Connection from " IP_ADDR_S ":%d"),
 764          IP_ADDR_V(p->real_ip), htons(ci.sin_port));
 765
 766   if(send_basic_info(p) < 0)
 767     {
 768       free(p);
 769       return NULL;
 770     }
 771 cp
 772   return p;
 773 }
 774
 775 /*
 776   put all file descriptors in an fd_set array
 777 */
 778 void build_fdset(fd_set *fs)
 779 {
 780   conn_list_t *p;
 781 cp
 782   FD_ZERO(fs);
 783
 784   for(p = conn_list; p != NULL; p = p->next)
 785     {
 786       if(p->status.meta)
 787         FD_SET(p->meta_socket, fs);
 788       if(p->status.dataopen)
 789         FD_SET(p->socket, fs);
 790     }
 791
 792   FD_SET(myself->meta_socket, fs);
 793   FD_SET(myself->socket, fs);
 794   FD_SET(tap_fd, fs);
 795 cp
 796 }
 797
 798 /*
 799   receive incoming data from the listening
 800   udp socket and write it to the ethertap
 801   device after being decrypted
 802 */
 803 int handle_incoming_vpn_data(conn_list_t *cl)
 804 {
 805   real_packet_t rp;
 806   int lenin;
 807   int x, l = sizeof(x);
 808   conn_list_t *f;
 809 cp
 810   if(getsockopt(cl->socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
 811     {
 812       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, cl->socket);
 813       return -1;
 814     }
 815   if(x)
 816     {
 817       syslog(LOG_ERR, _("Incoming data socket error: %s"), sys_errlist[x]);
 818       return -1;
 819     }
 820
 821   rp.len = -1;
 822   lenin = recvfrom(cl->socket, &rp, MTU, 0, NULL, NULL);
 823   if(lenin <= 0)
 824     {
 825       syslog(LOG_ERR, _("Receiving data failed: %m"));
 826       return -1;
 827     }
 828   total_socket_in += lenin;
 829
 830   rp.data.len = ntohs(rp.data.len);
 831   rp.len = ntohs(rp.len);
 832   rp.from = ntohl(rp.from);
 833
 834   if(rp.len >= 0)
 835     {
 836       f = lookup_conn(rp.from);
 837       if(debug_lvl > 3)
 838         syslog(LOG_DEBUG, _("packet from " IP_ADDR_S " (len %d)"),
 839                IP_ADDR_V(rp.from), rp.len);
 840       if(!f)
 841         {
 842           syslog(LOG_ERR, _("Got packet from unknown source " IP_ADDR_S),
 843                  IP_ADDR_V(rp.from));
 844           return -1;
 845         }
 846
 847       if(f->status.validkey)
 848         xrecv(f, &rp);
 849       else
 850         {
 851           add_queue(&(f->rq), &rp, rp.len);
 852           if(!cl->status.waitingforkey)
 853             send_key_request(rp.from);
 854         }
 855
 856       if(my_key_expiry <= time(NULL))
 857         regenerate_keys();
 858     }
 859 cp
 860   return 0;
 861 }
 862
 863 /*
 864   terminate a connection and notify the other
 865   end before closing the sockets
 866 */
 867 void terminate_connection(conn_list_t *cl)
 868 {
 869   conn_list_t *p, *q;
 870
 871 cp
 872   if(cl->status.remove)
 873     return;
 874
 875   if(debug_lvl > 0)
 876     syslog(LOG_NOTICE, _("Closing connection with " IP_ADDR_S " (%s)"),
 877            IP_ADDR_V(cl->vpn_ip), 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, _("Trying 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                   if(debug_lvl > 1)
 946                     syslog(LOG_INFO, _(IP_ADDR_S " (%s) didn't respond to ping"),
 947                            IP_ADDR_V(p->vpn_ip), p->hostname);
 948                   p->status.timeout = 1;
 949                   terminate_connection(p);
 950                 }
 951               else if(p->want_ping)
 952                 {
 953                   send_ping(p);
 954                   p->last_ping_time = now;
 955                   p->status.pinged = 1;
 956                   p->status.got_pong = 0;
 957                 }
 958             }
 959         }
 960     }
 961 cp
 962   return 0;
 963 }
 964
 965 /*
 966   accept a new tcp connect and create a
 967   new connection
 968 */
 969 int handle_new_meta_connection(conn_list_t *cl)
 970 {
 971   conn_list_t *ncn;
 972   struct sockaddr client;
 973   int nfd, len = sizeof(client);
 974 cp
 975   if((nfd = accept(cl->meta_socket, &client, &len)) < 0)
 976     {
 977       syslog(LOG_ERR, _("Accepting a new connection failed: %m"));
 978       return -1;
 979     }
 980
 981   if((ncn = create_new_connection(nfd)) == NULL)
 982     {
 983       shutdown(nfd, 2);
 984       close(nfd);
 985       syslog(LOG_NOTICE, _("Closed attempted connection"));
 986       return 0;
 987     }
 988
 989   ncn->status.meta = 1;
 990   ncn->next = conn_list;
 991   conn_list = ncn;
 992 cp
 993   return 0;
 994 }
 995
 996 /*
 997   dispatch any incoming meta requests
 998 */
 999 int handle_incoming_meta_data(conn_list_t *cl)
1000 {
1001   int x, l = sizeof(x);
1002   int request, oldlen, i;
1003   int lenin = 0;
1004 cp
1005   if(getsockopt(cl->meta_socket, SOL_SOCKET, SO_ERROR, &x, &l) < 0)
1006     {
1007       syslog(LOG_ERR, _("This is a bug: %s:%d: %d:%m"), __FILE__, __LINE__, cl->meta_socket);
1008       return -1;
1009     }
1010   if(x)
1011     {
1012       syslog(LOG_ERR, _("Metadata socket error: %s"), sys_errlist[x]);
1013       return -1;
1014     }
1015
1016   if(cl->buflen >= MAXBUFSIZE)
1017     {
1018       syslog(LOG_ERR, _("Metadata read buffer overflow!"));
1019       return -1;
1020     }
1021
1022   lenin = read(cl->meta_socket, cl->buffer, MAXBUFSIZE-cl->buflen);
1023
1024   if(lenin<=0)
1025     {
1026       syslog(LOG_ERR, _("Metadata socket read error: %m"));
1027       return -1;
1028     }
1029
1030   oldlen = cl->buflen;
1031   cl->buflen += lenin;
1032
1033   for(;;)
1034     {
1035       cl->reqlen = 0;
1036
1037       for(i = oldlen; i < cl->buflen; i++)
1038         {
1039           if(cl->buffer[i] == '\n')
1040             {
1041               cl->buffer[i] = 0;  /* replace end-of-line by end-of-string so we can use sscanf */
1042               cl->reqlen = i + 1;
1043               break;
1044             }
1045         }
1046
1047       if(cl->reqlen)
1048         {
1049           if(debug_lvl > 2)
1050             syslog(LOG_DEBUG, _("Got request from " IP_ADDR_S " (%s): %s"),
1051                          IP_ADDR_V(cl->vpn_ip), cl->hostname, cl->buffer);
1052           if(sscanf(cl->buffer, "%d", &request) == 1)
1053             {
1054               if((request < 0) || (request > 255) || (request_handlers[request] == NULL))
1055                 {
1056                   syslog(LOG_ERR, _("Unknown request from " IP_ADDR_S " (%s)"),
1057                          IP_ADDR_V(cl->vpn_ip), cl->hostname);
1058                   return -1;
1059                 }
1060
1061               if(request_handlers[request](cl))  /* Something went wrong. Probably scriptkiddies. Terminate. */
1062                 {
1063                   syslog(LOG_ERR, _("Error while processing request from " IP_ADDR_S " (%s)"),
1064                          IP_ADDR_V(cl->vpn_ip), cl->hostname);
1065                   return -1;
1066                 }
1067             }
1068           else
1069             {
1070               syslog(LOG_ERR, _("Bogus data received from " IP_ADDR_S " (%s)"),
1071                          IP_ADDR_V(cl->vpn_ip), cl->hostname);
1072               return -1;
1073             }
1074
1075           cl->buflen -= cl->reqlen;
1076           memmove(cl->buffer, cl->buffer + cl->reqlen, cl->buflen);
1077           oldlen = 0;
1078         }
1079       else
1080         {
1081           break;
1082         }
1083     }
1084
1085   cl->last_ping_time = time(NULL);
1086   cl->want_ping = 0;
1087 cp
1088   return 0;
1089 }
1090
1091 /*
1092   check all connections to see if anything
1093   happened on their sockets
1094 */
1095 void check_network_activity(fd_set *f)
1096 {
1097   conn_list_t *p;
1098   int x, l = sizeof(x);
1099 cp
1100   for(p = conn_list; p != NULL; p = p->next)
1101     {
1102       if(p->status.remove)
1103         continue;
1104
1105       if(p->status.dataopen)
1106         if(FD_ISSET(p->socket, f))
1107           {
1108             /*
1109               The only thing that can happen to get us here is apparently an
1110               error on this outgoing(!) UDP socket that isn't immediate (i.e.
1111               something that will not trigger an error directly on send()).
1112               I've once got here when it said `No route to host'.
1113             */
1114             getsockopt(p->socket, SOL_SOCKET, SO_ERROR, &x, &l);
1115             syslog(LOG_ERR, _("Outgoing data socket error: %s"), sys_errlist[x]);
1116             terminate_connection(p);
1117             return;
1118           }
1119
1120       if(p->status.meta)
1121         if(FD_ISSET(p->meta_socket, f))
1122           if(handle_incoming_meta_data(p) < 0)
1123             {
1124               terminate_connection(p);
1125               return;
1126             }
1127     }
1128
1129   if(FD_ISSET(myself->socket, f))
1130     handle_incoming_vpn_data(myself);
1131
1132   if(FD_ISSET(myself->meta_socket, f))
1133     handle_new_meta_connection(myself);
1134 cp
1135 }
1136
1137 /*
1138   read, encrypt and send data that is
1139   available through the ethertap device
1140 */
1141 void handle_tap_input(void)
1142 {
1143   vpn_packet_t vp;
1144   ip_t from, to;
1145   int ether_type, lenin;
1146 cp
1147   memset(&vp, 0, sizeof(vp));
1148   if((lenin = read(tap_fd, &vp, MTU)) <= 0)
1149     {
1150       syslog(LOG_ERR, _("Error while reading from tapdevice: %m"));
1151       return;
1152     }
1153
1154   total_tap_in += lenin;
1155
1156   ether_type = ntohs(*((unsigned short*)(&vp.data[12])));
1157   if(ether_type != 0x0800)
1158     {
1159       if(debug_lvl > 3)
1160         syslog(LOG_INFO, _("Non-IP ethernet frame %04x from " MAC_ADDR_S),
1161                ether_type, MAC_ADDR_V(vp.data[6]));
1162       return;
1163     }
1164
1165   if(lenin < 32)
1166     {
1167       if(debug_lvl > 3)
1168         syslog(LOG_INFO, _("Dropping short packet"));
1169       return;
1170     }
1171
1172   from = ntohl(*((unsigned long*)(&vp.data[26])));
1173   to = ntohl(*((unsigned long*)(&vp.data[30])));
1174
1175   if(debug_lvl > 3)
1176     syslog(LOG_DEBUG, _("An IP packet (%04x) for " IP_ADDR_S " from " IP_ADDR_S),
1177            ether_type, IP_ADDR_V(to), IP_ADDR_V(from));
1178   if(debug_lvl > 3)
1179     syslog(LOG_DEBUG, _(MAC_ADDR_S " to " MAC_ADDR_S),
1180            MAC_ADDR_V(vp.data[0]), MAC_ADDR_V(vp.data[6]));
1181
1182   vp.len = (length_t)lenin - 2;
1183
1184   strip_mac_addresses(&vp);
1185
1186   send_packet(to, &vp);
1187 cp
1188 }
1189
1190 /*
1191   this is where it all happens...
1192 */
1193 void main_loop(void)
1194 {
1195   fd_set fset;
1196   struct timeval tv;
1197   int r;
1198   time_t last_ping_check;
1199 cp
1200   last_ping_check = time(NULL);
1201
1202   for(;;)
1203     {
1204       tv.tv_sec = timeout;
1205       tv.tv_usec = 0;
1206
1207       prune_conn_list();
1208       build_fdset(&fset);
1209
1210       if((r = select(FD_SETSIZE, &fset, NULL, NULL, &tv)) < 0)
1211         {
1212           if(errno == EINTR) /* because of alarm */
1213             continue;
1214           syslog(LOG_ERR, _("Error while waiting for input: %m"));
1215           return;
1216         }
1217
1218       if(last_ping_check + timeout < time(NULL))
1219         /* Let's check if everybody is still alive */
1220         {
1221           check_dead_connections();
1222           last_ping_check = time(NULL);
1223           continue;
1224         }
1225
1226       check_network_activity(&fset);
1227
1228       /* local tap data */
1229       if(FD_ISSET(tap_fd, &fset))
1230         handle_tap_input();
1231     }
1232 cp
1233 }