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