src/cadet/gnunet-service-cadet_tunnel.c

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