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