src/cadet/gnunet-service-cadet_peer.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2013, 2015 GNUnet e.V.
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20 /**
  21  * @file cadet/gnunet-service-cadet_peer.c
  22  * @brief GNUnet CADET service connection handling
  23  * @author Bartlomiej Polot
  24  */
  25 #include "platform.h"
  26 #include "gnunet_util_lib.h"
  27 #include "gnunet_signatures.h"
  28 #include "gnunet_transport_service.h"
  29 #include "gnunet_ats_service.h"
  30 #include "gnunet_core_service.h"
  31 #include "gnunet_statistics_service.h"
  32 #include "cadet_protocol.h"
  33 #include "gnunet-service-cadet_peer.h"
  34 #include "gnunet-service-cadet_dht.h"
  35 #include "gnunet-service-cadet_connection.h"
  36 #include "gnunet-service-cadet_tunnel.h"
  37 #include "cadet_path.h"
  38
  39 #define LOG(level, ...) GNUNET_log_from (level,"cadet-p2p",__VA_ARGS__)
  40 #define LOG2(level, ...) GNUNET_log_from_nocheck(level,"cadet-p2p",__VA_ARGS__)
  41
  42
  43 /******************************************************************************/
  44 /********************************   STRUCTS  **********************************/
  45 /******************************************************************************/
  46
  47 /**
  48  * Struct containing info about a queued transmission to this peer
  49  */
  50 struct CadetPeerQueue
  51 {
  52   /**
  53    * DLL next
  54    */
  55   struct CadetPeerQueue *next;
  56
  57   /**
  58    * DLL previous
  59    */
  60   struct CadetPeerQueue *prev;
  61
  62   /**
  63    * Peer this transmission is directed to.
  64    */
  65   struct CadetPeer *peer;
  66
  67   /**
  68    * Connection this message belongs to.
  69    */
  70   struct CadetConnection *c;
  71
  72   /**
  73    * Is FWD in c?
  74    */
  75   int fwd;
  76
  77   /**
  78    * Pointer to info stucture used as cls.
  79    */
  80   void *cls;
  81
  82   /**
  83    * Type of message
  84    */
  85   uint16_t type;
  86
  87   /**
  88    * Type of message
  89    */
  90   uint16_t payload_type;
  91
  92   /**
  93    * Type of message
  94    */
  95   uint32_t payload_id;
  96
  97   /**
  98    * Size of the message
  99    */
 100   size_t size;
 101
 102   /**
 103    * Set when this message starts waiting for CORE.
 104    */
 105   struct GNUNET_TIME_Absolute start_waiting;
 106
 107   /**
 108    * Function to call on sending.
 109    */
 110   GCP_sent cont;
 111
 112   /**
 113    * Closure for callback.
 114    */
 115   void *cont_cls;
 116 };
 117
 118
 119 /**
 120  * Struct containing all information regarding a given peer
 121  */
 122 struct CadetPeer
 123 {
 124   /**
 125    * ID of the peer
 126    */
 127   GNUNET_PEER_Id id;
 128
 129   /**
 130    * Last time we heard from this peer
 131    */
 132   struct GNUNET_TIME_Absolute last_contact;
 133
 134   /**
 135    * Paths to reach the peer, ordered by ascending hop count
 136    */
 137   struct CadetPeerPath *path_head;
 138
 139   /**
 140    * Paths to reach the peer, ordered by ascending hop count
 141    */
 142   struct CadetPeerPath *path_tail;
 143
 144   /**
 145    * Handle to stop the DHT search for paths to this peer
 146    */
 147   struct GCD_search_handle *search_h;
 148
 149   /**
 150    * Handle to stop the DHT search for paths to this peer
 151    */
 152   struct GNUNET_SCHEDULER_Task *search_delayed;
 153
 154   /**
 155    * Tunnel to this peer, if any.
 156    */
 157   struct CadetTunnel *tunnel;
 158
 159   /**
 160    * Connections that go through this peer; indexed by tid.
 161    */
 162   struct GNUNET_CONTAINER_MultiHashMap *connections;
 163
 164   /**
 165    * Handle for queued transmissions
 166    */
 167   struct GNUNET_CORE_TransmitHandle *core_transmit;
 168
 169   /**
 170    * Timestamp
 171    */
 172   struct GNUNET_TIME_Absolute tmt_time;
 173
 174   /**
 175    * Transmission queue to core DLL head
 176    */
 177   struct CadetPeerQueue *queue_head;
 178
 179   /**
 180    * Transmission queue to core DLL tail
 181    */
 182   struct CadetPeerQueue *queue_tail;
 183
 184   /**
 185    * How many messages are in the queue to this peer.
 186    */
 187   unsigned int queue_n;
 188
 189   /**
 190    * Hello message.
 191    */
 192   struct GNUNET_HELLO_Message* hello;
 193
 194   /**
 195    * Handle to us offering the HELLO to the transport.
 196    */
 197   struct GNUNET_TRANSPORT_OfferHelloHandle *hello_offer;
 198
 199   /**
 200    * Handle to our ATS request asking ATS to suggest an address
 201    * to TRANSPORT for this peer (to establish a direct link).
 202    */
 203   struct GNUNET_ATS_ConnectivitySuggestHandle *connectivity_suggestion;
 204
 205 };
 206
 207
 208 /******************************************************************************/
 209 /*******************************   GLOBALS  ***********************************/
 210 /******************************************************************************/
 211
 212 /**
 213  * Global handle to the statistics service.
 214  */
 215 extern struct GNUNET_STATISTICS_Handle *stats;
 216
 217 /**
 218  * Local peer own ID (full value).
 219  */
 220 extern struct GNUNET_PeerIdentity my_full_id;
 221
 222 /**
 223  * Local peer own ID (short)
 224  */
 225 extern GNUNET_PEER_Id myid;
 226
 227 /**
 228  * Peers known, indexed by PeerIdentity, values of type `struct CadetPeer`.
 229  */
 230 static struct GNUNET_CONTAINER_MultiPeerMap *peers;
 231
 232 /**
 233  * How many peers do we want to remember?
 234  */
 235 static unsigned long long max_peers;
 236
 237 /**
 238  * Percentage of messages that will be dropped (for test purposes only).
 239  */
 240 static unsigned long long drop_percent;
 241
 242 /**
 243  * Handle to communicate with CORE.
 244  */
 245 static struct GNUNET_CORE_Handle *core_handle;
 246
 247 /**
 248  * Handle to communicate with ATS.
 249  */
 250 static struct GNUNET_ATS_ConnectivityHandle *ats_ch;
 251
 252 /**
 253  * Handle to try to start new connections.
 254  */
 255 static struct GNUNET_TRANSPORT_Handle *transport_handle;
 256
 257 /**
 258  * Shutdown falg.
 259  */
 260 static int in_shutdown;
 261
 262
 263 /******************************************************************************/
 264 /*****************************     DEBUG      *********************************/
 265 /******************************************************************************/
 266
 267 /**
 268  * Log all kinds of info about the queueing status of a peer.
 269  *
 270  * @param p Peer whose queue to show.
 271  * @param level Error level to use for logging.
 272  */
 273 static void
 274 queue_debug (const struct CadetPeer *p, enum GNUNET_ErrorType level)
 275 {
 276   struct GNUNET_TIME_Relative core_wait_time;
 277   struct CadetPeerQueue *q;
 278   int do_log;
 279
 280   do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK),
 281                                        "cadet-p2p",
 282                                        __FILE__, __FUNCTION__, __LINE__);
 283   if (0 == do_log)
 284     return;
 285
 286   LOG2 (level, "QQQ Message queue towards %s\n", GCP_2s (p));
 287   LOG2 (level, "QQQ  queue length: %u\n", p->queue_n);
 288   LOG2 (level, "QQQ  core tmt rdy: %p\n", p->core_transmit);
 289   if (NULL != p->core_transmit)
 290   {
 291     core_wait_time = GNUNET_TIME_absolute_get_duration (p->tmt_time);
 292     LOG2 (level, "QQQ  core called %s ago\n",
 293           GNUNET_STRINGS_relative_time_to_string (core_wait_time, GNUNET_NO));
 294   }
 295   for (q = p->queue_head; NULL != q; q = q->next)
 296   {
 297     LOG2 (level, "QQQ  - %s %s on %s\n",
 298          GC_m2s (q->type), GC_f2s (q->fwd), GCC_2s (q->c));
 299     LOG2 (level, "QQQ    payload %s, %u\n",
 300          GC_m2s (q->payload_type), q->payload_id);
 301     LOG2 (level, "QQQ    size: %u bytes\n", q->size);
 302   }
 303
 304   LOG2 (level, "QQQ End queue towards %s\n", GCP_2s (p));
 305 }
 306
 307
 308 /**
 309  * Log all kinds of info about a peer.
 310  *
 311  * @param peer Peer.
 312  */
 313 void
 314 GCP_debug (const struct CadetPeer *p, enum GNUNET_ErrorType level)
 315 {
 316   struct CadetPeerPath *path;
 317   unsigned int conns;
 318   int do_log;
 319
 320   do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK),
 321                                        "cadet-p2p",
 322                                        __FILE__, __FUNCTION__, __LINE__);
 323   if (0 == do_log)
 324     return;
 325
 326   if (NULL == p)
 327   {
 328     LOG2 (level, "PPP DEBUG PEER NULL\n");
 329     return;
 330   }
 331
 332   LOG2 (level, "PPP DEBUG PEER %s\n", GCP_2s (p));
 333   LOG2 (level, "PPP last contact %s\n",
 334        GNUNET_STRINGS_absolute_time_to_string (p->last_contact));
 335   for (path = p->path_head; NULL != path; path = path->next)
 336   {
 337     char *s;
 338
 339     s = path_2s (path);
 340     LOG2 (level, "PPP path: %s\n", s);
 341     GNUNET_free (s);
 342   }
 343
 344   LOG2 (level, "PPP core transmit handle %p\n", p->core_transmit);
 345   LOG2 (level, "PPP DHT GET handle %p\n", p->search_h);
 346   conns = 0;
 347   if (NULL != p->connections)
 348     conns += GNUNET_CONTAINER_multihashmap_size (p->connections);
 349   LOG2 (level, "PPP # connections over link to peer: %u\n", conns);
 350   queue_debug (p, level);
 351   LOG2 (level, "PPP DEBUG END\n");
 352 }
 353
 354
 355 /******************************************************************************/
 356 /*****************************  CORE HELPERS  *********************************/
 357 /******************************************************************************/
 358
 359
 360 /**
 361  * Iterator to notify all connections of a broken link. Mark connections
 362  * to destroy after all traffic has been sent.
 363  *
 364  * @param cls Closure (disconnected peer).
 365  * @param key Current key code (peer id).
 366  * @param value Value in the hash map (connection).
 367  *
 368  * @return #GNUNET_YES to continue to iterate.
 369  */
 370 static int
 371 notify_broken (void *cls,
 372                const struct GNUNET_HashCode *key,
 373                void *value)
 374 {
 375   struct CadetPeer *peer = cls;
 376   struct CadetConnection *c = value;
 377
 378   LOG (GNUNET_ERROR_TYPE_DEBUG,
 379        "Notifying %s due to %s disconnect\n",
 380        GCC_2s (c), GCP_2s (peer));
 381   GCC_neighbor_disconnected (c, peer);
 382   return GNUNET_YES;
 383 }
 384
 385
 386 /**
 387  * Remove the direct path to the peer.
 388  *
 389  * @param peer Peer to remove the direct path from.
 390  */
 391 static struct CadetPeerPath *
 392 pop_direct_path (struct CadetPeer *peer)
 393 {
 394   struct CadetPeerPath *iter;
 395
 396   for (iter = peer->path_head; NULL != iter; iter = iter->next)
 397   {
 398     if (2 >= iter->length)
 399     {
 400       GNUNET_CONTAINER_DLL_remove (peer->path_head,
 401                                    peer->path_tail,
 402                                    iter);
 403       return iter;
 404     }
 405   }
 406   return NULL;
 407 }
 408
 409
 410 /******************************************************************************/
 411 /***************************** CORE CALLBACKS *********************************/
 412 /******************************************************************************/
 413
 414
 415 /**
 416  * Method called whenever a given peer connects.
 417  *
 418  * @param cls closure
 419  * @param peer peer identity this notification is about
 420  */
 421 static void
 422 core_connect (void *cls,
 423               const struct GNUNET_PeerIdentity *peer)
 424 {
 425   struct CadetPeer *neighbor;
 426   struct CadetPeerPath *path;
 427   char own_id[16];
 428
 429   GCC_check_connections ();
 430   GNUNET_snprintf (own_id,
 431                    sizeof (own_id),
 432                    "%s",
 433                    GNUNET_i2s (&my_full_id));
 434   neighbor = GCP_get (peer, GNUNET_YES);
 435   if (myid == neighbor->id)
 436   {
 437     LOG (GNUNET_ERROR_TYPE_INFO,
 438          "CONNECTED %s (self)\n",
 439          own_id);
 440     path = path_new (1);
 441   }
 442   else
 443   {
 444     LOG (GNUNET_ERROR_TYPE_INFO,
 445          "CONNECTED %s <= %s\n",
 446          own_id,
 447          GNUNET_i2s (peer));
 448     path = path_new (2);
 449     path->peers[1] = neighbor->id;
 450     GNUNET_PEER_change_rc (neighbor->id, 1);
 451   }
 452   path->peers[0] = myid;
 453   GNUNET_PEER_change_rc (myid, 1);
 454   GCP_add_path (neighbor, path, GNUNET_YES);
 455
 456   GNUNET_assert (NULL == neighbor->connections);
 457   neighbor->connections = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
 458   GNUNET_STATISTICS_update (stats,
 459                             "# peers",
 460                             1,
 461                             GNUNET_NO);
 462
 463   if ( (NULL != GCP_get_tunnel (neighbor)) &&
 464        (0 > GNUNET_CRYPTO_cmp_peer_identity (&my_full_id, peer)) )
 465     GCP_connect (neighbor);
 466   GCC_check_connections ();
 467 }
 468
 469
 470 /**
 471  * Method called whenever a peer disconnects.
 472  *
 473  * @param cls closure
 474  * @param peer peer identity this notification is about
 475  */
 476 static void
 477 core_disconnect (void *cls,
 478                  const struct GNUNET_PeerIdentity *peer)
 479 {
 480   struct CadetPeer *p;
 481   struct CadetPeerPath *direct_path;
 482   char own_id[16];
 483
 484   GCC_check_connections ();
 485   strncpy (own_id, GNUNET_i2s (&my_full_id), 16);
 486   own_id[15] = '\0';
 487   p = GNUNET_CONTAINER_multipeermap_get (peers, peer);
 488   if (NULL == p)
 489   {
 490     GNUNET_break (GNUNET_YES == in_shutdown);
 491     return;
 492   }
 493   if (myid == p->id)
 494     LOG (GNUNET_ERROR_TYPE_INFO,
 495          "DISCONNECTED %s (self)\n",
 496          own_id);
 497   else
 498     LOG (GNUNET_ERROR_TYPE_INFO,
 499          "DISCONNECTED %s <= %s\n",
 500          own_id, GNUNET_i2s (peer));
 501   direct_path = pop_direct_path (p);
 502   if (NULL != p->connections)
 503   {
 504     GNUNET_CONTAINER_multihashmap_iterate (p->connections,
 505                                            &notify_broken,
 506                                            p);
 507     GNUNET_CONTAINER_multihashmap_destroy (p->connections);
 508     p->connections = NULL;
 509   }
 510   if (NULL != p->core_transmit)
 511   {
 512     GNUNET_CORE_notify_transmit_ready_cancel (p->core_transmit);
 513     p->core_transmit = NULL;
 514     p->tmt_time.abs_value_us = 0;
 515   }
 516   GNUNET_STATISTICS_update (stats,
 517                             "# peers",
 518                             -1,
 519                             GNUNET_NO);
 520   path_destroy (direct_path);
 521   GCC_check_connections ();
 522 }
 523
 524
 525 /**
 526  * Functions to handle messages from core
 527  */
 528 static struct GNUNET_CORE_MessageHandler core_handlers[] = {
 529   {&GCC_handle_create, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE, 0},
 530   {&GCC_handle_confirm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK,
 531     sizeof (struct GNUNET_CADET_ConnectionACK)},
 532   {&GCC_handle_broken, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN,
 533     sizeof (struct GNUNET_CADET_ConnectionBroken)},
 534   {&GCC_handle_destroy, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY,
 535     sizeof (struct GNUNET_CADET_ConnectionDestroy)},
 536   {&GCC_handle_ack, GNUNET_MESSAGE_TYPE_CADET_ACK,
 537     sizeof (struct GNUNET_CADET_ACK)},
 538   {&GCC_handle_poll, GNUNET_MESSAGE_TYPE_CADET_POLL,
 539     sizeof (struct GNUNET_CADET_Poll)},
 540   {&GCC_handle_kx, GNUNET_MESSAGE_TYPE_CADET_KX, 0},
 541   {&GCC_handle_encrypted, GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED, 0},
 542   {&GCC_handle_encrypted, GNUNET_MESSAGE_TYPE_CADET_AX, 0},
 543   {NULL, 0, 0}
 544 };
 545
 546
 547 /**
 548  * To be called on core init/fail.
 549  *
 550  * @param cls Closure (config)
 551  * @param identity the public identity of this peer
 552  */
 553 static void
 554 core_init (void *cls,
 555            const struct GNUNET_PeerIdentity *identity)
 556 {
 557   const struct GNUNET_CONFIGURATION_Handle *c = cls;
 558   static int i = 0;
 559
 560   LOG (GNUNET_ERROR_TYPE_DEBUG, "Core init\n");
 561   if (0 != memcmp (identity, &my_full_id, sizeof (my_full_id)))
 562   {
 563     LOG (GNUNET_ERROR_TYPE_ERROR, _("Wrong CORE service\n"));
 564     LOG (GNUNET_ERROR_TYPE_ERROR, " core id %s\n", GNUNET_i2s (identity));
 565     LOG (GNUNET_ERROR_TYPE_ERROR, " my id %s\n", GNUNET_i2s (&my_full_id));
 566     GNUNET_CORE_disconnect (core_handle);
 567     core_handle = GNUNET_CORE_connect (c, /* Main configuration */
 568                                        NULL,      /* Closure passed to CADET functions */
 569                                        &core_init,        /* Call core_init once connected */
 570                                        &core_connect,     /* Handle connects */
 571                                        &core_disconnect,  /* remove peers on disconnects */
 572                                        NULL,      /* Don't notify about all incoming messages */
 573                                        GNUNET_NO, /* For header only in notification */
 574                                        NULL,      /* Don't notify about all outbound messages */
 575                                        GNUNET_NO, /* For header-only out notification */
 576                                        core_handlers);    /* Register these handlers */
 577     if (10 < i++)
 578       GNUNET_assert (0);
 579   }
 580   GML_start ();
 581 }
 582
 583
 584 /**
 585   * Core callback to write a pre-constructed data packet to core buffer
 586   *
 587   * @param cls Closure (CadetTransmissionDescriptor with data in "data" member).
 588   * @param size Number of bytes available in buf.
 589   * @param buf Where the to write the message.
 590   *
 591   * @return number of bytes written to buf
 592   */
 593 static size_t
 594 send_core_data_raw (void *cls, size_t size, void *buf)
 595 {
 596   struct GNUNET_MessageHeader *msg = cls;
 597   size_t total_size;
 598
 599   GNUNET_assert (NULL != msg);
 600   total_size = ntohs (msg->size);
 601
 602   if (total_size > size)
 603   {
 604     GNUNET_break (0);
 605     return 0;
 606   }
 607   memcpy (buf, msg, total_size);
 608   GNUNET_free (cls);
 609   return total_size;
 610 }
 611
 612
 613 /**
 614  * Function to send a create connection message to a peer.
 615  *
 616  * @param c Connection to create.
 617  * @param size number of bytes available in buf
 618  * @param buf where the callee should write the message
 619  * @return number of bytes written to buf
 620  */
 621 static size_t
 622 send_core_connection_create (struct CadetConnection *c, size_t size, void *buf)
 623 {
 624   struct GNUNET_CADET_ConnectionCreate *msg;
 625   struct GNUNET_PeerIdentity *peer_ptr;
 626   const struct CadetPeerPath *p = GCC_get_path (c);
 627   size_t size_needed;
 628   int i;
 629
 630   if (NULL == p)
 631     return 0;
 632
 633   LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION CREATE...\n");
 634   size_needed =
 635       sizeof (struct GNUNET_CADET_ConnectionCreate) +
 636       p->length * sizeof (struct GNUNET_PeerIdentity);
 637
 638   if (size < size_needed || NULL == buf)
 639   {
 640     GNUNET_break (0);
 641     return 0;
 642   }
 643   msg = (struct GNUNET_CADET_ConnectionCreate *) buf;
 644   msg->header.size = htons (size_needed);
 645   msg->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE);
 646   msg->cid = *GCC_get_id (c);
 647
 648   peer_ptr = (struct GNUNET_PeerIdentity *) &msg[1];
 649   for (i = 0; i < p->length; i++)
 650   {
 651     GNUNET_PEER_resolve (p->peers[i], peer_ptr++);
 652   }
 653
 654   LOG (GNUNET_ERROR_TYPE_DEBUG,
 655        "CONNECTION CREATE (%u bytes long) sent!\n",
 656        size_needed);
 657   return size_needed;
 658 }
 659
 660
 661 /**
 662  * Creates a path ack message in buf and frees all unused resources.
 663  *
 664  * @param c Connection to send an ACK on.
 665  * @param size number of bytes available in buf
 666  * @param buf where the callee should write the message
 667  *
 668  * @return number of bytes written to buf
 669  */
 670 static size_t
 671 send_core_connection_ack (struct CadetConnection *c, size_t size, void *buf)
 672 {
 673   struct GNUNET_CADET_ConnectionACK *msg = buf;
 674
 675   LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION ACK...\n");
 676   if (sizeof (struct GNUNET_CADET_ConnectionACK) > size)
 677   {
 678     GNUNET_break (0);
 679     return 0;
 680   }
 681   msg->header.size = htons (sizeof (struct GNUNET_CADET_ConnectionACK));
 682   msg->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK);
 683   msg->cid = *GCC_get_id (c);
 684
 685   LOG (GNUNET_ERROR_TYPE_DEBUG, "CONNECTION ACK sent!\n");
 686   return sizeof (struct GNUNET_CADET_ConnectionACK);
 687 }
 688
 689
 690 /******************************************************************************/
 691 /********************************   STATIC  ***********************************/
 692 /******************************************************************************/
 693
 694
 695 /**
 696  * Get priority for a queued message.
 697  *
 698  * @param q Queued message
 699  *
 700  * @return CORE priority to use.
 701  */
 702 static enum GNUNET_CORE_Priority
 703 get_priority (struct CadetPeerQueue *q)
 704 {
 705   enum GNUNET_CORE_Priority low;
 706   enum GNUNET_CORE_Priority high;
 707
 708   if (NULL == q)
 709   {
 710     GNUNET_break (0);
 711     return GNUNET_CORE_PRIO_BACKGROUND;
 712   }
 713
 714   /* Relayed traffic has lower priority, our own traffic has higher */
 715   if (NULL == q->c || GNUNET_NO == GCC_is_origin (q->c, q->fwd))
 716   {
 717     low = GNUNET_CORE_PRIO_BEST_EFFORT;
 718     high = GNUNET_CORE_PRIO_URGENT;
 719   }
 720   else
 721   {
 722     low = GNUNET_CORE_PRIO_URGENT;
 723     high = GNUNET_CORE_PRIO_CRITICAL_CONTROL;
 724   }
 725
 726   /* Bulky payload has lower priority, control traffic has higher. */
 727   if (GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED == q->type
 728       || GNUNET_MESSAGE_TYPE_CADET_AX == q->type)
 729     return low;
 730   else
 731     return high;
 732 }
 733
 734
 735 /**
 736  * Destroy the peer_info and free any allocated resources linked to it
 737  *
 738  * @param peer The peer_info to destroy.
 739  * @return #GNUNET_OK on success
 740  */
 741 static int
 742 peer_destroy (struct CadetPeer *peer)
 743 {
 744   struct GNUNET_PeerIdentity id;
 745   struct CadetPeerPath *p;
 746   struct CadetPeerPath *nextp;
 747
 748   GNUNET_PEER_resolve (peer->id, &id);
 749   GNUNET_PEER_change_rc (peer->id, -1);
 750
 751   LOG (GNUNET_ERROR_TYPE_INFO,
 752        "destroying peer %s\n",
 753        GNUNET_i2s (&id));
 754
 755   if (GNUNET_YES !=
 756       GNUNET_CONTAINER_multipeermap_remove (peers, &id, peer))
 757   {
 758     GNUNET_break (0);
 759     LOG (GNUNET_ERROR_TYPE_WARNING, " peer not in peermap!!\n");
 760   }
 761   GCP_stop_search (peer);
 762   p = peer->path_head;
 763   while (NULL != p)
 764   {
 765     nextp = p->next;
 766     GNUNET_CONTAINER_DLL_remove (peer->path_head,
 767                                  peer->path_tail,
 768                                  p);
 769     path_destroy (p);
 770     p = nextp;
 771   }
 772   if (NULL != peer->tunnel)
 773     GCT_destroy_empty (peer->tunnel);
 774   if (NULL != peer->connections)
 775   {
 776     GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (peer->connections));
 777     GNUNET_CONTAINER_multihashmap_destroy (peer->connections);
 778     peer->connections = NULL;
 779   }
 780   if (NULL != peer->hello_offer)
 781   {
 782     GNUNET_TRANSPORT_offer_hello_cancel (peer->hello_offer);
 783     peer->hello_offer = NULL;
 784   }
 785   if (NULL != peer->connectivity_suggestion)
 786   {
 787     GNUNET_ATS_connectivity_suggest_cancel (peer->connectivity_suggestion);
 788     peer->connectivity_suggestion = NULL;
 789   }
 790   while (NULL != peer->queue_head)
 791   {
 792     GCP_queue_destroy (peer->queue_head, GNUNET_YES, GNUNET_NO, 0);
 793   }
 794   if (NULL != peer->core_transmit)
 795   {
 796     GNUNET_break (0); /* GCP_queue_destroy should've cancelled it! */
 797     GNUNET_CORE_notify_transmit_ready_cancel (peer->core_transmit);
 798     peer->core_transmit = NULL;
 799   }
 800
 801   GNUNET_free_non_null (peer->hello);
 802   GNUNET_free (peer);
 803   return GNUNET_OK;
 804 }
 805
 806
 807 /**
 808  * Iterator over peer hash map entries to destroy the peer during in_shutdown.
 809  *
 810  * @param cls closure
 811  * @param key current key code
 812  * @param value value in the hash map
 813  * @return #GNUNET_YES if we should continue to iterate,
 814  *         #GNUNET_NO if not.
 815  */
 816 static int
 817 shutdown_peer (void *cls,
 818                const struct GNUNET_PeerIdentity *key,
 819                void *value)
 820 {
 821   struct CadetPeer *p = value;
 822   struct CadetTunnel *t = p->tunnel;
 823
 824   LOG (GNUNET_ERROR_TYPE_DEBUG, "  shutting down %s\n", GCP_2s (p));
 825   if (NULL != t)
 826     GCT_destroy (t);
 827   p->tunnel = NULL;
 828   peer_destroy (p);
 829   return GNUNET_YES;
 830 }
 831
 832
 833
 834 /**
 835  * Check if peer is searching for a path (either active or delayed search).
 836  *
 837  * @param peer Peer to check
 838  * @return #GNUNET_YES if there is a search active.
 839  *         #GNUNET_NO otherwise.
 840  */
 841 static int
 842 is_searching (const struct CadetPeer *peer)
 843 {
 844   return ( (NULL == peer->search_h) &&
 845            (NULL == peer->search_delayed) ) ?
 846     GNUNET_NO : GNUNET_YES;
 847 }
 848
 849
 850 /**
 851  * @brief Start a search for a peer.
 852  *
 853  * @param cls Closure (Peer to search for).
 854  */
 855 static void
 856 delayed_search (void *cls)
 857 {
 858   struct CadetPeer *peer = cls;
 859
 860   peer->search_delayed = NULL;
 861   GCC_check_connections ();
 862   GCP_start_search (peer);
 863   GCC_check_connections ();
 864 }
 865
 866
 867 /**
 868  * Returns if peer is used (has a tunnel or is neighbor).
 869  *
 870  * @param peer Peer to check.
 871  * @return #GNUNET_YES if peer is in use.
 872  */
 873 static int
 874 peer_is_used (struct CadetPeer *peer)
 875 {
 876   struct CadetPeerPath *p;
 877
 878   if (NULL != peer->tunnel)
 879     return GNUNET_YES;
 880
 881   for (p = peer->path_head; NULL != p; p = p->next)
 882   {
 883     if (p->length < 3)
 884       return GNUNET_YES;
 885   }
 886     return GNUNET_NO;
 887 }
 888
 889
 890 /**
 891  * Iterator over all the peers to get the oldest timestamp.
 892  *
 893  * @param cls Closure (unsued).
 894  * @param key ID of the peer.
 895  * @param value Peer_Info of the peer.
 896  */
 897 static int
 898 peer_get_oldest (void *cls,
 899                  const struct GNUNET_PeerIdentity *key,
 900                  void *value)
 901 {
 902   struct CadetPeer *p = value;
 903   struct GNUNET_TIME_Absolute *abs = cls;
 904
 905   /* Don't count active peers */
 906   if (GNUNET_YES == peer_is_used (p))
 907     return GNUNET_YES;
 908
 909   if (abs->abs_value_us < p->last_contact.abs_value_us)
 910     abs->abs_value_us = p->last_contact.abs_value_us;
 911
 912   return GNUNET_YES;
 913 }
 914
 915
 916 /**
 917  * Iterator over all the peers to remove the oldest entry.
 918  *
 919  * @param cls Closure (unsued).
 920  * @param key ID of the peer.
 921  * @param value Peer_Info of the peer.
 922  */
 923 static int
 924 peer_timeout (void *cls,
 925               const struct GNUNET_PeerIdentity *key,
 926               void *value)
 927 {
 928   struct CadetPeer *p = value;
 929   struct GNUNET_TIME_Absolute *abs = cls;
 930
 931   LOG (GNUNET_ERROR_TYPE_WARNING,
 932        "peer %s timeout\n", GNUNET_i2s (key));
 933
 934   if (p->last_contact.abs_value_us == abs->abs_value_us &&
 935       GNUNET_NO == peer_is_used (p))
 936   {
 937     peer_destroy (p);
 938     return GNUNET_NO;
 939   }
 940     return GNUNET_YES;
 941 }
 942
 943
 944 /**
 945  * Delete oldest unused peer.
 946  */
 947 static void
 948 peer_delete_oldest (void)
 949 {
 950   struct GNUNET_TIME_Absolute abs;
 951
 952   abs = GNUNET_TIME_UNIT_FOREVER_ABS;
 953
 954   GNUNET_CONTAINER_multipeermap_iterate (peers,
 955                                          &peer_get_oldest,
 956                                          &abs);
 957   GNUNET_CONTAINER_multipeermap_iterate (peers,
 958                                          &peer_timeout,
 959                                          &abs);
 960 }
 961
 962
 963 /**
 964  * Choose the best (yet unused) path towards a peer,
 965  * considering the tunnel properties.
 966  *
 967  * @param peer The destination peer.
 968  * @return Best current known path towards the peer, if any.
 969  */
 970 static struct CadetPeerPath *
 971 peer_get_best_path (const struct CadetPeer *peer)
 972 {
 973   struct CadetPeerPath *best_p;
 974   struct CadetPeerPath *p;
 975   unsigned int best_cost;
 976   unsigned int cost;
 977
 978   best_cost = UINT_MAX;
 979   best_p = NULL;
 980   for (p = peer->path_head; NULL != p; p = p->next)
 981   {
 982     if (GNUNET_NO == path_is_valid (p))
 983       continue; /* Don't use invalid paths. */
 984     if (GNUNET_YES == GCT_is_path_used (peer->tunnel, p))
 985       continue; /* If path is already in use, skip it. */
 986
 987     if ((cost = GCT_get_path_cost (peer->tunnel, p)) < best_cost)
 988     {
 989       best_cost = cost;
 990       best_p = p;
 991     }
 992   }
 993   return best_p;
 994 }
 995
 996
 997 /**
 998  * Is this queue element sendable?
 999  *
1000  * - All management traffic is always sendable.
1001  * - For payload traffic, check the connection flow control.
1002  *
1003  * @param q Queue element to inspect.
1004  * @return #GNUNET_YES if it is sendable, #GNUNET_NO otherwise.
1005  */
1006 static int
1007 queue_is_sendable (struct CadetPeerQueue *q)
1008 {
1009   /* Is PID-independent? */
1010   switch (q->type)
1011   {
1012     case GNUNET_MESSAGE_TYPE_CADET_ACK:
1013     case GNUNET_MESSAGE_TYPE_CADET_POLL:
1014     case GNUNET_MESSAGE_TYPE_CADET_KX:
1015     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE:
1016     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK:
1017     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY:
1018     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN:
1019       return GNUNET_YES;
1020
1021     case GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED:
1022     case GNUNET_MESSAGE_TYPE_CADET_AX:
1023       break;
1024
1025     default:
1026       GNUNET_break (0);
1027   }
1028
1029   return GCC_is_sendable (q->c, q->fwd);
1030 }
1031
1032
1033 /**
1034  * Get first sendable message.
1035  *
1036  * @param peer The destination peer.
1037  *
1038  * @return First transmittable message, if any. Otherwise, NULL.
1039  */
1040 static struct CadetPeerQueue *
1041 peer_get_first_message (const struct CadetPeer *peer)
1042 {
1043   struct CadetPeerQueue *q;
1044
1045   for (q = peer->queue_head; NULL != q; q = q->next)
1046   {
1047     LOG (GNUNET_ERROR_TYPE_DEBUG, "Checking q:%p on c:%s\n", q, GCC_2s (q->c));
1048     if (queue_is_sendable (q))
1049       return q;
1050   }
1051
1052   return NULL;
1053 }
1054
1055
1056 /**
1057  * Function to process paths received for a new peer addition. The recorded
1058  * paths form the initial tunnel, which can be optimized later.
1059  * Called on each result obtained for the DHT search.
1060  *
1061  * @param cls Closure (peer towards a path has been found).
1062  * @param path Path created from the DHT query. Will be freed afterwards.
1063  */
1064 static void
1065 search_handler (void *cls, const struct CadetPeerPath *path)
1066 {
1067   struct CadetPeer *peer = cls;
1068   unsigned int connection_count;
1069
1070   GCC_check_connections ();
1071   GCP_add_path_to_all (path, GNUNET_NO);
1072
1073   /* Count connections */
1074   connection_count = GCT_count_connections (peer->tunnel);
1075
1076   /* If we already have our minimum (or more) connections, it's enough */
1077   if (CONNECTIONS_PER_TUNNEL <= connection_count)
1078   {
1079     GCC_check_connections ();
1080     return;
1081   }
1082
1083   if (CADET_TUNNEL_SEARCHING == GCT_get_cstate (peer->tunnel))
1084   {
1085     LOG (GNUNET_ERROR_TYPE_DEBUG, " ... connect!\n");
1086     GCP_connect (peer);
1087   }
1088   GCC_check_connections ();
1089 }
1090
1091
1092 /**
1093  * Adjust core requested size to accomodate an ACK.
1094  *
1095  * @param message_size Requested size.
1096  *
1097  * @return Size enough to fit @c message_size and an ACK.
1098  */
1099 static size_t
1100 get_core_size (size_t message_size)
1101 {
1102   return message_size + sizeof (struct GNUNET_CADET_ACK);
1103 }
1104
1105 /**
1106  * Test if a message type is connection management traffic
1107  * or regular payload traffic.
1108  *
1109  * @param type Message type.
1110  *
1111  * @return #GNUNET_YES if connection management, #GNUNET_NO otherwise.
1112  */
1113 static int
1114 is_connection_management (uint16_t type)
1115 {
1116   return type == GNUNET_MESSAGE_TYPE_CADET_ACK ||
1117          type == GNUNET_MESSAGE_TYPE_CADET_POLL;
1118 }
1119
1120
1121 /**
1122  * Fill a core buffer with the appropriate data for the queued message.
1123  *
1124  * @param queue Queue element for the message.
1125  * @param buf Core buffer to fill.
1126  * @param size Size remaining in @c buf.
1127  * @param[out] pid In case its an encrypted payload, set payload.
1128  *
1129  * @return Bytes written to @c buf.
1130  */
1131 static size_t
1132 fill_buf (struct CadetPeerQueue *queue, void *buf, size_t size, uint32_t *pid)
1133 {
1134   struct CadetConnection *c = queue->c;
1135   size_t msg_size;
1136
1137   switch (queue->type)
1138   {
1139     case GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED:
1140       *pid = GCC_get_pid (queue->c, queue->fwd);
1141       LOG (GNUNET_ERROR_TYPE_DEBUG, "  otr payload ID %u\n", *pid);
1142       msg_size = send_core_data_raw (queue->cls, size, buf);
1143       ((struct GNUNET_CADET_Encrypted *) buf)->pid = htonl (*pid);
1144       break;
1145     case GNUNET_MESSAGE_TYPE_CADET_AX:
1146       *pid = GCC_get_pid (queue->c, queue->fwd);
1147       LOG (GNUNET_ERROR_TYPE_DEBUG, "  ax payload ID %u\n", *pid);
1148       msg_size = send_core_data_raw (queue->cls, size, buf);
1149       ((struct GNUNET_CADET_AX *) buf)->pid = htonl (*pid);
1150       break;
1151     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY:
1152     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN:
1153     case GNUNET_MESSAGE_TYPE_CADET_KX:
1154     case GNUNET_MESSAGE_TYPE_CADET_ACK:
1155     case GNUNET_MESSAGE_TYPE_CADET_POLL:
1156       LOG (GNUNET_ERROR_TYPE_DEBUG, "  raw %s\n", GC_m2s (queue->type));
1157       msg_size = send_core_data_raw (queue->cls, size, buf);
1158       break;
1159     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE:
1160       LOG (GNUNET_ERROR_TYPE_DEBUG, "  path create\n");
1161       if (GCC_is_origin (c, GNUNET_YES))
1162         msg_size = send_core_connection_create (c, size, buf);
1163       else
1164         msg_size = send_core_data_raw (queue->cls, size, buf);
1165       break;
1166     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK:
1167       LOG (GNUNET_ERROR_TYPE_DEBUG, "  path ack\n");
1168       if (GCC_is_origin (c, GNUNET_NO) ||
1169           GCC_is_origin (c, GNUNET_YES))
1170       {
1171         msg_size = send_core_connection_ack (c, size, buf);
1172       }
1173       else
1174       {
1175         msg_size = send_core_data_raw (queue->cls, size, buf);
1176       }
1177       break;
1178     case GNUNET_MESSAGE_TYPE_CADET_DATA:
1179     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE:
1180     case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY:
1181       /* This should be encapsulted */
1182       msg_size = 0;
1183       GNUNET_assert (0);
1184       break;
1185     default:
1186       GNUNET_break (0);
1187       LOG (GNUNET_ERROR_TYPE_WARNING, "  type unknown: %u\n", queue->type);
1188       msg_size = 0;
1189   }
1190
1191   GNUNET_assert (size >= msg_size);
1192
1193   return msg_size;
1194 }
1195
1196
1197 /**
1198  * Debug function should NEVER return true in production code, useful to
1199  * simulate losses for testcases.
1200  *
1201  * @param q Queue handle with info about the message.
1202  *
1203  * @return #GNUNET_YES or #GNUNET_NO with the decision to drop.
1204  */
1205 static int
1206 should_I_drop (struct CadetPeerQueue *q)
1207 {
1208   if (0 == drop_percent)
1209     return GNUNET_NO;
1210
1211   if (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 101) < drop_percent)
1212     return GNUNET_YES;
1213
1214   return GNUNET_NO;
1215 }
1216
1217
1218 /**
1219  * Core callback to write a queued packet to core buffer
1220  *
1221  * @param cls Closure (peer info).
1222  * @param size Number of bytes available in buf.
1223  * @param buf Where the to write the message.
1224  *
1225  * @return number of bytes written to buf
1226  */
1227 static size_t
1228 queue_send (void *cls, size_t size, void *buf)
1229 {
1230   struct CadetPeer *peer = cls;
1231   struct CadetConnection *c;
1232   struct CadetPeerQueue *queue;
1233   struct GNUNET_TIME_Relative core_wait_time;
1234   const char *wait_s;
1235   const struct GNUNET_PeerIdentity *dst_id;
1236   size_t msg_size;
1237   size_t total_size;
1238   size_t rest;
1239   char *dst;
1240   uint32_t pid;
1241
1242   GCC_check_connections ();
1243   LOG (GNUNET_ERROR_TYPE_DEBUG, "\n");
1244   LOG (GNUNET_ERROR_TYPE_DEBUG, "\n");
1245   LOG (GNUNET_ERROR_TYPE_DEBUG, "Queue send towards %s (max %u)\n",
1246        GCP_2s (peer), size);
1247
1248   /* Sanity checking */
1249   if (NULL == buf || 0 == size)
1250   {
1251     LOG (GNUNET_ERROR_TYPE_DEBUG, "  not allowed/\n");
1252     if (GNUNET_NO == in_shutdown)
1253     {
1254       queue = peer_get_first_message (peer);
1255       if (NULL == queue)
1256       {
1257         peer->core_transmit = NULL;
1258         peer->tmt_time.abs_value_us = 0;
1259         GCC_check_connections ();
1260         return 0;
1261       }
1262       dst_id = GNUNET_PEER_resolve2 (peer->id);
1263       peer->core_transmit =
1264           GNUNET_CORE_notify_transmit_ready (core_handle,
1265                                              GNUNET_NO, get_priority (queue),
1266                                              GNUNET_TIME_UNIT_FOREVER_REL,
1267                                              dst_id,
1268                                              get_core_size (queue->size),
1269                                              &queue_send,
1270                                              peer);
1271       peer->tmt_time = GNUNET_TIME_absolute_get ();
1272     }
1273     else
1274     {
1275       peer->core_transmit = NULL;
1276       peer->tmt_time.abs_value_us = 0;
1277     }
1278     GCC_check_connections ();
1279     return 0;
1280   }
1281
1282   /* Init */
1283   rest = size;
1284   total_size = 0;
1285   dst = (char *) buf;
1286   pid = 0;
1287   peer->core_transmit = NULL;
1288   queue = peer_get_first_message (peer);
1289   if (NULL == queue)
1290   {
1291     GNUNET_break (0); /* Core tmt_rdy should've been canceled */
1292     peer->tmt_time.abs_value_us = 0;
1293     return 0;
1294   }
1295   core_wait_time = GNUNET_TIME_absolute_get_duration (peer->tmt_time);
1296   wait_s = GNUNET_STRINGS_relative_time_to_string (core_wait_time, GNUNET_YES);
1297   if (core_wait_time.rel_value_us >= 1000000)
1298   {
1299     LOG (GNUNET_ERROR_TYPE_WARNING,
1300          " %s: core wait time %s (> 1 second) for %u bytes\n",
1301          GCP_2s (peer), wait_s, queue->size);
1302   }
1303   peer->tmt_time.abs_value_us = 0;
1304
1305   /* Copy all possible messages to the core buffer */
1306   while (NULL != queue && rest >= queue->size)
1307   {
1308     c = queue->c;
1309
1310     LOG (GNUNET_ERROR_TYPE_DEBUG, "  on conn %s %s\n",
1311          GCC_2s (c), GC_f2s(queue->fwd));
1312     LOG (GNUNET_ERROR_TYPE_DEBUG, "  size %u ok (%u/%u)\n",
1313          queue->size, total_size, size);
1314
1315     msg_size = fill_buf (queue, (void *) dst, size, &pid);
1316
1317     if (should_I_drop (queue))
1318     {
1319       LOG (GNUNET_ERROR_TYPE_WARNING, "DD %s (%s %u) on conn %s %s\n",
1320            GC_m2s (queue->type), GC_m2s (queue->payload_type),
1321            queue->payload_id, GCC_2s (c), GC_f2s (queue->fwd));
1322       msg_size = 0;
1323     }
1324     else
1325     {
1326       LOG (GNUNET_ERROR_TYPE_INFO,
1327            ">>> %s (%s %4u) on conn %s (%p) %s [%5u], after %s\n",
1328            GC_m2s (queue->type), GC_m2s (queue->payload_type),
1329            queue->payload_id, GCC_2s (c), c,
1330            GC_f2s (queue->fwd), msg_size, wait_s);
1331     }
1332     total_size += msg_size;
1333     rest -= msg_size;
1334     dst = &dst[msg_size];
1335     msg_size = 0;
1336
1337     /* Free queue, but cls was freed by send_core_* in fill_buf. */
1338     (void) GCP_queue_destroy (queue, GNUNET_NO, GNUNET_YES, pid);
1339
1340     /* Next! */
1341     queue = peer_get_first_message (peer);
1342   }
1343
1344   /* If more data in queue, send next */
1345   if (NULL != queue)
1346   {
1347     LOG (GNUNET_ERROR_TYPE_DEBUG, "  more data! (%u)\n", queue->size);
1348     if (NULL == peer->core_transmit)
1349     {
1350       dst_id = GNUNET_PEER_resolve2 (peer->id);
1351       peer->core_transmit =
1352           GNUNET_CORE_notify_transmit_ready (core_handle,
1353                                              GNUNET_NO, get_priority (queue),
1354                                              GNUNET_TIME_UNIT_FOREVER_REL,
1355                                              dst_id,
1356                                              get_core_size (queue->size),
1357                                              &queue_send,
1358                                              peer);
1359       peer->tmt_time = GNUNET_TIME_absolute_get ();
1360       queue->start_waiting = GNUNET_TIME_absolute_get ();
1361     }
1362     else
1363     {
1364       LOG (GNUNET_ERROR_TYPE_DEBUG, "*   tmt rdy called somewhere else\n");
1365     }
1366 //     GCC_start_poll (); FIXME needed?
1367   }
1368   else
1369   {
1370 //     GCC_stop_poll(); FIXME needed?
1371   }
1372
1373   LOG (GNUNET_ERROR_TYPE_DEBUG, "  return %d\n", total_size);
1374   queue_debug (peer, GNUNET_ERROR_TYPE_DEBUG);
1375   GCC_check_connections ();
1376   return total_size;
1377 }
1378
1379
1380 /******************************************************************************/
1381 /********************************    API    ***********************************/
1382 /******************************************************************************/
1383
1384
1385 /**
1386  * Free a transmission that was already queued with all resources
1387  * associated to the request.
1388  *
1389  * If connection was marked to be destroyed, and this was the last queued
1390  * message on it, the connection will be free'd as a result.
1391  *
1392  * @param queue Queue handler to cancel.
1393  * @param clear_cls Is it necessary to free associated cls?
1394  * @param sent Was it really sent? (Could have been canceled)
1395  * @param pid PID, if relevant (was sent and was a payload message).
1396  *
1397  * @return #GNUNET_YES if connection was destroyed as a result,
1398  *         #GNUNET_NO otherwise.
1399  */
1400 int
1401 GCP_queue_destroy (struct CadetPeerQueue *queue,
1402                    int clear_cls,
1403                    int sent,
1404                    uint32_t pid)
1405 {
1406   struct CadetPeer *peer;
1407   int connection_destroyed;
1408
1409   GCC_check_connections ();
1410   peer = queue->peer;
1411   LOG (GNUNET_ERROR_TYPE_DEBUG, "queue destroy %s\n", GC_m2s (queue->type));
1412   if (GNUNET_YES == clear_cls)
1413   {
1414     LOG (GNUNET_ERROR_TYPE_DEBUG, " free cls\n");
1415     switch (queue->type)
1416     {
1417       case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY:
1418         LOG (GNUNET_ERROR_TYPE_INFO, "destroying a DESTROY message\n");
1419         /* fall through */
1420       case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK:
1421       case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE:
1422       case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN:
1423       case GNUNET_MESSAGE_TYPE_CADET_KX:
1424       case GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED:
1425       case GNUNET_MESSAGE_TYPE_CADET_AX:
1426       case GNUNET_MESSAGE_TYPE_CADET_ACK:
1427       case GNUNET_MESSAGE_TYPE_CADET_POLL:
1428         GNUNET_free_non_null (queue->cls);
1429         break;
1430
1431       default:
1432         GNUNET_break (0);
1433         LOG (GNUNET_ERROR_TYPE_ERROR, " type %s unknown!\n",
1434              GC_m2s (queue->type));
1435     }
1436   }
1437   GNUNET_CONTAINER_DLL_remove (peer->queue_head, peer->queue_tail, queue);
1438
1439   if (!is_connection_management (queue->type))
1440   {
1441     peer->queue_n--;
1442   }
1443
1444   if (NULL != queue->cont)
1445   {
1446     struct GNUNET_TIME_Relative wait_time;
1447
1448     wait_time = GNUNET_TIME_absolute_get_duration (queue->start_waiting);
1449     LOG (GNUNET_ERROR_TYPE_DEBUG, " calling callback, time elapsed %s\n",
1450          GNUNET_STRINGS_relative_time_to_string (wait_time, GNUNET_NO));
1451     connection_destroyed = queue->cont (queue->cont_cls,
1452                                         queue->c, sent, queue->type, pid,
1453                                         queue->fwd, queue->size, wait_time);
1454   }
1455   else
1456   {
1457     connection_destroyed = GNUNET_NO;
1458   }
1459
1460   if (NULL == peer_get_first_message (peer) && NULL != peer->core_transmit)
1461   {
1462     GNUNET_CORE_notify_transmit_ready_cancel (peer->core_transmit);
1463     peer->core_transmit = NULL;
1464     peer->tmt_time.abs_value_us = 0;
1465   }
1466
1467   GNUNET_free (queue);
1468   GCC_check_connections ();
1469   return connection_destroyed;
1470 }
1471
1472
1473 /**
1474  * @brief Queue and pass message to core when possible.
1475  *
1476  * @param peer Peer towards which to queue the message.
1477  * @param cls Closure (@c type dependant). It will be used by queue_send to
1478  *            build the message to be sent if not already prebuilt.
1479  * @param type Type of the message.
1480  * @param payload_type Type of the message's payload
1481  *                     0 if the message is a retransmission (unknown payload).
1482  *                     UINT16_MAX if the message does not have payload.
1483  * @param payload_id ID of the payload (MID, ACK #, etc)
1484  * @param size Size of the message.
1485  * @param c Connection this message belongs to (can be NULL).
1486  * @param fwd Is this a message going root->dest? (FWD ACK are NOT FWD!)
1487  * @param cont Continuation to be called once CORE has taken the message.
1488  * @param cont_cls Closure for @c cont.
1489  *
1490  * @return Handle to cancel the message before it is sent. Once cont is called
1491  *         message has been sent and therefore the handle is no longer valid.
1492  */
1493 struct CadetPeerQueue *
1494 GCP_queue_add (struct CadetPeer *peer,
1495                void *cls,
1496                uint16_t type,
1497                uint16_t payload_type,
1498                uint32_t payload_id,
1499                size_t size,
1500                struct CadetConnection *c,
1501                int fwd,
1502                GCP_sent cont,
1503                void *cont_cls)
1504 {
1505   struct CadetPeerQueue *q;
1506   int priority;
1507   int call_core;
1508
1509   GCC_check_connections ();
1510   LOG (GNUNET_ERROR_TYPE_DEBUG,
1511        "que %s (%s %4u) on conn %s (%p) %s towards %s (size %u)\n",
1512        GC_m2s (type), GC_m2s (payload_type), payload_id,
1513        GCC_2s (c), c, GC_f2s (fwd), GCP_2s (peer), size);
1514
1515   if (NULL == peer->connections)
1516   {
1517     /* We are not connected to this peer, ignore request. */
1518     LOG (GNUNET_ERROR_TYPE_INFO, "%s not a neighbor\n", GCP_2s (peer));
1519     GNUNET_STATISTICS_update (stats, "# messages dropped due to wrong hop", 1,
1520                               GNUNET_NO);
1521     return NULL;
1522   }
1523
1524   priority = 0;
1525   if (is_connection_management (type))
1526   {
1527     priority = 100;
1528   }
1529   LOG (GNUNET_ERROR_TYPE_DEBUG, "priority %d\n", priority);
1530
1531   call_core = (NULL == c || GNUNET_MESSAGE_TYPE_CADET_KX == type) ?
1532                GNUNET_YES : GCC_is_sendable (c, fwd);
1533   q = GNUNET_new (struct CadetPeerQueue);
1534   q->cls = cls;
1535   q->type = type;
1536   q->payload_type = payload_type;
1537   q->payload_id = payload_id;
1538   q->size = size;
1539   q->peer = peer;
1540   q->c = c;
1541   q->fwd = fwd;
1542   q->cont = cont;
1543   q->cont_cls = cont_cls;
1544   if (100 > priority)
1545   {
1546     GNUNET_CONTAINER_DLL_insert_tail (peer->queue_head, peer->queue_tail, q);
1547     peer->queue_n++;
1548   }
1549   else
1550   {
1551     GNUNET_CONTAINER_DLL_insert (peer->queue_head, peer->queue_tail, q);
1552     call_core = GNUNET_YES;
1553   }
1554
1555   q->start_waiting = GNUNET_TIME_absolute_get ();
1556   if (NULL == peer->core_transmit && GNUNET_YES == call_core)
1557   {
1558     LOG (GNUNET_ERROR_TYPE_DEBUG,
1559          "calling core tmt rdy towards %s for %u bytes\n",
1560          GCP_2s (peer), size);
1561     peer->core_transmit =
1562         GNUNET_CORE_notify_transmit_ready (core_handle,
1563                                            GNUNET_NO, get_priority (q),
1564                                            GNUNET_TIME_UNIT_FOREVER_REL,
1565                                            GNUNET_PEER_resolve2 (peer->id),
1566                                            get_core_size (size),
1567                                            &queue_send, peer);
1568     peer->tmt_time = GNUNET_TIME_absolute_get ();
1569   }
1570   else if (GNUNET_NO == call_core)
1571   {
1572     LOG (GNUNET_ERROR_TYPE_DEBUG, "core tmt rdy towards %s not needed\n",
1573          GCP_2s (peer));
1574
1575   }
1576   else
1577   {
1578     struct GNUNET_TIME_Relative elapsed;
1579     elapsed = GNUNET_TIME_absolute_get_duration (peer->tmt_time);
1580     LOG (GNUNET_ERROR_TYPE_DEBUG, "core tmt rdy towards %s already called %s\n",
1581          GCP_2s (peer),
1582          GNUNET_STRINGS_relative_time_to_string (elapsed, GNUNET_NO));
1583
1584   }
1585   queue_debug (peer, GNUNET_ERROR_TYPE_DEBUG);
1586   GCC_check_connections ();
1587   return q;
1588 }
1589
1590
1591 /**
1592  * Cancel all queued messages to a peer that belong to a certain connection.
1593  *
1594  * @param peer Peer towards whom to cancel.
1595  * @param c Connection whose queued messages to cancel. Might be destroyed by
1596  *          the sent continuation call.
1597  */
1598 void
1599 GCP_queue_cancel (struct CadetPeer *peer,
1600                   struct CadetConnection *c)
1601 {
1602   struct CadetPeerQueue *q;
1603   struct CadetPeerQueue *next;
1604   struct CadetPeerQueue *prev;
1605   int connection_destroyed;
1606
1607   GCC_check_connections ();
1608   connection_destroyed = GNUNET_NO;
1609   for (q = peer->queue_head; NULL != q; q = next)
1610   {
1611     prev = q->prev;
1612     if (q->c == c)
1613     {
1614       LOG (GNUNET_ERROR_TYPE_DEBUG,
1615            "GMP queue cancel %s\n",
1616            GC_m2s (q->type));
1617       GNUNET_assert (GNUNET_NO == connection_destroyed);
1618       if (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY == q->type)
1619       {
1620         q->c = NULL;
1621       }
1622       else
1623       {
1624         connection_destroyed = GCP_queue_destroy (q, GNUNET_YES, GNUNET_NO, 0);
1625       }
1626
1627       /* Get next from prev, q->next might be already freed:
1628        * queue destroy -> callback -> GCC_destroy -> cancel_queues -> here
1629        */
1630       if (NULL == prev)
1631         next = peer->queue_head;
1632       else
1633         next = prev->next;
1634     }
1635     else
1636     {
1637       next = q->next;
1638     }
1639   }
1640
1641   if ( (NULL == peer->queue_head) &&
1642        (NULL != peer->core_transmit) )
1643   {
1644     GNUNET_CORE_notify_transmit_ready_cancel (peer->core_transmit);
1645     peer->core_transmit = NULL;
1646     peer->tmt_time.abs_value_us = 0;
1647   }
1648   GCC_check_connections ();
1649 }
1650
1651
1652 /**
1653  * Get the first transmittable message for a connection.
1654  *
1655  * @param peer Neighboring peer.
1656  * @param c Connection.
1657  *
1658  * @return First transmittable message.
1659  */
1660 static struct CadetPeerQueue *
1661 connection_get_first_message (struct CadetPeer *peer, struct CadetConnection *c)
1662 {
1663   struct CadetPeerQueue *q;
1664
1665   for (q = peer->queue_head; NULL != q; q = q->next)
1666   {
1667     if (q->c != c)
1668       continue;
1669     if (queue_is_sendable (q))
1670     {
1671       LOG (GNUNET_ERROR_TYPE_DEBUG, "  sendable!!\n");
1672       return q;
1673     }
1674     LOG (GNUNET_ERROR_TYPE_DEBUG, "  not sendable\n");
1675   }
1676
1677   return NULL;
1678 }
1679
1680
1681 /**
1682  * Get the first message for a connection and unqueue it.
1683  *
1684  * Only tunnel (or higher) level messages are unqueued. Connection specific
1685  * messages are silently destroyed upon encounter.
1686  *
1687  * @param peer Neighboring peer.
1688  * @param c Connection.
1689  * @param destroyed[in/out] Was the connection destroyed (prev/as a result)?.
1690  *                          Can NOT be NULL.
1691  *
1692  * @return First message for this connection.
1693  */
1694 struct GNUNET_MessageHeader *
1695 GCP_connection_pop (struct CadetPeer *peer,
1696                     struct CadetConnection *c,
1697                     int *destroyed)
1698 {
1699   struct CadetPeerQueue *q;
1700   struct CadetPeerQueue *next;
1701   struct GNUNET_MessageHeader *msg;
1702   int dest;
1703
1704   GCC_check_connections ();
1705   GNUNET_assert (NULL != destroyed);
1706   LOG (GNUNET_ERROR_TYPE_DEBUG, "connection_pop on conn %p\n", c);
1707   for (q = peer->queue_head; NULL != q; q = next)
1708   {
1709     next = q->next;
1710     if (q->c != c)
1711       continue;
1712     LOG (GNUNET_ERROR_TYPE_DEBUG, " - queued: %s (%s %u), cont: %p\n",
1713          GC_m2s (q->type), GC_m2s (q->payload_type), q->payload_id,
1714          q->cont);
1715     switch (q->type)
1716     {
1717       case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE:
1718       case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK:
1719       case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY:
1720       case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN:
1721       case GNUNET_MESSAGE_TYPE_CADET_ACK:
1722       case GNUNET_MESSAGE_TYPE_CADET_POLL:
1723         dest = GCP_queue_destroy (q, GNUNET_YES, GNUNET_NO, 0);
1724         if (GNUNET_YES == dest)
1725         {
1726           GNUNET_break (GNUNET_NO == *destroyed);
1727           *destroyed = GNUNET_YES;
1728         }
1729         continue;
1730
1731       case GNUNET_MESSAGE_TYPE_CADET_KX:
1732       case GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED:
1733       case GNUNET_MESSAGE_TYPE_CADET_AX:
1734       case GNUNET_MESSAGE_TYPE_CADET_AX_KX:
1735         msg = (struct GNUNET_MessageHeader *) q->cls;
1736         dest = GCP_queue_destroy (q, GNUNET_NO, GNUNET_NO, 0);
1737         if (GNUNET_YES == dest)
1738         {
1739           GNUNET_break (GNUNET_NO == *destroyed);
1740           *destroyed = GNUNET_YES;
1741         }
1742         return msg;
1743
1744       default:
1745         GNUNET_break (0);
1746         LOG (GNUNET_ERROR_TYPE_DEBUG, "Unknown message %s\n", GC_m2s (q->type));
1747     }
1748   }
1749   GCC_check_connections ();
1750   return NULL;
1751 }
1752
1753
1754 /**
1755  * Unlock a possibly locked queue for a connection.
1756  *
1757  * If there is a message that can be sent on this connection, call core for it.
1758  * Otherwise (if core transmit is already called or there is no sendable
1759  * message) do nothing.
1760  *
1761  * @param peer Peer who keeps the queue.
1762  * @param c Connection whose messages to unlock.
1763  */
1764 void
1765 GCP_queue_unlock (struct CadetPeer *peer, struct CadetConnection *c)
1766 {
1767   struct CadetPeerQueue *q;
1768   size_t size;
1769
1770   GCC_check_connections ();
1771   if (NULL != peer->core_transmit)
1772   {
1773     LOG (GNUNET_ERROR_TYPE_DEBUG, "  already unlocked!\n");
1774     return; /* Already unlocked */
1775   }
1776
1777   q = connection_get_first_message (peer, c);
1778   if (NULL == q)
1779   {
1780     LOG (GNUNET_ERROR_TYPE_DEBUG, "  queue empty!\n");
1781     return; /* Nothing to transmit */
1782   }
1783
1784   size = q->size;
1785   peer->core_transmit =
1786       GNUNET_CORE_notify_transmit_ready (core_handle,
1787                                          GNUNET_NO, get_priority (q),
1788                                          GNUNET_TIME_UNIT_FOREVER_REL,
1789                                          GNUNET_PEER_resolve2 (peer->id),
1790                                          get_core_size (size),
1791                                          &queue_send,
1792                                          peer);
1793   peer->tmt_time = GNUNET_TIME_absolute_get ();
1794   GCC_check_connections ();
1795 }
1796
1797
1798 /**
1799  * Initialize the peer subsystem.
1800  *
1801  * @param c Configuration.
1802  */
1803 void
1804 GCP_init (const struct GNUNET_CONFIGURATION_Handle *c)
1805 {
1806   LOG (GNUNET_ERROR_TYPE_DEBUG,
1807        "GCP_init\n");
1808   in_shutdown = GNUNET_NO;
1809   peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
1810   if (GNUNET_OK !=
1811       GNUNET_CONFIGURATION_get_value_number (c, "CADET", "MAX_PEERS",
1812                                              &max_peers))
1813   {
1814     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
1815                                "CADET", "MAX_PEERS", "USING DEFAULT");
1816     max_peers = 1000;
1817   }
1818
1819   if (GNUNET_OK !=
1820       GNUNET_CONFIGURATION_get_value_number (c, "CADET", "DROP_PERCENT",
1821                                              &drop_percent))
1822   {
1823     drop_percent = 0;
1824   }
1825   else
1826   {
1827     LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1828     LOG (GNUNET_ERROR_TYPE_WARNING, "Cadet is running with DROP enabled.\n");
1829     LOG (GNUNET_ERROR_TYPE_WARNING, "This is NOT a good idea!\n");
1830     LOG (GNUNET_ERROR_TYPE_WARNING, "Remove DROP_PERCENT from config file.\n");
1831     LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1832   }
1833   ats_ch = GNUNET_ATS_connectivity_init (c);
1834   core_handle = GNUNET_CORE_connect (c, /* Main configuration */
1835                                      NULL,      /* Closure passed to CADET functions */
1836                                      &core_init,        /* Call core_init once connected */
1837                                      &core_connect,     /* Handle connects */
1838                                      &core_disconnect,  /* remove peers on disconnects */
1839                                      NULL,      /* Don't notify about all incoming messages */
1840                                      GNUNET_NO, /* For header only in notification */
1841                                      NULL,      /* Don't notify about all outbound messages */
1842                                      GNUNET_NO, /* For header-only out notification */
1843                                      core_handlers);    /* Register these handlers */
1844   if (GNUNET_YES !=
1845       GNUNET_CONFIGURATION_get_value_yesno (c, "CADET", "DISABLE_TRY_CONNECT"))
1846   {
1847     transport_handle = GNUNET_TRANSPORT_connect (c, &my_full_id, NULL, /* cls */
1848                                                  /* Notify callbacks */
1849                                                  NULL, NULL, NULL);
1850   }
1851   else
1852   {
1853     LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1854     LOG (GNUNET_ERROR_TYPE_WARNING, "*  DISABLE TRYING CONNECT in config  *\n");
1855     LOG (GNUNET_ERROR_TYPE_WARNING, "*  Use this only for test purposes.  *\n");
1856     LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1857     transport_handle = NULL;
1858   }
1859
1860
1861
1862   if (NULL == core_handle)
1863   {
1864     GNUNET_break (0);
1865     GNUNET_SCHEDULER_shutdown ();
1866     return;
1867   }
1868
1869 }
1870
1871
1872 /**
1873  * Shut down the peer subsystem.
1874  */
1875 void
1876 GCP_shutdown (void)
1877 {
1878   LOG (GNUNET_ERROR_TYPE_DEBUG,
1879        "Shutting down peer subsystem\n");
1880   in_shutdown = GNUNET_YES;
1881   GNUNET_CONTAINER_multipeermap_iterate (peers,
1882                                          &shutdown_peer,
1883                                          NULL);
1884   if (NULL != core_handle)
1885   {
1886     GNUNET_CORE_disconnect (core_handle);
1887     core_handle = NULL;
1888   }
1889   if (NULL != transport_handle)
1890   {
1891     GNUNET_TRANSPORT_disconnect (transport_handle);
1892     transport_handle = NULL;
1893   }
1894   if (NULL != ats_ch)
1895   {
1896     GNUNET_ATS_connectivity_done (ats_ch);
1897     ats_ch = NULL;
1898   }
1899   GNUNET_PEER_change_rc (myid, -1);
1900   GNUNET_CONTAINER_multipeermap_destroy (peers);
1901   peers = NULL;
1902 }
1903
1904
1905 /**
1906  * Retrieve the CadetPeer stucture associated with the peer. Optionally create
1907  * one and insert it in the appropriate structures if the peer is not known yet.
1908  *
1909  * @param peer_id Full identity of the peer.
1910  * @param create #GNUNET_YES if a new peer should be created if unknown.
1911  *               #GNUNET_NO otherwise.
1912  *
1913  * @return Existing or newly created peer structure.
1914  *         NULL if unknown and not requested @a create
1915  */
1916 struct CadetPeer *
1917 GCP_get (const struct GNUNET_PeerIdentity *peer_id, int create)
1918 {
1919   struct CadetPeer *peer;
1920
1921   peer = GNUNET_CONTAINER_multipeermap_get (peers, peer_id);
1922   if (NULL == peer)
1923   {
1924     peer = GNUNET_new (struct CadetPeer);
1925     if (GNUNET_CONTAINER_multipeermap_size (peers) > max_peers)
1926     {
1927       peer_delete_oldest ();
1928     }
1929     GNUNET_assert (GNUNET_OK ==
1930                    GNUNET_CONTAINER_multipeermap_put (peers,
1931                                                       peer_id,
1932                                                       peer,
1933                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
1934     peer->id = GNUNET_PEER_intern (peer_id);
1935   }
1936   peer->last_contact = GNUNET_TIME_absolute_get ();
1937
1938   return peer;
1939 }
1940
1941
1942 /**
1943  * Retrieve the CadetPeer stucture associated with the
1944  * peer. Optionally create one and insert it in the appropriate
1945  * structures if the peer is not known yet.
1946  *
1947  * @param peer Short identity of the peer.
1948  * @param create #GNUNET_YES if a new peer should be created if unknown.
1949  *               #GNUNET_NO otherwise.
1950  *
1951  * @return Existing or newly created peer structure.
1952  *         NULL if unknown and not requested @a create
1953  */
1954 struct CadetPeer *
1955 GCP_get_short (const GNUNET_PEER_Id peer, int create)
1956 {
1957   return GCP_get (GNUNET_PEER_resolve2 (peer), create);
1958 }
1959
1960
1961 /**
1962  * Function called once #GNUNET_TRANSPORT_offer_hello() is done.
1963  * Marks the operation as finished.
1964  *
1965  * @param cls Closure (our `struct CadetPeer`).
1966  */
1967 static void
1968 hello_offer_done (void *cls)
1969 {
1970   struct CadetPeer *peer = cls;
1971
1972   peer->hello_offer = NULL;
1973 }
1974
1975
1976 /**
1977  * Try to establish a new connection to this peer (in its tunnel).
1978  * If the peer doesn't have any path to it yet, try to get one.
1979  * If the peer already has some path, send a CREATE CONNECTION towards it.
1980  *
1981  * @param peer Peer to connect to.
1982  */
1983 void
1984 GCP_connect (struct CadetPeer *peer)
1985 {
1986   struct CadetTunnel *t;
1987   struct CadetPeerPath *path;
1988   struct CadetConnection *c;
1989   int rerun_search;
1990
1991   GCC_check_connections ();
1992   LOG (GNUNET_ERROR_TYPE_DEBUG,
1993        "peer_connect towards %s\n",
1994        GCP_2s (peer));
1995   /* If we have a current hello, try to connect using it. */
1996   GCP_try_connect (peer);
1997
1998   t = peer->tunnel;
1999   c = NULL;
2000   rerun_search = GNUNET_NO;
2001
2002   if (NULL != peer->path_head)
2003   {
2004     LOG (GNUNET_ERROR_TYPE_DEBUG, "  some path exists\n");
2005     path = peer_get_best_path (peer);
2006     if (NULL != path)
2007     {
2008       char *s;
2009
2010       s = path_2s (path);
2011       LOG (GNUNET_ERROR_TYPE_DEBUG, "  path to use: %s\n", s);
2012       GNUNET_free (s);
2013
2014       c = GCT_use_path (t, path);
2015       if (NULL == c)
2016       {
2017         /* This case can happen when the path includes a first hop that is
2018          * not yet known to be connected.
2019          *
2020          * This happens quite often during testing when running cadet
2021          * under valgrind: core connect notifications come very late
2022          * and the DHT result has already come and created a valid
2023          * path.  In this case, the peer->connections
2024          * hashmaps will be NULL and tunnel_use_path will not be able
2025          * to create a connection from that path.
2026          *
2027          * Re-running the DHT GET should give core time to callback.
2028          *
2029          * GCT_use_path -> GCC_new -> register_neighbors takes care of
2030          * updating statistics about this issue.
2031          */
2032         rerun_search = GNUNET_YES;
2033       }
2034       else
2035       {
2036         GCC_send_create (c);
2037         return;
2038       }
2039     }
2040     else
2041     {
2042       LOG (GNUNET_ERROR_TYPE_DEBUG, "  but is NULL, all paths are in use\n");
2043     }
2044   }
2045
2046   if (GNUNET_YES == rerun_search)
2047   {
2048     struct GNUNET_TIME_Relative delay;
2049
2050     GCP_stop_search (peer);
2051     delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100);
2052     peer->search_delayed = GNUNET_SCHEDULER_add_delayed (delay,
2053                                                          &delayed_search,
2054                                                          peer);
2055     GCC_check_connections ();
2056     return;
2057   }
2058
2059   if (GNUNET_NO == is_searching (peer))
2060     GCP_start_search (peer);
2061   GCC_check_connections ();
2062 }
2063
2064
2065 /**
2066  * Chech whether there is a direct (core level)  connection to peer.
2067  *
2068  * @param peer Peer to check.
2069  *
2070  * @return #GNUNET_YES if there is a direct connection.
2071  */
2072 int
2073 GCP_is_neighbor (const struct CadetPeer *peer)
2074 {
2075   struct CadetPeerPath *path;
2076
2077   if (NULL == peer->connections)
2078     return GNUNET_NO;
2079
2080   for (path = peer->path_head; NULL != path; path = path->next)
2081   {
2082     if (3 > path->length)
2083       return GNUNET_YES;
2084   }
2085
2086   /* Is not a neighbor but connections is not NULL, probably disconnecting */
2087   GNUNET_break (0);
2088   return GNUNET_NO;
2089 }
2090
2091
2092 /**
2093  * Create and initialize a new tunnel towards a peer, in case it has none.
2094  * In case the peer already has a tunnel, nothing is done.
2095  *
2096  * Does not generate any traffic, just creates the local data structures.
2097  *
2098  * @param peer Peer towards which to create the tunnel.
2099  */
2100 void
2101 GCP_add_tunnel (struct CadetPeer *peer)
2102 {
2103   GCC_check_connections ();
2104   if (NULL != peer->tunnel)
2105     return;
2106   peer->tunnel = GCT_new (peer);
2107   GCC_check_connections ();
2108 }
2109
2110
2111 /**
2112  * Add a connection to a neighboring peer.
2113  *
2114  * Store that the peer is the first hop of the connection in one
2115  * direction and that on peer disconnect the connection must be
2116  * notified and destroyed, for it will no longer be valid.
2117  *
2118  * @param peer Peer to add connection to.
2119  * @param c Connection to add.
2120  * @param pred #GNUNET_YES if we are predecessor, #GNUNET_NO if we are successor
2121  */
2122 void
2123 GCP_add_connection (struct CadetPeer *peer,
2124                     struct CadetConnection *c,
2125                     int pred)
2126 {
2127   LOG (GNUNET_ERROR_TYPE_DEBUG,
2128        "adding connection %s\n",
2129        GCC_2s (c));
2130   LOG (GNUNET_ERROR_TYPE_DEBUG,
2131        "to peer %s\n",
2132        GCP_2s (peer));
2133   GNUNET_assert (NULL != peer->connections);
2134   GNUNET_assert (GNUNET_OK ==
2135                  GNUNET_CONTAINER_multihashmap_put (peer->connections,
2136                                                     GCC_get_h (c),
2137                                                     c,
2138                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
2139   LOG (GNUNET_ERROR_TYPE_DEBUG,
2140        "Peer %s has now %u connections.\n",
2141        GCP_2s (peer),
2142        GNUNET_CONTAINER_multihashmap_size (peer->connections));
2143 }
2144
2145
2146 /**
2147  * Add the path to the peer and update the path used to reach it in case this
2148  * is the shortest.
2149  *
2150  * @param peer Destination peer to add the path to.
2151  * @param path New path to add. Last peer must be @c peer.
2152  *             Path will be either used of freed if already known.
2153  * @param trusted Do we trust that this path is real?
2154  *
2155  * @return path if path was taken, pointer to existing duplicate if exists
2156  *         NULL on error.
2157  */
2158 struct CadetPeerPath *
2159 GCP_add_path (struct CadetPeer *peer,
2160               struct CadetPeerPath *path,
2161               int trusted)
2162 {
2163   struct CadetPeerPath *aux;
2164   unsigned int l;
2165   unsigned int l2;
2166
2167   GCC_check_connections ();
2168   LOG (GNUNET_ERROR_TYPE_DEBUG,
2169        "adding path [%u] to peer %s\n",
2170        path->length, GCP_2s (peer));
2171
2172   if (NULL == peer || NULL == path
2173       || path->peers[path->length - 1] != peer->id)
2174   {
2175     GNUNET_break (0);
2176     path_destroy (path);
2177     return NULL;
2178   }
2179
2180   for (l = 1; l < path->length; l++)
2181   {
2182     if (path->peers[l] == myid)
2183     {
2184       LOG (GNUNET_ERROR_TYPE_DEBUG, " shortening path by %u\n", l);
2185       for (l2 = 0; l2 < path->length - l; l2++)
2186       {
2187         path->peers[l2] = path->peers[l + l2];
2188       }
2189       path->length -= l;
2190       l = 1;
2191       path->peers = GNUNET_realloc (path->peers,
2192                                     path->length * sizeof (GNUNET_PEER_Id));
2193     }
2194   }
2195
2196   LOG (GNUNET_ERROR_TYPE_DEBUG, " final length: %u\n", path->length);
2197
2198   if (2 >= path->length && GNUNET_NO == trusted)
2199   {
2200     /* Only allow CORE to tell us about direct paths */
2201     path_destroy (path);
2202     return NULL;
2203   }
2204
2205   l = path_get_length (path);
2206   if (0 == l)
2207   {
2208     path_destroy (path);
2209     return NULL;
2210   }
2211
2212   GNUNET_assert (peer->id == path->peers[path->length - 1]);
2213   for (aux = peer->path_head; aux != NULL; aux = aux->next)
2214   {
2215     l2 = path_get_length (aux);
2216     if (l2 > l)
2217     {
2218       LOG (GNUNET_ERROR_TYPE_DEBUG, "  added\n");
2219       GNUNET_CONTAINER_DLL_insert_before (peer->path_head,
2220                                           peer->path_tail, aux, path);
2221       goto finish;
2222     }
2223     else
2224     {
2225       if (l2 == l && memcmp (path->peers, aux->peers, l) == 0)
2226       {
2227         LOG (GNUNET_ERROR_TYPE_DEBUG, "  already known\n");
2228         path_destroy (path);
2229         return aux;
2230       }
2231     }
2232   }
2233   GNUNET_CONTAINER_DLL_insert_tail (peer->path_head,
2234                                     peer->path_tail,
2235                                     path);
2236   LOG (GNUNET_ERROR_TYPE_DEBUG, "  added last\n");
2237
2238 finish:
2239   if (NULL != peer->tunnel
2240       && CONNECTIONS_PER_TUNNEL > GCT_count_connections (peer->tunnel)
2241       && 2 < path->length) /* Direct paths are handled by core_connect */
2242   {
2243     GCP_connect (peer);
2244   }
2245   GCC_check_connections ();
2246   return path;
2247 }
2248
2249
2250 /**
2251  * Add the path to the origin peer and update the path used to reach it in case
2252  * this is the shortest.
2253  * The path is given in peer_info -> destination, therefore we turn the path
2254  * upside down first.
2255  *
2256  * @param peer Peer to add the path to, being the origin of the path.
2257  * @param path New path to add after being inversed.
2258  *             Path will be either used or freed.
2259  * @param trusted Do we trust that this path is real?
2260  *
2261  * @return path if path was taken, pointer to existing duplicate if exists
2262  *         NULL on error.
2263  */
2264 struct CadetPeerPath *
2265 GCP_add_path_to_origin (struct CadetPeer *peer,
2266                         struct CadetPeerPath *path,
2267                         int trusted)
2268 {
2269   if (NULL == path)
2270     return NULL;
2271   path_invert (path);
2272   return GCP_add_path (peer, path, trusted);
2273 }
2274
2275
2276 /**
2277  * Adds a path to the info of all the peers in the path
2278  *
2279  * @param p Path to process.
2280  * @param confirmed Whether we know if the path works or not.
2281  */
2282 void
2283 GCP_add_path_to_all (const struct CadetPeerPath *p, int confirmed)
2284 {
2285   unsigned int i;
2286
2287   /* TODO: invert and add */
2288   GCC_check_connections ();
2289   for (i = 0; i < p->length && p->peers[i] != myid; i++) /* skip'em */ ;
2290   for (i++; i < p->length; i++)
2291   {
2292     struct CadetPeer *peer;
2293     struct CadetPeerPath *copy;
2294
2295     peer = GCP_get_short (p->peers[i], GNUNET_YES);
2296     copy = path_duplicate (p);
2297     copy->length = i + 1;
2298     GCP_add_path (peer, copy, 3 > p->length ? GNUNET_NO : confirmed);
2299   }
2300   GCC_check_connections ();
2301 }
2302
2303
2304 /**
2305  * Remove any path to the peer that has the exact same peers as the one given.
2306  *
2307  * @param peer Peer to remove the path from.
2308  * @param path Path to remove. Is always destroyed .
2309  */
2310 void
2311 GCP_remove_path (struct CadetPeer *peer,
2312                  struct CadetPeerPath *path)
2313 {
2314   struct CadetPeerPath *iter;
2315   struct CadetPeerPath *next;
2316
2317   GCC_check_connections ();
2318   GNUNET_assert (myid == path->peers[0]);
2319   GNUNET_assert (peer->id == path->peers[path->length - 1]);
2320
2321   LOG (GNUNET_ERROR_TYPE_INFO,
2322        "Removing path %p (%u) from %s\n",
2323        path, path->length, GCP_2s (peer));
2324
2325   for (iter = peer->path_head; NULL != iter; iter = next)
2326   {
2327     next = iter->next;
2328     if (0 == path_cmp (path, iter))
2329     {
2330       GNUNET_CONTAINER_DLL_remove (peer->path_head,
2331                                    peer->path_tail,
2332                                    iter);
2333       if (iter != path)
2334         path_destroy (iter);
2335     }
2336   }
2337   path_destroy (path);
2338   GCC_check_connections ();
2339 }
2340
2341
2342 /**
2343  * Check that we are aware of a connection from a neighboring peer.
2344  *
2345  * @param peer Peer to the connection is with
2346  * @param c Connection that should be in the map with this peer.
2347  */
2348 void
2349 GCP_check_connection (const struct CadetPeer *peer,
2350                       const struct CadetConnection *c)
2351 {
2352   GNUNET_assert (NULL != peer);
2353   GNUNET_assert (NULL != peer->connections);
2354     return;
2355   GNUNET_assert (GNUNET_YES ==
2356                  GNUNET_CONTAINER_multihashmap_contains_value (peer->connections,
2357                                                                GCC_get_h (c),
2358                                                                c));
2359 }
2360
2361
2362 /**
2363  * Remove a connection from a neighboring peer.
2364  *
2365  * @param peer Peer to remove connection from.
2366  * @param c Connection to remove.
2367  */
2368 void
2369 GCP_remove_connection (struct CadetPeer *peer,
2370                        const struct CadetConnection *c)
2371 {
2372   LOG (GNUNET_ERROR_TYPE_DEBUG,
2373        "Removing connection %s\n",
2374        GCC_2s (c));
2375   LOG (GNUNET_ERROR_TYPE_DEBUG,
2376        "from peer %s\n",
2377        GCP_2s (peer));
2378   if ( (NULL == peer) ||
2379        (NULL == peer->connections) )
2380     return;
2381   GNUNET_assert (GNUNET_YES ==
2382                  GNUNET_CONTAINER_multihashmap_remove (peer->connections,
2383                                                        GCC_get_h (c),
2384                                                        c));
2385   LOG (GNUNET_ERROR_TYPE_DEBUG,
2386        "Peer %s remains with %u connections.\n",
2387        GCP_2s (peer),
2388        GNUNET_CONTAINER_multihashmap_size (peer->connections));
2389 }
2390
2391
2392 /**
2393  * Start the DHT search for new paths towards the peer: we don't have
2394  * enough good connections.
2395  *
2396  * @param peer Destination peer.
2397  */
2398 void
2399 GCP_start_search (struct CadetPeer *peer)
2400 {
2401   const struct GNUNET_PeerIdentity *id;
2402   struct CadetTunnel *t = peer->tunnel;
2403
2404   GCC_check_connections ();
2405  if (NULL != peer->search_h)
2406   {
2407     GNUNET_break (0);
2408     return;
2409   }
2410
2411   if (NULL != peer->search_delayed)
2412     GCP_stop_search (peer);
2413
2414   id = GNUNET_PEER_resolve2 (peer->id);
2415   peer->search_h = GCD_search (id, &search_handler, peer);
2416
2417   if (NULL == t)
2418   {
2419     /* Why would we search for a peer with no tunnel towards it? */
2420     GNUNET_break (0);
2421     return;
2422   }
2423
2424   if (CADET_TUNNEL_NEW == GCT_get_cstate (t)
2425       || 0 == GCT_count_any_connections (t))
2426   {
2427     GCT_change_cstate (t, CADET_TUNNEL_SEARCHING);
2428   }
2429   GCC_check_connections ();
2430 }
2431
2432
2433 /**
2434  * Stop the DHT search for new paths towards the peer: we already have
2435  * enough good connections.
2436  *
2437  * @param peer Destination peer.
2438  */
2439 void
2440 GCP_stop_search (struct CadetPeer *peer)
2441 {
2442   GCC_check_connections ();
2443   if (NULL != peer->search_h)
2444   {
2445     GCD_search_stop (peer->search_h);
2446     peer->search_h = NULL;
2447   }
2448   if (NULL != peer->search_delayed)
2449   {
2450     GNUNET_SCHEDULER_cancel (peer->search_delayed);
2451     peer->search_delayed = NULL;
2452   }
2453   GCC_check_connections ();
2454 }
2455
2456
2457 /**
2458  * Get the Full ID of a peer.
2459  *
2460  * @param peer Peer to get from.
2461  *
2462  * @return Full ID of peer.
2463  */
2464 const struct GNUNET_PeerIdentity *
2465 GCP_get_id (const struct CadetPeer *peer)
2466 {
2467   return GNUNET_PEER_resolve2 (peer->id);
2468 }
2469
2470
2471 /**
2472  * Get the Short ID of a peer.
2473  *
2474  * @param peer Peer to get from.
2475  *
2476  * @return Short ID of peer.
2477  */
2478 GNUNET_PEER_Id
2479 GCP_get_short_id (const struct CadetPeer *peer)
2480 {
2481   return peer->id;
2482 }
2483
2484
2485 /**
2486  * Set tunnel.
2487  *
2488  * If tunnel is NULL and there was a search active, stop it, as it's useless.
2489  *
2490  * @param peer Peer.
2491  * @param t Tunnel.
2492  */
2493 void
2494 GCP_set_tunnel (struct CadetPeer *peer, struct CadetTunnel *t)
2495 {
2496   peer->tunnel = t;
2497   if (NULL == t && GNUNET_YES == is_searching (peer))
2498   {
2499     GCP_stop_search (peer);
2500   }
2501 }
2502
2503
2504 /**
2505  * Get the tunnel towards a peer.
2506  *
2507  * @param peer Peer to get from.
2508  *
2509  * @return Tunnel towards peer.
2510  */
2511 struct CadetTunnel *
2512 GCP_get_tunnel (const struct CadetPeer *peer)
2513 {
2514   if (NULL == peer)
2515     return NULL;
2516   return peer->tunnel;
2517 }
2518
2519
2520 /**
2521  * Set the hello message.
2522  *
2523  * @param peer Peer whose message to set.
2524  * @param hello Hello message.
2525  */
2526 void
2527 GCP_set_hello (struct CadetPeer *peer,
2528                const struct GNUNET_HELLO_Message *hello)
2529 {
2530   struct GNUNET_HELLO_Message *old;
2531   size_t size;
2532
2533   GCC_check_connections ();
2534  LOG (GNUNET_ERROR_TYPE_DEBUG, "set hello for %s\n", GCP_2s (peer));
2535   if (NULL == hello)
2536     return;
2537
2538   old = GCP_get_hello (peer);
2539   if (NULL == old)
2540   {
2541     size = GNUNET_HELLO_size (hello);
2542     peer->hello = GNUNET_malloc (size);
2543     memcpy (peer->hello, hello, size);
2544   }
2545   else
2546   {
2547     peer->hello = GNUNET_HELLO_merge (old, hello);
2548     GNUNET_free (old);
2549   }
2550   GCC_check_connections ();
2551 }
2552
2553
2554 /**
2555  * Get the hello message.
2556  *
2557  * @param peer Peer whose message to get.
2558  *
2559  * @return Hello message.
2560  */
2561 struct GNUNET_HELLO_Message *
2562 GCP_get_hello (struct CadetPeer *peer)
2563 {
2564   struct GNUNET_TIME_Absolute expiration;
2565   struct GNUNET_TIME_Relative remaining;
2566
2567   if (NULL == peer->hello)
2568     return NULL;
2569
2570   expiration = GNUNET_HELLO_get_last_expiration (peer->hello);
2571   remaining = GNUNET_TIME_absolute_get_remaining (expiration);
2572   if (0 == remaining.rel_value_us)
2573   {
2574     LOG (GNUNET_ERROR_TYPE_DEBUG, " get - hello expired on %s\n",
2575          GNUNET_STRINGS_absolute_time_to_string (expiration));
2576     GNUNET_free (peer->hello);
2577     peer->hello = NULL;
2578   }
2579   return peer->hello;
2580 }
2581
2582
2583 /**
2584  * Try to connect to a peer on TRANSPORT level.
2585  *
2586  * @param peer Peer to whom to connect.
2587  */
2588 void
2589 GCP_try_connect (struct CadetPeer *peer)
2590 {
2591   struct GNUNET_HELLO_Message *hello;
2592   struct GNUNET_MessageHeader *mh;
2593
2594   if (NULL == transport_handle)
2595     return;
2596   GCC_check_connections ();
2597   if (GNUNET_YES == GCP_is_neighbor (peer))
2598     return;
2599   hello = GCP_get_hello (peer);
2600   if (NULL == hello)
2601     return;
2602
2603   mh = GNUNET_HELLO_get_header (hello);
2604   if (NULL != peer->hello_offer)
2605   {
2606     GNUNET_TRANSPORT_offer_hello_cancel (peer->hello_offer);
2607     peer->hello_offer = NULL;
2608   }
2609   peer->hello_offer = GNUNET_TRANSPORT_offer_hello (transport_handle,
2610                                                     mh,
2611                                                     &hello_offer_done,
2612                                                     peer);
2613   if (NULL == peer->connectivity_suggestion)
2614     peer->connectivity_suggestion
2615       = GNUNET_ATS_connectivity_suggest (ats_ch,
2616                                          GNUNET_PEER_resolve2 (peer->id),
2617                                          1 /* strength */);
2618   GCC_check_connections ();
2619 }
2620
2621
2622 /**
2623  * Notify a peer that a link between two other peers is broken. If any path
2624  * used that link, eliminate it.
2625  *
2626  * @param peer Peer affected by the change.
2627  * @param peer1 Peer whose link is broken.
2628  * @param peer2 Peer whose link is broken.
2629  */
2630 void
2631 GCP_notify_broken_link (struct CadetPeer *peer,
2632                         const struct GNUNET_PeerIdentity *peer1,
2633                         const struct GNUNET_PeerIdentity *peer2)
2634 {
2635   struct CadetPeerPath *iter;
2636   struct CadetPeerPath *next;
2637   unsigned int i;
2638   GNUNET_PEER_Id p1;
2639   GNUNET_PEER_Id p2;
2640
2641   GCC_check_connections ();
2642   p1 = GNUNET_PEER_search (peer1);
2643   p2 = GNUNET_PEER_search (peer2);
2644
2645   LOG (GNUNET_ERROR_TYPE_DEBUG, "Link %u-%u broken\n", p1, p2);
2646   if (0 == p1 || 0 == p2)
2647   {
2648     /* We don't even know them */
2649     return;
2650   }
2651
2652   for (iter = peer->path_head; NULL != iter; iter = next)
2653   {
2654     next = iter->next;
2655     for (i = 0; i < iter->length - 1; i++)
2656     {
2657       if ((iter->peers[i] == p1 && iter->peers[i + 1] == p2)
2658           || (iter->peers[i] == p2 && iter->peers[i + 1] == p1))
2659       {
2660         char *s;
2661
2662         s = path_2s (iter);
2663         LOG (GNUNET_ERROR_TYPE_DEBUG, " - invalidating %s\n", s);
2664         GNUNET_free (s);
2665
2666         path_invalidate (iter);
2667       }
2668     }
2669   }
2670   GCC_check_connections ();
2671 }
2672
2673
2674 /**
2675  * Count the number of known paths toward the peer.
2676  *
2677  * @param peer Peer to get path info.
2678  *
2679  * @return Number of known paths.
2680  */
2681 unsigned int
2682 GCP_count_paths (const struct CadetPeer *peer)
2683 {
2684   struct CadetPeerPath *iter;
2685   unsigned int i;
2686
2687   for (iter = peer->path_head, i = 0; NULL != iter; iter = iter->next)
2688     i++;
2689
2690   return i;
2691 }
2692
2693
2694 /**
2695  * Iterate over the paths to a peer.
2696  *
2697  * @param peer Peer to get path info.
2698  * @param callback Function to call for every path.
2699  * @param cls Closure for @a callback.
2700  *
2701  * @return Number of iterated paths.
2702  */
2703 unsigned int
2704 GCP_iterate_paths (struct CadetPeer *peer,
2705                    GCP_path_iterator callback,
2706                    void *cls)
2707 {
2708   struct CadetPeerPath *iter;
2709   unsigned int i;
2710
2711   for (iter = peer->path_head, i = 0; NULL != iter; iter = iter->next)
2712   {
2713     i++;
2714     if (GNUNET_YES != callback (cls, peer, iter))
2715       break;
2716   }
2717
2718   return i;
2719 }
2720
2721
2722 /**
2723  * Iterate all known peers.
2724  *
2725  * @param iter Iterator.
2726  * @param cls Closure for @c iter.
2727  */
2728 void
2729 GCP_iterate_all (GNUNET_CONTAINER_PeerMapIterator iter,
2730                  void *cls)
2731 {
2732   GCC_check_connections ();
2733   GNUNET_CONTAINER_multipeermap_iterate (peers,
2734                                          iter,
2735                                          cls);
2736   GCC_check_connections ();
2737 }
2738
2739
2740 /**
2741  * Get the static string for a peer ID.
2742  *
2743  * @param peer Peer.
2744  *
2745  * @return Static string for it's ID.
2746  */
2747 const char *
2748 GCP_2s (const struct CadetPeer *peer)
2749 {
2750   if (NULL == peer)
2751     return "(NULL)";
2752   return GNUNET_i2s (GNUNET_PEER_resolve2 (peer->id));
2753 }
2754
2755
2756 /* end of gnunet-service-cadet_peer.c */