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