www.tinc-vpn.org Git - tinc/blob - src/protocol.c

   1 /*
   2     protocol.c -- handle the meta-protocol
   3     Copyright (C) 1999-2001 Ivo Timmermans <itimmermans@bigfoot.com>,
   4                   2000,2001 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: protocol.c,v 1.28.4.83 2001/02/27 16:37:28 guus Exp $
  21 */
  22
  23 #include "config.h"
  24
  25 #include <sys/types.h>
  26
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <syslog.h>
  30 #include <sys/socket.h>
  31 #include <unistd.h>
  32 #include <stdio.h>
  33 #include <stdarg.h>
  34 #include <errno.h>
  35
  36 #include <utils.h>
  37 #include <xalloc.h>
  38 #include <avl_tree.h>
  39 #include <list.h>
  40
  41 #include <netinet/in.h>
  42
  43 #ifdef HAVE_OPENSSL_SHA_H
  44 # include <openssl/sha.h>
  45 #else
  46 # include <sha.h>
  47 #endif
  48
  49 #ifdef HAVE_OPENSSL_RAND_H
  50 # include <openssl/rand.h>
  51 #else
  52 # include <rand.h>
  53 #endif
  54
  55 #ifdef HAVE_OPENSSL_EVP_H
  56 # include <openssl/evp.h>
  57 #else
  58 # include <evp.h>
  59 #endif
  60
  61
  62 #include "conf.h"
  63 #include "net.h"
  64 #include "netutl.h"
  65 #include "protocol.h"
  66 #include "meta.h"
  67 #include "connection.h"
  68
  69 #include "system.h"
  70
  71 int check_id(char *id)
  72 {
  73   int i;
  74
  75   for (i = 0; i < strlen(id); i++)
  76     if(!isalnum(id[i]) && id[i] != '_')
  77       return -1;
  78
  79   return 0;
  80 }
  81
  82 /* Generic request routines - takes care of logging and error
  83    detection as well */
  84
  85 int send_request(connection_t *cl, const char *format, ...)
  86 {
  87   va_list args;
  88   char buffer[MAXBUFSIZE];
  89   int len, request;
  90
  91 cp
  92   /* Use vsnprintf instead of vasprintf: faster, no memory
  93      fragmentation, cleanup is automatic, and there is a limit on the
  94      input buffer anyway */
  95
  96   va_start(args, format);
  97   len = vsnprintf(buffer, MAXBUFSIZE, format, args);
  98   request = va_arg(args, int);
  99   va_end(args);
 100
 101   if(len < 0 || len > MAXBUFSIZE-1)
 102     {
 103       syslog(LOG_ERR, _("Output buffer overflow while sending %s to %s (%s)"), request_name[request], cl->name, cl->hostname);
 104       return -1;
 105     }
 106
 107   len++;
 108
 109   if(debug_lvl >= DEBUG_PROTOCOL)
 110     syslog(LOG_DEBUG, _("Sending %s to %s (%s)"), request_name[request], cl->name, cl->hostname);
 111
 112 cp
 113   return send_meta(cl, buffer, len);
 114 }
 115
 116 int receive_request(connection_t *cl)
 117 {
 118   int request;
 119 cp
 120   if(sscanf(cl->buffer, "%d", &request) == 1)
 121     {
 122       if((request < 0) || (request > 255) || (request_handlers[request] == NULL))
 123         {
 124           syslog(LOG_ERR, _("Unknown request from %s (%s)"),
 125                  cl->name, cl->hostname);
 126           return -1;
 127         }
 128       else
 129         {
 130           if(debug_lvl >= DEBUG_PROTOCOL)
 131             syslog(LOG_DEBUG, _("Got %s from %s (%s)"),
 132                    request_name[request], cl->name, cl->hostname);
 133         }
 134
 135       if((cl->allow_request != ALL) && (cl->allow_request != request))
 136         {
 137           syslog(LOG_ERR, _("Unauthorized request from %s (%s)"), cl->name, cl->hostname);
 138           return -1;
 139         }
 140
 141       if(request_handlers[request](cl))
 142         /* Something went wrong. Probably scriptkiddies. Terminate. */
 143         {
 144           syslog(LOG_ERR, _("Error while processing %s from %s (%s)"),
 145                  request_name[request], cl->name, cl->hostname);
 146           return -1;
 147         }
 148     }
 149   else
 150     {
 151       syslog(LOG_ERR, _("Bogus data received from %s (%s)"),
 152              cl->name, cl->hostname);
 153       return -1;
 154     }
 155 cp
 156   return 0;
 157 }
 158
 159 /* Connection protocol:
 160
 161    Client               Server
 162    send_id(u)
 163                         send_challenge(R)
 164    send_chal_reply(H)
 165                         send_id(u)
 166    send_challenge(R)
 167                         send_chal_reply(H)
 168    ---------------------------------------
 169    send_metakey(R)
 170                         send_metakey(R)
 171    ---------------------------------------
 172    send_ack(u)
 173                         send_ack(u)
 174    ---------------------------------------
 175    Other requests(E)...
 176
 177    (u) Unencrypted,
 178    (R) RSA,
 179    (H) SHA1,
 180    (E) Encrypted with symmetric cipher.
 181
 182    Part of the challenge is directly used to set the symmetric cipher
 183    key and the initial vector.  Since a man-in-the-middle cannot
 184    decrypt the RSA challenges, this means that he cannot get or forge
 185    the key for the symmetric cipher.
 186 */
 187
 188 int send_id(connection_t *cl)
 189 {
 190 cp
 191   return send_request(cl, "%d %s %d %lx %hd", ID, myself->name, myself->protocol_version, myself->options, myself->port);
 192 }
 193
 194 int id_h(connection_t *cl)
 195 {
 196   connection_t *old;
 197   unsigned short int port;
 198   char name[MAX_STRING_SIZE];
 199   avl_node_t *node;
 200 cp
 201   if(sscanf(cl->buffer, "%*d "MAX_STRING" %d %lx %hd", name, &cl->protocol_version, &cl->options, &port) != 4)
 202     {
 203        syslog(LOG_ERR, _("Got bad ID from %s"), cl->hostname);
 204        return -1;
 205     }
 206
 207   /* Check if version matches */
 208
 209   if(cl->protocol_version != myself->protocol_version)
 210     {
 211       syslog(LOG_ERR, _("Peer %s (%s) uses incompatible version %d"),
 212              cl->name, cl->hostname, cl->protocol_version);
 213       return -1;
 214     }
 215
 216   /* Check if identity is a valid name */
 217
 218   if(check_id(name))
 219     {
 220       syslog(LOG_ERR, _("Peer %s uses invalid identity name"), cl->hostname);
 221       return -1;
 222     }
 223
 224   /* Copy string to cl */
 225
 226   cl->name = xstrdup(name);
 227
 228   /* Load information about peer */
 229
 230   if(read_host_config(cl))
 231     {
 232       syslog(LOG_ERR, _("Peer %s had unknown identity (%s)"), cl->hostname, cl->name);
 233       return -1;
 234     }
 235
 236   /* First check if the host we connected to is already in our
 237      connection list. If so, we are probably making a loop, which
 238      is not desirable.
 239    */
 240
 241   if(cl->status.outgoing)
 242     {
 243       if((old = lookup_id(cl->name)))
 244         {
 245           if(debug_lvl >= DEBUG_CONNECTIONS)
 246             syslog(LOG_NOTICE, _("Uplink %s (%s) is already in our connection list"), cl->name, cl->hostname);
 247           cl->status.outgoing = 0;
 248           old->status.outgoing = 1;
 249           terminate_connection(cl);
 250           return 0;
 251         }
 252     }
 253
 254   /* Now we can add the name to the id tree */
 255
 256   id_add(cl);
 257
 258   /* And uhr... cl->port just changed so we have to unlink it from the connection tree and re-insert... */
 259
 260   node = avl_unlink(connection_tree, cl);
 261   cl->port = port;
 262   avl_insert_node(connection_tree, node);
 263
 264   /* Read in the public key, so that we can send a metakey */
 265
 266   if(read_rsa_public_key(cl))
 267     return -1;
 268
 269   cl->allow_request = METAKEY;
 270 cp
 271   return send_metakey(cl);
 272 }
 273
 274 int ack_h(connection_t *cl)
 275 {
 276   config_t const *cfg;
 277   connection_t *old, *p;
 278   subnet_t *subnet;
 279   avl_node_t *node, *node2;
 280 cp
 281   /* Okay, before we active the connection, we check if there is another entry
 282      in the connection list with the same name. If so, it presumably is an
 283      old connection that has timed out but we don't know it yet.
 284    */
 285
 286   while((old = lookup_id(cl->name)))
 287     {
 288       if(debug_lvl >= DEBUG_CONNECTIONS)
 289         syslog(LOG_NOTICE, _("Removing old entry for %s at %s in favour of new connection from %s"),
 290         cl->name, old->hostname, cl->hostname);
 291
 292       terminate_connection(old);
 293     }
 294
 295   /* Activate this connection */
 296
 297   cl->allow_request = ALL;
 298   cl->status.active = 1;
 299   cl->nexthop = cl;
 300   cl->cipher_pkttype = EVP_bf_cbc();
 301   cl->cipher_pktkeylength = cl->cipher_pkttype->key_len + cl->cipher_pkttype->iv_len;
 302
 303   if(debug_lvl >= DEBUG_CONNECTIONS)
 304     syslog(LOG_NOTICE, _("Connection with %s (%s) activated"), cl->name, cl->hostname);
 305
 306 cp
 307   /* Check some options */
 308
 309   if((cfg = get_config_val(cl->config, config_indirectdata)))
 310     {
 311       if(cfg->data.val == stupid_true)
 312         cl->options |= OPTION_INDIRECT;
 313     }
 314
 315   if((cfg = get_config_val(cl->config, config_tcponly)))
 316     {
 317       if(cfg->data.val == stupid_true)
 318         cl->options |= OPTION_TCPONLY;
 319     }
 320
 321   /* Send him our subnets */
 322
 323   for(node = myself->subnet_tree->head; node; node = node->next)
 324     {
 325       subnet = (subnet_t *)node->data;
 326       send_add_subnet(cl, subnet);
 327     }
 328   /* And send him all the hosts and their subnets we know... */
 329
 330   for(node = connection_tree->head; node; node = node->next)
 331     {
 332       p = (connection_t *)node->data;
 333
 334       if(p != cl && p->status.active)
 335         {
 336           /* Notify others of this connection */
 337
 338           if(p->status.meta)
 339             send_add_host(p, cl);
 340
 341           /* Notify new connection of everything we know */
 342
 343           send_add_host(cl, p);
 344
 345           for(node2 = p->subnet_tree->head; node2; node2 = node2->next)
 346             {
 347               subnet = (subnet_t *)node2->data;
 348               send_add_subnet(cl, subnet);
 349             }
 350         }
 351     }
 352 cp
 353   return 0;
 354 }
 355
 356 int send_challenge(connection_t *cl)
 357 {
 358   char *buffer;
 359   int len, x;
 360 cp
 361   /* CHECKME: what is most reasonable value for len? */
 362
 363   len = RSA_size(cl->rsa_key);
 364
 365   /* Allocate buffers for the challenge */
 366
 367   buffer = xmalloc(len*2+1);
 368
 369   if(cl->hischallenge)
 370     free(cl->hischallenge);
 371
 372   cl->hischallenge = xmalloc(len);
 373 cp
 374   /* Copy random data to the buffer */
 375
 376   RAND_bytes(cl->hischallenge, len);
 377
 378 cp
 379   /* Convert to hex */
 380
 381   bin2hex(cl->hischallenge, buffer, len);
 382   buffer[len*2] = '\0';
 383
 384 cp
 385   /* Send the challenge */
 386
 387   x = send_request(cl, "%d %s", CHALLENGE, buffer);
 388   free(buffer);
 389 cp
 390   return x;
 391 }
 392
 393 int challenge_h(connection_t *cl)
 394 {
 395   char buffer[MAX_STRING_SIZE];
 396   int len;
 397 cp
 398   if(sscanf(cl->buffer, "%*d "MAX_STRING, buffer) != 1)
 399     {
 400        syslog(LOG_ERR, _("Got bad CHALLENGE from %s (%s)"), cl->name, cl->hostname);
 401        return -1;
 402     }
 403
 404   len = RSA_size(myself->rsa_key);
 405
 406   /* Check if the length of the challenge is all right */
 407
 408   if(strlen(buffer) != len*2)
 409     {
 410       syslog(LOG_ERR, _("Intruder: wrong challenge length from %s (%s)"), cl->name, cl->hostname);
 411       return -1;
 412     }
 413
 414   /* Allocate buffers for the challenge */
 415
 416   if(!cl->mychallenge)
 417     cl->mychallenge = xmalloc(len);
 418
 419   /* Convert the challenge from hexadecimal back to binary */
 420
 421   hex2bin(buffer,cl->mychallenge,len);
 422
 423   cl->allow_request = CHAL_REPLY;
 424
 425   /* Rest is done by send_chal_reply() */
 426 cp
 427   return send_chal_reply(cl);
 428 }
 429
 430 int send_chal_reply(connection_t *cl)
 431 {
 432   char hash[SHA_DIGEST_LENGTH*2+1];
 433 cp
 434   if(!cl->mychallenge)
 435     {
 436       syslog(LOG_ERR, _("Trying to send CHAL_REPLY to %s (%s) without a valid CHALLENGE"), cl->name, cl->hostname);
 437       return -1;
 438     }
 439
 440   /* Calculate the hash from the challenge we received */
 441
 442   SHA1(cl->mychallenge, RSA_size(myself->rsa_key), hash);
 443
 444   /* Convert the hash to a hexadecimal formatted string */
 445
 446   bin2hex(hash,hash,SHA_DIGEST_LENGTH);
 447   hash[SHA_DIGEST_LENGTH*2] = '\0';
 448
 449   /* Send the reply */
 450
 451 cp
 452   return send_request(cl, "%d %s", CHAL_REPLY, hash);
 453 }
 454
 455 int chal_reply_h(connection_t *cl)
 456 {
 457   char hishash[MAX_STRING_SIZE];
 458   char myhash[SHA_DIGEST_LENGTH];
 459 cp
 460   if(sscanf(cl->buffer, "%*d "MAX_STRING, hishash) != 1)
 461     {
 462        syslog(LOG_ERR, _("Got bad CHAL_REPLY from %s (%s)"), cl->name, cl->hostname);
 463        return -1;
 464     }
 465
 466   /* Check if the length of the hash is all right */
 467
 468   if(strlen(hishash) != SHA_DIGEST_LENGTH*2)
 469     {
 470       syslog(LOG_ERR, _("Intruder: wrong challenge reply length from %s (%s)"), cl->name, cl->hostname);
 471       return -1;
 472     }
 473
 474   /* Convert the hash to binary format */
 475
 476   hex2bin(hishash, hishash, SHA_DIGEST_LENGTH);
 477
 478   /* Calculate the hash from the challenge we sent */
 479
 480   SHA1(cl->hischallenge, RSA_size(cl->rsa_key), myhash);
 481
 482   /* Verify the incoming hash with the calculated hash */
 483
 484   if(memcmp(hishash, myhash, SHA_DIGEST_LENGTH))
 485     {
 486       syslog(LOG_ERR, _("Intruder: wrong challenge reply from %s (%s)"), cl->name, cl->hostname);
 487       if(debug_lvl >= DEBUG_SCARY_THINGS)
 488         {
 489           bin2hex(myhash, hishash, SHA_DIGEST_LENGTH);
 490           hishash[SHA_DIGEST_LENGTH*2] = '\0';
 491           syslog(LOG_DEBUG, _("Expected challenge reply: %s"), hishash);
 492         }
 493       return -1;
 494     }
 495
 496   /* Identity has now been positively verified.
 497      ack_h() handles the rest from now on.
 498    */
 499 cp
 500   return ack_h(cl);
 501 }
 502
 503 int send_metakey(connection_t *cl)
 504 {
 505   char *buffer;
 506   int len, x;
 507 cp
 508   len = RSA_size(cl->rsa_key);
 509
 510   /* Allocate buffers for the meta key */
 511
 512   buffer = xmalloc(len*2+1);
 513
 514   if(!cl->cipher_outkey)
 515     cl->cipher_outkey = xmalloc(len);
 516
 517   if(!cl->cipher_outctx)
 518     cl->cipher_outctx = xmalloc(sizeof(*cl->cipher_outctx));
 519 cp
 520   /* Copy random data to the buffer */
 521
 522   RAND_bytes(cl->cipher_outkey, len);
 523
 524   cl->cipher_outkey[0] &= 0x0F; /* Make sure that the random data is smaller than the modulus of the RSA key */
 525
 526   if(debug_lvl >= DEBUG_SCARY_THINGS)
 527     {
 528       bin2hex(cl->cipher_outkey, buffer, len);
 529       buffer[len*2] = '\0';
 530       syslog(LOG_DEBUG, _("Generated random meta key (unencrypted): %s"), buffer);
 531     }
 532
 533   /* Encrypt the random data */
 534
 535   if(RSA_public_encrypt(len, cl->cipher_outkey, buffer, cl->rsa_key, RSA_NO_PADDING) != len)    /* NO_PADDING because the message size equals the RSA key size and it is totally random */
 536     {
 537       syslog(LOG_ERR, _("Error during encryption of meta key for %s (%s)"), cl->name, cl->hostname);
 538       free(buffer);
 539       return -1;
 540     }
 541 cp
 542   /* Convert the encrypted random data to a hexadecimal formatted string */
 543
 544   bin2hex(buffer, buffer, len);
 545   buffer[len*2] = '\0';
 546
 547   /* Send the meta key */
 548
 549   x = send_request(cl, "%d %s", METAKEY, buffer);
 550   free(buffer);
 551
 552   /* Further outgoing requests are encrypted with the key we just generated */
 553
 554   EVP_EncryptInit(cl->cipher_outctx, EVP_bf_cfb(),
 555                   cl->cipher_outkey + len - EVP_bf_cfb()->key_len,
 556                   cl->cipher_outkey + len - EVP_bf_cfb()->key_len - EVP_bf_cfb()->iv_len);
 557
 558   cl->status.encryptout = 1;
 559 cp
 560   return x;
 561 }
 562
 563 int metakey_h(connection_t *cl)
 564 {
 565   char buffer[MAX_STRING_SIZE];
 566   int len;
 567 cp
 568   if(sscanf(cl->buffer, "%*d "MAX_STRING, buffer) != 1)
 569     {
 570        syslog(LOG_ERR, _("Got bad METAKEY from %s (%s)"), cl->name, cl->hostname);
 571        return -1;
 572     }
 573
 574   len = RSA_size(myself->rsa_key);
 575
 576   /* Check if the length of the meta key is all right */
 577
 578   if(strlen(buffer) != len*2)
 579     {
 580       syslog(LOG_ERR, _("Intruder: wrong meta key length from %s (%s)"), cl->name, cl->hostname);
 581       return -1;
 582     }
 583
 584   /* Allocate buffers for the meta key */
 585
 586   if(!cl->cipher_inkey)
 587     cl->cipher_inkey = xmalloc(len);
 588
 589   if(!cl->cipher_inctx)
 590     cl->cipher_inctx = xmalloc(sizeof(*cl->cipher_inctx));
 591
 592   /* Convert the challenge from hexadecimal back to binary */
 593
 594   hex2bin(buffer,buffer,len);
 595
 596   /* Decrypt the meta key */
 597
 598   if(RSA_private_decrypt(len, buffer, cl->cipher_inkey, myself->rsa_key, RSA_NO_PADDING) != len)        /* See challenge() */
 599     {
 600       syslog(LOG_ERR, _("Error during encryption of meta key for %s (%s)"), cl->name, cl->hostname);
 601       return -1;
 602     }
 603
 604   if(debug_lvl >= DEBUG_SCARY_THINGS)
 605     {
 606       bin2hex(cl->cipher_inkey, buffer, len);
 607       buffer[len*2] = '\0';
 608       syslog(LOG_DEBUG, _("Received random meta key (unencrypted): %s"), buffer);
 609     }
 610
 611   /* All incoming requests will now be encrypted. */
 612
 613   EVP_DecryptInit(cl->cipher_inctx, EVP_bf_cfb(),
 614                   cl->cipher_inkey + len - EVP_bf_cfb()->key_len,
 615                   cl->cipher_inkey + len - EVP_bf_cfb()->key_len - EVP_bf_cfb()->iv_len);
 616
 617   cl->status.decryptin = 1;
 618
 619   cl->allow_request = CHALLENGE;
 620 cp
 621   return send_challenge(cl);
 622 }
 623
 624 /* Address and subnet information exchange */
 625
 626 int send_add_subnet(connection_t *cl, subnet_t *subnet)
 627 {
 628   int x;
 629   char *netstr;
 630   char *owner;
 631 cp
 632   if(cl->options & OPTION_INDIRECT)
 633     owner = myself->name;
 634   else
 635     owner = subnet->owner->name;
 636
 637   x = send_request(cl, "%d %s %s", ADD_SUBNET,
 638                       owner, netstr = net2str(subnet));
 639   free(netstr);
 640 cp
 641   return x;
 642 }
 643
 644 int add_subnet_h(connection_t *cl)
 645 {
 646   char subnetstr[MAX_STRING_SIZE];
 647   char name[MAX_STRING_SIZE];
 648   connection_t *owner, *p;
 649   subnet_t *subnet;
 650   avl_node_t *node;
 651 cp
 652   if(sscanf(cl->buffer, "%*d "MAX_STRING" "MAX_STRING, name, subnetstr) != 2)
 653     {
 654       syslog(LOG_ERR, _("Got bad ADD_SUBNET from %s (%s)"), cl->name, cl->hostname);
 655       return -1;
 656     }
 657
 658   /* Check if owner name is a valid */
 659
 660   if(check_id(name))
 661     {
 662       syslog(LOG_ERR, _("Got bad ADD_SUBNET from %s (%s): invalid identity name"), cl->name, cl->hostname);
 663       return -1;
 664     }
 665
 666   /* Check if subnet string is valid */
 667
 668   if(!(subnet = str2net(subnetstr)))
 669     {
 670       syslog(LOG_ERR, _("Got bad ADD_SUBNET from %s (%s): invalid subnet string"), cl->name, cl->hostname);
 671       return -1;
 672     }
 673
 674   /* Check if somebody tries to add a subnet of ourself */
 675
 676   if(!strcmp(name, myself->name))
 677     {
 678       syslog(LOG_ERR, _("Warning: got ADD_SUBNET from %s (%s) for ourself, restarting"),
 679              cl->name, cl->hostname);
 680       sighup = 1;
 681       return 0;
 682     }
 683
 684   /* Check if the owner of the new subnet is in the connection list */
 685
 686   if(!(owner = lookup_id(name)))
 687     {
 688       syslog(LOG_ERR, _("Got ADD_SUBNET for %s from %s (%s) which is not in our connection list"),
 689              name, cl->name, cl->hostname);
 690       return -1;
 691     }
 692
 693   /* If everything is correct, add the subnet to the list of the owner */
 694
 695   subnet_add(owner, subnet);
 696
 697   /* Tell the rest */
 698
 699   for(node = connection_tree->head; node; node = node->next)
 700     {
 701       p = (connection_t *)node->data;
 702       if(p->status.meta && p->status.active && p!= cl)
 703         send_add_subnet(p, subnet);
 704     }
 705 cp
 706   return 0;
 707 }
 708
 709 int send_del_subnet(connection_t *cl, subnet_t *subnet)
 710 {
 711   int x;
 712   char *netstr;
 713   char *owner;
 714 cp
 715   if(cl->options & OPTION_INDIRECT)
 716     owner = myself->name;
 717   else
 718     owner = subnet->owner->name;
 719
 720   x = send_request(cl, "%d %s %s", DEL_SUBNET, owner, netstr = net2str(subnet));
 721   free(netstr);
 722 cp
 723   return x;
 724 }
 725
 726 int del_subnet_h(connection_t *cl)
 727 {
 728   char subnetstr[MAX_STRING_SIZE];
 729   char name[MAX_STRING_SIZE];
 730   connection_t *owner, *p;
 731   subnet_t *subnet;
 732   avl_node_t *node;
 733 cp
 734   if(sscanf(cl->buffer, "%*d "MAX_STRING" "MAX_STRING, name, subnetstr) != 3)
 735     {
 736       syslog(LOG_ERR, _("Got bad DEL_SUBNET from %s (%s)"), cl->name, cl->hostname);
 737       return -1;
 738     }
 739
 740   /* Check if owner name is a valid */
 741
 742   if(check_id(name))
 743     {
 744       syslog(LOG_ERR, _("Got bad DEL_SUBNET from %s (%s): invalid identity name"), cl->name, cl->hostname);
 745       return -1;
 746     }
 747
 748   /* Check if subnet string is valid */
 749
 750   if(!(subnet = str2net(subnetstr)))
 751     {
 752       syslog(LOG_ERR, _("Got bad DEL_SUBNET from %s (%s): invalid subnet string"), cl->name, cl->hostname);
 753       return -1;
 754     }
 755
 756   free(subnetstr);
 757
 758   /* Check if somebody tries to add a subnet of ourself */
 759
 760   if(!strcmp(name, myself->name))
 761     {
 762       syslog(LOG_ERR, _("Warning: got DEL_SUBNET from %s (%s) for ourself, restarting"),
 763              cl->name, cl->hostname);
 764       sighup = 1;
 765       return 0;
 766     }
 767
 768   /* Check if the owner of the new subnet is in the connection list */
 769
 770   if(!(owner = lookup_id(name)))
 771     {
 772       syslog(LOG_ERR, _("Got DEL_SUBNET for %s from %s (%s) which is not in our connection list"),
 773              name, cl->name, cl->hostname);
 774       return -1;
 775     }
 776
 777   /* If everything is correct, delete the subnet from the list of the owner */
 778
 779   subnet_del(subnet);
 780
 781   /* Tell the rest */
 782
 783   for(node = connection_tree->head; node; node = node->next)
 784     {
 785       p = (connection_t *)node->data;
 786       if(p->status.meta && p->status.active && p!= cl)
 787         send_del_subnet(p, subnet);
 788     }
 789 cp
 790   return 0;
 791 }
 792
 793 /* New and closed connections notification */
 794
 795 int send_add_host(connection_t *cl, connection_t *other)
 796 {
 797 cp
 798   if(!(cl->options & OPTION_INDIRECT))
 799     return send_request(cl, "%d %s %lx:%d %lx", ADD_HOST,
 800                       other->name, other->address, other->port, other->options);
 801   else
 802     return 0;
 803 }
 804
 805 int add_host_h(connection_t *cl)
 806 {
 807   connection_t *old, *new, *p;
 808   char name[MAX_STRING_SIZE];
 809   avl_node_t *node;
 810 cp
 811   new = new_connection();
 812
 813   if(sscanf(cl->buffer, "%*d "MAX_STRING" %lx:%hd %lx", name, &new->address, &new->port, &new->options) != 4)
 814     {
 815        syslog(LOG_ERR, _("Got bad ADD_HOST from %s (%s)"), cl->name, cl->hostname);
 816        return -1;
 817     }
 818
 819   /* Check if identity is a valid name */
 820
 821   if(check_id(name))
 822     {
 823       syslog(LOG_ERR, _("Got bad ADD_HOST from %s (%s): invalid identity name"), cl->name, cl->hostname);
 824       free_connection(new);
 825       return -1;
 826     }
 827
 828   /* Check if somebody tries to add ourself */
 829
 830   if(!strcmp(name, myself->name))
 831     {
 832       syslog(LOG_ERR, _("Warning: got ADD_HOST from %s (%s) for ourself, restarting"), cl->name, cl->hostname);
 833       sighup = 1;
 834       free_connection(new);
 835       return 0;
 836     }
 837
 838   /* Fill in more of the new connection structure */
 839
 840   new->hostname = hostlookup(htonl(new->address));
 841
 842   /* Check if the new host already exists in the connnection list */
 843
 844   if((old = lookup_id(name)))
 845     {
 846       if((new->address == old->address) && (new->port == old->port))
 847         {
 848           if(debug_lvl >= DEBUG_CONNECTIONS)
 849             syslog(LOG_NOTICE, _("Got duplicate ADD_HOST for %s (%s) from %s (%s)"),
 850                    old->name, old->hostname, name, new->hostname);
 851           free_connection(new);
 852           return 0;
 853         }
 854       else
 855         {
 856           if(debug_lvl >= DEBUG_CONNECTIONS)
 857             syslog(LOG_NOTICE, _("Removing old entry for %s (%s) in favour of new connection"),
 858                    old->name, old->hostname);
 859
 860           terminate_connection(old);
 861         }
 862     }
 863
 864   /* Hook it up into the connection */
 865
 866   new->name = xstrdup(name);
 867   connection_add(new);
 868   id_add(new);
 869
 870   /* Tell the rest about the new host */
 871
 872   for(node = connection_tree->head; node; node = node->next)
 873     {
 874       p = (connection_t *)node->data;
 875       if(p->status.meta && p->status.active && p!=cl)
 876         send_add_host(p, new);
 877     }
 878
 879   /* Fill in rest of connection structure */
 880
 881   new->nexthop = cl;
 882   new->status.active = 1;
 883   new->cipher_pkttype = EVP_bf_cbc();
 884   new->cipher_pktkeylength = cl->cipher_pkttype->key_len + cl->cipher_pkttype->iv_len;
 885 cp
 886   return 0;
 887 }
 888
 889 int send_del_host(connection_t *cl, connection_t *other)
 890 {
 891 cp
 892   if(!(cl->options & OPTION_INDIRECT))
 893     return send_request(cl, "%d %s %lx:%d %lx", DEL_HOST,
 894                       other->name, other->address, other->port, other->options);
 895   else
 896     return 0;
 897 }
 898
 899 int del_host_h(connection_t *cl)
 900 {
 901   char name[MAX_STRING_SIZE];
 902   ip_t address;
 903   port_t port;
 904   long int options;
 905   connection_t *old, *p;
 906   avl_node_t *node;
 907 cp
 908   if(sscanf(cl->buffer, "%*d "MAX_STRING" %lx:%hd %lx", name, &address, &port, &options) != 4)
 909     {
 910       syslog(LOG_ERR, _("Got bad DEL_HOST from %s (%s)"),
 911              cl->name, cl->hostname);
 912       return -1;
 913     }
 914
 915   /* Check if identity is a valid name */
 916
 917   if(check_id(name))
 918     {
 919       syslog(LOG_ERR, _("Got bad DEL_HOST from %s (%s): invalid identity name"), cl->name, cl->hostname);
 920       return -1;
 921     }
 922
 923   /* Check if somebody tries to delete ourself */
 924
 925   if(!strcmp(name, myself->name))
 926     {
 927       syslog(LOG_ERR, _("Warning: got DEL_HOST from %s (%s) for ourself, restarting"),
 928              cl->name, cl->hostname);
 929       sighup = 1;
 930       return 0;
 931     }
 932
 933   /* Check if the new host already exists in the connnection list */
 934
 935   if(!(old = lookup_id(name)))
 936     {
 937       syslog(LOG_ERR, _("Got DEL_HOST from %s (%s) for %s which is not in our connection list"),
 938              name, cl->name, cl->hostname);
 939       return -1;
 940     }
 941
 942   /* Check if the rest matches */
 943
 944   if(address!=old->address || port!=old->port || options!=old->options || cl!=old->nexthop)
 945     {
 946       syslog(LOG_WARNING, _("Got DEL_HOST from %s (%s) for %s which doesn't match"), cl->name, cl->hostname, old->name);
 947       return 0;
 948     }
 949
 950   /* Ok, since EVERYTHING seems to check out all right, delete it */
 951
 952   old->status.active = 0;
 953   terminate_connection(old);
 954
 955   /* Tell the rest about the new host */
 956
 957   for(node = connection_tree->head; node; node = node->next)
 958     {
 959       p = (connection_t *)node->data;
 960       if(p->status.meta && p->status.active && p!=cl)
 961         send_del_host(p, old);
 962     }
 963 cp
 964   return 0;
 965 }
 966
 967 /* Status and error notification routines */
 968
 969 int send_status(connection_t *cl, int statusno, char *statusstring)
 970 {
 971 cp
 972   if(!statusstring)
 973     statusstring = status_text[statusno];
 974 cp
 975   return send_request(cl, "%d %d %s", STATUS, statusno, statusstring);
 976 }
 977
 978 int status_h(connection_t *cl)
 979 {
 980   int statusno;
 981   char statusstring[MAX_STRING_SIZE];
 982 cp
 983   if(sscanf(cl->buffer, "%*d %d "MAX_STRING, &statusno, statusstring) != 2)
 984     {
 985        syslog(LOG_ERR, _("Got bad STATUS from %s (%s)"),
 986               cl->name, cl->hostname);
 987        return -1;
 988     }
 989
 990   if(debug_lvl >= DEBUG_STATUS)
 991     {
 992       syslog(LOG_NOTICE, _("Status message from %s (%s): %s: %s"),
 993              cl->name, cl->hostname, status_text[statusno], statusstring);
 994     }
 995
 996 cp
 997   return 0;
 998 }
 999
