src/cadet/gnunet-service-cadet_tunnel.c

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