- fix "broken connection" notifications
[oweals/gnunet.git] / src / mesh / gnunet-service-mesh_tunnel.c
1 /*
2      This file is part of GNUnet.
3      (C) 2013 Christian Grothoff (and other contributing authors)
4
5      GNUnet is free software; you can redistribute it and/or modify
6      it under the terms of the GNU General Public License as published
7      by the Free Software Foundation; either version 3, or (at your
8      option) any later version.
9
10      GNUnet is distributed in the hope that it will be useful, but
11      WITHOUT ANY WARRANTY; without even the implied warranty of
12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13      General Public License for more details.
14
15      You should have received a copy of the GNU General Public License
16      along with GNUnet; see the file COPYING.  If not, write to the
17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18      Boston, MA 02111-1307, USA.
19 */
20
21 #include "platform.h"
22 #include "gnunet_util_lib.h"
23
24 #include "gnunet_statistics_service.h"
25
26 #include "mesh_protocol_enc.h"
27
28 #include "gnunet-service-mesh_tunnel.h"
29 #include "gnunet-service-mesh_connection.h"
30 #include "gnunet-service-mesh_channel.h"
31 #include "gnunet-service-mesh_peer.h"
32 #include "mesh_path.h"
33
34 #define LOG(level, ...) GNUNET_log_from(level,"mesh-tun",__VA_ARGS__)
35
36
37 /******************************************************************************/
38 /********************************   STRUCTS  **********************************/
39 /******************************************************************************/
40
41 struct MeshTChannel
42 {
43   struct MeshTChannel *next;
44   struct MeshTChannel *prev;
45   struct MeshChannel *ch;
46 };
47
48 struct MeshTConnection
49 {
50   struct MeshTConnection *next;
51   struct MeshTConnection *prev;
52   struct MeshConnection *c;
53 };
54
55 /**
56  * Struct containing all information regarding a tunnel to a peer.
57  */
58 struct MeshTunnel3
59 {
60     /**
61      * Endpoint of the tunnel.
62      */
63   struct MeshPeer *peer;
64
65     /**
66      * State of the tunnel.
67      */
68   enum MeshTunnel3State state;
69
70   /**
71    * Local peer ephemeral private key
72    */
73   struct GNUNET_CRYPTO_EddsaPrivateKey *my_eph_key;
74
75   /**
76    * Local peer ephemeral public key
77    */
78   struct GNUNET_CRYPTO_EddsaPublicKey *my_eph;
79
80   /**
81    * Remote peer's public key.
82    */
83   struct GNUNET_CRYPTO_EddsaPublicKey *peers_eph;
84
85   /**
86    * Encryption ("our") key.
87    */
88   struct GNUNET_CRYPTO_SymmetricSessionKey e_key;
89
90   /**
91    * Decryption ("their") key.
92    */
93   struct GNUNET_CRYPTO_SymmetricSessionKey d_key;
94
95   /**
96    * Paths that are actively used to reach the destination peer.
97    */
98   struct MeshTConnection *connection_head;
99   struct MeshTConnection *connection_tail;
100
101   /**
102    * Next connection number.
103    */
104   uint32_t next_cid;
105
106   /**
107    * Channels inside this tunnel.
108    */
109   struct MeshTChannel *channel_head;
110   struct MeshTChannel *channel_tail;
111
112   /**
113    * Channel ID for the next created channel.
114    */
115   MESH_ChannelNumber next_chid;
116
117   /**
118    * Pending message count.
119    */
120   int pending_messages;
121
122   /**
123    * Destroy flag: if true, destroy on last message.
124    */
125   int destroy;
126
127   /**
128    * Queued messages, to transmit once tunnel gets connected.
129    */
130   struct MeshTunnelQueue *tq_head;
131   struct MeshTunnelQueue *tq_tail;
132 };
133
134
135 /**
136  * Struct used to queue messages in a tunnel.
137  */
138 struct MeshTunnelQueue
139 {
140   /**
141    * DLL
142    */
143   struct MeshTunnelQueue *next;
144   struct MeshTunnelQueue *prev;
145
146   /**
147    * Channel.
148    */
149   struct MeshChannel *ch;
150
151   /**
152    * Message to send.
153    */
154   /* struct GNUNET_MessageHeader *msg; */
155 };
156
157 /******************************************************************************/
158 /*******************************   GLOBALS  ***********************************/
159 /******************************************************************************/
160
161 /**
162  * Global handle to the statistics service.
163  */
164 extern struct GNUNET_STATISTICS_Handle *stats;
165
166 /**
167  * Local peer own ID (memory efficient handle).
168  */
169 extern GNUNET_PEER_Id myid;
170
171 /**
172  * Local peer own ID (full value).
173  */
174 extern struct GNUNET_PeerIdentity my_full_id;
175
176 /**
177  * Default TTL for payload packets.
178  */
179 static unsigned long long default_ttl;
180
181 /**
182  * Own private key.
183  */
184 const static struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
185
186
187 /******************************************************************************/
188 /********************************   STATIC  ***********************************/
189 /******************************************************************************/
190
191 /**
192  * Get string description for tunnel state.
193  *
194  * @param s Tunnel state.
195  *
196  * @return String representation.
197  */
198 static const char *
199 GMT_state2s (enum MeshTunnel3State s)
200 {
201   static char buf[128];
202
203   switch (s)
204   {
205     case MESH_TUNNEL3_NEW:
206       return "MESH_TUNNEL3_NEW";
207     case MESH_TUNNEL3_SEARCHING:
208       return "MESH_TUNNEL3_SEARCHING";
209     case MESH_TUNNEL3_WAITING:
210       return "MESH_TUNNEL3_WAITING";
211     case MESH_TUNNEL3_READY:
212       return "MESH_TUNNEL3_READY";
213     case MESH_TUNNEL3_RECONNECTING:
214       return "MESH_TUNNEL3_RECONNECTING";
215
216     default:
217       sprintf (buf, "%u (UNKNOWN STATE)", s);
218       return buf;
219   }
220 }
221
222 /**
223  * Pick a connection on which send the next data message.
224  *
225  * @param t Tunnel on which to send the message.
226  * @param fwd Is this a fwd message?
227  *
228  * @return The connection on which to send the next message.
229  */
230 static struct MeshConnection *
231 tunnel_get_connection (struct MeshTunnel3 *t, int fwd)
232 {
233   struct MeshTConnection *iter;
234   struct MeshConnection *best;
235   unsigned int qn;
236   unsigned int lowest_q;
237
238   LOG (GNUNET_ERROR_TYPE_DEBUG, "tunnel_get_connection %s\n", GMP_2s (t->peer));
239   best = NULL;
240   lowest_q = UINT_MAX;
241   for (iter = t->connection_head; NULL != iter; iter = iter->next)
242   {
243     LOG (GNUNET_ERROR_TYPE_DEBUG, "  connection %s: %u\n",
244          GNUNET_h2s (GMC_get_id (iter->c)), GMC_get_state (iter->c));
245     if (MESH_CONNECTION_READY == GMC_get_state (iter->c))
246     {
247       qn = GMC_get_qn (iter->c, fwd);
248       LOG (GNUNET_ERROR_TYPE_DEBUG, "    q_n %u, \n", qn);
249       if (qn < lowest_q)
250       {
251         best = iter->c;
252         lowest_q = qn;
253       }
254     }
255   }
256   return best;
257 }
258
259
260 void
261 handle_data (struct MeshTunnel3 *t,
262              const struct GNUNET_MESH_Data *msg,
263              int fwd)
264 {
265   struct MeshChannel *ch;
266   uint16_t type;
267   size_t size;
268
269   /* Check size */
270   size = ntohs (msg->header.size);
271   if (size <
272       sizeof (struct GNUNET_MESH_Data) +
273       sizeof (struct GNUNET_MessageHeader))
274   {
275     GNUNET_break (0);
276     return;
277   }
278   type = ntohs (msg->header.type);
279   LOG (GNUNET_ERROR_TYPE_DEBUG, "got a %s message\n",
280               GNUNET_MESH_DEBUG_M2S (type));
281   LOG (GNUNET_ERROR_TYPE_DEBUG, " payload of type %s\n",
282               GNUNET_MESH_DEBUG_M2S (ntohs (msg[1].header.type)));
283
284   /* Check channel */
285   ch = GMT_get_channel (t, ntohl (msg->chid));
286   if (NULL == ch)
287   {
288     GNUNET_STATISTICS_update (stats, "# data on unknown channel",
289                               1, GNUNET_NO);
290     LOG (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel %u unknown\n",
291          ntohl (msg->chid));
292     return;
293   }
294
295   GMT_change_state (t, MESH_TUNNEL3_READY);
296   GMCH_handle_data (ch, msg, fwd);
297 }
298
299 void
300 handle_data_ack (struct MeshTunnel3 *t,
301                  const struct GNUNET_MESH_DataACK *msg,
302                  int fwd)
303 {
304   struct MeshChannel *ch;
305   size_t size;
306
307   /* Check size */
308   size = ntohs (msg->header.size);
309   if (size != sizeof (struct GNUNET_MESH_DataACK))
310   {
311     GNUNET_break (0);
312     return;
313   }
314
315   /* Check channel */
316   ch = GMT_get_channel (t, ntohl (msg->chid));
317   if (NULL == ch)
318   {
319     GNUNET_STATISTICS_update (stats, "# data ack on unknown channel",
320                               1, GNUNET_NO);
321     LOG (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel %u unknown\n",
322          ntohl (msg->chid));
323     return;
324   }
325
326   GMCH_handle_data_ack (ch, msg, fwd);
327 }
328
329 void
330 handle_ch_create (struct MeshTunnel3 *t,
331                   const struct GNUNET_MESH_ChannelCreate *msg,
332                   int fwd)
333 {
334   struct MeshTChannel *tch;
335   struct MeshChannel *ch;
336   size_t size;
337
338   /* Check size */
339   size = ntohs (msg->header.size);
340   if (size != sizeof (struct GNUNET_MESH_ChannelCreate))
341   {
342     GNUNET_break (0);
343     return;
344   }
345
346   /* Check channel */
347   ch = GMT_get_channel (t, ntohl (msg->chid));
348   if (NULL != ch)
349   {
350     /* Probably a retransmission, safe to ignore */
351     LOG (GNUNET_ERROR_TYPE_DEBUG, "   already exists...\n");
352   }
353   else
354   {
355     ch = GMCH_handle_create (msg, fwd);
356   }
357
358   tch = GNUNET_new (struct MeshTChannel);
359   tch->ch = ch;
360   GNUNET_CONTAINER_DLL_insert (t->channel_head, t->channel_tail, tch);
361 }
362
363 void
364 handle_ch_ack (struct MeshTunnel3 *t,
365                const struct GNUNET_MESH_ChannelManage *msg,
366                int fwd)
367 {
368   struct MeshChannel *ch;
369   size_t size;
370
371   /* Check size */
372   size = ntohs (msg->header.size);
373   if (size != sizeof (struct GNUNET_MESH_ChannelManage))
374   {
375     GNUNET_break (0);
376     return;
377   }
378
379   /* Check channel */
380   ch = GMT_get_channel (t, ntohl (msg->chid));
381   if (NULL == ch)
382   {
383     GNUNET_STATISTICS_update (stats, "# channel ack on unknown channel",
384                               1, GNUNET_NO);
385     LOG (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel %u unknown\n",
386          ntohl (msg->chid));
387     return;
388   }
389
390   GMCH_handle_ack (ch, msg, fwd);
391 }
392
393 void
394 handle_ch_destroy (struct MeshTunnel3 *t,
395                    const struct GNUNET_MESH_ChannelManage *msg,
396                    int fwd)
397 {
398   struct MeshChannel *ch;
399   size_t size;
400
401   /* Check size */
402   size = ntohs (msg->header.size);
403   if (size != sizeof (struct GNUNET_MESH_ChannelManage))
404   {
405     GNUNET_break (0);
406     return;
407   }
408
409   /* Check channel */
410   ch = GMT_get_channel (t, ntohl (msg->chid));
411   if (NULL == ch)
412   {
413     /* Probably a retransmission, safe to ignore */
414     return;
415   }
416
417   GMCH_handle_destroy (ch, msg, fwd);
418 }
419
420 /******************************************************************************/
421 /********************************    API    ***********************************/
422 /******************************************************************************/
423
424 /**
425  * Demultiplex by message type and call appropriate handler for a message
426  * towards a channel of a local tunnel.
427  *
428  * @param t Tunnel this message came on.
429  * @param msgh Message header.
430  * @param fwd Is this message fwd?
431  */
432 void
433 GMT_handle_decrypted (struct MeshTunnel3 *t,
434                       const struct GNUNET_MessageHeader *msgh,
435                       int fwd)
436 {
437   uint16_t type;
438
439   type = ntohs (msgh->type);
440   LOG (GNUNET_ERROR_TYPE_DEBUG,
441        "Got a %s message!\n",
442        GNUNET_MESH_DEBUG_M2S (type));
443
444   switch (type)
445   {
446     case GNUNET_MESSAGE_TYPE_MESH_DATA:
447       /* Don't send hop ACK, wait for client to ACK */
448       handle_data (t, (struct GNUNET_MESH_Data *) msgh, fwd);
449       break;
450
451     case GNUNET_MESSAGE_TYPE_MESH_DATA_ACK:
452       handle_data_ack (t, (struct GNUNET_MESH_DataACK *) msgh, fwd);
453       break;
454
455     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE:
456       handle_ch_create (t,
457                         (struct GNUNET_MESH_ChannelCreate *) msgh,
458                         fwd);
459       break;
460
461     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_ACK:
462       handle_ch_ack (t,
463                      (struct GNUNET_MESH_ChannelManage *) msgh,
464                      fwd);
465       break;
466
467     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY:
468       handle_ch_destroy (t,
469                          (struct GNUNET_MESH_ChannelManage *) msgh,
470                          fwd);
471       break;
472
473     default:
474       GNUNET_break_op (0);
475       LOG (GNUNET_ERROR_TYPE_DEBUG,
476            "end-to-end message not known (%u)\n",
477            ntohs (msgh->type));
478   }
479 }
480
481
482 /**
483  * Cache a message to be sent once tunnel is online.
484  *
485  * @param t Tunnel to hold the message.
486  * @param ch Channel the message is about.
487  * @param msg Message itself (copy will be made).
488  * @param fwd Is this fwd?
489  */
490 void
491 GMT_queue_data (struct MeshTunnel3 *t,
492                 struct MeshChannel *ch,
493                 struct GNUNET_MessageHeader *msg,
494                 int fwd)
495 {
496   struct MeshTunnelQueue *tq;
497   uint16_t size = ntohs (msg->size);
498
499   tq = GNUNET_malloc (sizeof (struct MeshTunnelQueue) + size);
500
501   tq->ch = ch;
502   memcpy (&tq[1], msg, size);
503   GNUNET_CONTAINER_DLL_insert_tail (t->tq_head, t->tq_tail, tq);
504
505   if (MESH_TUNNEL3_READY == t->state)
506     GMT_send_queued_data (t, fwd);
507 }
508
509
510 /**
511  * Send all cached messages that we can, tunnel is online.
512  *
513  * @param t Tunnel that holds the messages.
514  * @param fwd Is this fwd?
515  */
516 void
517 GMT_send_queued_data (struct MeshTunnel3 *t, int fwd)
518 {
519   struct MeshTunnelQueue *tq;
520   struct MeshTunnelQueue *next;
521   unsigned int room;
522
523   LOG (GNUNET_ERROR_TYPE_DEBUG,
524               "GMT_send_queued_data on tunnel %s\n",
525               GMP_2s (t->peer));
526   room = GMT_get_buffer (t, fwd);
527   LOG (GNUNET_ERROR_TYPE_DEBUG, "  buffer space: %u\n", room);
528   for (tq = t->tq_head; NULL != tq && room > 0; tq = next)
529   {
530     next = tq->next;
531     room--;
532     GNUNET_CONTAINER_DLL_remove (t->tq_head, t->tq_tail, tq);
533     GMCH_send_prebuilt_message ((struct GNUNET_MessageHeader *) &tq[1],
534                                 tq->ch, fwd);
535
536     GNUNET_free (tq);
537   }
538 }
539
540
541 /**
542  * Initialize the tunnel subsystem.
543  *
544  * @param c Configuration handle.
545  * @param id Peer identity.
546  * @param key ECC private key, to derive all other keys and do crypto.
547  */
548 void
549 GMT_init (const struct GNUNET_CONFIGURATION_Handle *c,
550           const struct GNUNET_CRYPTO_EddsaPrivateKey *key)
551 {
552   if (GNUNET_OK !=
553       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "DEFAULT_TTL",
554                                              &default_ttl))
555   {
556     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
557                                "MESH", "DEFAULT_TTL", "USING DEFAULT");
558     default_ttl = 64;
559   }
560   my_private_key = key;
561 }
562
563
564 /**
565  * Shut down the tunnel subsystem.
566  */
567 void
568 GMT_shutdown (void)
569 {
570   GNUNET_PEER_change_rc (myid, -1);
571 }
572
573
574 /**
575  * Create a tunnel.
576  *
577  * @param destination Peer this tunnel is towards.
578  */
579 struct MeshTunnel3 *
580 GMT_new (struct MeshPeer *destination)
581 {
582   struct MeshTunnel3 *t;
583
584   t = GNUNET_new (struct MeshTunnel3);
585   t->next_chid = 0;
586   t->peer = destination;
587 //   if (GNUNET_OK !=
588 //       GNUNET_CONTAINER_multihashmap_put (tunnels, tid, t,
589 //                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
590 //   {
591 //     GNUNET_break (0);
592 //     tunnel_destroy (t);
593 //     return NULL;
594 //   }
595
596 //   char salt[] = "salt";
597 //   GNUNET_CRYPTO_kdf (&t->e_key, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
598 //                      salt, sizeof (salt),
599 //                      &t->e_key, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
600 //                      &my_full_id, sizeof (struct GNUNET_PeerIdentity),
601 //                      GNUNET_PEER_resolve2 (t->peer->id), sizeof (struct GNUNET_PeerIdentity),
602 //                      NULL);
603 //   GNUNET_CRYPTO_kdf (&t->d_key, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
604 //                      salt, sizeof (salt),
605 //                      &t->d_key, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey),
606 //                      GNUNET_PEER_resolve2 (t->peer->id), sizeof (struct GNUNET_PeerIdentity),
607 //                      &my_full_id, sizeof (struct GNUNET_PeerIdentity),
608 //                      NULL);
609
610   return t;
611 }
612
613
614 /**
615  * Change the tunnel state.
616  *
617  * @param t Tunnel whose state to change.
618  * @param state New state.
619  */
620 void
621 GMT_change_state (struct MeshTunnel3* t, enum MeshTunnel3State state)
622 {
623   if (NULL == t)
624     return;
625   LOG (GNUNET_ERROR_TYPE_DEBUG,
626               "Tunnel %s state was %s\n",
627               GMP_2s (t->peer),
628               GMT_state2s (t->state));
629   LOG (GNUNET_ERROR_TYPE_DEBUG,
630               "Tunnel %s state is now %s\n",
631               GMP_2s (t->peer),
632               GMT_state2s (state));
633   t->state = state;
634   if (MESH_TUNNEL3_READY == state && 3 <= GMT_count_connections (t))
635   {
636     GMP_stop_search (t->peer);
637   }
638 }
639
640
641 /**
642  * Add a connection to a tunnel.
643  *
644  * @param t Tunnel.
645  * @param c Connection.
646  */
647 void
648 GMT_add_connection (struct MeshTunnel3 *t, struct MeshConnection *c)
649 {
650   struct MeshTConnection *aux;
651
652   for (aux = t->connection_head; aux != NULL; aux = aux->next)
653     if (aux->c == c)
654       return;
655
656   aux = GNUNET_new (struct MeshTConnection);
657   aux->c = c;
658   GNUNET_CONTAINER_DLL_insert_tail (t->connection_head, t->connection_tail, aux);
659 }
660
661
662 /**
663  * Remove a connection from a tunnel.
664  *
665  * @param t Tunnel.
666  * @param c Connection.
667  */
668 void
669 GMT_remove_connection (struct MeshTunnel3 *t, struct MeshConnection *c)
670 {
671   struct MeshTConnection *aux;
672
673   for (aux = t->connection_head; aux != NULL; aux = aux->next)
674     if (aux->c == c)
675     {
676       GNUNET_CONTAINER_DLL_remove (t->connection_head, t->connection_tail, aux);
677       GNUNET_free (aux);
678       return;
679     }
680 }
681
682
683 /**
684  * Add a channel to a tunnel.
685  *
686  * @param t Tunnel.
687  * @param ch Channel.
688  */
689 void
690 GMT_add_channel (struct MeshTunnel3 *t, struct MeshChannel *ch)
691 {
692   struct MeshTChannel *aux;
693
694   for (aux = t->channel_head; aux != NULL; aux = aux->next)
695     if (aux->ch == ch)
696       return;
697
698   aux = GNUNET_new (struct MeshTChannel);
699   aux->ch = ch;
700   GNUNET_CONTAINER_DLL_insert_tail (t->channel_head, t->channel_tail, aux);
701 }
702
703
704 /**
705  * Remove a channel from a tunnel.
706  *
707  * @param t Tunnel.
708  * @param ch Channel.
709  */
710 void
711 GMT_remove_channel (struct MeshTunnel3 *t, struct MeshChannel *ch)
712 {
713   struct MeshTChannel *aux;
714
715   for (aux = t->channel_head; aux != NULL; aux = aux->next)
716     if (aux->ch == ch)
717     {
718       GNUNET_CONTAINER_DLL_remove (t->channel_head, t->channel_tail, aux);
719       GNUNET_free (aux);
720       return;
721     }
722 }
723
724
725 /**
726  * Search for a channel by global ID.
727  *
728  * @param t Tunnel containing the channel.
729  * @param chid Public channel number.
730  *
731  * @return channel handler, NULL if doesn't exist
732  */
733 struct MeshChannel *
734 GMT_get_channel (struct MeshTunnel3 *t, MESH_ChannelNumber chid)
735 {
736   struct MeshTChannel *iter;
737
738   if (NULL == t)
739     return NULL;
740
741   for (iter = t->channel_head; NULL != iter; iter = iter->next)
742   {
743     if (GMCH_get_id (iter->ch) == chid)
744       break;
745   }
746
747   return NULL == iter ? NULL : iter->ch;
748 }
749
750
751 /**
752  * Tunnel is empty: destroy it.
753  *
754  * Notifies all connections about the destruction.
755  *
756  * @param t Tunnel to destroy.
757  */
758 void
759 GMT_destroy_empty (struct MeshTunnel3 *t)
760 {
761   struct MeshTConnection *iter;
762
763   for (iter = t->connection_head; NULL != iter; iter = iter->next)
764   {
765     GMC_send_destroy (iter->c);
766   }
767
768   if (0 == t->pending_messages)
769     GMT_destroy (t);
770   else
771     t->destroy = GNUNET_YES;
772 }
773
774
775 /**
776  * Destroy tunnel if empty (no more channels).
777  *
778  * @param t Tunnel to destroy if empty.
779  */
780 void
781 GMT_destroy_if_empty (struct MeshTunnel3 *t)
782 {
783   if (1 < GMT_count_channels (t))
784     return;
785
786   GMT_destroy_empty (t);
787 }
788
789
790 /**
791  * Destroy the tunnel.
792  *
793  * This function does not generate any warning traffic to clients or peers.
794  *
795  * Tasks:
796  * Cancel messages belonging to this tunnel queued to neighbors.
797  * Free any allocated resources linked to the tunnel.
798  *
799  * @param t The tunnel to destroy.
800  */
801 void
802 GMT_destroy (struct MeshTunnel3 *t)
803 {
804   struct MeshTConnection *iter;
805   struct MeshTConnection *next;
806
807   if (NULL == t)
808     return;
809
810   LOG (GNUNET_ERROR_TYPE_DEBUG, "destroying tunnel %s\n", GMP_2s (t->peer));
811
812 //   if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (tunnels, &t->id, t))
813 //     GNUNET_break (0);
814
815   for (iter = t->connection_head; NULL != iter; iter = next)
816   {
817     next = iter->next;
818     GMC_destroy (iter->c);
819     GNUNET_free (iter);
820   }
821
822   GNUNET_STATISTICS_update (stats, "# tunnels", -1, GNUNET_NO);
823   GMP_set_tunnel (t->peer, NULL);
824
825   GNUNET_free (t);
826 }
827
828
829 /**
830  * @brief Use the given path for the tunnel.
831  * Update the next and prev hops (and RCs).
832  * (Re)start the path refresh in case the tunnel is locally owned.
833  *
834  * @param t Tunnel to update.
835  * @param p Path to use.
836  *
837  * @return Connection created.
838  */
839 struct MeshConnection *
840 GMT_use_path (struct MeshTunnel3 *t, struct MeshPeerPath *p)
841 {
842   struct MeshConnection *c;
843   struct GNUNET_HashCode cid;
844   unsigned int own_pos;
845
846   if (NULL == t || NULL == p)
847   {
848     GNUNET_break (0);
849     return NULL;
850   }
851
852   for (own_pos = 0; own_pos < p->length; own_pos++)
853   {
854     if (p->peers[own_pos] == myid)
855       break;
856   }
857   if (own_pos > p->length - 1)
858   {
859     GNUNET_break (0);
860     return NULL;
861   }
862
863   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_NONCE, &cid);
864   c = GMC_new (&cid, t, p, own_pos);
865   GMT_add_connection (t, c);
866   return c;
867 }
868
869
870 /**
871  * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
872  * Encrypt data with the tunnel key.
873  * Make static?
874  *
875  * @param t Tunnel whose key to use.
876  * @param dst Destination for the encrypted data.
877  * @param src Source of the plaintext.
878  * @param size Size of the plaintext.
879  * @param iv Initialization Vector to use.
880  * @param fwd Is this a fwd message?
881  */
882 void
883 GMT_encrypt (struct MeshTunnel3 *t,
884              void *dst, const void *src,
885              size_t size, uint64_t iv, int fwd)
886 {
887   memcpy (dst, src, size);
888 }
889
890
891 /**
892  * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
893  * Decrypt data with the tunnel key.
894  * Make static?
895  *
896  * @param t Tunnel whose key to use.
897  * @param dst Destination for the plaintext.
898  * @param src Source of the encrypted data.
899  * @param size Size of the encrypted data.
900  * @param iv Initialization Vector to use.
901  * @param fwd Is this a fwd message?
902  */
903 void
904 GMT_decrypt (struct MeshTunnel3 *t,
905              void *dst, const void *src,
906              size_t size, uint64_t iv, int fwd)
907 {
908   memcpy (dst, src, size);
909 }
910
911
912 /**
913  * Count established (ready) connections of a tunnel.
914  *
915  * @param t Tunnel on which to count.
916  *
917  * @return Number of connections.
918  */
919 unsigned int
920 GMT_count_connections (struct MeshTunnel3 *t)
921 {
922   struct MeshTConnection *iter;
923   unsigned int count;
924
925   for (count = 0, iter = t->connection_head;
926        NULL != iter;
927        iter = iter->next, count++);
928
929   return count;
930 }
931
932 /**
933  * Count channels of a tunnel.
934  *
935  * @param t Tunnel on which to count.
936  *
937  * @return Number of channels.
938  */
939 unsigned int
940 GMT_count_channels (struct MeshTunnel3 *t)
941 {
942   struct MeshTChannel *iter;
943   unsigned int count;
944
945   for (count = 0, iter = t->channel_head;
946        NULL != iter;
947   iter = iter->next, count++);
948
949   return count;
950 }
951
952
953 /**
954  * Get the state of a tunnel.
955  *
956  * @param t Tunnel.
957  *
958  * @return Tunnel's state.
959  */
960 enum MeshTunnel3State
961 GMT_get_state (struct MeshTunnel3 *t)
962 {
963   if (NULL == t)
964     return (enum MeshTunnel3State) -1;
965   return t->state;
966 }
967
968 /**
969  * Get the total buffer space for a tunnel.
970  *
971  * @param t Tunnel.
972  * @param fwd Is this for FWD traffic?
973  *
974  * @return Buffer space offered by all connections in the tunnel.
975  */
976 unsigned int
977 GMT_get_buffer (struct MeshTunnel3 *t, int fwd)
978 {
979   struct MeshTConnection *iter;
980   unsigned int buffer;
981
982   iter = t->connection_head;
983   buffer = 0;
984
985   /* If terminal, return biggest channel buffer */
986   if (NULL == iter || GMC_is_terminal (iter->c, fwd))
987   {
988     struct MeshTChannel *iter_ch;
989     unsigned int ch_buf;
990
991     if (NULL == t->channel_head)
992       return 64;
993
994     for (iter_ch = t->channel_head; NULL != iter_ch; iter_ch = iter_ch->next)
995     {
996       ch_buf = GMCH_get_buffer (iter_ch->ch, fwd);
997       if (ch_buf > buffer)
998         buffer = ch_buf;
999     }
1000     return buffer;
1001   }
1002
1003   /* If not terminal, return sum of connection buffers */
1004   while (NULL != iter)
1005   {
1006     if (GMC_get_state (iter->c) != MESH_CONNECTION_READY)
1007     {
1008       iter = iter->next;
1009       continue;
1010     }
1011
1012     buffer += GMC_get_buffer (iter->c, fwd);
1013     iter = iter->next;
1014   }
1015
1016   return buffer;
1017 }
1018
1019
1020 /**
1021  * Get the tunnel's destination.
1022  *
1023  * @param t Tunnel.
1024  *
1025  * @return ID of the destination peer.
1026  */
1027 const struct GNUNET_PeerIdentity *
1028 GMT_get_destination (struct MeshTunnel3 *t)
1029 {
1030   return GMP_get_id (t->peer);
1031 }
1032
1033
1034 /**
1035  * Get the tunnel's next free global channel ID.
1036  *
1037  * @param t Tunnel.
1038  *
1039  * @return GID of a channel free to use.
1040  */
1041 MESH_ChannelNumber
1042 GMT_get_next_chid (struct MeshTunnel3 *t)
1043 {
1044   MESH_ChannelNumber chid;
1045
1046   while (NULL != GMT_get_channel (t, t->next_chid))
1047   {
1048     LOG (GNUNET_ERROR_TYPE_DEBUG, "Channel %u exists...\n", t->next_chid);
1049     t->next_chid = (t->next_chid + 1) & ~GNUNET_MESH_LOCAL_CHANNEL_ID_CLI;
1050   }
1051   chid = t->next_chid;
1052   t->next_chid = (t->next_chid + 1) & ~GNUNET_MESH_LOCAL_CHANNEL_ID_CLI;
1053
1054   return chid;
1055 }
1056
1057
1058 /**
1059  * Sends an already built message on a tunnel, encrypting it and
1060  * choosing the best connection.
1061  *
1062  * @param message Message to send. Function modifies it.
1063  * @param t Tunnel on which this message is transmitted.
1064  * @param ch Channel on which this message is transmitted.
1065  * @param fwd Is this a fwd message?
1066  */
1067 void
1068 GMT_send_prebuilt_message (const struct GNUNET_MessageHeader *message,
1069                            struct MeshTunnel3 *t,
1070                            struct MeshChannel *ch,
1071                            int fwd)
1072 {
1073   struct MeshConnection *c;
1074   struct GNUNET_MESH_Encrypted *msg;
1075   size_t size = ntohs (message->size);
1076   char *cbuf[sizeof (struct GNUNET_MESH_Encrypted) + size];
1077   uint64_t iv;
1078   uint16_t type;
1079
1080   LOG (GNUNET_ERROR_TYPE_DEBUG, "Send on Tunnel %s\n", GMP_2s (t->peer));
1081
1082   iv = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_NONCE, UINT64_MAX);
1083   msg = (struct GNUNET_MESH_Encrypted *) cbuf;
1084   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_ENCRYPTED);
1085   msg->header.size = htons (sizeof (struct GNUNET_MESH_Encrypted) + size);
1086   msg->iv = GNUNET_htonll (iv);
1087   GMT_encrypt (t, &msg[1], message, size, iv, fwd);
1088   c = tunnel_get_connection (t, fwd);
1089   if (NULL == c)
1090   {
1091     GNUNET_break (GNUNET_YES == t->destroy);
1092     return;
1093   }
1094   type = ntohs (message->type);
1095   switch (type)
1096   {
1097     case GNUNET_MESSAGE_TYPE_MESH_FWD:
1098     case GNUNET_MESSAGE_TYPE_MESH_BCK:
1099     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE:
1100     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY:
1101       msg->cid = *GMC_get_id (c);
1102       msg->ttl = htonl (default_ttl);
1103       break;
1104     default:
1105       LOG (GNUNET_ERROR_TYPE_DEBUG, "unkown type %s\n",
1106            GNUNET_MESH_DEBUG_M2S (type));
1107       GNUNET_break (0);
1108   }
1109   msg->reserved = 0;
1110
1111   t->pending_messages++;
1112   GMC_send_prebuilt_message (&msg->header, c, ch, fwd);
1113 }
1114
1115 /**
1116  * Is the tunnel directed towards the local peer?
1117  *
1118  * @param t Tunnel.
1119  *
1120  * @return GNUNET_YES if it is loopback.
1121  */
1122 int
1123 GMT_is_loopback (const struct MeshTunnel3 *t)
1124 {
1125   return (myid == GMP_get_short_id(t->peer));
1126 }
1127
1128
1129 /**
1130  * Is the tunnel using this path already?
1131  *
1132  * @param t Tunnel.
1133  * @param p Path.
1134  *
1135  * @return GNUNET_YES a connection uses this path.
1136  */
1137 int
1138 GMT_is_path_used (const struct MeshTunnel3 *t, const struct MeshPeerPath *p)
1139 {
1140   struct MeshTConnection *iter;
1141
1142   for (iter = t->connection_head; NULL != iter; iter = iter->next)
1143     if (GMC_get_path (iter->c) == p)
1144       return GNUNET_YES;
1145
1146   return GNUNET_NO;
1147 }
1148
1149
1150 /**
1151  * Get a cost of a path for a tunnel considering existing connections.
1152  *
1153  * @param t Tunnel.
1154  * @param path Candidate path.
1155  *
1156  * @return Cost of the path (path length + number of overlapping nodes)
1157  */
1158 unsigned int
1159 GMT_get_path_cost (const struct MeshTunnel3 *t,
1160                    const struct MeshPeerPath *path)
1161 {
1162   struct MeshTConnection *iter;
1163   unsigned int overlap;
1164   unsigned int i;
1165   unsigned int j;
1166
1167   if (NULL == path)
1168     return 0;
1169
1170   overlap = 0;
1171   GNUNET_assert (NULL != t);
1172
1173   for (i = 0; i < path->length; i++)
1174   {
1175     for (iter = t->connection_head; NULL != iter; iter = iter->next)
1176     {
1177       for (j = 0; j < GMC_get_path (iter->c)->length; j++)
1178       {
1179         if (path->peers[i] == GMC_get_path (iter->c)->peers[j])
1180         {
1181           overlap++;
1182           break;
1183         }
1184       }
1185     }
1186   }
1187   return (path->length + overlap) * (path->score * -1);
1188 }
1189
1190
1191 /**
1192  * Get the static string for the peer this tunnel is directed.
1193  *
1194  * @param t Tunnel.
1195  *
1196  * @return Static string the destination peer's ID.
1197  */
1198 const char *
1199 GMT_2s (const struct MeshTunnel3 *t)
1200 {
1201   return GMP_2s (t->peer);
1202 }