1000 int send_error(connection_t *cl, int err, char *errstring)
1001 {
1002 cp
1003   if(!errstring)
1004     errstring = strerror(err);
1005   return send_request(cl, "%d %d %s", ERROR, err, errstring);
1006 }
1007
1008 int error_h(connection_t *cl)
1009 {
1010   int err;
1011   char errorstring[MAX_STRING_SIZE];
1012 cp
1013   if(sscanf(cl->buffer, "%*d %d "MAX_STRING, &err, errorstring) != 2)
1014     {
1015        syslog(LOG_ERR, _("Got bad ERROR from %s (%s)"),
1016               cl->name, cl->hostname);
1017        return -1;
1018     }
1019
1020   if(debug_lvl >= DEBUG_ERROR)
1021     {
1022       syslog(LOG_NOTICE, _("Error message from %s (%s): %s: %s"),
1023              cl->name, cl->hostname, strerror(err), errorstring);
1024     }
1025
1026   terminate_connection(cl);
1027 cp
1028   return 0;
1029 }
1030
1031 int send_termreq(connection_t *cl)
1032 {
1033 cp
1034   return send_request(cl, "%d", TERMREQ);
1035 }
1036
1037 int termreq_h(connection_t *cl)
1038 {
1039 cp
1040   terminate_connection(cl);
1041 cp
1042   return 0;
1043 }
1044
1045 int send_ping(connection_t *cl)
1046 {
1047 cp
1048   cl->status.pinged = 1;
1049   cl->last_ping_time = time(NULL);
1050 cp
1051   return send_request(cl, "%d", PING);
1052 }
1053
1054 int ping_h(connection_t *cl)
1055 {
1056 cp
1057   return send_pong(cl);
1058 }
1059
1060 int send_pong(connection_t *cl)
1061 {
1062 cp
1063   return send_request(cl, "%d", PONG);
1064 }
1065
1066 int pong_h(connection_t *cl)
1067 {
1068 cp
1069   cl->status.pinged = 0;
1070 cp
1071   return 0;
1072 }
1073
1074 /* Key exchange */
1075
1076 int send_key_changed(connection_t *from, connection_t *cl)
1077 {
1078   connection_t *p;
1079   avl_node_t *node;
1080 cp
1081   for(node = connection_tree->head; node; node = node->next)
1082     {
1083       p = (connection_t *)node->data;
1084       if(p != cl && p->status.meta && p->status.active)
1085         if(!(p->options & OPTION_INDIRECT) || from == myself)
1086           send_request(p, "%d %s", KEY_CHANGED, from->name);
1087     }
1088 cp
1089   return 0;
1090 }
1091
1092 int key_changed_h(connection_t *cl)
1093 {
1094   char from_id[MAX_STRING_SIZE];
1095   connection_t *from;
1096 cp
1097   if(sscanf(cl->buffer, "%*d "MAX_STRING, from_id) != 1)
1098     {
1099       syslog(LOG_ERR, _("Got bad KEY_CHANGED from %s (%s)"),
1100              cl->name, cl->hostname);
1101       return -1;
1102     }
1103
1104   if(!(from = lookup_id(from_id)))
1105     {
1106       syslog(LOG_ERR, _("Got KEY_CHANGED from %s (%s) origin %s which does not exist in our connection list"),
1107              cl->name, cl->hostname, from_id);
1108       return -1;
1109     }
1110
1111   from->status.validkey = 0;
1112   from->status.waitingforkey = 0;
1113
1114   send_key_changed(from, cl);
1115 cp
1116   return 0;
1117 }
1118
1119 int send_req_key(connection_t *from, connection_t *to)
1120 {
1121 cp
1122   return send_request(to->nexthop, "%d %s %s", REQ_KEY,
1123                       from->name, to->name);
1124 }
1125
1126 int req_key_h(connection_t *cl)
1127 {
1128   char from_id[MAX_STRING_SIZE];
1129   char to_id[MAX_STRING_SIZE];
1130   connection_t *from, *to;
1131   char pktkey[129];
1132 cp
1133   if(sscanf(cl->buffer, "%*d "MAX_STRING" "MAX_STRING, from_id, to_id) != 2)
1134     {
1135        syslog(LOG_ERR, _("Got bad REQ_KEY from %s (%s)"),
1136               cl->name, cl->hostname);
1137        return -1;
1138     }
1139
1140   if(!(from = lookup_id(from_id)))
1141     {
1142       syslog(LOG_ERR, _("Got REQ_KEY from %s (%s) origin %s which does not exist in our connection list"),
1143              cl->name, cl->hostname, from_id);
1144       return -1;
1145     }
1146
1147   /* Check if this key request is for us */
1148
1149   if(!strcmp(to_id, myself->name))
1150     {
1151       bin2hex(myself->cipher_pktkey, pktkey, myself->cipher_pktkeylength);
1152       pktkey[myself->cipher_pktkeylength*2] = '\0';
1153       send_ans_key(myself, from, pktkey);
1154     }
1155   else
1156     {
1157       if(!(to = lookup_id(to_id)))
1158         {
1159           syslog(LOG_ERR, _("Got REQ_KEY from %s (%s) destination %s which does not exist in our connection list"),
1160                  cl->name, cl->hostname, to_id);
1161           return -1;
1162         }
1163
1164       if(to->status.validkey)   /* Proxy keys */
1165         {
1166           bin2hex(to->cipher_pktkey, pktkey, to->cipher_pktkeylength);
1167           pktkey[to->cipher_pktkeylength*2] = '\0';
1168           send_ans_key(to, from, pktkey);
1169         }
1170       else
1171         send_req_key(from, to);
1172     }
1173
1174 cp
1175   return 0;
1176 }
1177
1178 int send_ans_key(connection_t *from, connection_t *to, char *pktkey)
1179 {
1180 cp
1181   return send_request(to->nexthop, "%d %s %s %s", ANS_KEY,
1182                       from->name, to->name, pktkey);
1183 }
1184
1185 int ans_key_h(connection_t *cl)
1186 {
1187   char from_id[MAX_STRING_SIZE];
1188   char to_id[MAX_STRING_SIZE];
1189   char pktkey[MAX_STRING_SIZE];
1190   int keylength;
1191   connection_t *from, *to;
1192 cp
1193   if(sscanf(cl->buffer, "%*d "MAX_STRING" "MAX_STRING" "MAX_STRING, from_id, to_id, pktkey) != 3)
1194     {
1195        syslog(LOG_ERR, _("Got bad ANS_KEY from %s (%s)"),
1196               cl->name, cl->hostname);
1197        return -1;
1198     }
1199
1200   if(!(from = lookup_id(from_id)))
1201     {
1202       syslog(LOG_ERR, _("Got ANS_KEY from %s (%s) origin %s which does not exist in our connection list"),
1203              cl->name, cl->hostname, from_id);
1204       return -1;
1205     }
1206
1207   /* Check correctness of packet key */
1208
1209   keylength = strlen(pktkey);
1210
1211   if(keylength != from->cipher_pktkeylength*2)
1212     {
1213       syslog(LOG_ERR, _("Got bad ANS_KEY from %s (%s) origin %s: invalid key length"),
1214              cl->name, cl->hostname, from->name);
1215       return -1;
1216     }
1217
1218   /* Forward it if necessary */
1219
1220   if(strcmp(to_id, myself->name))
1221     {
1222       if(!(to = lookup_id(to_id)))
1223         {
1224           syslog(LOG_ERR, _("Got ANS_KEY from %s (%s) destination %s which does not exist in our connection list"),
1225                  cl->name, cl->hostname, to_id);
1226           return -1;
1227         }
1228       send_ans_key(from, to, pktkey);
1229     }
1230
1231   /* Update our copy of the origin's packet key */
1232
1233   if(from->cipher_pktkey)
1234     free(from->cipher_pktkey);
1235
1236   from->cipher_pktkey = xstrdup(pktkey);
1237   keylength /= 2;
1238   hex2bin(from->cipher_pktkey, from->cipher_pktkey, keylength);
1239   from->cipher_pktkey[keylength] = '\0';
1240
1241   from->status.validkey = 1;
1242   from->status.waitingforkey = 0;
1243
1244   flush_queue(from);
1245 cp
1246   return 0;
1247 }
1248
1249 int send_tcppacket(connection_t *cl, vpn_packet_t *packet)
1250 {
1251   int x;
1252
1253   x = send_request(cl->nexthop, "%d %hd", PACKET, packet->len);
1254
1255   if(x)
1256     return x;
1257
1258   return send_meta(cl->nexthop, packet->data, packet->len);
1259 }
1260
1261 int tcppacket_h(connection_t *cl)
1262 {
1263   vpn_packet_t packet;
1264   char *p;
1265   int todo, x;
1266
1267   if(sscanf(cl->buffer, "%*d %hd", packet.len) != 1)
1268     {
1269       syslog(LOG_ERR, _("Got bad PACKET from %s (%s)"), cl->name, cl->hostname);
1270       return -1;
1271     }
1272
1273   /* Evil hack. */
1274
1275   p = packet.data;
1276   todo = packet.len;
1277
1278   while(todo)
1279     {
1280       x = read(cl->meta_socket, p, todo);
1281
1282       if(x<=0)
1283         {
1284           if(x==0)
1285             syslog(LOG_NOTICE, _("Connection closed by %s (%s)"), cl->name, cl->hostname);
1286           else
1287             if(errno==EINTR)
1288               continue;
1289             else
1290               syslog(LOG_ERR, _("Error during reception of PACKET from %s (%s): %m"), cl->name, cl->hostname);
1291
1292           return -1;
1293         }
1294
1295       todo -= x;
1296       p += x;
1297     }
1298
1299   return receive_packet(cl, &packet);
1300 }
1301
1302 /* Jumptable for the request handlers */
1303
1304 int (*request_handlers[])(connection_t*) = {
1305   id_h, metakey_h, challenge_h, chal_reply_h,
1306   status_h, error_h, termreq_h,
1307   ping_h, pong_h,
1308   add_host_h, del_host_h,
1309   add_subnet_h, del_subnet_h,
1310   key_changed_h, req_key_h, ans_key_h,
1311   tcppacket_h,
1312 };
1313
1314 /* Request names */
1315
1316 char (*request_name[]) = {
1317   "ID", "METAKEY", "CHALLENGE", "CHAL_REPLY",
1318   "STATUS", "ERROR", "TERMREQ",
1319   "PING", "PONG",
1320   "ADD_HOST", "DEL_HOST",
1321   "ADD_SUBNET", "DEL_SUBNET",
1322   "KEY_CHANGED", "REQ_KEY", "ANS_KEY",
1323   "PACKET",
1324 };
1325
1326 /* Status strings */
1327
1328 char (*status_text[]) = {
1329   "Warning",
1330 };
1331
1332 /* Error strings */
1333
1334 char (*error_text[]) = {
1335   "Error",
1336 };