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