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