src/protocol.c

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