src/mesh/gnunet-service-mesh_tunnel.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2013 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 #include "platform.h"
  22 #include "gnunet_util_lib.h"
  23
  24 #include "gnunet_signatures.h"
  25 #include "gnunet_statistics_service.h"
  26
  27 #include "mesh_protocol.h"
  28 #include "mesh_path.h"
  29
  30 #include "gnunet-service-mesh_tunnel.h"
  31 #include "gnunet-service-mesh_connection.h"
  32 #include "gnunet-service-mesh_channel.h"
  33 #include "gnunet-service-mesh_peer.h"
  34
  35 #define LOG(level, ...) GNUNET_log_from(level,"mesh-tun",__VA_ARGS__)
  36
  37 #define REKEY_WAIT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
  38
  39 /******************************************************************************/
  40 /********************************   STRUCTS  **********************************/
  41 /******************************************************************************/
  42
  43 struct MeshTChannel
  44 {
  45   struct MeshTChannel *next;
  46   struct MeshTChannel *prev;
  47   struct MeshChannel *ch;
  48 };
  49
  50 struct MeshTConnection
  51 {
  52   struct MeshTConnection *next;
  53   struct MeshTConnection *prev;
  54   struct MeshConnection *c;
  55 };
  56
  57 /**
  58  * Structure used during a Key eXchange.
  59  */
  60 struct MeshTunnelKXCtx
  61 {
  62   /**
  63    * Decryption ("their") old key, for decrypting traffic sent by the
  64    * other end before the key exchange started.
  65    */
  66   struct GNUNET_CRYPTO_SymmetricSessionKey d_key_old;
  67
  68   /**
  69    * Challenge to send in a ping and expect in the pong.
  70    */
  71   uint32_t challenge;
  72 };
  73
  74 /**
  75  * Struct containing all information regarding a tunnel to a peer.
  76  */
  77 struct MeshTunnel3
  78 {
  79     /**
  80      * Endpoint of the tunnel.
  81      */
  82   struct MeshPeer *peer;
  83
  84     /**
  85      * State of the tunnel connectivity.
  86      */
  87   enum MeshTunnel3CState cstate;
  88
  89   /**
  90    * State of the tunnel encryption.
  91    */
  92   enum MeshTunnel3EState estate;
  93
  94   /**
  95    * Key eXchange context.
  96    */
  97   struct MeshTunnelKXCtx *kx_ctx;
  98
  99   /**
 100    * Encryption ("our") key.
 101    */
 102   struct GNUNET_CRYPTO_SymmetricSessionKey e_key;
 103
 104   /**
 105    * Decryption ("their") key.
 106    */
 107   struct GNUNET_CRYPTO_SymmetricSessionKey d_key;
 108
 109   /**
 110    * Task to start the rekey process.
 111    */
 112   GNUNET_SCHEDULER_TaskIdentifier rekey_task;
 113
 114   /**
 115    * Paths that are actively used to reach the destination peer.
 116    */
 117   struct MeshTConnection *connection_head;
 118   struct MeshTConnection *connection_tail;
 119
 120   /**
 121    * Next connection number.
 122    */
 123   uint32_t next_cid;
 124
 125   /**
 126    * Channels inside this tunnel.
 127    */
 128   struct MeshTChannel *channel_head;
 129   struct MeshTChannel *channel_tail;
 130
 131   /**
 132    * Channel ID for the next created channel.
 133    */
 134   MESH_ChannelNumber next_chid;
 135
 136   /**
 137    * Destroy flag: if true, destroy on last message.
 138    */
 139   int destroy;
 140
 141   /**
 142    * Queued messages, to transmit once tunnel gets connected.
 143    */
 144   struct MeshTunnelDelayed *tq_head;
 145   struct MeshTunnelDelayed *tq_tail;
 146 };
 147
 148
 149 /**
 150  * Struct used to save messages in a non-ready tunnel to send once connected.
 151  */
 152 struct MeshTunnelDelayed
 153 {
 154   /**
 155    * DLL
 156    */
 157   struct MeshTunnelDelayed *next;
 158   struct MeshTunnelDelayed *prev;
 159
 160   /**
 161    * Channel.
 162    */
 163   struct MeshChannel *ch;
 164
 165   /**
 166    * Message to send.
 167    */
 168   /* struct GNUNET_MessageHeader *msg; */
 169 };
 170
 171
 172 /**
 173  * Handle for messages queued but not yet sent.
 174  */
 175 struct MeshTunnel3Queue
 176 {
 177   /**
 178    * Connection queue handle, to cancel if necessary.
 179    */
 180   struct MeshConnectionQueue *q;
 181
 182   /**
 183    * Continuation to call once sent.
 184    */
 185   GMT_sent cont;
 186
 187   /**
 188    * Closure for @c cont.
 189    */
 190   void *cont_cls;
 191 };
 192
 193
 194 /******************************************************************************/
 195 /*******************************   GLOBALS  ***********************************/
 196 /******************************************************************************/
 197
 198 /**
 199  * Global handle to the statistics service.
 200  */
 201 extern struct GNUNET_STATISTICS_Handle *stats;
 202
 203 /**
 204  * Local peer own ID (memory efficient handle).
 205  */
 206 extern GNUNET_PEER_Id myid;
 207
 208 /**
 209  * Local peer own ID (full value).
 210  */
 211 extern struct GNUNET_PeerIdentity my_full_id;
 212
 213
 214 /**
 215  * Set of all tunnels, in order to trigger a new exchange on rekey.
 216  * Indexed by peer's ID.
 217  */
 218 static struct GNUNET_CONTAINER_MultiPeerMap *tunnels;
 219
 220 /**
 221  * Default TTL for payload packets.
 222  */
 223 static unsigned long long default_ttl;
 224
 225 /**
 226  * Own private key.
 227  */
 228 const static struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
 229
 230 /**
 231  * Own ephemeral private key.
 232  */
 233 static struct GNUNET_CRYPTO_EcdhePrivateKey *my_ephemeral_key;
 234
 235 /**
 236  * Cached message used to perform a key exchange.
 237  */
 238 static struct GNUNET_MESH_KX_Ephemeral kx_msg;
 239
 240 /**
 241  * Task to generate a new ephemeral key.
 242  */
 243 static GNUNET_SCHEDULER_TaskIdentifier rekey_task;
 244
 245 /**
 246  * Rekey period.
 247  */
 248 static struct GNUNET_TIME_Relative rekey_period;
 249
 250 /******************************************************************************/
 251 /********************************   STATIC  ***********************************/
 252 /******************************************************************************/
 253
 254 /**
 255  * Get string description for tunnel connectivity state.
 256  *
 257  * @param cs Tunnel state.
 258  *
 259  * @return String representation.
 260  */
 261 static const char *
 262 cstate2s (enum MeshTunnel3CState cs)
 263 {
 264   static char buf[128];
 265
 266   switch (cs)
 267   {
 268     case MESH_TUNNEL3_NEW:
 269       return "MESH_TUNNEL3_NEW";
 270     case MESH_TUNNEL3_SEARCHING:
 271       return "MESH_TUNNEL3_SEARCHING";
 272     case MESH_TUNNEL3_WAITING:
 273       return "MESH_TUNNEL3_WAITING";
 274     case MESH_TUNNEL3_READY:
 275       return "MESH_TUNNEL3_READY";
 276
 277     default:
 278       sprintf (buf, "%u (UNKNOWN STATE)", cs);
 279       return buf;
 280   }
 281   return "";
 282 }
 283
 284
 285 /**
 286  * Get string description for tunnel encryption state.
 287  *
 288  * @param es Tunnel state.
 289  *
 290  * @return String representation.
 291  */
 292 static const char *
 293 estate2s (enum MeshTunnel3EState es)
 294 {
 295   static char buf[128];
 296
 297   switch (es)
 298   {
 299     case MESH_TUNNEL3_KEY_UNINITIALIZED:
 300       return "MESH_TUNNEL3_KEY_UNINITIALIZED";
 301     case MESH_TUNNEL3_KEY_SENT:
 302       return "MESH_TUNNEL3_KEY_SENT";
 303     case MESH_TUNNEL3_KEY_PING:
 304       return "MESH_TUNNEL3_KEY_PING";
 305     case MESH_TUNNEL3_KEY_OK:
 306       return "MESH_TUNNEL3_KEY_OK";
 307
 308     default:
 309       sprintf (buf, "%u (UNKNOWN STATE)", es);
 310       return buf;
 311   }
 312   return "";
 313 }
 314
 315
 316 /**
 317  * @brief Check if tunnel is ready to send traffic.
 318  *
 319  * Tunnel must be connected and with encryption correctly set up.
 320  *
 321  * @param t Tunnel to check.
 322  *
 323  * @return #GNUNET_YES if ready, #GNUNET_NO otherwise
 324  */
 325 static int
 326 is_ready (struct MeshTunnel3 *t)
 327 {
 328   return (MESH_TUNNEL3_READY == t->cstate
 329           && MESH_TUNNEL3_KEY_OK == t->estate)
 330          || GMT_is_loopback (t);
 331 }
 332
 333
 334 /**
 335  * Ephemeral key message purpose size.
 336  *
 337  * @return Size of the part of the ephemeral key message that must be signed.
 338  */
 339 size_t
 340 ephemeral_purpose_size (void)
 341 {
 342   return sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
 343          sizeof (struct GNUNET_TIME_AbsoluteNBO) +
 344          sizeof (struct GNUNET_TIME_AbsoluteNBO) +
 345          sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) +
 346          sizeof (struct GNUNET_PeerIdentity);
 347 }
 348
 349
 350 /**
 351  * Size of the encrypted part of a ping message.
 352  *
 353  * @return Size of the encrypted part of a ping message.
 354  */
 355 size_t
 356 ping_encryption_size (void)
 357 {
 358   return sizeof (struct GNUNET_PeerIdentity) + sizeof (uint32_t);
 359 }
 360
 361
 362 /**
 363  * Get the channel's buffer. ONLY FOR NON-LOOPBACK CHANNELS!!
 364  *
 365  * @param tch Tunnel's channel handle.
 366  *
 367  * @return Amount of messages the channel can still buffer towards the client.
 368  */
 369 static unsigned int
 370 get_channel_buffer (const struct MeshTChannel *tch)
 371 {
 372   int fwd;
 373
 374   /* If channel is outgoing, is origin in the FWD direction and fwd is YES */
 375   fwd = GMCH_is_origin (tch->ch, GNUNET_YES);
 376
 377   return GMCH_get_buffer (tch->ch, fwd);
 378 }
 379
 380
 381 /**
 382  * Get the channel's allowance status.
 383  *
 384  * @param tch Tunnel's channel handle.
 385  *
 386  * @return #GNUNET_YES if we allowed the client to send data to us.
 387  */
 388 static int
 389 get_channel_allowed (const struct MeshTChannel *tch)
 390 {
 391   int fwd;
 392
 393   /* If channel is outgoing, is origin in the FWD direction and fwd is YES */
 394   fwd = GMCH_is_origin (tch->ch, GNUNET_YES);
 395
 396   return GMCH_get_allowed (tch->ch, fwd);
 397 }
 398
 399
 400 /**
 401  * Get the connection's buffer.
 402  *
 403  * @param tc Tunnel's connection handle.
 404  *
 405  * @return Amount of messages the connection can still buffer.
 406  */
 407 static unsigned int
 408 get_connection_buffer (const struct MeshTConnection *tc)
 409 {
 410   int fwd;
 411
 412   /* If connection is outgoing, is origin in the FWD direction and fwd is YES */
 413   fwd = GMC_is_origin (tc->c, GNUNET_YES);
 414
 415   return GMC_get_buffer (tc->c, fwd);
 416 }
 417
 418
 419 /**
 420  * Get the connection's allowance.
 421  *
 422  * @param tc Tunnel's connection handle.
 423  *
 424  * @return Amount of messages we have allowed the next peer to send us.
 425  */
 426 static unsigned int
 427 get_connection_allowed (const struct MeshTConnection *tc)
 428 {
 429   int fwd;
 430
 431   /* If connection is outgoing, is origin in the FWD direction and fwd is YES */
 432   fwd = GMC_is_origin (tc->c, GNUNET_YES);
 433
 434   return GMC_get_allowed (tc->c, fwd);
 435 }
 436
 437
 438 /**
 439  * Check that a ephemeral key message s well formed and correctly signed.
 440  *
 441  * @param t Tunnel on which the message came.
 442  * @param msg The ephemeral key message.
 443  *
 444  * @return GNUNET_OK if message is fine, GNUNET_SYSERR otherwise.
 445  */
 446 int
 447 check_ephemeral (struct MeshTunnel3 *t,
 448                  const struct GNUNET_MESH_KX_Ephemeral *msg)
 449 {
 450   /* Check message size */
 451   if (ntohs (msg->header.size) != sizeof (struct GNUNET_MESH_KX_Ephemeral))
 452     return GNUNET_SYSERR;
 453
 454   /* Check signature size */
 455   if (ntohl (msg->purpose.size) != ephemeral_purpose_size ())
 456     return GNUNET_SYSERR;
 457
 458   /* Check origin */
 459   if (0 != memcmp (&msg->origin_identity,
 460                    GMP_get_id (t->peer),
 461                    sizeof (struct GNUNET_PeerIdentity)))
 462     return GNUNET_SYSERR;
 463
 464   /* Check signature */
 465   if (GNUNET_OK !=
 466       GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_MESH_KX,
 467                                   &msg->purpose,
 468                                   &msg->signature,
 469                                   &msg->origin_identity.public_key))
 470     return GNUNET_SYSERR;
 471
 472   return GNUNET_OK;
 473 }
 474
 475
 476 /**
 477  * Encrypt data with the tunnel key.
 478  *
 479  * @param t Tunnel whose key to use.
 480  * @param dst Destination for the encrypted data.
 481  * @param src Source of the plaintext. Can overlap with @c dst.
 482  * @param size Size of the plaintext.
 483  * @param iv Initialization Vector to use.
 484  */
 485 static int
 486 t_encrypt (struct MeshTunnel3 *t,
 487            void *dst, const void *src,
 488            size_t size, uint32_t iv)
 489 {
 490   struct GNUNET_CRYPTO_SymmetricInitializationVector siv;
 491
 492   GNUNET_CRYPTO_symmetric_derive_iv (&siv, &t->e_key, &iv, sizeof (uint32_t), NULL);
 493   return GNUNET_CRYPTO_symmetric_encrypt (src, size, &t->e_key, &siv, dst);
 494 }
 495
 496
 497 /**
 498  * Decrypt data with the tunnel key.
 499  *
 500  * @param t Tunnel whose key to use.
 501  * @param dst Destination for the plaintext.
 502  * @param src Source of the encrypted data. Can overlap with @c dst.
 503  * @param size Size of the encrypted data.
 504  * @param iv Initialization Vector to use.
 505  */
 506 static int
 507 t_decrypt (struct MeshTunnel3 *t,
 508            void *dst, const void *src,
 509            size_t size, uint32_t iv)
 510 {
 511   struct GNUNET_CRYPTO_SymmetricInitializationVector siv;
 512
 513   GNUNET_CRYPTO_symmetric_derive_iv (&siv, &t->d_key, &iv, sizeof (uint32_t), NULL);
 514   return GNUNET_CRYPTO_symmetric_decrypt (src, size, &t->d_key, &siv, dst);
 515 }
 516
 517
 518 /**
 519  * Create key material by doing ECDH on the local and remote ephemeral keys.
 520  *
 521  * @param key_material Where to store the key material.
 522  * @param ephemeral_key Peer's public ephemeral key.
 523  */
 524 void
 525 derive_key_material (struct GNUNET_HashCode *key_material,
 526                      const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral_key)
 527 {
 528   if (GNUNET_OK !=
 529       GNUNET_CRYPTO_ecc_ecdh (my_ephemeral_key,
 530                               ephemeral_key,
 531                               key_material))
 532   {
 533     GNUNET_break (0);
 534   }
 535 }
 536
 537 /**
 538  * Create a symmetic key from the identities of both ends and the key material
 539  * from ECDH.
 540  *
 541  * @param key Destination for the generated key.
 542  * @param sender ID of the peer that will encrypt with @c key.
 543  * @param receiver ID of the peer that will decrypt with @c key.
 544  * @param key_material Hash created with ECDH with the ephemeral keys.
 545  */
 546 void
 547 derive_symmertic (struct GNUNET_CRYPTO_SymmetricSessionKey *key,
 548                   const struct GNUNET_PeerIdentity *sender,
 549                   const struct GNUNET_PeerIdentity *receiver,
 550                   const struct GNUNET_HashCode *key_material)
 551 {
 552   const char salt[] = "MESH kx salt";
 553
 554   GNUNET_CRYPTO_kdf (key, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
 555                      salt, sizeof (salt),
 556                      key_material, sizeof (struct GNUNET_HashCode),
 557                      sender, sizeof (struct GNUNET_PeerIdentity),
 558                      receiver, sizeof (struct GNUNET_PeerIdentity),
 559                      NULL);
 560 }
 561
 562 /**
 563  * Pick a connection on which send the next data message.
 564  *
 565  * @param t Tunnel on which to send the message.
 566  *
 567  * @return The connection on which to send the next message.
 568  */
 569 static struct MeshConnection *
 570 tunnel_get_connection (struct MeshTunnel3 *t)
 571 {
 572   struct MeshTConnection *iter;
 573   struct MeshConnection *best;
 574   unsigned int qn;
 575   unsigned int lowest_q;
 576
 577   LOG (GNUNET_ERROR_TYPE_DEBUG, "tunnel_get_connection %s\n", GMP_2s (t->peer));
 578   best = NULL;
 579   lowest_q = UINT_MAX;
 580   for (iter = t->connection_head; NULL != iter; iter = iter->next)
 581   {
 582     LOG (GNUNET_ERROR_TYPE_DEBUG, "  connection %s: %u\n",
 583          GMC_2s (iter->c), GMC_get_state (iter->c));
 584     if (MESH_CONNECTION_READY == GMC_get_state (iter->c))
 585     {
 586       qn = GMC_get_qn (iter->c, GMC_is_origin (iter->c, GNUNET_YES));
 587       LOG (GNUNET_ERROR_TYPE_DEBUG, "    q_n %u, \n", qn);
 588       if (qn < lowest_q)
 589       {
 590         best = iter->c;
 591         lowest_q = qn;
 592       }
 593     }
 594   }
 595   LOG (GNUNET_ERROR_TYPE_DEBUG, " selected: connection %s\n", GMC_2s (best));
 596   return best;
 597 }
 598
 599
 600 /**
 601  * Send all cached messages that we can, tunnel is online.
 602  *
 603  * @param t Tunnel that holds the messages. Cannot be loopback.
 604  */
 605 static void
 606 send_queued_data (struct MeshTunnel3 *t)
 607 {
 608   struct MeshTunnelDelayed *tq;
 609   struct MeshTunnelDelayed *next;
 610   unsigned int room;
 611
 612   LOG (GNUNET_ERROR_TYPE_DEBUG,
 613        "GMT_send_queued_data on tunnel %s\n",
 614        GMT_2s (t));
 615
 616   if (GMT_is_loopback (t))
 617   {
 618     GNUNET_break (0);
 619     return;
 620   }
 621
 622   if (GNUNET_NO == is_ready (t))
 623   {
 624     LOG (GNUNET_ERROR_TYPE_DEBUG, "  not ready yet: %s/%s\n",
 625          estate2s (t->estate), cstate2s (t->cstate));
 626     return;
 627   }
 628
 629   room = GMT_get_connections_buffer (t);
 630   LOG (GNUNET_ERROR_TYPE_DEBUG, "  buffer space: %u\n", room);
 631   for (tq = t->tq_head; NULL != tq && room > 0; tq = next)
 632   {
 633     LOG (GNUNET_ERROR_TYPE_DEBUG, " data on channel %s\n", GMCH_2s (tq->ch));
 634     next = tq->next;
 635     room--;
 636     GNUNET_CONTAINER_DLL_remove (t->tq_head, t->tq_tail, tq);
 637     GMCH_send_prebuilt_message ((struct GNUNET_MessageHeader *) &tq[1],
 638                                 tq->ch, GMCH_is_origin (tq->ch, GNUNET_YES),
 639                                 GNUNET_NO);
 640
 641     GNUNET_free (tq);
 642   }
 643   LOG (GNUNET_ERROR_TYPE_DEBUG,
 644        "GMT_send_queued_data end\n",
 645        GMP_2s (t->peer));
 646 }
 647
 648
 649
 650
 651 /**
 652  * Cache a message to be sent once tunnel is online.
 653  *
 654  * @param t Tunnel to hold the message.
 655  * @param ch Channel the message is about.
 656  * @param msg Message itself (copy will be made).
 657  */
 658 static void
 659 queue_data (struct MeshTunnel3 *t,
 660             struct MeshChannel *ch,
 661             const struct GNUNET_MessageHeader *msg)
 662 {
 663   struct MeshTunnelDelayed *tq;
 664   uint16_t size = ntohs (msg->size);
 665
 666   LOG (GNUNET_ERROR_TYPE_DEBUG, "queue data on Tunnel %s\n", GMT_2s (t));
 667
 668   if (GNUNET_YES == is_ready (t))
 669   {
 670     GNUNET_break (0);
 671     return;
 672   }
 673
 674   tq = GNUNET_malloc (sizeof (struct MeshTunnelDelayed) + size);
 675
 676   tq->ch = ch;
 677   memcpy (&tq[1], msg, size);
 678   GNUNET_CONTAINER_DLL_insert_tail (t->tq_head, t->tq_tail, tq);
 679 }
 680
 681
 682
 683 /**
 684  * Sends key exchange message on a tunnel, choosing the best connection.
 685  * Should not be called on loopback tunnels.
 686  *
 687  * @param t Tunnel on which this message is transmitted.
 688  * @param message Message to send. Function modifies it.
 689  */
 690 static void
 691 send_kx (struct MeshTunnel3 *t,
 692          const struct GNUNET_MessageHeader *message)
 693 {
 694   struct MeshConnection *c;
 695   struct GNUNET_MESH_KX *msg;
 696   size_t size = ntohs (message->size);
 697   char cbuf[sizeof (struct GNUNET_MESH_KX) + size];
 698   uint16_t type;
 699   int fwd;
 700
 701   LOG (GNUNET_ERROR_TYPE_DEBUG, "GMT KX on Tunnel %s\n", GMT_2s (t));
 702
 703   /* Avoid loopback. */
 704   if (GMT_is_loopback (t))
 705   {
 706     LOG (GNUNET_ERROR_TYPE_DEBUG, "  loopback!\n");
 707     GNUNET_break (0);
 708     return;
 709   }
 710
 711   /* Must have a connection. */
 712   if (NULL == t->connection_head)
 713   {
 714     GNUNET_break (0);
 715     return;
 716   }
 717
 718   msg = (struct GNUNET_MESH_KX *) cbuf;
 719   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_KX);
 720   msg->header.size = htons (sizeof (struct GNUNET_MESH_KX) + size);
 721   c = tunnel_get_connection (t);
 722   if (NULL == c)
 723   {
 724     GNUNET_break (GNUNET_YES == t->destroy);
 725     return;
 726   }
 727   type = ntohs (message->type);
 728   switch (type)
 729   {
 730     case GNUNET_MESSAGE_TYPE_MESH_KX_EPHEMERAL:
 731     case GNUNET_MESSAGE_TYPE_MESH_KX_PING:
 732     case GNUNET_MESSAGE_TYPE_MESH_KX_PONG:
 733       msg->reserved = htonl (0);
 734       memcpy (&msg[1], message, size);
 735       break;
 736     default:
 737       LOG (GNUNET_ERROR_TYPE_DEBUG, "unkown type %s\n",
 738            GNUNET_MESH_DEBUG_M2S (type));
 739       GNUNET_break (0);
 740   }
 741
 742   fwd = GMC_is_origin (t->connection_head->c, GNUNET_YES);
 743   /* TODO save handle and cancel in case of a unneeded retransmission */
 744   GMC_send_prebuilt_message (&msg->header, c, fwd, NULL, NULL);
 745 }
 746
 747
 748 /**
 749  * Send the ephemeral key on a tunnel.
 750  *
 751  * @param t Tunnel on which to send the key.
 752  */
 753 static void
 754 send_ephemeral (struct MeshTunnel3 *t)
 755 {
 756   LOG (GNUNET_ERROR_TYPE_DEBUG, "%s()\n", __FUNCTION__);
 757
 758   kx_msg.sender_status = htonl (t->estate);
 759   send_kx (t, &kx_msg.header);
 760 }
 761
 762 /**
 763  * Send a ping message on a tunnel.
 764  *
 765  * @param t Tunnel on which to send the ping.
 766  */
 767 static void
 768 send_ping (struct MeshTunnel3 *t)
 769 {
 770   struct GNUNET_MESH_KX_Ping msg;
 771
 772   LOG (GNUNET_ERROR_TYPE_DEBUG, "%s()\n", __FUNCTION__);
 773   msg.header.size = htons (sizeof (msg));
 774   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_KX_PING);
 775   msg.iv = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX);
 776   msg.target = *GMP_get_id (t->peer);
 777   msg.nonce = t->kx_ctx->challenge;
 778
 779   LOG (GNUNET_ERROR_TYPE_DEBUG, "  sending %u\n", msg.nonce);
 780   LOG (GNUNET_ERROR_TYPE_DEBUG, "  towards %s\n", GNUNET_i2s (&msg.target));
 781   t_encrypt (t, &msg.target, &msg.target, ping_encryption_size(), msg.iv);
 782   LOG (GNUNET_ERROR_TYPE_DEBUG, "  e sending %u\n", msg.nonce);
 783   LOG (GNUNET_ERROR_TYPE_DEBUG, "  e towards %s\n", GNUNET_i2s (&msg.target));
 784
 785   send_kx (t, &msg.header);
 786 }
 787
 788
 789 /**
 790  * Send a pong message on a tunnel.
 791  *
 792  * @param t Tunnel on which to send the pong.
 793  * @param challenge Value sent in the ping that we have to send back.
 794  */
 795 static void
 796 send_pong (struct MeshTunnel3 *t, uint32_t challenge)
 797 {
 798   struct GNUNET_MESH_KX_Pong msg;
 799
 800   LOG (GNUNET_ERROR_TYPE_DEBUG, "%s()\n", __FUNCTION__);
 801   msg.header.size = htons (sizeof (msg));
 802   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_KX_PONG);
 803   msg.iv = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX);
 804   msg.nonce = challenge;
 805   LOG (GNUNET_ERROR_TYPE_DEBUG, "  sending %u\n", msg.nonce);
 806   t_encrypt (t, &msg.nonce, &msg.nonce, sizeof (msg.nonce), msg.iv);
 807   LOG (GNUNET_ERROR_TYPE_DEBUG, "  e sending %u\n", msg.nonce);
 808
 809   send_kx (t, &msg.header);
 810 }
 811
 812
 813 /**
 814  * Initiate a rekey with the remote peer.
 815  *
 816  * @param cls Closure (tunnel).
 817  * @param tc TaskContext.
 818  */
 819 static void
 820 rekey_tunnel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 821 {
 822   struct MeshTunnel3 *t = cls;
 823
 824   t->rekey_task = GNUNET_SCHEDULER_NO_TASK;
 825
 826   LOG (GNUNET_ERROR_TYPE_DEBUG, "Re-key Tunnel\n");
 827   if (NULL != tc && 0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
 828     return;
 829
 830   if (NULL == t->kx_ctx)
 831   {
 832     LOG (GNUNET_ERROR_TYPE_DEBUG, "  new kx ctx\n");
 833     t->kx_ctx = GNUNET_new (struct MeshTunnelKXCtx);
 834     t->kx_ctx->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
 835                                                      UINT32_MAX);
 836     t->kx_ctx->d_key_old = t->d_key;
 837   }
 838   send_ephemeral (t);
 839   switch (t->estate)
 840   {
 841     case MESH_TUNNEL3_KEY_UNINITIALIZED:
 842       t->estate = MESH_TUNNEL3_KEY_SENT;
 843       break;
 844     case MESH_TUNNEL3_KEY_SENT:
 845       break;
 846     case MESH_TUNNEL3_KEY_PING:
 847     case MESH_TUNNEL3_KEY_OK:
 848       send_ping (t);
 849       t->estate = MESH_TUNNEL3_KEY_PING;
 850       break;
 851     default:
 852       LOG (GNUNET_ERROR_TYPE_DEBUG, "Unexpected state %u\n", t->estate);
 853   }
 854
 855   LOG (GNUNET_ERROR_TYPE_DEBUG, "  next call in %s\n",
 856        GNUNET_STRINGS_relative_time_to_string (REKEY_WAIT, GNUNET_YES));
 857   t->rekey_task = GNUNET_SCHEDULER_add_delayed (REKEY_WAIT, &rekey_tunnel, t);
 858 }
 859
 860
 861 /**
 862  * Out ephemeral key has changed, create new session key on all tunnels.
 863  *
 864  * @param cls Closure (size of the hashmap).
 865  * @param key Current public key.
 866  * @param value Value in the hash map (tunnel).
 867  *
 868  * @return #GNUNET_YES, so we should continue to iterate,
 869  */
 870 static int
 871 rekey_iterator (void *cls,
 872                 const struct GNUNET_PeerIdentity *key,
 873                 void *value)
 874 {
 875   struct MeshTunnel3 *t = value;
 876   struct GNUNET_TIME_Relative delay;
 877   long n = (long) cls;
 878   uint32_t r;
 879
 880   if (GNUNET_SCHEDULER_NO_TASK != t->rekey_task)
 881     return GNUNET_YES;
 882
 883   r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, (uint32_t) n * 100);
 884   delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, r);
 885   t->rekey_task = GNUNET_SCHEDULER_add_delayed (delay, &rekey_tunnel, t);
 886
 887   return GNUNET_YES;
 888 }
 889
 890
 891 /**
 892  * Create a new ephemeral key and key message, schedule next rekeying.
 893  *
 894  * @param cls Closure (unused).
 895  * @param tc TaskContext.
 896  */
 897 static void
 898 rekey (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 899 {
 900   struct GNUNET_TIME_Absolute time;
 901   long n;
 902
 903   rekey_task = GNUNET_SCHEDULER_NO_TASK;
 904
 905   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
 906     return;
 907
 908   GNUNET_free_non_null (my_ephemeral_key);
 909   my_ephemeral_key = GNUNET_CRYPTO_ecdhe_key_create ();
 910
 911   time = GNUNET_TIME_absolute_get ();
 912   kx_msg.creation_time = GNUNET_TIME_absolute_hton (time);
 913   time = GNUNET_TIME_absolute_add (time, rekey_period);
 914   time = GNUNET_TIME_absolute_add (time, GNUNET_TIME_UNIT_MINUTES);
 915   kx_msg.expiration_time = GNUNET_TIME_absolute_hton (time);
 916   GNUNET_CRYPTO_ecdhe_key_get_public (my_ephemeral_key, &kx_msg.ephemeral_key);
 917
 918   GNUNET_assert (GNUNET_OK ==
 919                  GNUNET_CRYPTO_eddsa_sign (my_private_key,
 920                                            &kx_msg.purpose,
 921                                            &kx_msg.signature));
 922
 923   n = (long) GNUNET_CONTAINER_multipeermap_size (tunnels);
 924   GNUNET_CONTAINER_multipeermap_iterate (tunnels, &rekey_iterator, (void *) n);
 925
 926   rekey_task = GNUNET_SCHEDULER_add_delayed (rekey_period, &rekey, NULL);
 927 }
 928
 929
 930 /**
 931  * Called only on shutdown, destroy every tunnel.
 932  *
 933  * @param cls Closure (unused).
 934  * @param key Current public key.
 935  * @param value Value in the hash map (tunnel).
 936  *
 937  * @return #GNUNET_YES, so we should continue to iterate,
 938  */
 939 static int
 940 destroy_iterator (void *cls,
 941                 const struct GNUNET_PeerIdentity *key,
 942                 void *value)
 943 {
 944   struct MeshTunnel3 *t = value;
 945
 946   GMT_destroy (t);
 947   return GNUNET_YES;
 948 }
 949
 950
 951 /**
 952  * Demultiplex data per channel and call appropriate channel handler.
 953  *
 954  * @param t Tunnel on which the data came.
 955  * @param msg Data message.
 956  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
 957  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
 958  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
 959  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
 960  */
 961 static void
 962 handle_data (struct MeshTunnel3 *t,
 963              const struct GNUNET_MESH_Data *msg,
 964              int fwd)
 965 {
 966   struct MeshChannel *ch;
 967   uint16_t type;
 968   size_t size;
 969
 970   /* Check size */
 971   size = ntohs (msg->header.size);
 972   if (size <
 973       sizeof (struct GNUNET_MESH_Data) +
 974       sizeof (struct GNUNET_MessageHeader))
 975   {
 976     GNUNET_break (0);
 977     return;
 978   }
 979   type = ntohs (msg->header.type);
 980   LOG (GNUNET_ERROR_TYPE_DEBUG, "got a %s message\n",
 981               GNUNET_MESH_DEBUG_M2S (type));
 982   LOG (GNUNET_ERROR_TYPE_DEBUG, " payload of type %s\n",
 983               GNUNET_MESH_DEBUG_M2S (ntohs (msg[1].header.type)));
 984
 985   /* Check channel */
 986   ch = GMT_get_channel (t, ntohl (msg->chid));
 987   if (NULL == ch)
 988   {
 989     GNUNET_STATISTICS_update (stats, "# data on unknown channel",
 990                               1, GNUNET_NO);
 991     LOG (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel %u unknown\n",
 992          ntohl (msg->chid));
 993     return;
 994   }
 995
 996   GMT_change_cstate (t, MESH_TUNNEL3_READY);
 997   GMCH_handle_data (ch, msg, fwd);
 998 }
 999
1000
1001 /**
1002  * Demultiplex data ACKs per channel and update appropriate channel buffer info.
1003  *
1004  * @param t Tunnel on which the DATA ACK came.
1005  * @param msg DATA ACK message.
1006  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1007  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1008  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1009  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1010  */
1011 static void
1012 handle_data_ack (struct MeshTunnel3 *t,
1013                  const struct GNUNET_MESH_DataACK *msg,
1014                  int fwd)
1015 {
1016   struct MeshChannel *ch;
1017   size_t size;
1018
1019   /* Check size */
1020   size = ntohs (msg->header.size);
1021   if (size != sizeof (struct GNUNET_MESH_DataACK))
1022   {
1023     GNUNET_break (0);
1024     return;
1025   }
1026
1027   /* Check channel */
1028   ch = GMT_get_channel (t, ntohl (msg->chid));
1029   if (NULL == ch)
1030   {
1031     GNUNET_STATISTICS_update (stats, "# data ack on unknown channel",
1032                               1, GNUNET_NO);
1033     LOG (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel %u unknown\n",
1034          ntohl (msg->chid));
1035     return;
1036   }
1037
1038   GMCH_handle_data_ack (ch, msg, fwd);
1039 }
1040
1041
1042 /**
1043  * Handle channel create.
1044  *
1045  * @param t Tunnel on which the data came.
1046  * @param msg Data message.
1047  */
1048 static void
1049 handle_ch_create (struct MeshTunnel3 *t,
1050                   const struct GNUNET_MESH_ChannelCreate *msg)
1051 {
1052   struct MeshChannel *ch;
1053   size_t size;
1054
1055   /* Check size */
1056   size = ntohs (msg->header.size);
1057   if (size != sizeof (struct GNUNET_MESH_ChannelCreate))
1058   {
1059     GNUNET_break (0);
1060     return;
1061   }
1062
1063   /* Check channel */
1064   ch = GMT_get_channel (t, ntohl (msg->chid));
1065   if (NULL != ch && ! GMT_is_loopback (t))
1066   {
1067     /* Probably a retransmission, safe to ignore */
1068     LOG (GNUNET_ERROR_TYPE_DEBUG, "   already exists...\n");
1069   }
1070   else
1071   {
1072     ch = GMCH_handle_create (t, msg);
1073   }
1074   if (NULL != ch)
1075     GMT_add_channel (t, ch);
1076 }
1077
1078
1079
1080 /**
1081  * Handle channel NACK: check correctness and call channel handler for NACKs.
1082  *
1083  * @param t Tunnel on which the NACK came.
1084  * @param msg NACK message.
1085  */
1086 static void
1087 handle_ch_nack (struct MeshTunnel3 *t,
1088                 const struct GNUNET_MESH_ChannelManage *msg)
1089 {
1090   struct MeshChannel *ch;
1091   size_t size;
1092
1093   /* Check size */
1094   size = ntohs (msg->header.size);
1095   if (size != sizeof (struct GNUNET_MESH_ChannelManage))
1096   {
1097     GNUNET_break (0);
1098     return;
1099   }
1100
1101   /* Check channel */
1102   ch = GMT_get_channel (t, ntohl (msg->chid));
1103   if (NULL == ch)
1104   {
1105     GNUNET_STATISTICS_update (stats, "# channel NACK on unknown channel",
1106                               1, GNUNET_NO);
1107     LOG (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel %u unknown\n",
1108          ntohl (msg->chid));
1109     return;
1110   }
1111
1112   GMCH_handle_nack (ch);
1113 }
1114
1115
1116 /**
1117  * Handle a CHANNEL ACK (SYNACK/ACK).
1118  *
1119  * @param t Tunnel on which the CHANNEL ACK came.
1120  * @param msg CHANNEL ACK message.
1121  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1122  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1123  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1124  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1125  */
1126 static void
1127 handle_ch_ack (struct MeshTunnel3 *t,
1128                const struct GNUNET_MESH_ChannelManage *msg,
1129                int fwd)
1130 {
1131   struct MeshChannel *ch;
1132   size_t size;
1133
1134   /* Check size */
1135   size = ntohs (msg->header.size);
1136   if (size != sizeof (struct GNUNET_MESH_ChannelManage))
1137   {
1138     GNUNET_break (0);
1139     return;
1140   }
1141
1142   /* Check channel */
1143   ch = GMT_get_channel (t, ntohl (msg->chid));
1144   if (NULL == ch)
1145   {
1146     GNUNET_STATISTICS_update (stats, "# channel ack on unknown channel",
1147                               1, GNUNET_NO);
1148     LOG (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel %u unknown\n",
1149          ntohl (msg->chid));
1150     return;
1151   }
1152
1153   GMCH_handle_ack (ch, msg, fwd);
1154 }
1155
1156
1157
1158 /**
1159  * Handle a channel destruction message.
1160  *
1161  * @param t Tunnel on which the message came.
1162  * @param msg Channel destroy message.
1163  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1164  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1165  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1166  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1167  */
1168 static void
1169 handle_ch_destroy (struct MeshTunnel3 *t,
1170                    const struct GNUNET_MESH_ChannelManage *msg,
1171                    int fwd)
1172 {
1173   struct MeshChannel *ch;
1174   size_t size;
1175
1176   /* Check size */
1177   size = ntohs (msg->header.size);
1178   if (size != sizeof (struct GNUNET_MESH_ChannelManage))
1179   {
1180     GNUNET_break (0);
1181     return;
1182   }
1183
1184   /* Check channel */
1185   ch = GMT_get_channel (t, ntohl (msg->chid));
1186   if (NULL == ch)
1187   {
1188     /* Probably a retransmission, safe to ignore */
1189     return;
1190   }
1191
1192   GMCH_handle_destroy (ch, msg, fwd);
1193 }
1194
1195
1196 /**
1197  * The peer's ephemeral key has changed: update the symmetrical keys.
1198  *
1199  * @param t Tunnel this message came on.
1200  * @param msg Key eXchange message.
1201  */
1202 static void
1203 handle_ephemeral (struct MeshTunnel3 *t,
1204                   const struct GNUNET_MESH_KX_Ephemeral *msg)
1205 {
1206   struct GNUNET_HashCode km;
1207   LOG (GNUNET_ERROR_TYPE_DEBUG, "  ephemeral key message\n");
1208
1209   if (GNUNET_OK != check_ephemeral (t, msg))
1210   {
1211     GNUNET_break_op (0);
1212     return;
1213   }
1214   derive_key_material (&km, &msg->ephemeral_key);
1215   LOG (GNUNET_ERROR_TYPE_DEBUG, "  km is %s\n", GNUNET_h2s (&km));
1216   derive_symmertic (&t->e_key, &my_full_id, GMP_get_id (t->peer), &km);
1217   derive_symmertic (&t->d_key, GMP_get_id (t->peer), &my_full_id, &km);
1218   if (MESH_TUNNEL3_KEY_SENT == t->estate)
1219   {
1220     LOG (GNUNET_ERROR_TYPE_DEBUG, "  our key was sent, send ping\n");
1221     send_ping (t);
1222     t->estate = MESH_TUNNEL3_KEY_PING;
1223   }
1224 }
1225
1226
1227 /**
1228  * Peer wants to check our symmetrical keys by sending an encrypted challenge.
1229  * Answer with by retransmitting the challenge with the "opposite" key.
1230  *
1231  * @param t Tunnel this message came on.
1232  * @param msg Key eXchange Ping message.
1233  */
1234 static void
1235 handle_ping (struct MeshTunnel3 *t,
1236              const struct GNUNET_MESH_KX_Ping *msg)
1237 {
1238   struct GNUNET_MESH_KX_Ping res;
1239
1240   if (ntohs (msg->header.size) != sizeof (res))
1241   {
1242     GNUNET_break_op (0);
1243     return;
1244   }
1245
1246   LOG (GNUNET_ERROR_TYPE_DEBUG, "  ping message\n");
1247   t_decrypt (t, &res.target, &msg->target, ping_encryption_size (), msg->iv);
1248   if (0 != memcmp (&my_full_id, &res.target, sizeof (my_full_id)))
1249   {
1250     GNUNET_break_op (0);
1251     LOG (GNUNET_ERROR_TYPE_DEBUG, "  e got %u\n", msg->nonce);
1252     LOG (GNUNET_ERROR_TYPE_DEBUG, "  e towards %s\n", GNUNET_i2s (&msg->target));
1253     LOG (GNUNET_ERROR_TYPE_DEBUG, "  got %u\n", res.nonce);
1254     LOG (GNUNET_ERROR_TYPE_DEBUG, "  towards %s\n", GNUNET_i2s (&res.target));
1255     return;
1256   }
1257
1258   send_pong (t, res.nonce);
1259 }
1260
1261
1262 /**
1263  * Peer has answer to our challenge.
1264  * If answer is successful, consider the key exchange finished and clean
1265  * up all related state.
1266  *
1267  * @param t Tunnel this message came on.
1268  * @param msg Key eXchange Pong message.
1269  */
1270 static void
1271 handle_pong (struct MeshTunnel3 *t,
1272              const struct GNUNET_MESH_KX_Pong *msg)
1273 {
1274   uint32_t challenge;
1275
1276   LOG (GNUNET_ERROR_TYPE_DEBUG, "PONG received\n");
1277   if (GNUNET_SCHEDULER_NO_TASK == t->rekey_task)
1278   {
1279     GNUNET_break_op (0);
1280     return;
1281   }
1282   t_decrypt (t, &challenge, &msg->nonce, sizeof (uint32_t), msg->iv);
1283
1284   if (challenge != t->kx_ctx->challenge)
1285   {
1286     LOG (GNUNET_ERROR_TYPE_DEBUG,
1287          "Wrong PONG challenge: %u (e: %u). Expected: %u.\n",
1288          challenge, msg->nonce, t->kx_ctx->challenge);
1289     GNUNET_break_op (0);
1290     return;
1291   }
1292   GNUNET_SCHEDULER_cancel (t->rekey_task);
1293   t->rekey_task = GNUNET_SCHEDULER_NO_TASK;
1294   GNUNET_free (t->kx_ctx);
1295   t->kx_ctx = NULL;
1296   GMT_change_estate (t, MESH_TUNNEL3_KEY_OK);
1297 }
1298
1299
1300 /**
1301  * Demultiplex by message type and call appropriate handler for a message
1302  * towards a channel of a local tunnel.
1303  *
1304  * @param t Tunnel this message came on.
1305  * @param msgh Message header.
1306  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1307  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1308  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1309  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1310  */
1311 static void
1312 handle_decrypted (struct MeshTunnel3 *t,
1313                   const struct GNUNET_MessageHeader *msgh,
1314                   int fwd)
1315 {
1316   uint16_t type;
1317
1318   type = ntohs (msgh->type);
1319   LOG (GNUNET_ERROR_TYPE_DEBUG,
1320        "Got a %s message!\n",
1321        GNUNET_MESH_DEBUG_M2S (type));
1322
1323   switch (type)
1324   {
1325     case GNUNET_MESSAGE_TYPE_MESH_DATA:
1326       /* Don't send hop ACK, wait for client to ACK */
1327       handle_data (t, (struct GNUNET_MESH_Data *) msgh, fwd);
1328       break;
1329
1330     case GNUNET_MESSAGE_TYPE_MESH_DATA_ACK:
1331       handle_data_ack (t, (struct GNUNET_MESH_DataACK *) msgh, fwd);
1332       break;
1333
1334     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE:
1335       handle_ch_create (t,
1336                         (struct GNUNET_MESH_ChannelCreate *) msgh);
1337       break;
1338
1339     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_NACK:
1340       handle_ch_nack (t,
1341                       (struct GNUNET_MESH_ChannelManage *) msgh);
1342       break;
1343
1344     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_ACK:
1345       handle_ch_ack (t,
1346                      (struct GNUNET_MESH_ChannelManage *) msgh,
1347                      fwd);
1348       break;
1349
1350     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY:
1351       handle_ch_destroy (t,
1352                          (struct GNUNET_MESH_ChannelManage *) msgh,
1353                          fwd);
1354       break;
1355
1356     default:
1357       GNUNET_break_op (0);
1358       LOG (GNUNET_ERROR_TYPE_DEBUG,
1359            "end-to-end message not known (%u)\n",
1360            ntohs (msgh->type));
1361   }
1362 }
1363
1364 /******************************************************************************/
1365 /********************************    API    ***********************************/
1366 /******************************************************************************/
1367
1368 /**
1369  * Decrypt and demultiplex by message type. Call appropriate handler
1370  * for every message.
1371  *
1372  * @param t Tunnel this message came on.
1373  * @param msg Encrypted message.
1374  */
1375 void
1376 GMT_handle_encrypted (struct MeshTunnel3 *t,
1377                       const struct GNUNET_MESH_Encrypted *msg)
1378 {
1379   size_t size = ntohs (msg->header.size);
1380   size_t payload_size = size - sizeof (struct GNUNET_MESH_Encrypted);
1381   size_t decrypted_size;
1382   char cbuf [payload_size];
1383   struct GNUNET_MessageHeader *msgh;
1384   unsigned int off;
1385
1386   decrypted_size = t_decrypt (t, cbuf, &msg[1], payload_size, msg->iv);
1387   off = 0;
1388   while (off < decrypted_size)
1389   {
1390     msgh = (struct GNUNET_MessageHeader *) &cbuf[off];
1391     handle_decrypted (t, msgh, GNUNET_SYSERR);
1392     off += ntohs (msgh->size);
1393   }
1394 }
1395
1396
1397 /**
1398  * Demultiplex an encapsulated KX message by message type.
1399  *
1400  * @param t Tunnel on which the message came.
1401  * @param message Payload of KX message.
1402  */
1403 void
1404 GMT_handle_kx (struct MeshTunnel3 *t,
1405                const struct GNUNET_MessageHeader *message)
1406 {
1407   uint16_t type;
1408
1409   type = ntohs (message->type);
1410   LOG (GNUNET_ERROR_TYPE_DEBUG, "kx message received\n", type);
1411   switch (type)
1412   {
1413     case GNUNET_MESSAGE_TYPE_MESH_KX_EPHEMERAL:
1414       handle_ephemeral (t, (struct GNUNET_MESH_KX_Ephemeral *) message);
1415       break;
1416
1417     case GNUNET_MESSAGE_TYPE_MESH_KX_PING:
1418       handle_ping (t, (struct GNUNET_MESH_KX_Ping *) message);
1419       break;
1420
1421     case GNUNET_MESSAGE_TYPE_MESH_KX_PONG:
1422       handle_pong (t, (struct GNUNET_MESH_KX_Pong *) message);
1423       break;
1424
1425     default:
1426       GNUNET_break_op (0);
1427       LOG (GNUNET_ERROR_TYPE_DEBUG, "kx message not known (%u)\n", type);
1428   }
1429 }
1430
1431
1432 /**
1433  * Initialize the tunnel subsystem.
1434  *
1435  * @param c Configuration handle.
1436  * @param key ECC private key, to derive all other keys and do crypto.
1437  */
1438 void
1439 GMT_init (const struct GNUNET_CONFIGURATION_Handle *c,
1440           const struct GNUNET_CRYPTO_EddsaPrivateKey *key)
1441 {
1442   LOG (GNUNET_ERROR_TYPE_DEBUG, "init\n");
1443   if (GNUNET_OK !=
1444       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "DEFAULT_TTL",
1445                                              &default_ttl))
1446   {
1447     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
1448                                "MESH", "DEFAULT_TTL", "USING DEFAULT");
1449     default_ttl = 64;
1450   }
1451   if (GNUNET_OK !=
1452       GNUNET_CONFIGURATION_get_value_time (c, "MESH", "REKEY_PERIOD",
1453                                            &rekey_period))
1454   {
1455     rekey_period = GNUNET_TIME_UNIT_DAYS;
1456   }
1457
1458   my_private_key = key;
1459   kx_msg.header.size = htons (sizeof (kx_msg));
1460   kx_msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_KX_EPHEMERAL);
1461   kx_msg.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_MESH_KX);
1462   kx_msg.purpose.size = htonl (ephemeral_purpose_size ());
1463   kx_msg.origin_identity = my_full_id;
1464   rekey_task = GNUNET_SCHEDULER_add_now (&rekey, NULL);
1465
1466   tunnels = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
1467 }
1468
1469
1470 /**
1471  * Shut down the tunnel subsystem.
1472  */
1473 void
1474 GMT_shutdown (void)
1475 {
1476   if (GNUNET_SCHEDULER_NO_TASK != rekey_task)
1477   {
1478     GNUNET_SCHEDULER_cancel (rekey_task);
1479     rekey_task = GNUNET_SCHEDULER_NO_TASK;
1480   }
1481   GNUNET_CONTAINER_multipeermap_iterate (tunnels, &destroy_iterator, NULL);
1482   GNUNET_CONTAINER_multipeermap_destroy (tunnels);
1483 }
1484
1485
1486 /**
1487  * Create a tunnel.
1488  *
1489  * @param destination Peer this tunnel is towards.
1490  */
1491 struct MeshTunnel3 *
1492 GMT_new (struct MeshPeer *destination)
1493 {
1494   struct MeshTunnel3 *t;
1495
1496   t = GNUNET_new (struct MeshTunnel3);
1497   t->next_chid = 0;
1498   t->peer = destination;
1499
1500   if (GNUNET_OK !=
1501       GNUNET_CONTAINER_multipeermap_put (tunnels, GMP_get_id (destination), t,
1502                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
1503   {
1504     GNUNET_break (0);
1505     GNUNET_free (t);
1506     return NULL;
1507   }
1508   return t;
1509 }
1510
1511
1512 /**
1513  * Change the tunnel's connection state.
1514  *
1515  * @param t Tunnel whose connection state to change.
1516  * @param cstate New connection state.
1517  */
1518 void
1519 GMT_change_cstate (struct MeshTunnel3* t, enum MeshTunnel3CState state)
1520 {
1521   if (NULL == t)
1522     return;
1523   LOG (GNUNET_ERROR_TYPE_DEBUG,
1524               "Tunnel %s cstate was %s\n",
1525               GMP_2s (t->peer), cstate2s (t->cstate));
1526   LOG (GNUNET_ERROR_TYPE_DEBUG,
1527               "Tunnel %s cstate is now %s\n",
1528               GMP_2s (t->peer), cstate2s (state));
1529   if (myid != GMP_get_short_id (t->peer) &&
1530       MESH_TUNNEL3_READY != t->cstate &&
1531       MESH_TUNNEL3_READY == state)
1532   {
1533     t->cstate = state;
1534     if (MESH_TUNNEL3_KEY_OK == t->estate)
1535     {
1536       LOG (GNUNET_ERROR_TYPE_DEBUG, "  triggered send queued data\n");
1537       send_queued_data (t);
1538     }
1539     else if (MESH_TUNNEL3_KEY_UNINITIALIZED == t->estate)
1540     {
1541       LOG (GNUNET_ERROR_TYPE_DEBUG, "  triggered rekey\n");
1542       rekey_tunnel (t, NULL);
1543     }
1544   }
1545   t->cstate = state;
1546
1547   if (MESH_TUNNEL3_READY == state && 3 <= GMT_count_connections (t))
1548   {
1549     GMP_stop_search (t->peer);
1550   }
1551 }
1552
1553 /**
1554  * Change the tunnel encryption state.
1555  *
1556  * @param t Tunnel whose encryption state to change.
1557  * @param state New encryption state.
1558  */
1559 void
1560 GMT_change_estate (struct MeshTunnel3* t, enum MeshTunnel3EState state)
1561 {
1562   if (NULL == t)
1563     return;
1564   LOG (GNUNET_ERROR_TYPE_DEBUG,
1565        "Tunnel %s estate was %s\n",
1566        GMP_2s (t->peer), estate2s (t->estate));
1567   LOG (GNUNET_ERROR_TYPE_DEBUG,
1568        "Tunnel %s estate is now %s\n",
1569        GMP_2s (t->peer), estate2s (state));
1570   if (myid != GMP_get_short_id (t->peer) &&
1571       MESH_TUNNEL3_KEY_OK != t->estate && MESH_TUNNEL3_KEY_OK == state)
1572   {
1573     t->estate = state;
1574     send_queued_data (t);
1575     return;
1576   }
1577   t->estate = state;
1578 }
1579
1580
1581 /**
1582  * Add a connection to a tunnel.
1583  *
1584  * @param t Tunnel.
1585  * @param c Connection.
1586  */
1587 void
1588 GMT_add_connection (struct MeshTunnel3 *t, struct MeshConnection *c)
1589 {
1590   struct MeshTConnection *aux;
1591
1592   for (aux = t->connection_head; aux != NULL; aux = aux->next)
1593     if (aux->c == c)
1594       return;
1595
1596   aux = GNUNET_new (struct MeshTConnection);
1597   aux->c = c;
1598   GNUNET_CONTAINER_DLL_insert_tail (t->connection_head, t->connection_tail, aux);
1599 }
1600
1601
1602 /**
1603  * Remove a connection from a tunnel.
1604  *
1605  * @param t Tunnel.
1606  * @param c Connection.
1607  */
1608 void
1609 GMT_remove_connection (struct MeshTunnel3 *t, struct MeshConnection *c)
1610 {
1611   struct MeshTConnection *aux;
1612
1613   for (aux = t->connection_head; aux != NULL; aux = aux->next)
1614     if (aux->c == c)
1615     {
1616       GNUNET_CONTAINER_DLL_remove (t->connection_head, t->connection_tail, aux);
1617       GNUNET_free (aux);
1618       return;
1619     }
1620 }
1621
1622
1623 /**
1624  * Add a channel to a tunnel.
1625  *
1626  * @param t Tunnel.
1627  * @param ch Channel.
1628  */
1629 void
1630 GMT_add_channel (struct MeshTunnel3 *t, struct MeshChannel *ch)
1631 {
1632   struct MeshTChannel *aux;
1633
1634   GNUNET_assert (NULL != ch);
1635
1636   LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding channel %p to tunnel %p\n", ch, t);
1637
1638   for (aux = t->channel_head; aux != NULL; aux = aux->next)
1639   {
1640     LOG (GNUNET_ERROR_TYPE_DEBUG, "  already there %p\n", aux->ch);
1641     if (aux->ch == ch)
1642       return;
1643   }
1644
1645   aux = GNUNET_new (struct MeshTChannel);
1646   aux->ch = ch;
1647   LOG (GNUNET_ERROR_TYPE_DEBUG, " adding %p to %p\n", aux, t->channel_head);
1648   GNUNET_CONTAINER_DLL_insert_tail (t->channel_head, t->channel_tail, aux);
1649 }
1650
1651
1652 /**
1653  * Remove a channel from a tunnel.
1654  *
1655  * @param t Tunnel.
1656  * @param ch Channel.
1657  */
1658 void
1659 GMT_remove_channel (struct MeshTunnel3 *t, struct MeshChannel *ch)
1660 {
1661   struct MeshTChannel *aux;
1662
1663   LOG (GNUNET_ERROR_TYPE_DEBUG, "Removing channel %p from tunnel %p\n", ch, t);
1664   for (aux = t->channel_head; aux != NULL; aux = aux->next)
1665   {
1666     if (aux->ch == ch)
1667     {
1668       LOG (GNUNET_ERROR_TYPE_DEBUG, " found! %s\n", GMCH_2s (ch));
1669       GNUNET_CONTAINER_DLL_remove (t->channel_head, t->channel_tail, aux);
1670       GNUNET_free (aux);
1671       return;
1672     }
1673   }
1674 }
1675
1676
1677 /**
1678  * Search for a channel by global ID.
1679  *
1680  * @param t Tunnel containing the channel.
1681  * @param chid Public channel number.
1682  *
1683  * @return channel handler, NULL if doesn't exist
1684  */
1685 struct MeshChannel *
1686 GMT_get_channel (struct MeshTunnel3 *t, MESH_ChannelNumber chid)
1687 {
1688   struct MeshTChannel *iter;
1689
1690   if (NULL == t)
1691     return NULL;
1692
1693   for (iter = t->channel_head; NULL != iter; iter = iter->next)
1694   {
1695     if (GMCH_get_id (iter->ch) == chid)
1696       break;
1697   }
1698
1699   return NULL == iter ? NULL : iter->ch;
1700 }
1701
1702
1703 /**
1704  * Tunnel is empty: destroy it.
1705  *
1706  * Notifies all connections about the destruction.
1707  *
1708  * @param t Tunnel to destroy.
1709  */
1710 void
1711 GMT_destroy_empty (struct MeshTunnel3 *t)
1712 {
1713   struct MeshTConnection *iter;
1714
1715   LOG (GNUNET_ERROR_TYPE_DEBUG, "Tunnel empty: destroying scheduled\n");
1716   for (iter = t->connection_head; NULL != iter; iter = iter->next)
1717   {
1718     GMC_send_destroy (iter->c);
1719   }
1720
1721   t->cstate = MESH_TUNNEL3_NEW;
1722   t->destroy = GNUNET_YES;
1723 }
1724
1725
1726 /**
1727  * Destroy tunnel if empty (no more channels).
1728  *
1729  * @param t Tunnel to destroy if empty.
1730  */
1731 void
1732 GMT_destroy_if_empty (struct MeshTunnel3 *t)
1733 {
1734   if (1 < GMT_count_channels (t))
1735     return;
1736
1737   GMT_destroy_empty (t);
1738 }
1739
1740
1741 /**
1742  * Destroy the tunnel.
1743  *
1744  * This function does not generate any warning traffic to clients or peers.
1745  *
1746  * Tasks:
1747  * Cancel messages belonging to this tunnel queued to neighbors.
1748  * Free any allocated resources linked to the tunnel.
1749  *
1750  * @param t The tunnel to destroy.
1751  */
1752 void
1753 GMT_destroy (struct MeshTunnel3 *t)
1754 {
1755   struct MeshTConnection *iter_c;
1756   struct MeshTConnection *next_c;
1757   struct MeshTChannel *iter_ch;
1758   struct MeshTChannel *next_ch;
1759
1760   if (NULL == t)
1761     return;
1762
1763   LOG (GNUNET_ERROR_TYPE_DEBUG, "destroying tunnel %s\n", GMP_2s (t->peer));
1764
1765   GNUNET_break (GNUNET_YES ==
1766                 GNUNET_CONTAINER_multipeermap_remove (tunnels,
1767                                                       GMP_get_id (t->peer), t));
1768
1769   for (iter_c = t->connection_head; NULL != iter_c; iter_c = next_c)
1770   {
1771     next_c = iter_c->next;
1772     GMC_destroy (iter_c->c);
1773   }
1774   for (iter_ch = t->channel_head; NULL != iter_ch; iter_ch = next_ch)
1775   {
1776     next_ch = iter_ch->next;
1777     GMCH_destroy (iter_ch->ch);
1778     /* Should only happen on shutdown, but it's ok. */
1779   }
1780
1781   GNUNET_STATISTICS_update (stats, "# tunnels", -1, GNUNET_NO);
1782   GMP_set_tunnel (t->peer, NULL);
1783
1784   if (GNUNET_SCHEDULER_NO_TASK != t->rekey_task)
1785     GNUNET_SCHEDULER_cancel (t->rekey_task);
1786
1787   GNUNET_free (t);
1788 }
1789
1790
1791 /**
1792  * @brief Use the given path for the tunnel.
1793  * Update the next and prev hops (and RCs).
1794  * (Re)start the path refresh in case the tunnel is locally owned.
1795  *
1796  * @param t Tunnel to update.
1797  * @param p Path to use.
1798  *
1799  * @return Connection created.
1800  */
1801 struct MeshConnection *
1802 GMT_use_path (struct MeshTunnel3 *t, struct MeshPeerPath *p)
1803 {
1804   struct MeshConnection *c;
1805   struct GNUNET_HashCode cid;
1806   unsigned int own_pos;
1807
1808   if (NULL == t || NULL == p)
1809   {
1810     GNUNET_break (0);
1811     return NULL;
1812   }
1813
1814   for (own_pos = 0; own_pos < p->length; own_pos++)
1815   {
1816     if (p->peers[own_pos] == myid)
1817       break;
1818   }
1819   if (own_pos > p->length - 1)
1820   {
1821     GNUNET_break (0);
1822     return NULL;
1823   }
1824
1825   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_NONCE, &cid);
1826   c = GMC_new (&cid, t, p, own_pos);
1827   GMT_add_connection (t, c);
1828   return c;
1829 }
1830
1831
1832 /**
1833  * Count established (ready) connections of a tunnel.
1834  *
1835  * @param t Tunnel on which to count.
1836  *
1837  * @return Number of connections.
1838  */
1839 unsigned int
1840 GMT_count_connections (struct MeshTunnel3 *t)
1841 {
1842   struct MeshTConnection *iter;
1843   unsigned int count;
1844
1845   for (count = 0, iter = t->connection_head;
1846        NULL != iter;
1847        iter = iter->next, count++);
1848
1849   return count;
1850 }
1851
1852 /**
1853  * Count channels of a tunnel.
1854  *
1855  * @param t Tunnel on which to count.
1856  *
1857  * @return Number of channels.
1858  */
1859 unsigned int
1860 GMT_count_channels (struct MeshTunnel3 *t)
1861 {
1862   struct MeshTChannel *iter;
1863   unsigned int count;
1864
1865   for (count = 0, iter = t->channel_head;
1866        NULL != iter;
1867        iter = iter->next, count++) /* skip */;
1868
1869   return count;
1870 }
1871
1872
1873 /**
1874  * Get the connectivity state of a tunnel.
1875  *
1876  * @param t Tunnel.
1877  *
1878  * @return Tunnel's connectivity state.
1879  */
1880 enum MeshTunnel3CState
1881 GMT_get_cstate (struct MeshTunnel3 *t)
1882 {
1883   if (NULL == t)
1884   {
1885     GNUNET_break (0);
1886     return (enum MeshTunnel3CState) -1;
1887   }
1888   return t->cstate;
1889 }
1890
1891
1892 /**
1893  * Get the maximum buffer space for a tunnel towards a local client.
1894  *
1895  * @param t Tunnel.
1896  *
1897  * @return Biggest buffer space offered by any channel in the tunnel.
1898  */
1899 unsigned int
1900 GMT_get_channels_buffer (struct MeshTunnel3 *t)
1901 {
1902   struct MeshTChannel *iter;
1903   unsigned int buffer;
1904   unsigned int ch_buf;
1905
1906   if (NULL == t->channel_head)
1907   {
1908     /* Probably getting buffer for a channel create/handshake. */
1909     return 64;
1910   }
1911
1912   buffer = 0;
1913   for (iter = t->channel_head; NULL != iter; iter = iter->next)
1914   {
1915     ch_buf = get_channel_buffer (iter);
1916     if (ch_buf > buffer)
1917       buffer = ch_buf;
1918   }
1919   return buffer;
1920 }
1921
1922
1923 /**
1924  * Get the total buffer space for a tunnel for P2P traffic.
1925  *
1926  * @param t Tunnel.
1927  *
1928  * @return Buffer space offered by all connections in the tunnel.
1929  */
1930 unsigned int
1931 GMT_get_connections_buffer (struct MeshTunnel3 *t)
1932 {
1933   struct MeshTConnection *iter;
1934   unsigned int buffer;
1935
1936   iter = t->connection_head;
1937   buffer = 0;
1938   while (NULL != iter)
1939   {
1940     if (GMC_get_state (iter->c) != MESH_CONNECTION_READY)
1941     {
1942       iter = iter->next;
1943       continue;
1944     }
1945
1946     buffer += get_connection_buffer (iter);
1947     iter = iter->next;
1948   }
1949
1950   return buffer;
1951 }
1952
1953
1954 /**
1955  * Get the tunnel's destination.
1956  *
1957  * @param t Tunnel.
1958  *
1959  * @return ID of the destination peer.
1960  */
1961 const struct GNUNET_PeerIdentity *
1962 GMT_get_destination (struct MeshTunnel3 *t)
1963 {
1964   return GMP_get_id (t->peer);
1965 }
1966
1967
1968 /**
1969  * Get the tunnel's next free global channel ID.
1970  *
1971  * @param t Tunnel.
1972  *
1973  * @return GID of a channel free to use.
1974  */
1975 MESH_ChannelNumber
1976 GMT_get_next_chid (struct MeshTunnel3 *t)
1977 {
1978   MESH_ChannelNumber chid;
1979
1980   while (NULL != GMT_get_channel (t, t->next_chid))
1981   {
1982     LOG (GNUNET_ERROR_TYPE_DEBUG, "Channel %u exists...\n", t->next_chid);
1983     t->next_chid = (t->next_chid + 1) & ~GNUNET_MESH_LOCAL_CHANNEL_ID_CLI;
1984   }
1985   chid = t->next_chid;
1986   t->next_chid = (t->next_chid + 1) & ~GNUNET_MESH_LOCAL_CHANNEL_ID_CLI;
1987
1988   return chid;
1989 }
1990
1991
1992 /**
1993  * Send ACK on one or more channels due to buffer in connections.
1994  *
1995  * @param t Channel which has some free buffer space.
1996  */
1997 void
1998 GMT_unchoke_channels (struct MeshTunnel3 *t)
1999 {
2000   struct MeshTChannel *iter;
2001   unsigned int buffer;
2002   unsigned int channels = GMT_count_channels (t);
2003   unsigned int choked_n;
2004   struct MeshChannel *choked[channels];
2005
2006   LOG (GNUNET_ERROR_TYPE_DEBUG, "GMT_unchoke_channels on %s\n", GMT_2s (t));
2007   LOG (GNUNET_ERROR_TYPE_DEBUG, " head: %p\n", t->channel_head);
2008   if (NULL != t->channel_head)
2009     LOG (GNUNET_ERROR_TYPE_DEBUG, " head ch: %p\n", t->channel_head->ch);
2010
2011   /* Get buffer space */
2012   buffer = GMT_get_connections_buffer (t);
2013   if (0 == buffer)
2014   {
2015     return;
2016   }
2017
2018   /* Count and remember choked channels */
2019   choked_n = 0;
2020   for (iter = t->channel_head; NULL != iter; iter = iter->next)
2021   {
2022     if (GNUNET_NO == get_channel_allowed (iter))
2023     {
2024       choked[choked_n++] = iter->ch;
2025     }
2026   }
2027
2028   /* Unchoke random channels */
2029   while (0 < buffer && 0 < choked_n)
2030   {
2031     unsigned int r = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
2032                                                choked_n);
2033     GMCH_allow_client (choked[r], GMCH_is_origin (choked[r], GNUNET_YES));
2034     choked_n--;
2035     buffer--;
2036     choked[r] = choked[choked_n];
2037   }
2038 }
2039
2040
2041 /**
2042  * Send ACK on one or more connections due to buffer space to the client.
2043  *
2044  * Iterates all connections of the tunnel and sends ACKs appropriately.
2045  *
2046  * @param t Tunnel.
2047  */
2048 void
2049 GMT_send_connection_acks (struct MeshTunnel3 *t)
2050 {
2051   struct MeshTConnection *iter;
2052   uint32_t allowed;
2053   uint32_t to_allow;
2054   uint32_t allow_per_connection;
2055   unsigned int cs;
2056   unsigned int buffer;
2057
2058   LOG (GNUNET_ERROR_TYPE_DEBUG,
2059        "Tunnel send connection ACKs on %s\n",
2060        GMT_2s (t));
2061
2062   if (NULL == t)
2063   {
2064     GNUNET_break (0);
2065     return;
2066   }
2067
2068   buffer = GMT_get_channels_buffer (t);
2069
2070   /* Count connections, how many messages are already allowed */
2071   cs = GMT_count_connections (t);
2072   for (allowed = 0, iter = t->connection_head; NULL != iter; iter = iter->next)
2073   {
2074     allowed += get_connection_allowed (iter);
2075   }
2076
2077   /* Make sure there is no overflow */
2078   if (allowed > buffer)
2079   {
2080     return;
2081   }
2082
2083   /* Authorize connections to send more data */
2084   to_allow = buffer; /* - allowed; */
2085
2086   for (iter = t->connection_head; NULL != iter && to_allow > 0; iter = iter->next)
2087   {
2088     allow_per_connection = to_allow/cs;
2089     to_allow -= allow_per_connection;
2090     cs--;
2091     if (get_connection_allowed (iter) > 64 / 3)
2092     {
2093       continue;
2094     }
2095     GMC_allow (iter->c, buffer, GMC_is_origin (iter->c, GNUNET_YES));
2096   }
2097
2098   GNUNET_break (to_allow == 0);
2099 }
2100
2101
2102 /**
2103  * Callback called when a queued message is sent.
2104  *
2105  * Calculates the average time and connection packet tracking.
2106  *
2107  * @param cls Closure (TunnelQueue handle).
2108  * @param c Connection this message was on.
2109  * @param type Type of message sent.
2110  * @param fwd Was this a FWD going message?
2111  * @param size Size of the message.
2112  */
2113 static void
2114 message_sent (void *cls,
2115               struct MeshConnection *c,
2116               struct MeshConnectionQueue *q,
2117               uint16_t type, int fwd, size_t size)
2118 {
2119   struct MeshTunnel3Queue *qt = cls;
2120
2121   GNUNET_assert (NULL != qt->cont);
2122   qt->cont (qt->cont_cls, GMC_get_tunnel (c), qt, type, size);
2123   GNUNET_free (qt);
2124 }
2125
2126
2127 /**
2128  * Cancel a previously sent message while it's in the queue.
2129  *
2130  * ONLY can be called before the continuation given to the send function
2131  * is called. Once the continuation is called, the message is no longer in the
2132  * queue.
2133  *
2134  * @param q Handle to the queue.
2135  */
2136 void
2137 GMT_cancel (struct MeshTunnel3Queue *q)
2138 {
2139   GMC_cancel (q->q);
2140   /* message_sent() will be called and free q */
2141 }
2142
2143
2144 /**
2145  * Sends an already built message on a tunnel, encrypting it and
2146  * choosing the best connection.
2147  *
2148  * @param message Message to send. Function modifies it.
2149  * @param t Tunnel on which this message is transmitted.
2150  * @param ch Channel on which this message is transmitted.
2151  * @param fwd Is this a fwd message on @c ch?
2152  * @param cont Continuation to call once message is really sent.
2153  * @param cont_cls Closure for @c cont.
2154  *
2155  * @return Handle to cancel message. NULL if @c cont is NULL.
2156  */
2157 struct MeshTunnel3Queue *
2158 GMT_send_prebuilt_message (const struct GNUNET_MessageHeader *message,
2159                            struct MeshTunnel3 *t,
2160                            struct MeshChannel *ch, int fwd,
2161                            GMT_sent cont, void *cont_cls)
2162 {
2163   struct MeshTunnel3Queue *q;
2164   struct MeshConnection *c;
2165   struct GNUNET_MESH_Encrypted *msg;
2166   size_t size = ntohs (message->size);
2167   size_t encrypted_size;
2168   char cbuf[sizeof (struct GNUNET_MESH_Encrypted) + size];
2169   uint32_t iv;
2170   uint16_t type;
2171
2172   LOG (GNUNET_ERROR_TYPE_DEBUG, "GMT Send on Tunnel %s\n", GMT_2s (t));
2173
2174   if (GNUNET_NO == is_ready (t))
2175   {
2176     queue_data (t, ch, message);
2177     /* FIXME */
2178     return NULL;
2179   }
2180
2181   if (GMT_is_loopback (t))
2182   {
2183     LOG (GNUNET_ERROR_TYPE_DEBUG, "  loopback!\n");
2184     handle_decrypted (t, message, fwd);
2185     /* FIXME: call cont? */
2186     return NULL; /* Already delivered, cannot cancel */
2187   }
2188
2189   iv = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX);
2190   msg = (struct GNUNET_MESH_Encrypted *) cbuf;
2191   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_ENCRYPTED);
2192   msg->iv = iv;
2193   encrypted_size = t_encrypt (t, &msg[1], message, size, iv);
2194   msg->header.size = htons (sizeof (struct GNUNET_MESH_Encrypted) + encrypted_size);
2195   c = tunnel_get_connection (t);
2196   if (NULL == c)
2197   {
2198     GNUNET_break (GNUNET_YES == t->destroy);
2199     return NULL;
2200   }
2201   type = ntohs (message->type);
2202   switch (type)
2203   {
2204     case GNUNET_MESSAGE_TYPE_MESH_DATA:
2205     case GNUNET_MESSAGE_TYPE_MESH_DATA_ACK:
2206     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE:
2207     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY:
2208     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_ACK:
2209       msg->cid = *GMC_get_id (c);
2210       msg->ttl = htonl (default_ttl);
2211       break;
2212     default:
2213       LOG (GNUNET_ERROR_TYPE_DEBUG, "unkown type %s\n",
2214            GNUNET_MESH_DEBUG_M2S (type));
2215       GNUNET_break (0);
2216   }
2217
2218   fwd = GMC_is_origin (c, GNUNET_YES);
2219
2220   if (NULL == cont)
2221   {
2222     (void) GMC_send_prebuilt_message (&msg->header, c, fwd, NULL, NULL);
2223     return NULL;
2224   }
2225   q = GNUNET_new (struct MeshTunnel3Queue); /* FIXME valgrind: leak*/
2226   q->q = GMC_send_prebuilt_message (&msg->header, c, fwd, &message_sent, q);
2227   q->cont = cont;
2228   q->cont_cls = cont_cls;
2229
2230   return q;
2231 }
2232
2233 /**
2234  * Is the tunnel directed towards the local peer?
2235  *
2236  * @param t Tunnel.
2237  *
2238  * @return #GNUNET_YES if it is loopback.
2239  */
2240 int
2241 GMT_is_loopback (const struct MeshTunnel3 *t)
2242 {
2243   return (myid == GMP_get_short_id (t->peer));
2244 }
2245
2246
2247 /**
2248  * Is the tunnel this path already?
2249  *
2250  * @param t Tunnel.
2251  * @param p Path.
2252  *
2253  * @return #GNUNET_YES a connection uses this path.
2254  */
2255 int
2256 GMT_is_path_used (const struct MeshTunnel3 *t, const struct MeshPeerPath *p)
2257 {
2258   struct MeshTConnection *iter;
2259
2260   for (iter = t->connection_head; NULL != iter; iter = iter->next)
2261     if (GMC_get_path (iter->c) == p)
2262       return GNUNET_YES;
2263
2264   return GNUNET_NO;
2265 }
2266
2267
2268 /**
2269  * Get a cost of a path for a tunnel considering existing connections.
2270  *
2271  * @param t Tunnel.
2272  * @param path Candidate path.
2273  *
2274  * @return Cost of the path (path length + number of overlapping nodes)
2275  */
2276 unsigned int
2277 GMT_get_path_cost (const struct MeshTunnel3 *t,
2278                    const struct MeshPeerPath *path)
2279 {
2280   struct MeshTConnection *iter;
2281   unsigned int overlap;
2282   unsigned int i;
2283   unsigned int j;
2284
2285   if (NULL == path)
2286     return 0;
2287
2288   overlap = 0;
2289   GNUNET_assert (NULL != t);
2290
2291   for (i = 0; i < path->length; i++)
2292   {
2293     for (iter = t->connection_head; NULL != iter; iter = iter->next)
2294     {
2295       for (j = 0; j < GMC_get_path (iter->c)->length; j++)
2296       {
2297         if (path->peers[i] == GMC_get_path (iter->c)->peers[j])
2298         {
2299           overlap++;
2300           break;
2301         }
2302       }
2303     }
2304   }
2305   return (path->length + overlap) * (path->score * -1);
2306 }
2307
2308
2309 /**
2310  * Get the static string for the peer this tunnel is directed.
2311  *
2312  * @param t Tunnel.
2313  *
2314  * @return Static string the destination peer's ID.
2315  */
2316 const char *
2317 GMT_2s (const struct MeshTunnel3 *t)
2318 {
2319   if (NULL == t)
2320     return "(NULL)";
2321
2322   return GMP_2s (t->peer);
2323 }