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