src/cadet/gnunet-service-cadet_tunnel.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2013 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 #include "platform.h"
  22 #include "gnunet_util_lib.h"
  23
  24 #include "gnunet_signatures.h"
  25 #include "gnunet_statistics_service.h"
  26
  27 #include "cadet_protocol.h"
  28 #include "cadet_path.h"
  29
  30 #include "gnunet-service-cadet_tunnel.h"
  31 #include "gnunet-service-cadet_connection.h"
  32 #include "gnunet-service-cadet_channel.h"
  33 #include "gnunet-service-cadet_peer.h"
  34
  35 #define LOG(level, ...) GNUNET_log_from(level,"cadet-tun",__VA_ARGS__)
  36
  37 #define REKEY_WAIT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
  38
  39 #define CONNECTIONS_PER_TUNNEL 3
  40
  41 #if !defined(GNUNET_CULL_LOGGING)
  42 #define DUMP_KEYS_TO_STDERR GNUNET_YES
  43 #else
  44 #define DUMP_KEYS_TO_STDERR GNUNET_NO
  45 #endif
  46
  47 /******************************************************************************/
  48 /********************************   STRUCTS  **********************************/
  49 /******************************************************************************/
  50
  51 struct CadetTChannel
  52 {
  53   struct CadetTChannel *next;
  54   struct CadetTChannel *prev;
  55   struct CadetChannel *ch;
  56 };
  57
  58
  59 /**
  60  * Connection list and metadata.
  61  */
  62 struct CadetTConnection
  63 {
  64   /**
  65    * Next in DLL.
  66    */
  67   struct CadetTConnection *next;
  68
  69   /**
  70    * Prev in DLL.
  71    */
  72   struct CadetTConnection *prev;
  73
  74   /**
  75    * Connection handle.
  76    */
  77   struct CadetConnection *c;
  78
  79   /**
  80    * Creation time, to keep oldest connection alive.
  81    */
  82   struct GNUNET_TIME_Absolute created;
  83
  84   /**
  85    * Connection throughput, to keep fastest connection alive.
  86    */
  87   uint32_t throughput;
  88 };
  89
  90 /**
  91  * Structure used during a Key eXchange.
  92  */
  93 struct CadetTunnelKXCtx
  94 {
  95   /**
  96    * Encryption ("our") old key, for encrypting traffic sent by us
  97    * end before the key exchange is finished or times out.
  98    */
  99   struct GNUNET_CRYPTO_SymmetricSessionKey e_key_old;
 100
 101   /**
 102    * Decryption ("their") old key, for decrypting traffic sent by the
 103    * other end before the key exchange started.
 104    */
 105   struct GNUNET_CRYPTO_SymmetricSessionKey d_key_old;
 106
 107   /**
 108    * Challenge to send in a ping and expect in the pong.
 109    */
 110   uint32_t challenge;
 111
 112   /**
 113    * When the rekey started. One minute after this the new key will be used.
 114    */
 115   struct GNUNET_TIME_Absolute rekey_start_time;
 116
 117   /**
 118    * Task for delayed destruction of the Key eXchange context, to allow delayed
 119    * messages with the old key to be decrypted successfully.
 120    */
 121   GNUNET_SCHEDULER_TaskIdentifier finish_task;
 122 };
 123
 124 /**
 125  * Struct containing all information regarding a tunnel to a peer.
 126  */
 127 struct CadetTunnel
 128 {
 129     /**
 130      * Endpoint of the tunnel.
 131      */
 132   struct CadetPeer *peer;
 133
 134     /**
 135      * State of the tunnel connectivity.
 136      */
 137   enum CadetTunnelCState cstate;
 138
 139   /**
 140    * State of the tunnel encryption.
 141    */
 142   enum CadetTunnelEState estate;
 143
 144   /**
 145    * Key eXchange context.
 146    */
 147   struct CadetTunnelKXCtx *kx_ctx;
 148
 149   /**
 150    * Peer's ephemeral key, to recreate @c e_key and @c d_key when own ephemeral
 151    * key changes.
 152    */
 153   struct GNUNET_CRYPTO_EcdhePublicKey peers_ephemeral_key;
 154
 155   /**
 156    * Encryption ("our") key.
 157    */
 158   struct GNUNET_CRYPTO_SymmetricSessionKey e_key;
 159
 160   /**
 161    * Decryption ("their") key.
 162    */
 163   struct GNUNET_CRYPTO_SymmetricSessionKey d_key;
 164
 165   /**
 166    * Task to start the rekey process.
 167    */
 168   GNUNET_SCHEDULER_TaskIdentifier rekey_task;
 169
 170   /**
 171    * Paths that are actively used to reach the destination peer.
 172    */
 173   struct CadetTConnection *connection_head;
 174   struct CadetTConnection *connection_tail;
 175
 176   /**
 177    * Next connection number.
 178    */
 179   uint32_t next_cid;
 180
 181   /**
 182    * Channels inside this tunnel.
 183    */
 184   struct CadetTChannel *channel_head;
 185   struct CadetTChannel *channel_tail;
 186
 187   /**
 188    * Channel ID for the next created channel.
 189    */
 190   CADET_ChannelNumber next_chid;
 191
 192   /**
 193    * Destroy flag: if true, destroy on last message.
 194    */
 195   GNUNET_SCHEDULER_TaskIdentifier destroy_task;
 196
 197   /**
 198    * Queued messages, to transmit once tunnel gets connected.
 199    */
 200   struct CadetTunnelDelayed *tq_head;
 201   struct CadetTunnelDelayed *tq_tail;
 202 };
 203
 204
 205 /**
 206  * Struct used to save messages in a non-ready tunnel to send once connected.
 207  */
 208 struct CadetTunnelDelayed
 209 {
 210   /**
 211    * DLL
 212    */
 213   struct CadetTunnelDelayed *next;
 214   struct CadetTunnelDelayed *prev;
 215
 216   /**
 217    * Tunnel.
 218    */
 219   struct CadetTunnel *t;
 220
 221   /**
 222    * Tunnel queue given to the channel to cancel request. Update on send_queued.
 223    */
 224   struct CadetTunnelQueue *tq;
 225
 226   /**
 227    * Message to send.
 228    */
 229   /* struct GNUNET_MessageHeader *msg; */
 230 };
 231
 232
 233 /**
 234  * Handle for messages queued but not yet sent.
 235  */
 236 struct CadetTunnelQueue
 237 {
 238   /**
 239    * Connection queue handle, to cancel if necessary.
 240    */
 241   struct CadetConnectionQueue *cq;
 242
 243   /**
 244    * Handle in case message hasn't been given to a connection yet.
 245    */
 246   struct CadetTunnelDelayed *tqd;
 247
 248   /**
 249    * Continuation to call once sent.
 250    */
 251   GCT_sent cont;
 252
 253   /**
 254    * Closure for @c cont.
 255    */
 256   void *cont_cls;
 257 };
 258
 259
 260 /******************************************************************************/
 261 /*******************************   GLOBALS  ***********************************/
 262 /******************************************************************************/
 263
 264 /**
 265  * Global handle to the statistics service.
 266  */
 267 extern struct GNUNET_STATISTICS_Handle *stats;
 268
 269 /**
 270  * Local peer own ID (memory efficient handle).
 271  */
 272 extern GNUNET_PEER_Id myid;
 273
 274 /**
 275  * Local peer own ID (full value).
 276  */
 277 extern struct GNUNET_PeerIdentity my_full_id;
 278
 279
 280 /**
 281  * Don't try to recover tunnels if shutting down.
 282  */
 283 extern int shutting_down;
 284
 285
 286 /**
 287  * Set of all tunnels, in order to trigger a new exchange on rekey.
 288  * Indexed by peer's ID.
 289  */
 290 static struct GNUNET_CONTAINER_MultiPeerMap *tunnels;
 291
 292 /**
 293  * Default TTL for payload packets.
 294  */
 295 static unsigned long long default_ttl;
 296
 297 /**
 298  * Own private key.
 299  */
 300 const static struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
 301
 302 /**
 303  * Own ephemeral private key.
 304  */
 305 static struct GNUNET_CRYPTO_EcdhePrivateKey *my_ephemeral_key;
 306
 307 /**
 308  * Cached message used to perform a key exchange.
 309  */
 310 static struct GNUNET_CADET_KX_Ephemeral kx_msg;
 311
 312 /**
 313  * Task to generate a new ephemeral key.
 314  */
 315 static GNUNET_SCHEDULER_TaskIdentifier rekey_task;
 316
 317 /**
 318  * Rekey period.
 319  */
 320 static struct GNUNET_TIME_Relative rekey_period;
 321
 322 /******************************************************************************/
 323 /********************************   STATIC  ***********************************/
 324 /******************************************************************************/
 325
 326 /**
 327  * Get string description for tunnel connectivity state.
 328  *
 329  * @param cs Tunnel state.
 330  *
 331  * @return String representation.
 332  */
 333 static const char *
 334 cstate2s (enum CadetTunnelCState cs)
 335 {
 336   static char buf[32];
 337
 338   switch (cs)
 339   {
 340     case CADET_TUNNEL_NEW:
 341       return "CADET_TUNNEL_NEW";
 342     case CADET_TUNNEL_SEARCHING:
 343       return "CADET_TUNNEL_SEARCHING";
 344     case CADET_TUNNEL_WAITING:
 345       return "CADET_TUNNEL_WAITING";
 346     case CADET_TUNNEL_READY:
 347       return "CADET_TUNNEL_READY";
 348
 349     default:
 350       sprintf (buf, "%u (UNKNOWN STATE)", cs);
 351       return buf;
 352   }
 353   return "";
 354 }
 355
 356
 357 /**
 358  * Get string description for tunnel encryption state.
 359  *
 360  * @param es Tunnel state.
 361  *
 362  * @return String representation.
 363  */
 364 static const char *
 365 estate2s (enum CadetTunnelEState es)
 366 {
 367   static char buf[32];
 368
 369   switch (es)
 370   {
 371     case CADET_TUNNEL_KEY_UNINITIALIZED:
 372       return "CADET_TUNNEL_KEY_UNINITIALIZED";
 373     case CADET_TUNNEL_KEY_SENT:
 374       return "CADET_TUNNEL_KEY_SENT";
 375     case CADET_TUNNEL_KEY_PING:
 376       return "CADET_TUNNEL_KEY_PING";
 377     case CADET_TUNNEL_KEY_OK:
 378       return "CADET_TUNNEL_KEY_OK";
 379     case CADET_TUNNEL_KEY_REKEY:
 380       return "CADET_TUNNEL_KEY_REKEY";
 381     default:
 382       sprintf (buf, "%u (UNKNOWN STATE)", es);
 383       return buf;
 384   }
 385   return "";
 386 }
 387
 388
 389 /**
 390  * @brief Check if tunnel is ready to send traffic.
 391  *
 392  * Tunnel must be connected and with encryption correctly set up.
 393  *
 394  * @param t Tunnel to check.
 395  *
 396  * @return #GNUNET_YES if ready, #GNUNET_NO otherwise
 397  */
 398 static int
 399 is_ready (struct CadetTunnel *t)
 400 {
 401   int ready;
 402
 403   GCT_debug (t, GNUNET_ERROR_TYPE_DEBUG);
 404   ready = CADET_TUNNEL_READY == t->cstate
 405           && (CADET_TUNNEL_KEY_OK == t->estate
 406               || CADET_TUNNEL_KEY_REKEY == t->estate);
 407   ready = ready || GCT_is_loopback (t);
 408   return ready;
 409 }
 410
 411
 412 /**
 413  * Ephemeral key message purpose size.
 414  *
 415  * @return Size of the part of the ephemeral key message that must be signed.
 416  */
 417 size_t
 418 ephemeral_purpose_size (void)
 419 {
 420   return sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
 421          sizeof (struct GNUNET_TIME_AbsoluteNBO) +
 422          sizeof (struct GNUNET_TIME_AbsoluteNBO) +
 423          sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) +
 424          sizeof (struct GNUNET_PeerIdentity);
 425 }
 426
 427
 428 /**
 429  * Size of the encrypted part of a ping message.
 430  *
 431  * @return Size of the encrypted part of a ping message.
 432  */
 433 size_t
 434 ping_encryption_size (void)
 435 {
 436   return sizeof (struct GNUNET_PeerIdentity) + sizeof (uint32_t);
 437 }
 438
 439
 440 /**
 441  * Get the channel's buffer. ONLY FOR NON-LOOPBACK CHANNELS!!
 442  *
 443  * @param tch Tunnel's channel handle.
 444  *
 445  * @return Amount of messages the channel can still buffer towards the client.
 446  */
 447 static unsigned int
 448 get_channel_buffer (const struct CadetTChannel *tch)
 449 {
 450   int fwd;
 451
 452   /* If channel is outgoing, is origin in the FWD direction and fwd is YES */
 453   fwd = GCCH_is_origin (tch->ch, GNUNET_YES);
 454
 455   return GCCH_get_buffer (tch->ch, fwd);
 456 }
 457
 458
 459 /**
 460  * Get the channel's allowance status.
 461  *
 462  * @param tch Tunnel's channel handle.
 463  *
 464  * @return #GNUNET_YES if we allowed the client to send data to us.
 465  */
 466 static int
 467 get_channel_allowed (const struct CadetTChannel *tch)
 468 {
 469   int fwd;
 470
 471   /* If channel is outgoing, is origin in the FWD direction and fwd is YES */
 472   fwd = GCCH_is_origin (tch->ch, GNUNET_YES);
 473
 474   return GCCH_get_allowed (tch->ch, fwd);
 475 }
 476
 477
 478 /**
 479  * Get the connection's buffer.
 480  *
 481  * @param tc Tunnel's connection handle.
 482  *
 483  * @return Amount of messages the connection can still buffer.
 484  */
 485 static unsigned int
 486 get_connection_buffer (const struct CadetTConnection *tc)
 487 {
 488   int fwd;
 489
 490   /* If connection is outgoing, is origin in the FWD direction and fwd is YES */
 491   fwd = GCC_is_origin (tc->c, GNUNET_YES);
 492
 493   return GCC_get_buffer (tc->c, fwd);
 494 }
 495
 496
 497 /**
 498  * Get the connection's allowance.
 499  *
 500  * @param tc Tunnel's connection handle.
 501  *
 502  * @return Amount of messages we have allowed the next peer to send us.
 503  */
 504 static unsigned int
 505 get_connection_allowed (const struct CadetTConnection *tc)
 506 {
 507   int fwd;
 508
 509   /* If connection is outgoing, is origin in the FWD direction and fwd is YES */
 510   fwd = GCC_is_origin (tc->c, GNUNET_YES);
 511
 512   return GCC_get_allowed (tc->c, fwd);
 513 }
 514
 515
 516 /**
 517  * Check that a ephemeral key message s well formed and correctly signed.
 518  *
 519  * @param t Tunnel on which the message came.
 520  * @param msg The ephemeral key message.
 521  *
 522  * @return GNUNET_OK if message is fine, GNUNET_SYSERR otherwise.
 523  */
 524 int
 525 check_ephemeral (struct CadetTunnel *t,
 526                  const struct GNUNET_CADET_KX_Ephemeral *msg)
 527 {
 528   /* Check message size */
 529   if (ntohs (msg->header.size) != sizeof (struct GNUNET_CADET_KX_Ephemeral))
 530     return GNUNET_SYSERR;
 531
 532   /* Check signature size */
 533   if (ntohl (msg->purpose.size) != ephemeral_purpose_size ())
 534     return GNUNET_SYSERR;
 535
 536   /* Check origin */
 537   if (0 != memcmp (&msg->origin_identity,
 538                    GCP_get_id (t->peer),
 539                    sizeof (struct GNUNET_PeerIdentity)))
 540     return GNUNET_SYSERR;
 541
 542   /* Check signature */
 543   if (GNUNET_OK !=
 544       GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_CADET_KX,
 545                                   &msg->purpose,
 546                                   &msg->signature,
 547                                   &msg->origin_identity.public_key))
 548     return GNUNET_SYSERR;
 549
 550   return GNUNET_OK;
 551 }
 552
 553
 554 /**
 555  * Select the best key to use for encryption (send), based on KX status.
 556  *
 557  * Normally, return the current key. If there is a KX in progress and the old
 558  * key is fresh enough, return the old key.
 559  *
 560  * @param t Tunnel to choose the key from.
 561  *
 562  * @return The optimal key to encrypt/hmac outgoing traffic.
 563  */
 564 static const struct GNUNET_CRYPTO_SymmetricSessionKey *
 565 select_key (const struct CadetTunnel *t)
 566 {
 567   const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
 568
 569   if (NULL != t->kx_ctx
 570       && GNUNET_SCHEDULER_NO_TASK == t->kx_ctx->finish_task)
 571   {
 572     struct GNUNET_TIME_Relative age;
 573
 574     age = GNUNET_TIME_absolute_get_duration (t->kx_ctx->rekey_start_time);
 575     LOG (GNUNET_ERROR_TYPE_DEBUG,
 576          "  key exchange in progress, started %s ago\n",
 577          GNUNET_STRINGS_relative_time_to_string (age, GNUNET_YES));
 578     // FIXME make duration of old keys configurable
 579     if (age.rel_value_us < GNUNET_TIME_UNIT_MINUTES.rel_value_us)
 580     {
 581       LOG (GNUNET_ERROR_TYPE_DEBUG, "  using old key\n");
 582       key = &t->kx_ctx->e_key_old;
 583     }
 584     else
 585     {
 586       LOG (GNUNET_ERROR_TYPE_DEBUG, "  using new key\n");
 587       key = &t->e_key;
 588     }
 589   }
 590   else
 591   {
 592     LOG (GNUNET_ERROR_TYPE_DEBUG, "  no KX: using current key\n");
 593     key = &t->e_key;
 594   }
 595   return key;
 596 }
 597
 598
 599 /**
 600  * Calculate HMAC.
 601  *
 602  * @param plaintext Content to HMAC.
 603  * @param size Size of @c plaintext.
 604  * @param iv Initialization vector for the message.
 605  * @param key Key to use.
 606  * @param hmac[out] Destination to store the HMAC.
 607  */
 608 static void
 609 t_hmac (const void *plaintext, size_t size,
 610         uint32_t iv, const struct GNUNET_CRYPTO_SymmetricSessionKey *key,
 611         struct GNUNET_CADET_Hash *hmac)
 612 {
 613   static const char ctx[] = "cadet authentication key";
 614   struct GNUNET_CRYPTO_AuthKey auth_key;
 615   struct GNUNET_HashCode hash;
 616
 617 #if DUMP_KEYS_TO_STDERR
 618   LOG (GNUNET_ERROR_TYPE_INFO, "  HMAC with key %s\n",
 619        GNUNET_h2s ((struct GNUNET_HashCode *) key));
 620 #endif
 621   GNUNET_CRYPTO_hmac_derive_key (&auth_key, key,
 622                                  &iv, sizeof (iv),
 623                                  key, sizeof (*key),
 624                                  ctx, sizeof (ctx),
 625                                  NULL);
 626   /* Two step: CADET_Hash is only 256 bits, HashCode is 512. */
 627   GNUNET_CRYPTO_hmac (&auth_key, plaintext, size, &hash);
 628   memcpy (hmac, &hash, sizeof (*hmac));
 629 }
 630
 631
 632 /**
 633  * Encrypt daforce_newest_keyta with the tunnel key.
 634  *
 635  * @param t Tunnel whose key to use.
 636  * @param dst Destination for the encrypted data.
 637  * @param src Source of the plaintext. Can overlap with @c dst.
 638  * @param size Size of the plaintext.
 639  * @param iv Initialization Vector to use.
 640  * @param force_newest_key Force the use of the newest key, otherwise
 641  *                         CADET will use the old key when allowed.
 642  *                         This can happen in the case when a KX is going on
 643  *                         and the old one hasn't expired.
 644  */
 645 static int
 646 t_encrypt (struct CadetTunnel *t, void *dst, const void *src,
 647            size_t size, uint32_t iv, int force_newest_key)
 648 {
 649   struct GNUNET_CRYPTO_SymmetricInitializationVector siv;
 650   const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
 651   size_t out_size;
 652
 653   LOG (GNUNET_ERROR_TYPE_DEBUG, "  t_encrypt start\n");
 654
 655   key = GNUNET_YES == force_newest_key ? &t->e_key : select_key (t);
 656   #if DUMP_KEYS_TO_STDERR
 657   LOG (GNUNET_ERROR_TYPE_INFO, "  ENC with key %s\n",
 658        GNUNET_h2s ((struct GNUNET_HashCode *) key));
 659   #endif
 660   GNUNET_CRYPTO_symmetric_derive_iv (&siv, key, &iv, sizeof (iv), NULL);
 661   LOG (GNUNET_ERROR_TYPE_DEBUG, "  t_encrypt IV derived\n");
 662   out_size = GNUNET_CRYPTO_symmetric_encrypt (src, size, key, &siv, dst);
 663   LOG (GNUNET_ERROR_TYPE_DEBUG, "  t_encrypt end\n");
 664
 665   return out_size;
 666 }
 667
 668
 669 /**
 670  * Decrypt and verify data with the appropriate tunnel key.
 671  *
 672  * @param key Key to use.
 673  * @param dst Destination for the plaintext.
 674  * @param src Source of the encrypted data. Can overlap with @c dst.
 675  * @param size Size of the encrypted data.
 676  * @param iv Initialization Vector to use.
 677  *
 678  * @return Size of the decrypted data, -1 if an error was encountered.
 679  */
 680 static int
 681 decrypt (const struct GNUNET_CRYPTO_SymmetricSessionKey *key,
 682          void *dst, const void *src, size_t size, uint32_t iv)
 683 {
 684   struct GNUNET_CRYPTO_SymmetricInitializationVector siv;
 685   size_t out_size;
 686
 687   LOG (GNUNET_ERROR_TYPE_DEBUG, "  decrypt start\n");
 688   LOG (GNUNET_ERROR_TYPE_DEBUG, "  decrypt iv\n");
 689   GNUNET_CRYPTO_symmetric_derive_iv (&siv, key, &iv, sizeof (iv), NULL);
 690   LOG (GNUNET_ERROR_TYPE_DEBUG, "  decrypt iv done\n");
 691   out_size = GNUNET_CRYPTO_symmetric_decrypt (src, size, key, &siv, dst);
 692   LOG (GNUNET_ERROR_TYPE_DEBUG, "  decrypt end\n");
 693
 694   return out_size;
 695 }
 696
 697
 698 /**
 699  * Decrypt and verify data with the most recent tunnel key.
 700  *
 701  * @param t Tunnel whose key to use.
 702  * @param dst Destination for the plaintext.
 703  * @param src Source of the encrypted data. Can overlap with @c dst.
 704  * @param size Size of the encrypted data.
 705  * @param iv Initialization Vector to use.
 706  *
 707  * @return Size of the decrypted data, -1 if an error was encountered.
 708  */
 709 static int
 710 t_decrypt (struct CadetTunnel *t, void *dst, const void *src,
 711            size_t size, uint32_t iv)
 712 {
 713   size_t out_size;
 714
 715 #if DUMP_KEYS_TO_STDERR
 716   LOG (GNUNET_ERROR_TYPE_DEBUG, "  t_decrypt with %s\n",
 717        GNUNET_h2s ((struct GNUNET_HashCode *) &t->d_key));
 718 #endif
 719   if (t->estate == CADET_TUNNEL_KEY_UNINITIALIZED)
 720   {
 721     GNUNET_STATISTICS_update (stats, "# non decryptable data", 1, GNUNET_NO);
 722     LOG (GNUNET_ERROR_TYPE_WARNING,
 723          "got data on %s without a valid key\n",
 724          GCT_2s (t));
 725     GCT_debug (t, GNUNET_ERROR_TYPE_WARNING);
 726     return -1;
 727   }
 728
 729   out_size = decrypt (&t->d_key, dst, src, size, iv);
 730
 731   return out_size;
 732 }
 733
 734
 735 /**
 736  * Decrypt and verify data with the appropriate tunnel key and verify that the
 737  * data has not been altered since it was sent by the remote peer.
 738  *
 739  * @param t Tunnel whose key to use.
 740  * @param dst Destination for the plaintext.
 741  * @param src Source of the encrypted data. Can overlap with @c dst.
 742  * @param size Size of the encrypted data.
 743  * @param iv Initialization Vector to use.
 744  * @param msg_hmac HMAC of the message, cannot be NULL.
 745  *
 746  * @return Size of the decrypted data, -1 if an error was encountered.
 747  */
 748 static int
 749 t_decrypt_and_validate (struct CadetTunnel *t,
 750                         void *dst, const void *src,
 751                         size_t size, uint32_t iv,
 752                         const struct GNUNET_CADET_Hash *msg_hmac)
 753 {
 754   struct GNUNET_CRYPTO_SymmetricSessionKey *key;
 755   struct GNUNET_CADET_Hash hmac;
 756   int decrypted_size;
 757
 758   /* Try primary (newest) key */
 759   key = &t->d_key;
 760   decrypted_size = decrypt (key, dst, src, size, iv);
 761   t_hmac (src, size, iv, key, &hmac);
 762   if (0 == memcmp (msg_hmac, &hmac, sizeof (hmac)))
 763     return decrypted_size;
 764
 765   /* If no key exchange is going on, we just failed */
 766   if (NULL == t->kx_ctx)
 767   {
 768     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 769                 "Failed checksum validation on tunnel %s with no KX\n",
 770                 GCT_2s (t));
 771     GNUNET_STATISTICS_update (stats, "# wrong HMAC", 1, GNUNET_NO);
 772     return -1;
 773   }
 774
 775   /* Try secondary (from previous KX period) key */
 776   key = &t->kx_ctx->d_key_old;
 777   decrypted_size = decrypt (key, dst, src, size, iv);
 778   t_hmac (src, size, iv, key, &hmac);
 779   if (0 == memcmp (msg_hmac, &hmac, sizeof (hmac)))
 780     return decrypted_size;
 781
 782   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 783               "Failed checksum validation on tunnel %s with KX\n",
 784               GCT_2s (t));
 785   GNUNET_STATISTICS_update (stats, "# wrong HMAC", 1, GNUNET_NO);
 786   return -1;
 787 }
 788
 789
 790 /**
 791  * Create key material by doing ECDH on the local and remote ephemeral keys.
 792  *
 793  * @param key_material Where to store the key material.
 794  * @param ephemeral_key Peer's public ephemeral key.
 795  */
 796 void
 797 derive_key_material (struct GNUNET_HashCode *key_material,
 798                      const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral_key)
 799 {
 800   if (GNUNET_OK !=
 801       GNUNET_CRYPTO_ecc_ecdh (my_ephemeral_key,
 802                               ephemeral_key,
 803                               key_material))
 804   {
 805     GNUNET_break (0);
 806   }
 807 }
 808
 809
 810 /**
 811  * Create a symmetic key from the identities of both ends and the key material
 812  * from ECDH.
 813  *
 814  * @param key Destination for the generated key.
 815  * @param sender ID of the peer that will encrypt with @c key.
 816  * @param receiver ID of the peer that will decrypt with @c key.
 817  * @param key_material Hash created with ECDH with the ephemeral keys.
 818  */
 819 void
 820 derive_symmertic (struct GNUNET_CRYPTO_SymmetricSessionKey *key,
 821                   const struct GNUNET_PeerIdentity *sender,
 822                   const struct GNUNET_PeerIdentity *receiver,
 823                   const struct GNUNET_HashCode *key_material)
 824 {
 825   const char salt[] = "CADET kx salt";
 826
 827   GNUNET_CRYPTO_kdf (key, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
 828                      salt, sizeof (salt),
 829                      key_material, sizeof (struct GNUNET_HashCode),
 830                      sender, sizeof (struct GNUNET_PeerIdentity),
 831                      receiver, sizeof (struct GNUNET_PeerIdentity),
 832                      NULL);
 833 }
 834
 835
 836 /**
 837  * Create a new Key eXchange context for the tunnel.
 838  *
 839  * Initializes the key copies, KX start timestamp and creates a new nonce.
 840  *
 841  * @param t Tunnel for which to create the KX ctx.
 842  */
 843 static void
 844 create_kx_ctx (struct CadetTunnel *t)
 845 {
 846   GNUNET_assert (NULL == t->kx_ctx);
 847
 848   LOG (GNUNET_ERROR_TYPE_INFO, "  new kx ctx for %s\n", GCT_2s (t));
 849   t->kx_ctx = GNUNET_new (struct CadetTunnelKXCtx);
 850   t->kx_ctx->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
 851                                                    UINT32_MAX);
 852   t->kx_ctx->d_key_old = t->d_key;
 853   t->kx_ctx->e_key_old = t->e_key;
 854   t->kx_ctx->rekey_start_time = GNUNET_TIME_absolute_get ();
 855 }
 856
 857
 858 /**
 859  * Derive the tunnel's keys using our own and the peer's ephemeral keys.
 860  *
 861  * @param t Tunnel for which to create the keys.
 862  */
 863 static void
 864 create_keys (struct CadetTunnel *t)
 865 {
 866   struct GNUNET_HashCode km;
 867
 868   derive_key_material (&km, &t->peers_ephemeral_key);
 869   derive_symmertic (&t->e_key, &my_full_id, GCP_get_id (t->peer), &km);
 870   derive_symmertic (&t->d_key, GCP_get_id (t->peer), &my_full_id, &km);
 871 #if DUMP_KEYS_TO_STDERR
 872   LOG (GNUNET_ERROR_TYPE_INFO, "ME: %s\n",
 873        GNUNET_h2s ((struct GNUNET_HashCode *) &kx_msg.ephemeral_key));
 874   LOG (GNUNET_ERROR_TYPE_INFO, "PE: %s\n",
 875        GNUNET_h2s ((struct GNUNET_HashCode *) &t->peers_ephemeral_key));
 876   LOG (GNUNET_ERROR_TYPE_INFO, "KM: %s\n", GNUNET_h2s (&km));
 877   LOG (GNUNET_ERROR_TYPE_INFO, "EK: %s\n",
 878        GNUNET_h2s ((struct GNUNET_HashCode *) &t->e_key));
 879   LOG (GNUNET_ERROR_TYPE_INFO, "DK: %s\n",
 880        GNUNET_h2s ((struct GNUNET_HashCode *) &t->d_key));
 881 #endif
 882 }
 883
 884
 885 /**
 886  * Pick a connection on which send the next data message.
 887  *
 888  * @param t Tunnel on which to send the message.
 889  *
 890  * @return The connection on which to send the next message.
 891  */
 892 static struct CadetConnection *
 893 tunnel_get_connection (struct CadetTunnel *t)
 894 {
 895   struct CadetTConnection *iter;
 896   struct CadetConnection *best;
 897   unsigned int qn;
 898   unsigned int lowest_q;
 899
 900   LOG (GNUNET_ERROR_TYPE_DEBUG, "tunnel_get_connection %s\n", GCT_2s (t));
 901   best = NULL;
 902   lowest_q = UINT_MAX;
 903   for (iter = t->connection_head; NULL != iter; iter = iter->next)
 904   {
 905     LOG (GNUNET_ERROR_TYPE_DEBUG, "  connection %s: %u\n",
 906          GCC_2s (iter->c), GCC_get_state (iter->c));
 907     if (CADET_CONNECTION_READY == GCC_get_state (iter->c))
 908     {
 909       qn = GCC_get_qn (iter->c, GCC_is_origin (iter->c, GNUNET_YES));
 910       LOG (GNUNET_ERROR_TYPE_DEBUG, "    q_n %u, \n", qn);
 911       if (qn < lowest_q)
 912       {
 913         best = iter->c;
 914         lowest_q = qn;
 915       }
 916     }
 917   }
 918   LOG (GNUNET_ERROR_TYPE_DEBUG, " selected: connection %s\n", GCC_2s (best));
 919   return best;
 920 }
 921
 922
 923 /**
 924  * Callback called when a queued message is sent.
 925  *
 926  * Calculates the average time and connection packet tracking.
 927  *
 928  * @param cls Closure (TunnelQueue handle).
 929  * @param c Connection this message was on.
 930  * @param q Connection queue handle (unused).
 931  * @param type Type of message sent.
 932  * @param fwd Was this a FWD going message?
 933  * @param size Size of the message.
 934  */
 935 static void
 936 tun_message_sent (void *cls,
 937               struct CadetConnection *c,
 938               struct CadetConnectionQueue *q,
 939               uint16_t type, int fwd, size_t size)
 940 {
 941   struct CadetTunnelQueue *qt = cls;
 942   struct CadetTunnel *t;
 943
 944   LOG (GNUNET_ERROR_TYPE_DEBUG, "tun_message_sent\n");
 945
 946   GNUNET_assert (NULL != qt->cont);
 947   t = NULL == c ? NULL : GCC_get_tunnel (c);
 948   qt->cont (qt->cont_cls, t, qt, type, size);
 949   GNUNET_free (qt);
 950 }
 951
 952
 953 static unsigned int
 954 count_queued_data (const struct CadetTunnel *t)
 955 {
 956   struct CadetTunnelDelayed *iter;
 957   unsigned int count;
 958
 959   for (count = 0, iter = t->tq_head; iter != NULL; iter = iter->next)
 960     count++;
 961
 962   return count;
 963 }
 964
 965 /**
 966  * Delete a queued message: either was sent or the channel was destroyed
 967  * before the tunnel's key exchange had a chance to finish.
 968  *
 969  * @param tqd Delayed queue handle.
 970  */
 971 static void
 972 unqueue_data (struct CadetTunnelDelayed *tqd)
 973 {
 974   GNUNET_CONTAINER_DLL_remove (tqd->t->tq_head, tqd->t->tq_tail, tqd);
 975   GNUNET_free (tqd);
 976 }
 977
 978
 979 /**
 980  * Cache a message to be sent once tunnel is online.
 981  *
 982  * @param t Tunnel to hold the message.
 983  * @param msg Message itself (copy will be made).
 984  */
 985 static struct CadetTunnelDelayed *
 986 queue_data (struct CadetTunnel *t, const struct GNUNET_MessageHeader *msg)
 987 {
 988   struct CadetTunnelDelayed *tqd;
 989   uint16_t size = ntohs (msg->size);
 990
 991   LOG (GNUNET_ERROR_TYPE_DEBUG, "queue data on Tunnel %s\n", GCT_2s (t));
 992
 993   if (GNUNET_YES == is_ready (t))
 994   {
 995     GNUNET_break (0);
 996     return NULL;
 997   }
 998
 999   tqd = GNUNET_malloc (sizeof (struct CadetTunnelDelayed) + size);
1000
1001   tqd->t = t;
1002   memcpy (&tqd[1], msg, size);
1003   GNUNET_CONTAINER_DLL_insert_tail (t->tq_head, t->tq_tail, tqd);
1004   return tqd;
1005 }
1006
1007
1008 /**
1009  * Sends an already built message on a tunnel, encrypting it and
1010  * choosing the best connection.
1011  *
1012  * @param message Message to send. Function modifies it.
1013  * @param t Tunnel on which this message is transmitted.
1014  * @param c Connection to use (autoselect if NULL).
1015  * @param force Force the tunnel to take the message (buffer overfill).
1016  * @param cont Continuation to call once message is really sent.
1017  * @param cont_cls Closure for @c cont.
1018  * @param existing_q In case this a transmission of previously queued data,
1019  *                   this should be TunnelQueue given to the client.
1020  *                   Otherwise, NULL.
1021  *
1022  * @return Handle to cancel message. NULL if @c cont is NULL.
1023  */
1024 static struct CadetTunnelQueue *
1025 send_prebuilt_message (const struct GNUNET_MessageHeader *message,
1026                        struct CadetTunnel *t, struct CadetConnection *c,
1027                        int force, GCT_sent cont, void *cont_cls,
1028                        struct CadetTunnelQueue *existing_q)
1029 {
1030   struct CadetTunnelQueue *tq;
1031   struct GNUNET_CADET_Encrypted *msg;
1032   size_t size = ntohs (message->size);
1033   char cbuf[sizeof (struct GNUNET_CADET_Encrypted) + size];
1034   uint32_t mid;
1035   uint32_t iv;
1036   uint16_t type;
1037   int fwd;
1038
1039   LOG (GNUNET_ERROR_TYPE_DEBUG, "GMT Send on Tunnel %s\n", GCT_2s (t));
1040
1041   if (GNUNET_NO == is_ready (t))
1042   {
1043     struct CadetTunnelDelayed *tqd;
1044     /* A non null existing_q indicates sending of queued data.
1045      * Should only happen after tunnel becomes ready.
1046      */
1047     GNUNET_assert (NULL == existing_q);
1048     tqd = queue_data (t, message);
1049     if (NULL == cont)
1050       return NULL;
1051     tq = GNUNET_new (struct CadetTunnelQueue);
1052     tq->tqd = tqd;
1053     tqd->tq = tq;
1054     tq->cont = cont;
1055     tq->cont_cls = cont_cls;
1056     return tq;
1057   }
1058
1059   GNUNET_assert (GNUNET_NO == GCT_is_loopback (t));
1060
1061   iv = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX);
1062   msg = (struct GNUNET_CADET_Encrypted *) cbuf;
1063   msg->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED);
1064   msg->iv = iv;
1065   GNUNET_assert (t_encrypt (t, &msg[1], message, size, iv, GNUNET_NO) == size);
1066   t_hmac (&msg[1], size, iv, select_key (t), &msg->hmac);
1067   msg->header.size = htons (sizeof (struct GNUNET_CADET_Encrypted) + size);
1068
1069   if (NULL == c)
1070     c = tunnel_get_connection (t);
1071   if (NULL == c)
1072   {
1073     if (GNUNET_SCHEDULER_NO_TASK != t->destroy_task
1074         || CADET_TUNNEL_SEARCHING != t->cstate)
1075     {
1076       GNUNET_break (0);
1077       GCT_debug (t, GNUNET_ERROR_TYPE_WARNING);
1078     }
1079     return NULL;
1080   }
1081
1082   mid = 0;
1083   type = ntohs (message->type);
1084   switch (type)
1085   {
1086     case GNUNET_MESSAGE_TYPE_CADET_DATA:
1087     case GNUNET_MESSAGE_TYPE_CADET_DATA_ACK:
1088       if (GNUNET_MESSAGE_TYPE_CADET_DATA == type)
1089         mid = ntohl (((struct GNUNET_CADET_Data *) message)->mid);
1090       else
1091         mid = ntohl (((struct GNUNET_CADET_DataACK *) message)->mid);
1092       /* Fall thru */
1093     case GNUNET_MESSAGE_TYPE_CADET_KEEPALIVE:
1094     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE:
1095     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY:
1096     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_ACK:
1097     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_NACK:
1098       msg->cid = *GCC_get_id (c);
1099       msg->ttl = htonl (default_ttl);
1100       break;
1101     default:
1102       GNUNET_break (0);
1103   }
1104   LOG (GNUNET_ERROR_TYPE_DEBUG, "type %s\n", GC_m2s (type));
1105
1106   fwd = GCC_is_origin (c, GNUNET_YES);
1107
1108   if (NULL == cont)
1109   {
1110     GNUNET_break (NULL == GCC_send_prebuilt_message (&msg->header, type, mid, c,
1111                                                      fwd, force, NULL, NULL));
1112     return NULL;
1113   }
1114   if (NULL == existing_q)
1115   {
1116     tq = GNUNET_new (struct CadetTunnelQueue); /* FIXME valgrind: leak*/
1117   }
1118   else
1119   {
1120     tq = existing_q;
1121     tq->tqd = NULL;
1122   }
1123   tq->cq = GCC_send_prebuilt_message (&msg->header, type, mid, c, fwd, force,
1124                                       &tun_message_sent, tq);
1125   GNUNET_assert (NULL != tq->cq);
1126   tq->cont = cont;
1127   tq->cont_cls = cont_cls;
1128
1129   return tq;
1130 }
1131
1132
1133 /**
1134  * Send all cached messages that we can, tunnel is online.
1135  *
1136  * @param t Tunnel that holds the messages. Cannot be loopback.
1137  */
1138 static void
1139 send_queued_data (struct CadetTunnel *t)
1140 {
1141   struct CadetTunnelDelayed *tqd;
1142   struct CadetTunnelDelayed *next;
1143   unsigned int room;
1144
1145   LOG (GNUNET_ERROR_TYPE_DEBUG,
1146        "GCT_send_queued_data on tunnel %s\n",
1147        GCT_2s (t));
1148
1149   if (GCT_is_loopback (t))
1150   {
1151     GNUNET_break (0);
1152     return;
1153   }
1154
1155   if (GNUNET_NO == is_ready (t))
1156   {
1157     LOG (GNUNET_ERROR_TYPE_DEBUG, "  not ready yet: %s/%s\n",
1158          estate2s (t->estate), cstate2s (t->cstate));
1159     return;
1160   }
1161
1162   room = GCT_get_connections_buffer (t);
1163   LOG (GNUNET_ERROR_TYPE_DEBUG, "  buffer space: %u\n", room);
1164   LOG (GNUNET_ERROR_TYPE_DEBUG, "  tq head: %p\n", t->tq_head);
1165   for (tqd = t->tq_head; NULL != tqd && room > 0; tqd = next)
1166   {
1167     LOG (GNUNET_ERROR_TYPE_DEBUG, " sending queued data\n");
1168     next = tqd->next;
1169     room--;
1170     send_prebuilt_message ((struct GNUNET_MessageHeader *) &tqd[1],
1171                            tqd->t, NULL, GNUNET_YES,
1172                            NULL != tqd->tq ? tqd->tq->cont : NULL,
1173                            NULL != tqd->tq ? tqd->tq->cont_cls : NULL,
1174                            tqd->tq);
1175     unqueue_data (tqd);
1176   }
1177   LOG (GNUNET_ERROR_TYPE_DEBUG, "GCT_send_queued_data end\n", GCP_2s (t->peer));
1178 }
1179
1180
1181 /**
1182  * Sends key exchange message on a tunnel, choosing the best connection.
1183  * Should not be called on loopback tunnels.
1184  *
1185  * @param t Tunnel on which this message is transmitted.
1186  * @param message Message to send. Function modifies it.
1187  */
1188 static void
1189 send_kx (struct CadetTunnel *t,
1190          const struct GNUNET_MessageHeader *message)
1191 {
1192   struct CadetConnection *c;
1193   struct GNUNET_CADET_KX *msg;
1194   size_t size = ntohs (message->size);
1195   char cbuf[sizeof (struct GNUNET_CADET_KX) + size];
1196   uint16_t type;
1197   int fwd;
1198
1199   LOG (GNUNET_ERROR_TYPE_DEBUG, "GMT KX on Tunnel %s\n", GCT_2s (t));
1200
1201   /* Avoid loopback. */
1202   if (GCT_is_loopback (t))
1203   {
1204     LOG (GNUNET_ERROR_TYPE_DEBUG, "  loopback!\n");
1205     GNUNET_break (0);
1206     return;
1207   }
1208   type = ntohs (message->type);
1209
1210   /* Even if tunnel is being destroyed, send anyway.
1211    * Could be a response to a rekey initiated by remote peer,
1212    * who is trying to create a new channel!
1213    */
1214
1215   /* Must have a connection. */
1216   if (NULL == t->connection_head && CADET_TUNNEL_SEARCHING != t->cstate)
1217   {
1218     LOG (GNUNET_ERROR_TYPE_WARNING, "\n\n\n");
1219     GNUNET_break (0);
1220     LOG (GNUNET_ERROR_TYPE_WARNING, "sending %s\n", GC_m2s (type));
1221     GCT_debug (t, GNUNET_ERROR_TYPE_WARNING);
1222     GCP_debug (t->peer, GNUNET_ERROR_TYPE_WARNING);
1223     LOG (GNUNET_ERROR_TYPE_WARNING, "\n\n\n");
1224     return;
1225   }
1226
1227   msg = (struct GNUNET_CADET_KX *) cbuf;
1228   msg->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_KX);
1229   msg->header.size = htons (sizeof (struct GNUNET_CADET_KX) + size);
1230   c = tunnel_get_connection (t);
1231   if (NULL == c)
1232   {
1233     GNUNET_break (GNUNET_SCHEDULER_NO_TASK != t->destroy_task
1234                   || CADET_TUNNEL_READY != t->cstate);
1235     GCT_debug (t, GNUNET_ERROR_TYPE_WARNING);
1236     return;
1237   }
1238   switch (type)
1239   {
1240     case GNUNET_MESSAGE_TYPE_CADET_KX_EPHEMERAL:
1241     case GNUNET_MESSAGE_TYPE_CADET_KX_PING:
1242     case GNUNET_MESSAGE_TYPE_CADET_KX_PONG:
1243       memcpy (&msg[1], message, size);
1244       break;
1245     default:
1246       LOG (GNUNET_ERROR_TYPE_DEBUG, "unkown type %s\n",
1247            GC_m2s (type));
1248       GNUNET_break (0);
1249   }
1250
1251   fwd = GCC_is_origin (t->connection_head->c, GNUNET_YES);
1252   /* TODO save handle and cancel in case of a unneeded retransmission */
1253   GNUNET_assert (NULL == GCC_send_prebuilt_message (&msg->header, type, 0, c,
1254                                                     fwd, GNUNET_YES,
1255                                                     NULL, NULL));
1256 }
1257
1258
1259 /**
1260  * Send the ephemeral key on a tunnel.
1261  *
1262  * @param t Tunnel on which to send the key.
1263  */
1264 static void
1265 send_ephemeral (struct CadetTunnel *t)
1266 {
1267   LOG (GNUNET_ERROR_TYPE_INFO, "===> EPHM for %s\n", GCT_2s (t));
1268
1269   kx_msg.sender_status = htonl (t->estate);
1270   send_kx (t, &kx_msg.header);
1271 }
1272
1273 /**
1274  * Send a ping message on a tunnel.
1275  *
1276  * @param t Tunnel on which to send the ping.
1277  */
1278 static void
1279 send_ping (struct CadetTunnel *t)
1280 {
1281   struct GNUNET_CADET_KX_Ping msg;
1282
1283   LOG (GNUNET_ERROR_TYPE_INFO, "===> PING for %s\n", GCT_2s (t));
1284   msg.header.size = htons (sizeof (msg));
1285   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_KX_PING);
1286   msg.iv = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX);
1287   msg.target = *GCP_get_id (t->peer);
1288   msg.nonce = t->kx_ctx->challenge;
1289
1290   LOG (GNUNET_ERROR_TYPE_DEBUG, "  sending %u\n", msg.nonce);
1291   LOG (GNUNET_ERROR_TYPE_DEBUG, "  towards %s\n", GNUNET_i2s (&msg.target));
1292   t_encrypt (t, &msg.target, &msg.target,
1293              ping_encryption_size(), msg.iv, GNUNET_YES);
1294   LOG (GNUNET_ERROR_TYPE_DEBUG, "  e sending %u\n", msg.nonce);
1295   LOG (GNUNET_ERROR_TYPE_DEBUG, "  e towards %s\n", GNUNET_i2s (&msg.target));
1296
1297   send_kx (t, &msg.header);
1298 }
1299
1300
1301 /**
1302  * Send a pong message on a tunnel.
1303  *d_
1304  * @param t Tunnel on which to send the pong.
1305  * @param challenge Value sent in the ping that we have to send back.
1306  */
1307 static void
1308 send_pong (struct CadetTunnel *t, uint32_t challenge)
1309 {
1310   struct GNUNET_CADET_KX_Pong msg;
1311
1312   LOG (GNUNET_ERROR_TYPE_INFO, "===> PONG for %s\n", GCT_2s (t));
1313   msg.header.size = htons (sizeof (msg));
1314   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_KX_PONG);
1315   msg.iv = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX);
1316   msg.nonce = challenge;
1317   LOG (GNUNET_ERROR_TYPE_DEBUG, "  sending %u\n", msg.nonce);
1318   t_encrypt (t, &msg.nonce, &msg.nonce,
1319              sizeof (msg.nonce), msg.iv, GNUNET_YES);
1320   LOG (GNUNET_ERROR_TYPE_DEBUG, "  e sending %u\n", msg.nonce);
1321
1322   send_kx (t, &msg.header);
1323 }
1324
1325
1326 /**
1327  * Initiate a rekey with the remote peer.
1328  *
1329  * @param cls Closure (tunnel).
1330  * @param tc TaskContext.
1331  */
1332 static void
1333 rekey_tunnel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1334 {
1335   struct CadetTunnel *t = cls;
1336
1337   t->rekey_task = GNUNET_SCHEDULER_NO_TASK;
1338
1339   LOG (GNUNET_ERROR_TYPE_INFO, "Re-key Tunnel %s\n", GCT_2s (t));
1340   if (NULL != tc && 0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
1341     return;
1342
1343   if (NULL == t->kx_ctx)
1344   {
1345     create_kx_ctx (t);
1346     create_keys (t);
1347   }
1348   else
1349   {
1350     struct GNUNET_TIME_Relative duration;
1351
1352     duration = GNUNET_TIME_absolute_get_duration (t->kx_ctx->rekey_start_time);
1353     LOG (GNUNET_ERROR_TYPE_DEBUG, " kx started %s ago\n",
1354          GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
1355
1356     // FIXME make duration of old keys configurable
1357     if (duration.rel_value_us >= GNUNET_TIME_UNIT_MINUTES.rel_value_us)
1358     {
1359       memset (&t->kx_ctx->d_key_old, 0, sizeof (t->kx_ctx->d_key_old));
1360       memset (&t->kx_ctx->e_key_old, 0, sizeof (t->kx_ctx->e_key_old));
1361     }
1362   }
1363
1364   send_ephemeral (t);
1365
1366   switch (t->estate)
1367   {
1368     case CADET_TUNNEL_KEY_UNINITIALIZED:
1369       t->estate = CADET_TUNNEL_KEY_SENT;
1370       break;
1371     case CADET_TUNNEL_KEY_SENT:
1372       break;
1373     case CADET_TUNNEL_KEY_OK:
1374       t->estate = CADET_TUNNEL_KEY_REKEY;
1375       /* fall-thru */
1376     case CADET_TUNNEL_KEY_PING:
1377     case CADET_TUNNEL_KEY_REKEY:
1378       send_ping (t);
1379       break;
1380     default:
1381       LOG (GNUNET_ERROR_TYPE_DEBUG, "Unexpected state %u\n", t->estate);
1382   }
1383
1384   // FIXME exponential backoff
1385   struct GNUNET_TIME_Relative delay;
1386
1387   delay = GNUNET_TIME_relative_divide (rekey_period, 16);
1388   delay = GNUNET_TIME_relative_min (delay, REKEY_WAIT);
1389   LOG (GNUNET_ERROR_TYPE_DEBUG, "  next call in %s\n",
1390        GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
1391   t->rekey_task = GNUNET_SCHEDULER_add_delayed (delay, &rekey_tunnel, t);
1392 }
1393
1394
1395 /**
1396  * Our ephemeral key has changed, create new session key on all tunnels.
1397  *
1398  * Each tunnel will start the Key Exchange with a random delay between
1399  * 0 and number_of_tunnels*100 milliseconds, so there are 10 key exchanges
1400  * per second, on average.
1401  *
1402  * @param cls Closure (size of the hashmap).
1403  * @param key Current public key.
1404  * @param value Value in the hash map (tunnel).
1405  *
1406  * @return #GNUNET_YES, so we should continue to iterate,
1407  */
1408 static int
1409 rekey_iterator (void *cls,
1410                 const struct GNUNET_PeerIdentity *key,
1411                 void *value)
1412 {
1413   struct CadetTunnel *t = value;
1414   struct GNUNET_TIME_Relative delay;
1415   long n = (long) cls;
1416   uint32_t r;
1417
1418   if (GNUNET_SCHEDULER_NO_TASK != t->rekey_task)
1419     return GNUNET_YES;
1420
1421   if (GNUNET_YES == GCT_is_loopback (t))
1422     return GNUNET_YES;
1423
1424   r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, (uint32_t) n * 100);
1425   delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, r);
1426   t->rekey_task = GNUNET_SCHEDULER_add_delayed (delay, &rekey_tunnel, t);
1427
1428   return GNUNET_YES;
1429 }
1430
1431
1432 /**
1433  * Create a new ephemeral key and key message, schedule next rekeying.
1434  *
1435  * @param cls Closure (unused).
1436  * @param tc TaskContext.
1437  */
1438 static void
1439 rekey (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1440 {
1441   struct GNUNET_TIME_Absolute time;
1442   long n;
1443
1444   rekey_task = GNUNET_SCHEDULER_NO_TASK;
1445
1446   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
1447     return;
1448
1449   GNUNET_free_non_null (my_ephemeral_key);
1450   my_ephemeral_key = GNUNET_CRYPTO_ecdhe_key_create ();
1451
1452   time = GNUNET_TIME_absolute_get ();
1453   kx_msg.creation_time = GNUNET_TIME_absolute_hton (time);
1454   time = GNUNET_TIME_absolute_add (time, rekey_period);
1455   time = GNUNET_TIME_absolute_add (time, GNUNET_TIME_UNIT_MINUTES);
1456   kx_msg.expiration_time = GNUNET_TIME_absolute_hton (time);
1457   GNUNET_CRYPTO_ecdhe_key_get_public (my_ephemeral_key, &kx_msg.ephemeral_key);
1458
1459   GNUNET_assert (GNUNET_OK ==
1460                  GNUNET_CRYPTO_eddsa_sign (my_private_key,
1461                                            &kx_msg.purpose,
1462                                            &kx_msg.signature));
1463
1464   n = (long) GNUNET_CONTAINER_multipeermap_size (tunnels);
1465   GNUNET_CONTAINER_multipeermap_iterate (tunnels, &rekey_iterator, (void *) n);
1466
1467   rekey_task = GNUNET_SCHEDULER_add_delayed (rekey_period, &rekey, NULL);
1468 }
1469
1470
1471 /**
1472  * Called only on shutdown, destroy every tunnel.
1473  *
1474  * @param cls Closure (unused).
1475  * @param key Current public key.
1476  * @param value Value in the hash map (tunnel).
1477  *
1478  * @return #GNUNET_YES, so we should continue to iterate,
1479  */
1480 static int
1481 destroy_iterator (void *cls,
1482                 const struct GNUNET_PeerIdentity *key,
1483                 void *value)
1484 {
1485   struct CadetTunnel *t = value;
1486
1487   LOG (GNUNET_ERROR_TYPE_DEBUG, "GCT_shutdown destroying tunnel at %p\n", t);
1488   GCT_destroy (t);
1489   return GNUNET_YES;
1490 }
1491
1492
1493 /**
1494  * Notify remote peer that we don't know a channel he is talking about,
1495  * probably CHANNEL_DESTROY was missed.
1496  *
1497  * @param t Tunnel on which to notify.
1498  * @param gid ID of the channel.
1499  */
1500 static void
1501 send_channel_destroy (struct CadetTunnel *t, unsigned int gid)
1502 {
1503   struct GNUNET_CADET_ChannelManage msg;
1504
1505   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY);
1506   msg.header.size = htons (sizeof (msg));
1507   msg.chid = htonl (gid);
1508
1509   LOG (GNUNET_ERROR_TYPE_DEBUG,
1510        "WARNING destroying unknown channel %u on tunnel %s\n",
1511        gid, GCT_2s (t));
1512   send_prebuilt_message (&msg.header, t, NULL, GNUNET_YES, NULL, NULL, NULL);
1513 }
1514
1515
1516 /**
1517  * Demultiplex data per channel and call appropriate channel handler.
1518  *
1519  * @param t Tunnel on which the data came.
1520  * @param msg Data message.
1521  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1522  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1523  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1524  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1525  */
1526 static void
1527 handle_data (struct CadetTunnel *t,
1528              const struct GNUNET_CADET_Data *msg,
1529              int fwd)
1530 {
1531   struct CadetChannel *ch;
1532   size_t size;
1533
1534   /* Check size */
1535   size = ntohs (msg->header.size);
1536   if (size <
1537       sizeof (struct GNUNET_CADET_Data) +
1538       sizeof (struct GNUNET_MessageHeader))
1539   {
1540     GNUNET_break (0);
1541     return;
1542   }
1543   LOG (GNUNET_ERROR_TYPE_DEBUG, " payload of type %s\n",
1544               GC_m2s (ntohs (msg[1].header.type)));
1545
1546   /* Check channel */
1547   ch = GCT_get_channel (t, ntohl (msg->chid));
1548   if (NULL == ch)
1549   {
1550     GNUNET_STATISTICS_update (stats, "# data on unknown channel",
1551                               1, GNUNET_NO);
1552     LOG (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel 0x%X unknown\n",
1553          ntohl (msg->chid));
1554     send_channel_destroy (t, ntohl (msg->chid));
1555     return;
1556   }
1557
1558   GCCH_handle_data (ch, msg, fwd);
1559 }
1560
1561
1562 /**
1563  * Demultiplex data ACKs per channel and update appropriate channel buffer info.
1564  *
1565  * @param t Tunnel on which the DATA ACK came.
1566  * @param msg DATA ACK message.
1567  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1568  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1569  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1570  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1571  */
1572 static void
1573 handle_data_ack (struct CadetTunnel *t,
1574                  const struct GNUNET_CADET_DataACK *msg,
1575                  int fwd)
1576 {
1577   struct CadetChannel *ch;
1578   size_t size;
1579
1580   /* Check size */
1581   size = ntohs (msg->header.size);
1582   if (size != sizeof (struct GNUNET_CADET_DataACK))
1583   {
1584     GNUNET_break (0);
1585     return;
1586   }
1587
1588   /* Check channel */
1589   ch = GCT_get_channel (t, ntohl (msg->chid));
1590   if (NULL == ch)
1591   {
1592     GNUNET_STATISTICS_update (stats, "# data ack on unknown channel",
1593                               1, GNUNET_NO);
1594     LOG (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel %u unknown\n",
1595          ntohl (msg->chid));
1596     return;
1597   }
1598
1599   GCCH_handle_data_ack (ch, msg, fwd);
1600 }
1601
1602
1603 /**
1604  * Handle channel create.
1605  *
1606  * @param t Tunnel on which the data came.
1607  * @param msg Data message.
1608  */
1609 static void
1610 handle_ch_create (struct CadetTunnel *t,
1611                   const struct GNUNET_CADET_ChannelCreate *msg)
1612 {
1613   struct CadetChannel *ch;
1614   size_t size;
1615
1616   /* Check size */
1617   size = ntohs (msg->header.size);
1618   if (size != sizeof (struct GNUNET_CADET_ChannelCreate))
1619   {
1620     GNUNET_break (0);
1621     return;
1622   }
1623
1624   /* Check channel */
1625   ch = GCT_get_channel (t, ntohl (msg->chid));
1626   if (NULL != ch && ! GCT_is_loopback (t))
1627   {
1628     /* Probably a retransmission, safe to ignore */
1629     LOG (GNUNET_ERROR_TYPE_DEBUG, "   already exists...\n");
1630   }
1631   ch = GCCH_handle_create (t, msg);
1632   if (NULL != ch)
1633     GCT_add_channel (t, ch);
1634 }
1635
1636
1637
1638 /**
1639  * Handle channel NACK: check correctness and call channel handler for NACKs.
1640  *
1641  * @param t Tunnel on which the NACK came.
1642  * @param msg NACK message.
1643  */
1644 static void
1645 handle_ch_nack (struct CadetTunnel *t,
1646                 const struct GNUNET_CADET_ChannelManage *msg)
1647 {
1648   struct CadetChannel *ch;
1649   size_t size;
1650
1651   /* Check size */
1652   size = ntohs (msg->header.size);
1653   if (size != sizeof (struct GNUNET_CADET_ChannelManage))
1654   {
1655     GNUNET_break (0);
1656     return;
1657   }
1658
1659   /* Check channel */
1660   ch = GCT_get_channel (t, ntohl (msg->chid));
1661   if (NULL == ch)
1662   {
1663     GNUNET_STATISTICS_update (stats, "# channel NACK on unknown channel",
1664                               1, GNUNET_NO);
1665     LOG (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel %u unknown\n",
1666          ntohl (msg->chid));
1667     return;
1668   }
1669
1670   GCCH_handle_nack (ch);
1671 }
1672
1673
1674 /**
1675  * Handle a CHANNEL ACK (SYNACK/ACK).
1676  *
1677  * @param t Tunnel on which the CHANNEL ACK came.
1678  * @param msg CHANNEL ACK message.
1679  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1680  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1681  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1682  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1683  */
1684 static void
1685 handle_ch_ack (struct CadetTunnel *t,
1686                const struct GNUNET_CADET_ChannelManage *msg,
1687                int fwd)
1688 {
1689   struct CadetChannel *ch;
1690   size_t size;
1691
1692   /* Check size */
1693   size = ntohs (msg->header.size);
1694   if (size != sizeof (struct GNUNET_CADET_ChannelManage))
1695   {
1696     GNUNET_break (0);
1697     return;
1698   }
1699
1700   /* Check channel */
1701   ch = GCT_get_channel (t, ntohl (msg->chid));
1702   if (NULL == ch)
1703   {
1704     GNUNET_STATISTICS_update (stats, "# channel ack on unknown channel",
1705                               1, GNUNET_NO);
1706     LOG (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel %u unknown\n",
1707          ntohl (msg->chid));
1708     return;
1709   }
1710
1711   GCCH_handle_ack (ch, msg, fwd);
1712 }
1713
1714
1715 /**
1716  * Handle a channel destruction message.
1717  *
1718  * @param t Tunnel on which the message came.
1719  * @param msg Channel destroy message.
1720  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1721  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1722  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1723  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1724  */
1725 static void
1726 handle_ch_destroy (struct CadetTunnel *t,
1727                    const struct GNUNET_CADET_ChannelManage *msg,
1728                    int fwd)
1729 {
1730   struct CadetChannel *ch;
1731   size_t size;
1732
1733   /* Check size */
1734   size = ntohs (msg->header.size);
1735   if (size != sizeof (struct GNUNET_CADET_ChannelManage))
1736   {
1737     GNUNET_break (0);
1738     return;
1739   }
1740
1741   /* Check channel */
1742   ch = GCT_get_channel (t, ntohl (msg->chid));
1743   if (NULL == ch)
1744   {
1745     /* Probably a retransmission, safe to ignore */
1746     return;
1747   }
1748
1749   GCCH_handle_destroy (ch, msg, fwd);
1750 }
1751
1752
1753 /**
1754  * The peer's ephemeral key has changed: update the symmetrical keys.
1755  *
1756  * @param t Tunnel this message came on.
1757  * @param msg Key eXchange message.
1758  */
1759 static void
1760 handle_ephemeral (struct CadetTunnel *t,
1761                   const struct GNUNET_CADET_KX_Ephemeral *msg)
1762 {
1763   LOG (GNUNET_ERROR_TYPE_INFO, "<=== EPHM for %s\n", GCT_2s (t));
1764
1765   if (GNUNET_OK != check_ephemeral (t, msg))
1766   {
1767     GNUNET_break_op (0);
1768     return;
1769   }
1770
1771   if (NULL == t->kx_ctx)
1772     create_kx_ctx (t);
1773   if (0 != memcmp (&t->peers_ephemeral_key, &msg->ephemeral_key,
1774                    sizeof (msg->ephemeral_key)))
1775   {
1776     t->peers_ephemeral_key = msg->ephemeral_key;
1777     create_keys (t);
1778     if (CADET_TUNNEL_KEY_OK == t->estate)
1779     {
1780       t->estate = CADET_TUNNEL_KEY_REKEY;
1781     }
1782   }
1783   if (CADET_TUNNEL_KEY_SENT == t->estate)
1784   {
1785     LOG (GNUNET_ERROR_TYPE_DEBUG, "  our key was sent, sending ping\n");
1786     send_ping (t);
1787     t->estate = CADET_TUNNEL_KEY_PING;
1788   }
1789 }
1790
1791
1792 /**
1793  * Peer wants to check our symmetrical keys by sending an encrypted challenge.
1794  * Answer with by retransmitting the challenge with the "opposite" key.
1795  *
1796  * @param t Tunnel this message came on.
1797  * @param msg Key eXchange Ping message.
1798  */
1799 static void
1800 handle_ping (struct CadetTunnel *t,
1801              const struct GNUNET_CADET_KX_Ping *msg)
1802 {
1803   struct GNUNET_CADET_KX_Ping res;
1804
1805   if (ntohs (msg->header.size) != sizeof (res))
1806   {
1807     GNUNET_break_op (0);
1808     return;
1809   }
1810
1811   LOG (GNUNET_ERROR_TYPE_INFO, "<=== PING for %s\n", GCT_2s (t));
1812   t_decrypt (t, &res.target, &msg->target, ping_encryption_size (), msg->iv);
1813   if (0 != memcmp (&my_full_id, &res.target, sizeof (my_full_id)))
1814   {
1815     GNUNET_STATISTICS_update (stats, "# malformed PINGs", 1, GNUNET_NO);
1816     LOG (GNUNET_ERROR_TYPE_WARNING, "  malformed PING on %s\n", GCT_2s (t));
1817     LOG (GNUNET_ERROR_TYPE_DEBUG, "  e got %u\n", msg->nonce);
1818     LOG (GNUNET_ERROR_TYPE_DEBUG, "  e towards %s\n", GNUNET_i2s (&msg->target));
1819     LOG (GNUNET_ERROR_TYPE_DEBUG, "  got %u\n", res.nonce);
1820     LOG (GNUNET_ERROR_TYPE_DEBUG, "  towards %s\n", GNUNET_i2s (&res.target));
1821     if (NULL == t->kx_ctx)
1822       create_kx_ctx (t);
1823     send_ephemeral (t);
1824     send_ping (t);
1825     return;
1826   }
1827
1828   send_pong (t, res.nonce);
1829 }
1830
1831
1832 /**
1833  * @brief Finish the Key eXchange and destroy the old keys.
1834  *
1835  * @param cls Closure (Tunnel for which to finish the KX).
1836  * @param tc Task context.
1837  */
1838 static void
1839 finish_kx (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1840 {
1841   struct CadetTunnel *t = cls;
1842
1843   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1844     return;
1845
1846   LOG (GNUNET_ERROR_TYPE_INFO, "finish KX for %s\n", GCT_2s (t));
1847
1848   GNUNET_free (t->kx_ctx);
1849   t->kx_ctx = NULL;
1850 }
1851
1852
1853 /**
1854  * Peer has answer to our challenge.
1855  * If answer is successful, consider the key exchange finished and clean
1856  * up all related state.
1857  *
1858  * @param t Tunnel this message came on.
1859  * @param msg Key eXchange Pong message.
1860  */
1861 static void
1862 handle_pong (struct CadetTunnel *t,
1863              const struct GNUNET_CADET_KX_Pong *msg)
1864 {
1865   uint32_t challenge;
1866
1867   LOG (GNUNET_ERROR_TYPE_INFO, "<=== PONG for %s\n", GCT_2s (t));
1868   if (GNUNET_SCHEDULER_NO_TASK == t->rekey_task)
1869   {
1870     GNUNET_STATISTICS_update (stats, "# duplicate PONG messages", 1, GNUNET_NO);
1871     return;
1872   }
1873   t_decrypt (t, &challenge, &msg->nonce, sizeof (uint32_t), msg->iv);
1874
1875   if (challenge != t->kx_ctx->challenge)
1876   {
1877     LOG (GNUNET_ERROR_TYPE_WARNING, "Wrong PONG challenge on %s\n", GCT_2s (t));
1878     LOG (GNUNET_ERROR_TYPE_DEBUG, "PONG: %u (e: %u). Expected: %u.\n",
1879          challenge, msg->nonce, t->kx_ctx->challenge);
1880     send_ephemeral (t);
1881     send_ping (t);
1882     return;
1883   }
1884   GNUNET_SCHEDULER_cancel (t->rekey_task);
1885   t->rekey_task = GNUNET_SCHEDULER_NO_TASK;
1886
1887   /* Don't free the old keys right away, but after a delay.
1888    * Rationale: the KX could have happened over a very fast connection,
1889    * with payload traffic still signed with the old key stuck in a slower
1890    * connection.
1891    * Don't keep the keys longer than 1/4 the rekey period, and no longer than
1892    * one minute.
1893    */
1894   if (GNUNET_SCHEDULER_NO_TASK == t->kx_ctx->finish_task)
1895   {
1896     struct GNUNET_TIME_Relative delay;
1897
1898     delay = GNUNET_TIME_relative_divide (rekey_period, 4);
1899     delay = GNUNET_TIME_relative_min (delay, GNUNET_TIME_UNIT_MINUTES);
1900     t->kx_ctx->finish_task = GNUNET_SCHEDULER_add_delayed (delay, finish_kx, t);
1901   }
1902   GCT_change_estate (t, CADET_TUNNEL_KEY_OK);
1903 }
1904
1905
1906 /**
1907  * Demultiplex by message type and call appropriate handler for a message
1908  * towards a channel of a local tunnel.
1909  *
1910  * @param t Tunnel this message came on.
1911  * @param msgh Message header.
1912  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1913  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1914  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1915  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1916  */
1917 static void
1918 handle_decrypted (struct CadetTunnel *t,
1919                   const struct GNUNET_MessageHeader *msgh,
1920                   int fwd)
1921 {
1922   uint16_t type;
1923
1924   type = ntohs (msgh->type);
1925   LOG (GNUNET_ERROR_TYPE_INFO, "<=== %s on %s\n", GC_m2s (type), GCT_2s (t));
1926
1927   switch (type)
1928   {
1929     case GNUNET_MESSAGE_TYPE_CADET_KEEPALIVE:
1930       /* Do nothing, connection aleady got updated. */
1931       GNUNET_STATISTICS_update (stats, "# keepalives received", 1, GNUNET_NO);
1932       break;
1933
1934     case GNUNET_MESSAGE_TYPE_CADET_DATA:
1935       /* Don't send hop ACK, wait for client to ACK */
1936       handle_data (t, (struct GNUNET_CADET_Data *) msgh, fwd);
1937       break;
1938
1939     case GNUNET_MESSAGE_TYPE_CADET_DATA_ACK:
1940       handle_data_ack (t, (struct GNUNET_CADET_DataACK *) msgh, fwd);
1941       break;
1942
1943     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE:
1944       handle_ch_create (t,
1945                         (struct GNUNET_CADET_ChannelCreate *) msgh);
1946       break;
1947
1948     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_NACK:
1949       handle_ch_nack (t,
1950                       (struct GNUNET_CADET_ChannelManage *) msgh);
1951       break;
1952
1953     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_ACK:
1954       handle_ch_ack (t,
1955                      (struct GNUNET_CADET_ChannelManage *) msgh,
1956                      fwd);
1957       break;
1958
1959     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY:
1960       handle_ch_destroy (t,
1961                          (struct GNUNET_CADET_ChannelManage *) msgh,
1962                          fwd);
1963       break;
1964
1965     default:
1966       GNUNET_break_op (0);
1967       LOG (GNUNET_ERROR_TYPE_WARNING,
1968            "end-to-end message not known (%u)\n",
1969            ntohs (msgh->type));
1970       GCT_debug (t, GNUNET_ERROR_TYPE_WARNING);
1971   }
1972 }
1973
1974 /******************************************************************************/
1975 /********************************    API    ***********************************/
1976 /******************************************************************************/
1977
1978 /**
1979  * Decrypt and demultiplex by message type. Call appropriate handler
1980  * for every message.
1981  *
1982  * @param t Tunnel this message came on.
1983  * @param msg Encrypted message.
1984  */
1985 void
1986 GCT_handle_encrypted (struct CadetTunnel *t,
1987                       const struct GNUNET_CADET_Encrypted *msg)
1988 {
1989   size_t size = ntohs (msg->header.size);
1990   size_t payload_size = size - sizeof (struct GNUNET_CADET_Encrypted);
1991   int decrypted_size;
1992   char cbuf [payload_size];
1993   struct GNUNET_MessageHeader *msgh;
1994   unsigned int off;
1995
1996   decrypted_size = t_decrypt_and_validate (t, cbuf, &msg[1], payload_size,
1997                                            msg->iv, &msg->hmac);
1998
1999   if (-1 == decrypted_size)
2000   {
2001     GNUNET_break_op (0);
2002     return;
2003   }
2004
2005   off = 0;
2006   while (off < decrypted_size)
2007   {
2008     uint16_t msize;
2009
2010     msgh = (struct GNUNET_MessageHeader *) &cbuf[off];
2011     msize = ntohs (msgh->size);
2012     if (msize < sizeof (struct GNUNET_MessageHeader))
2013     {
2014       GNUNET_break_op (0);
2015       return;
2016     }
2017     handle_decrypted (t, msgh, GNUNET_SYSERR);
2018     off += msize;
2019   }
2020 }
2021
2022
2023 /**
2024  * Demultiplex an encapsulated KX message by message type.
2025  *
2026  * @param t Tunnel on which the message came.
2027  * @param message Payload of KX message.
2028  */
2029 void
2030 GCT_handle_kx (struct CadetTunnel *t,
2031                const struct GNUNET_MessageHeader *message)
2032 {
2033   uint16_t type;
2034
2035   type = ntohs (message->type);
2036   LOG (GNUNET_ERROR_TYPE_DEBUG, "kx message received\n", type);
2037   switch (type)
2038   {
2039     case GNUNET_MESSAGE_TYPE_CADET_KX_EPHEMERAL:
2040       handle_ephemeral (t, (struct GNUNET_CADET_KX_Ephemeral *) message);
2041       break;
2042
2043     case GNUNET_MESSAGE_TYPE_CADET_KX_PING:
2044       handle_ping (t, (struct GNUNET_CADET_KX_Ping *) message);
2045       break;
2046
2047     case GNUNET_MESSAGE_TYPE_CADET_KX_PONG:
2048       handle_pong (t, (struct GNUNET_CADET_KX_Pong *) message);
2049       break;
2050
2051     default:
2052       GNUNET_break_op (0);
2053       LOG (GNUNET_ERROR_TYPE_DEBUG, "kx message not known (%u)\n", type);
2054   }
2055 }
2056
2057
2058 /**
2059  * Initialize the tunnel subsystem.
2060  *
2061  * @param c Configuration handle.
2062  * @param key ECC private key, to derive all other keys and do crypto.
2063  */
2064 void
2065 GCT_init (const struct GNUNET_CONFIGURATION_Handle *c,
2066           const struct GNUNET_CRYPTO_EddsaPrivateKey *key)
2067 {
2068   LOG (GNUNET_ERROR_TYPE_DEBUG, "init\n");
2069   if (GNUNET_OK !=
2070       GNUNET_CONFIGURATION_get_value_number (c, "CADET", "DEFAULT_TTL",
2071                                              &default_ttl))
2072   {
2073     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
2074                                "CADET", "DEFAULT_TTL", "USING DEFAULT");
2075     default_ttl = 64;
2076   }
2077   if (GNUNET_OK !=
2078       GNUNET_CONFIGURATION_get_value_time (c, "CADET", "REKEY_PERIOD",
2079                                            &rekey_period))
2080   {
2081     rekey_period = GNUNET_TIME_UNIT_DAYS;
2082   }
2083
2084   my_private_key = key;
2085   kx_msg.header.size = htons (sizeof (kx_msg));
2086   kx_msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_KX_EPHEMERAL);
2087   kx_msg.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CADET_KX);
2088   kx_msg.purpose.size = htonl (ephemeral_purpose_size ());
2089   kx_msg.origin_identity = my_full_id;
2090   rekey_task = GNUNET_SCHEDULER_add_now (&rekey, NULL);
2091
2092   tunnels = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
2093 }
2094
2095
2096 /**
2097  * Shut down the tunnel subsystem.
2098  */
2099 void
2100 GCT_shutdown (void)
2101 {
2102   if (GNUNET_SCHEDULER_NO_TASK != rekey_task)
2103   {
2104     GNUNET_SCHEDULER_cancel (rekey_task);
2105     rekey_task = GNUNET_SCHEDULER_NO_TASK;
2106   }
2107   GNUNET_CONTAINER_multipeermap_iterate (tunnels, &destroy_iterator, NULL);
2108   GNUNET_CONTAINER_multipeermap_destroy (tunnels);
2109 }
2110
2111
2112 /**
2113  * Create a tunnel.
2114  *
2115  * @param destination Peer this tunnel is towards.
2116  */
2117 struct CadetTunnel *
2118 GCT_new (struct CadetPeer *destination)
2119 {
2120   struct CadetTunnel *t;
2121
2122   t = GNUNET_new (struct CadetTunnel);
2123   t->next_chid = 0;
2124   t->peer = destination;
2125
2126   if (GNUNET_OK !=
2127       GNUNET_CONTAINER_multipeermap_put (tunnels, GCP_get_id (destination), t,
2128                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
2129   {
2130     GNUNET_break (0);
2131     GNUNET_free (t);
2132     return NULL;
2133   }
2134   return t;
2135 }
2136
2137
2138 /**
2139  * Change the tunnel's connection state.
2140  *
2141  * @param t Tunnel whose connection state to change.
2142  * @param cstate New connection state.
2143  */
2144 void
2145 GCT_change_cstate (struct CadetTunnel* t, enum CadetTunnelCState cstate)
2146 {
2147   if (NULL == t)
2148     return;
2149   LOG (GNUNET_ERROR_TYPE_DEBUG, "Tunnel %s cstate %s => %s\n",
2150        GCP_2s (t->peer), cstate2s (t->cstate), cstate2s (cstate));
2151   if (myid != GCP_get_short_id (t->peer) &&
2152       CADET_TUNNEL_READY != t->cstate &&
2153       CADET_TUNNEL_READY == cstate)
2154   {
2155     t->cstate = cstate;
2156     if (CADET_TUNNEL_KEY_OK == t->estate)
2157     {
2158       LOG (GNUNET_ERROR_TYPE_DEBUG, "  cstate triggered send queued data\n");
2159       send_queued_data (t);
2160     }
2161     else if (CADET_TUNNEL_KEY_UNINITIALIZED == t->estate)
2162     {
2163       LOG (GNUNET_ERROR_TYPE_DEBUG, "  cstate triggered rekey\n");
2164       rekey_tunnel (t, NULL);
2165     }
2166   }
2167   t->cstate = cstate;
2168
2169   if (CADET_TUNNEL_READY == cstate
2170       && CONNECTIONS_PER_TUNNEL <= GCT_count_connections (t))
2171   {
2172     LOG (GNUNET_ERROR_TYPE_DEBUG, "  cstate triggered stop dht\n");
2173     GCP_stop_search (t->peer);
2174   }
2175 }
2176
2177 /**
2178  * Change the tunnel encryption state.
2179  *
2180  * @param t Tunnel whose encryption state to change.
2181  * @param state New encryption state.
2182  */
2183 void
2184 GCT_change_estate (struct CadetTunnel* t, enum CadetTunnelEState state)
2185 {
2186   if (NULL == t)
2187     return;
2188   LOG (GNUNET_ERROR_TYPE_DEBUG,
2189        "Tunnel %s estate was %s\n",
2190        GCP_2s (t->peer), estate2s (t->estate));
2191   LOG (GNUNET_ERROR_TYPE_DEBUG,
2192        "Tunnel %s estate is now %s\n",
2193        GCP_2s (t->peer), estate2s (state));
2194   if (myid != GCP_get_short_id (t->peer) &&
2195       CADET_TUNNEL_KEY_OK != t->estate && CADET_TUNNEL_KEY_OK == state)
2196   {
2197     t->estate = state;
2198     send_queued_data (t);
2199     return;
2200   }
2201   t->estate = state;
2202 }
2203
2204
2205 /**
2206  * @brief Check if tunnel has too many connections, and remove one if necessary.
2207  *
2208  * Currently this means the newest connection, unless it is a direct one.
2209  * Implemented as a task to avoid freeing a connection that is in the middle
2210  * of being created/processed.
2211  *
2212  * @param cls Closure (Tunnel to check).
2213  * @param tc Task context.
2214  */
2215 static void
2216 trim_connections (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
2217 {
2218   struct CadetTunnel *t = cls;
2219
2220   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
2221     return;
2222
2223   if (GCT_count_connections (t) > 2 * CONNECTIONS_PER_TUNNEL)
2224   {
2225     struct CadetTConnection *iter;
2226     struct CadetTConnection *c;
2227
2228     for (c = iter = t->connection_head; NULL != iter; iter = iter->next)
2229     {
2230       if ((NULL == c || iter->created.abs_value_us > c->created.abs_value_us)
2231           && GNUNET_NO == GCC_is_direct (iter->c))
2232       {
2233         c = iter;
2234       }
2235     }
2236     if (NULL != c)
2237     {
2238       LOG (GNUNET_ERROR_TYPE_DEBUG, "Too many connections on tunnel %s\n",
2239            GCT_2s (t));
2240       LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroying connection %s\n",
2241            GCC_2s (c->c));
2242       GCC_destroy (c->c);
2243     }
2244     else
2245     {
2246       GNUNET_break (0);
2247     }
2248   }
2249 }
2250
2251
2252 /**
2253  * Add a connection to a tunnel.
2254  *
2255  * @param t Tunnel.
2256  * @param c Connection.
2257  */
2258 void
2259 GCT_add_connection (struct CadetTunnel *t, struct CadetConnection *c)
2260 {
2261   struct CadetTConnection *aux;
2262
2263   GNUNET_assert (NULL != c);
2264
2265   LOG (GNUNET_ERROR_TYPE_DEBUG, "add connection %s\n", GCC_2s (c));
2266   LOG (GNUNET_ERROR_TYPE_DEBUG, " to tunnel %s\n", GCT_2s (t));
2267   for (aux = t->connection_head; aux != NULL; aux = aux->next)
2268     if (aux->c == c)
2269       return;
2270
2271   aux = GNUNET_new (struct CadetTConnection);
2272   aux->c = c;
2273   aux->created = GNUNET_TIME_absolute_get ();
2274
2275   GNUNET_CONTAINER_DLL_insert (t->connection_head, t->connection_tail, aux);
2276
2277   GNUNET_SCHEDULER_add_now (&trim_connections, t);
2278 }
2279
2280
2281 /**
2282  * Mark a path as no longer valid for this tunnel: has been tried and failed.
2283  *
2284  * @param t Tunnel to update.
2285  * @param path Invalid path to remove. Is destroyed after removal.
2286  */
2287 void
2288 GCT_remove_path (struct CadetTunnel *t, struct CadetPeerPath *path)
2289 {
2290   GCP_remove_path (t->peer, path);
2291 }
2292
2293
2294 /**
2295  * Remove a connection from a tunnel.
2296  *
2297  * @param t Tunnel.
2298  * @param c Connection.
2299  */
2300 void
2301 GCT_remove_connection (struct CadetTunnel *t,
2302                        struct CadetConnection *c)
2303 {
2304   struct CadetTConnection *aux;
2305   struct CadetTConnection *next;
2306
2307   LOG (GNUNET_ERROR_TYPE_DEBUG, "Removing connection %s from tunnel %s\n",
2308        GCC_2s (c), GCT_2s (t));
2309   for (aux = t->connection_head; aux != NULL; aux = next)
2310   {
2311     next = aux->next;
2312     if (aux->c == c)
2313     {
2314       GNUNET_CONTAINER_DLL_remove (t->connection_head, t->connection_tail, aux);
2315       GNUNET_free (aux);
2316     }
2317   }
2318
2319   /* Start new connections if needed */
2320   if (CONNECTIONS_PER_TUNNEL > GCT_count_connections (t)
2321       && GNUNET_SCHEDULER_NO_TASK == t->destroy_task
2322       && CADET_TUNNEL_SHUTDOWN != t->cstate
2323       && GNUNET_NO == shutting_down)
2324   {
2325     LOG (GNUNET_ERROR_TYPE_DEBUG, "  no more connections, getting new ones\n");
2326     GCT_change_cstate (t, CADET_TUNNEL_SEARCHING);
2327     GCP_connect (t->peer);
2328     return;
2329   }
2330
2331   /* If not marked as ready, no change is needed */
2332   if (CADET_TUNNEL_READY != t->cstate)
2333     return;
2334
2335   /* Check if any connection is ready to maintain cstate */
2336   for (aux = t->connection_head; aux != NULL; aux = aux->next)
2337     if (CADET_CONNECTION_READY == GCC_get_state (aux->c))
2338       return;
2339
2340   GCT_change_cstate (t, CADET_TUNNEL_WAITING);
2341 }
2342
2343
2344 /**
2345  * Add a channel to a tunnel.
2346  *
2347  * @param t Tunnel.
2348  * @param ch Channel.
2349  */
2350 void
2351 GCT_add_channel (struct CadetTunnel *t, struct CadetChannel *ch)
2352 {
2353   struct CadetTChannel *aux;
2354
2355   GNUNET_assert (NULL != ch);
2356
2357   LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding channel %p to tunnel %p\n", ch, t);
2358
2359   for (aux = t->channel_head; aux != NULL; aux = aux->next)
2360   {
2361     LOG (GNUNET_ERROR_TYPE_DEBUG, "  already there %p\n", aux->ch);
2362     if (aux->ch == ch)
2363       return;
2364   }
2365
2366   aux = GNUNET_new (struct CadetTChannel);
2367   aux->ch = ch;
2368   LOG (GNUNET_ERROR_TYPE_DEBUG, " adding %p to %p\n", aux, t->channel_head);
2369   GNUNET_CONTAINER_DLL_insert_tail (t->channel_head, t->channel_tail, aux);
2370
2371   if (GNUNET_SCHEDULER_NO_TASK != t->destroy_task)
2372   {
2373     GNUNET_SCHEDULER_cancel (t->destroy_task);
2374     t->destroy_task = GNUNET_SCHEDULER_NO_TASK;
2375     LOG (GNUNET_ERROR_TYPE_DEBUG, " undo destroy!\n");
2376   }
2377 }
2378
2379
2380 /**
2381  * Remove a channel from a tunnel.
2382  *
2383  * @param t Tunnel.
2384  * @param ch Channel.
2385  */
2386 void
2387 GCT_remove_channel (struct CadetTunnel *t, struct CadetChannel *ch)
2388 {
2389   struct CadetTChannel *aux;
2390
2391   LOG (GNUNET_ERROR_TYPE_DEBUG, "Removing channel %p from tunnel %p\n", ch, t);
2392   for (aux = t->channel_head; aux != NULL; aux = aux->next)
2393   {
2394     if (aux->ch == ch)
2395     {
2396       LOG (GNUNET_ERROR_TYPE_DEBUG, " found! %s\n", GCCH_2s (ch));
2397       GNUNET_CONTAINER_DLL_remove (t->channel_head, t->channel_tail, aux);
2398       GNUNET_free (aux);
2399       return;
2400     }
2401   }
2402 }
2403
2404
2405 /**
2406  * Search for a channel by global ID.
2407  *
2408  * @param t Tunnel containing the channel.
2409  * @param chid Public channel number.
2410  *
2411  * @return channel handler, NULL if doesn't exist
2412  */
2413 struct CadetChannel *
2414 GCT_get_channel (struct CadetTunnel *t, CADET_ChannelNumber chid)
2415 {
2416   struct CadetTChannel *iter;
2417
2418   if (NULL == t)
2419     return NULL;
2420
2421   for (iter = t->channel_head; NULL != iter; iter = iter->next)
2422   {
2423     if (GCCH_get_id (iter->ch) == chid)
2424       break;
2425   }
2426
2427   return NULL == iter ? NULL : iter->ch;
2428 }
2429
2430
2431 /**
2432  * @brief Destroy a tunnel and free all resources.
2433  *
2434  * Should only be called a while after the tunnel has been marked as destroyed,
2435  * in case there is a new channel added to the same peer shortly after marking
2436  * the tunnel. This way we avoid a new public key handshake.
2437  *
2438  * @param cls Closure (tunnel to destroy).
2439  * @param tc Task context.
2440  */
2441 static void
2442 delayed_destroy (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
2443 {
2444   struct CadetTunnel *t = cls;
2445   struct CadetTConnection *iter;
2446
2447   LOG (GNUNET_ERROR_TYPE_DEBUG, "delayed destroying tunnel %p\n", t);
2448   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
2449   {
2450     LOG (GNUNET_ERROR_TYPE_WARNING,
2451          "Not destroying tunnel, due to shutdown. "
2452          "Tunnel at %p should have been freed by GCT_shutdown\n", t);
2453     return;
2454   }
2455   t->destroy_task = GNUNET_SCHEDULER_NO_TASK;
2456   t->cstate = CADET_TUNNEL_SHUTDOWN;
2457
2458   for (iter = t->connection_head; NULL != iter; iter = iter->next)
2459   {
2460     GCC_send_destroy (iter->c);
2461   }
2462   GCT_destroy (t);
2463 }
2464
2465
2466 /**
2467  * Tunnel is empty: destroy it.
2468  *
2469  * Notifies all connections about the destruction.
2470  *
2471  * @param t Tunnel to destroy.
2472  */
2473 void
2474 GCT_destroy_empty (struct CadetTunnel *t)
2475 {
2476   if (GNUNET_YES == shutting_down)
2477     return; /* Will be destroyed immediately anyway */
2478
2479   if (GNUNET_SCHEDULER_NO_TASK != t->destroy_task)
2480   {
2481     LOG (GNUNET_ERROR_TYPE_WARNING,
2482          "Tunnel %s is already scheduled for destruction. Tunnel debug dump:\n",
2483          GCT_2s (t));
2484     GCT_debug (t, GNUNET_ERROR_TYPE_WARNING);
2485     GNUNET_break (0);
2486     /* should never happen, tunnel can only become empty once, and the
2487      * task identifier should be NO_TASK (cleaned when the tunnel was created
2488      * or became un-empty)
2489      */
2490     return;
2491   }
2492
2493   LOG (GNUNET_ERROR_TYPE_DEBUG, "Tunnel %s empty: destroying scheduled\n",
2494        GCT_2s (t));
2495
2496   // FIXME make delay a config option
2497   t->destroy_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
2498                                                   &delayed_destroy, t);
2499   LOG (GNUNET_ERROR_TYPE_DEBUG, "Scheduled destroy of %p as %llX\n",
2500        t, t->destroy_task);
2501 }
2502
2503
2504 /**
2505  * Destroy tunnel if empty (no more channels).
2506  *
2507  * @param t Tunnel to destroy if empty.
2508  */
2509 void
2510 GCT_destroy_if_empty (struct CadetTunnel *t)
2511 {
2512   LOG (GNUNET_ERROR_TYPE_DEBUG, "Tunnel %s destroy if empty\n", GCT_2s (t));
2513   if (1 < GCT_count_channels (t))
2514     return;
2515
2516   GCT_destroy_empty (t);
2517 }
2518
2519
2520 /**
2521  * Destroy the tunnel.
2522  *
2523  * This function does not generate any warning traffic to clients or peers.
2524  *
2525  * Tasks:
2526  * Cancel messages belonging to this tunnel queued to neighbors.
2527  * Free any allocated resources linked to the tunnel.
2528  *
2529  * @param t The tunnel to destroy.
2530  */
2531 void
2532 GCT_destroy (struct CadetTunnel *t)
2533 {
2534   struct CadetTConnection *iter_c;
2535   struct CadetTConnection *next_c;
2536   struct CadetTChannel *iter_ch;
2537   struct CadetTChannel *next_ch;
2538
2539   if (NULL == t)
2540     return;
2541
2542   LOG (GNUNET_ERROR_TYPE_DEBUG, "destroying tunnel %s\n", GCP_2s (t->peer));
2543
2544   GNUNET_break (GNUNET_YES ==
2545                 GNUNET_CONTAINER_multipeermap_remove (tunnels,
2546                                                       GCP_get_id (t->peer), t));
2547
2548   for (iter_c = t->connection_head; NULL != iter_c; iter_c = next_c)
2549   {
2550     next_c = iter_c->next;
2551     GCC_destroy (iter_c->c);
2552   }
2553   for (iter_ch = t->channel_head; NULL != iter_ch; iter_ch = next_ch)
2554   {
2555     next_ch = iter_ch->next;
2556     GCCH_destroy (iter_ch->ch);
2557     /* Should only happen on shutdown, but it's ok. */
2558   }
2559
2560   if (GNUNET_SCHEDULER_NO_TASK != t->destroy_task)
2561   {
2562     LOG (GNUNET_ERROR_TYPE_DEBUG, "cancelling %llX\n", t->destroy_task);
2563     GNUNET_SCHEDULER_cancel (t->destroy_task);
2564     t->destroy_task = GNUNET_SCHEDULER_NO_TASK;
2565   }
2566
2567   GNUNET_STATISTICS_update (stats, "# tunnels", -1, GNUNET_NO);
2568   GCP_set_tunnel (t->peer, NULL);
2569
2570   if (GNUNET_SCHEDULER_NO_TASK != t->rekey_task)
2571   {
2572     GNUNET_SCHEDULER_cancel (t->rekey_task);
2573     t->rekey_task = GNUNET_SCHEDULER_NO_TASK;
2574   }
2575   if (NULL != t->kx_ctx)
2576   {
2577     if (GNUNET_SCHEDULER_NO_TASK != t->kx_ctx->finish_task)
2578       GNUNET_SCHEDULER_cancel (t->kx_ctx->finish_task);
2579     GNUNET_free (t->kx_ctx);
2580   }
2581   GNUNET_free (t);
2582 }
2583
2584
2585 /**
2586  * @brief Use the given path for the tunnel.
2587  * Update the next and prev hops (and RCs).
2588  * (Re)start the path refresh in case the tunnel is locally owned.
2589  *
2590  * @param t Tunnel to update.
2591  * @param p Path to use.
2592  *
2593  * @return Connection created.
2594  */
2595 struct CadetConnection *
2596 GCT_use_path (struct CadetTunnel *t, struct CadetPeerPath *p)
2597 {
2598   struct CadetConnection *c;
2599   struct GNUNET_CADET_Hash cid;
2600   unsigned int own_pos;
2601
2602   if (NULL == t || NULL == p)
2603   {
2604     GNUNET_break (0);
2605     return NULL;
2606   }
2607
2608   if (CADET_TUNNEL_SHUTDOWN == t->cstate)
2609   {
2610     GNUNET_break (0);
2611     return NULL;
2612   }
2613
2614   for (own_pos = 0; own_pos < p->length; own_pos++)
2615   {
2616     if (p->peers[own_pos] == myid)
2617       break;
2618   }
2619   if (own_pos >= p->length)
2620   {
2621     GNUNET_break_op (0);
2622     return NULL;
2623   }
2624
2625   GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE, &cid, sizeof (cid));
2626   c = GCC_new (&cid, t, p, own_pos);
2627   if (NULL == c)
2628   {
2629     /* Path was flawed */
2630     return NULL;
2631   }
2632   GCT_add_connection (t, c);
2633   return c;
2634 }
2635
2636
2637 /**
2638  * Count created connections of a tunnel. Not necessarily ready connections!
2639  *
2640  * @param t Tunnel on which to count.
2641  *
2642  * @return Number of connections created, either being established or ready.
2643  */
2644 unsigned int
2645 GCT_count_connections (struct CadetTunnel *t)
2646 {
2647   struct CadetTConnection *iter;
2648   unsigned int count;
2649
2650   if (NULL == t)
2651     return 0;
2652
2653   for (count = 0, iter = t->connection_head; NULL != iter; iter = iter->next)
2654     if (CADET_CONNECTION_DESTROYED != GCC_get_state (iter->c))
2655       count++;
2656
2657   return count;
2658 }
2659
2660 /**
2661  * Count channels of a tunnel.
2662  *
2663  * @param t Tunnel on which to count.
2664  *
2665  * @return Number of channels.
2666  */
2667 unsigned int
2668 GCT_count_channels (struct CadetTunnel *t)
2669 {
2670   struct CadetTChannel *iter;
2671   unsigned int count;
2672
2673   for (count = 0, iter = t->channel_head;
2674        NULL != iter;
2675        iter = iter->next, count++) /* skip */;
2676
2677   return count;
2678 }
2679
2680
2681 /**
2682  * Get the connectivity state of a tunnel.
2683  *
2684  * @param t Tunnel.
2685  *
2686  * @return Tunnel's connectivity state.
2687  */
2688 enum CadetTunnelCState
2689 GCT_get_cstate (struct CadetTunnel *t)
2690 {
2691   if (NULL == t)
2692   {
2693     GNUNET_assert (0);
2694     return (enum CadetTunnelCState) -1;
2695   }
2696   return t->cstate;
2697 }
2698
2699
2700 /**
2701  * Get the encryption state of a tunnel.
2702  *
2703  * @param t Tunnel.
2704  *
2705  * @return Tunnel's encryption state.
2706  */
2707 enum CadetTunnelEState
2708 GCT_get_estate (struct CadetTunnel *t)
2709 {
2710   if (NULL == t)
2711   {
2712     GNUNET_assert (0);
2713     return (enum CadetTunnelEState) -1;
2714   }
2715   return t->estate;
2716 }
2717
2718 /**
2719  * Get the maximum buffer space for a tunnel towards a local client.
2720  *
2721  * @param t Tunnel.
2722  *
2723  * @return Biggest buffer space offered by any channel in the tunnel.
2724  */
2725 unsigned int
2726 GCT_get_channels_buffer (struct CadetTunnel *t)
2727 {
2728   struct CadetTChannel *iter;
2729   unsigned int buffer;
2730   unsigned int ch_buf;
2731
2732   if (NULL == t->channel_head)
2733   {
2734     /* Probably getting buffer for a channel create/handshake. */
2735     return 64;
2736   }
2737
2738   buffer = 0;
2739   for (iter = t->channel_head; NULL != iter; iter = iter->next)
2740   {
2741     ch_buf = get_channel_buffer (iter);
2742     if (ch_buf > buffer)
2743       buffer = ch_buf;
2744   }
2745   return buffer;
2746 }
2747
2748
2749 /**
2750  * Get the total buffer space for a tunnel for P2P traffic.
2751  *
2752  * @param t Tunnel.
2753  *
2754  * @return Buffer space offered by all connections in the tunnel.
2755  */
2756 unsigned int
2757 GCT_get_connections_buffer (struct CadetTunnel *t)
2758 {
2759   struct CadetTConnection *iter;
2760   unsigned int buffer;
2761
2762   if (GNUNET_NO == is_ready (t))
2763   {
2764     if (count_queued_data (t) > 3)
2765       return 0;
2766     else
2767       return 1;
2768   }
2769
2770   buffer = 0;
2771   for (iter = t->connection_head; NULL != iter; iter = iter->next)
2772   {
2773     if (GCC_get_state (iter->c) != CADET_CONNECTION_READY)
2774     {
2775       continue;
2776     }
2777     buffer += get_connection_buffer (iter);
2778   }
2779
2780   return buffer;
2781 }
2782
2783
2784 /**
2785  * Get the tunnel's destination.
2786  *
2787  * @param t Tunnel.
2788  *
2789  * @return ID of the destination peer.
2790  */
2791 const struct GNUNET_PeerIdentity *
2792 GCT_get_destination (struct CadetTunnel *t)
2793 {
2794   return GCP_get_id (t->peer);
2795 }
2796
2797
2798 /**
2799  * Get the tunnel's next free global channel ID.
2800  *
2801  * @param t Tunnel.
2802  *
2803  * @return GID of a channel free to use.
2804  */
2805 CADET_ChannelNumber
2806 GCT_get_next_chid (struct CadetTunnel *t)
2807 {
2808   CADET_ChannelNumber chid;
2809   CADET_ChannelNumber mask;
2810   int result;
2811
2812   /* Set bit 30 depending on the ID relationship. Bit 31 is always 0 for GID.
2813    * If our ID is bigger or loopback tunnel, start at 0, bit 30 = 0
2814    * If peer's ID is bigger, start at 0x4... bit 30 = 1
2815    */
2816   result = GNUNET_CRYPTO_cmp_peer_identity (&my_full_id, GCP_get_id (t->peer));
2817   if (0 > result)
2818     mask = 0x40000000;
2819   else
2820     mask = 0x0;
2821   t->next_chid |= mask;
2822
2823   while (NULL != GCT_get_channel (t, t->next_chid))
2824   {
2825     LOG (GNUNET_ERROR_TYPE_DEBUG, "Channel %u exists...\n", t->next_chid);
2826     t->next_chid = (t->next_chid + 1) & ~GNUNET_CADET_LOCAL_CHANNEL_ID_CLI;
2827     t->next_chid |= mask;
2828   }
2829   chid = t->next_chid;
2830   t->next_chid = (t->next_chid + 1) & ~GNUNET_CADET_LOCAL_CHANNEL_ID_CLI;
2831   t->next_chid |= mask;
2832
2833   return chid;
2834 }
2835
2836
2837 /**
2838  * Send ACK on one or more channels due to buffer in connections.
2839  *
2840  * @param t Channel which has some free buffer space.
2841  */
2842 void
2843 GCT_unchoke_channels (struct CadetTunnel *t)
2844 {
2845   struct CadetTChannel *iter;
2846   unsigned int buffer;
2847   unsigned int channels = GCT_count_channels (t);
2848   unsigned int choked_n;
2849   struct CadetChannel *choked[channels];
2850
2851   LOG (GNUNET_ERROR_TYPE_DEBUG, "GCT_unchoke_channels on %s\n", GCT_2s (t));
2852   LOG (GNUNET_ERROR_TYPE_DEBUG, " head: %p\n", t->channel_head);
2853   if (NULL != t->channel_head)
2854     LOG (GNUNET_ERROR_TYPE_DEBUG, " head ch: %p\n", t->channel_head->ch);
2855
2856   /* Get buffer space */
2857   buffer = GCT_get_connections_buffer (t);
2858   if (0 == buffer)
2859   {
2860     return;
2861   }
2862
2863   /* Count and remember choked channels */
2864   choked_n = 0;
2865   for (iter = t->channel_head; NULL != iter; iter = iter->next)
2866   {
2867     if (GNUNET_NO == get_channel_allowed (iter))
2868     {
2869       choked[choked_n++] = iter->ch;
2870     }
2871   }
2872
2873   /* Unchoke random channels */
2874   while (0 < buffer && 0 < choked_n)
2875   {
2876     unsigned int r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
2877                                                choked_n);
2878     GCCH_allow_client (choked[r], GCCH_is_origin (choked[r], GNUNET_YES));
2879     choked_n--;
2880     buffer--;
2881     choked[r] = choked[choked_n];
2882   }
2883 }
2884
2885
2886 /**
2887  * Send ACK on one or more connections due to buffer space to the client.
2888  *
2889  * Iterates all connections of the tunnel and sends ACKs appropriately.
2890  *
2891  * @param t Tunnel.
2892  */
2893 void
2894 GCT_send_connection_acks (struct CadetTunnel *t)
2895 {
2896   struct CadetTConnection *iter;
2897   uint32_t allowed;
2898   uint32_t to_allow;
2899   uint32_t allow_per_connection;
2900   unsigned int cs;
2901   unsigned int buffer;
2902
2903   LOG (GNUNET_ERROR_TYPE_DEBUG, "Tunnel send connection ACKs on %s\n",
2904        GCT_2s (t));
2905
2906   if (NULL == t)
2907   {
2908     GNUNET_break (0);
2909     return;
2910   }
2911
2912   buffer = GCT_get_channels_buffer (t);
2913   LOG (GNUNET_ERROR_TYPE_DEBUG, "  buffer %u\n", buffer);
2914
2915   /* Count connections, how many messages are already allowed */
2916   cs = GCT_count_connections (t);
2917   for (allowed = 0, iter = t->connection_head; NULL != iter; iter = iter->next)
2918   {
2919     allowed += get_connection_allowed (iter);
2920   }
2921   LOG (GNUNET_ERROR_TYPE_DEBUG, "  allowed %u\n", allowed);
2922
2923   /* Make sure there is no overflow */
2924   if (allowed > buffer)
2925   {
2926     return;
2927   }
2928
2929   /* Authorize connections to send more data */
2930   to_allow = buffer; /* - allowed; */
2931
2932   for (iter = t->connection_head;
2933        NULL != iter && to_allow > 0;
2934        iter = iter->next)
2935   {
2936     allow_per_connection = to_allow/cs;
2937     to_allow -= allow_per_connection;
2938     cs--;
2939     if (get_connection_allowed (iter) > 64 / 3)
2940     {
2941       continue;
2942     }
2943     GCC_allow (iter->c, allow_per_connection,
2944                GCC_is_origin (iter->c, GNUNET_NO));
2945   }
2946
2947   GNUNET_break (to_allow == 0);
2948 }
2949
2950
2951 /**
2952  * Cancel a previously sent message while it's in the queue.
2953  *
2954  * ONLY can be called before the continuation given to the send function
2955  * is called. Once the continuation is called, the message is no longer in the
2956  * queue.
2957  *
2958  * @param q Handle to the queue.
2959  */
2960 void
2961 GCT_cancel (struct CadetTunnelQueue *q)
2962 {
2963   if (NULL != q->cq)
2964   {
2965     GCC_cancel (q->cq);
2966     /* tun_message_sent() will be called and free q */
2967   }
2968   else if (NULL != q->tqd)
2969   {
2970     unqueue_data (q->tqd);
2971     q->tqd = NULL;
2972     if (NULL != q->cont)
2973       q->cont (q->cont_cls, NULL, q, 0, 0);
2974     GNUNET_free (q);
2975   }
2976   else
2977   {
2978     GNUNET_break (0);
2979   }
2980 }
2981
2982
2983 /**
2984  * Sends an already built message on a tunnel, encrypting it and
2985  * choosing the best connection if not provided.
2986  *
2987  * @param message Message to send. Function modifies it.
2988  * @param t Tunnel on which this message is transmitted.
2989  * @param c Connection to use (autoselect if NULL).
2990  * @param force Force the tunnel to take the message (buffer overfill).
2991  * @param cont Continuation to call once message is really sent.
2992  * @param cont_cls Closure for @c cont.
2993  *
2994  * @return Handle to cancel message. NULL if @c cont is NULL.
2995  */
2996 struct CadetTunnelQueue *
2997 GCT_send_prebuilt_message (const struct GNUNET_MessageHeader *message,
2998                            struct CadetTunnel *t, struct CadetConnection *c,
2999                            int force, GCT_sent cont, void *cont_cls)
3000 {
3001   return send_prebuilt_message (message, t, c, force, cont, cont_cls, NULL);
3002 }
3003
3004
3005 /**
3006  * Is the tunnel directed towards the local peer?
3007  *
3008  * @param t Tunnel.
3009  *
3010  * @return #GNUNET_YES if it is loopback.
3011  */
3012 int
3013 GCT_is_loopback (const struct CadetTunnel *t)
3014 {
3015   return (myid == GCP_get_short_id (t->peer));
3016 }
3017
3018
3019 /**
3020  * Is the tunnel this path already?
3021  *
3022  * @param t Tunnel.
3023  * @param p Path.
3024  *
3025  * @return #GNUNET_YES a connection uses this path.
3026  */
3027 int
3028 GCT_is_path_used (const struct CadetTunnel *t, const struct CadetPeerPath *p)
3029 {
3030   struct CadetTConnection *iter;
3031
3032   for (iter = t->connection_head; NULL != iter; iter = iter->next)
3033     if (GCC_get_path (iter->c) == p)
3034       return GNUNET_YES;
3035
3036   return GNUNET_NO;
3037 }
3038
3039
3040 /**
3041  * Get a cost of a path for a tunnel considering existing connections.
3042  *
3043  * @param t Tunnel.
3044  * @param path Candidate path.
3045  *
3046  * @return Cost of the path (path length + number of overlapping nodes)
3047  */
3048 unsigned int
3049 GCT_get_path_cost (const struct CadetTunnel *t,
3050                    const struct CadetPeerPath *path)
3051 {
3052   struct CadetTConnection *iter;
3053   const struct CadetPeerPath *aux;
3054   unsigned int overlap;
3055   unsigned int i;
3056   unsigned int j;
3057
3058   if (NULL == path)
3059     return 0;
3060
3061   overlap = 0;
3062   GNUNET_assert (NULL != t);
3063
3064   for (i = 0; i < path->length; i++)
3065   {
3066     for (iter = t->connection_head; NULL != iter; iter = iter->next)
3067     {
3068       aux = GCC_get_path (iter->c);
3069       if (NULL == aux)
3070         continue;
3071
3072       for (j = 0; j < aux->length; j++)
3073       {
3074         if (path->peers[i] == aux->peers[j])
3075         {
3076           overlap++;
3077           break;
3078         }
3079       }
3080     }
3081   }
3082   return path->length + overlap;
3083 }
3084
3085
3086 /**
3087  * Get the static string for the peer this tunnel is directed.
3088  *
3089  * @param t Tunnel.
3090  *
3091  * @return Static string the destination peer's ID.
3092  */
3093 const char *
3094 GCT_2s (const struct CadetTunnel *t)
3095 {
3096   if (NULL == t)
3097     return "(NULL)";
3098
3099   return GCP_2s (t->peer);
3100 }
3101
3102
3103 /******************************************************************************/
3104 /*****************************    INFO/DEBUG    *******************************/
3105 /******************************************************************************/
3106
3107 /**
3108  * Log all possible info about the tunnel state.
3109  *
3110  * @param t Tunnel to debug.
3111  * @param level Debug level to use.
3112  */
3113 void
3114 GCT_debug (const struct CadetTunnel *t, enum GNUNET_ErrorType level)
3115 {
3116   struct CadetTChannel *iterch;
3117   struct CadetTConnection *iterc;
3118
3119   LOG (level, "TTT DEBUG TUNNEL TOWARDS %s\n", GCT_2s (t));
3120   LOG (level, "TTT  cstate %s, estate %s\n",
3121        cstate2s (t->cstate), estate2s (t->estate));
3122   LOG (level, "TTT  kx_ctx %p, rekey_task %u\n", t->kx_ctx, t->rekey_task);
3123   LOG (level, "TTT  tq_head %p, tq_tail %p\n", t->tq_head, t->tq_tail);
3124   LOG (level, "TTT  destroy %u\n", t->destroy_task);
3125
3126   LOG (level, "TTT  channels:\n");
3127   for (iterch = t->channel_head; NULL != iterch; iterch = iterch->next)
3128   {
3129     LOG (level, "TTT  - %s\n", GCCH_2s (iterch->ch));
3130   }
3131
3132   LOG (level, "TTT  connections:\n");
3133   for (iterc = t->connection_head; NULL != iterc; iterc = iterc->next)
3134   {
3135     LOG (level, "TTT  - %s [%u] buf: %u/%u (qn %u/%u)\n",
3136          GCC_2s (iterc->c), GCC_get_state (iterc->c),
3137          GCC_get_buffer (iterc->c, GNUNET_YES),
3138          GCC_get_buffer (iterc->c, GNUNET_NO),
3139          GCC_get_qn (iterc->c, GNUNET_YES),
3140          GCC_get_qn (iterc->c, GNUNET_NO));
3141   }
3142
3143   LOG (level, "TTT DEBUG TUNNEL END\n");
3144 }
3145
3146
3147 /**
3148  * Iterate all tunnels.
3149  *
3150  * @param iter Iterator.
3151  * @param cls Closure for @c iter.
3152  */
3153 void
3154 GCT_iterate_all (GNUNET_CONTAINER_PeerMapIterator iter, void *cls)
3155 {
3156   GNUNET_CONTAINER_multipeermap_iterate (tunnels, iter, cls);
3157 }
3158
3159
3160 /**
3161  * Count all tunnels.
3162  *
3163  * @return Number of tunnels to remote peers kept by this peer.
3164  */
3165 unsigned int
3166 GCT_count_all (void)
3167 {
3168   return GNUNET_CONTAINER_multipeermap_size (tunnels);
3169 }
3170
3171
3172 /**
3173  * Iterate all connections of a tunnel.
3174  *
3175  * @param t Tunnel whose connections to iterate.
3176  * @param iter Iterator.
3177  * @param cls Closure for @c iter.
3178  */
3179 void
3180 GCT_iterate_connections (struct CadetTunnel *t, GCT_conn_iter iter, void *cls)
3181 {
3182   struct CadetTConnection *ct;
3183
3184   for (ct = t->connection_head; NULL != ct; ct = ct->next)
3185     iter (cls, ct->c);
3186 }
3187
3188
3189 /**
3190  * Iterate all channels of a tunnel.
3191  *
3192  * @param t Tunnel whose channels to iterate.
3193  * @param iter Iterator.
3194  * @param cls Closure for @c iter.
3195  */
3196 void
3197 GCT_iterate_channels (struct CadetTunnel *t, GCT_chan_iter iter, void *cls)
3198 {
3199   struct CadetTChannel *cht;
3200
3201   for (cht = t->channel_head; NULL != cht; cht = cht->next)
3202     iter (cls, cht->ch);
3203 }