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