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