- fixes in local
[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 /**
616  * Change the tunnel state.
617  *
618  * @param t Tunnel whose state to change.
619  * @param state New state.
620  */
621 void
622 GMT_change_state (struct MeshTunnel3* t, enum MeshTunnel3State state)
623 {
624   if (NULL == t)
625     return;
626   LOG (GNUNET_ERROR_TYPE_DEBUG,
627               "Tunnel %s state was %s\n",
628               GMP_2s (t->peer),
629               GMT_state2s (t->state));
630   LOG (GNUNET_ERROR_TYPE_DEBUG,
631               "Tunnel %s state is now %s\n",
632               GMP_2s (t->peer),
633               GMT_state2s (state));
634   t->state = state;
635   if (MESH_TUNNEL3_READY == state && 3 <= GMT_count_connections (t))
636   {
637     GMP_stop_search (t->peer);
638   }
639 }
640
641
642 /**
643  * Add a connection to a tunnel.
644  *
645  * @param t Tunnel.
646  * @param c Connection.
647  */
648 void
649 GMT_add_connection (struct MeshTunnel3 *t, struct MeshConnection *c)
650 {
651   struct MeshTConnection *aux;
652
653   for (aux = t->connection_head; aux != NULL; aux = aux->next)
654     if (aux->c == c)
655       return;
656
657   aux = GNUNET_new (struct MeshTConnection);
658   aux->c = c;
659   GNUNET_CONTAINER_DLL_insert_tail (t->connection_head, t->connection_tail, aux);
660 }
661
662
663 /**
664  * Remove a connection from a tunnel.
665  *
666  * @param t Tunnel.
667  * @param c Connection.
668  */
669 void
670 GMT_remove_connection (struct MeshTunnel3 *t, struct MeshConnection *c)
671 {
672   struct MeshTConnection *aux;
673
674   for (aux = t->connection_head; aux != NULL; aux = aux->next)
675     if (aux->c == c)
676     {
677       GNUNET_CONTAINER_DLL_remove (t->connection_head, t->connection_tail, aux);
678       GNUNET_free (aux);
679       return;
680     }
681 }
682
683
684 /**
685  * Add a channel to a tunnel.
686  *
687  * @param t Tunnel.
688  * @param ch Channel.
689  */
690 void
691 GMT_add_channel (struct MeshTunnel3 *t, struct MeshChannel *ch)
692 {
693   struct MeshTChannel *aux;
694
695   for (aux = t->channel_head; aux != NULL; aux = aux->next)
696     if (aux->ch == ch)
697       return;
698
699   aux = GNUNET_new (struct MeshTChannel);
700   aux->ch = ch;
701   GNUNET_CONTAINER_DLL_insert_tail (t->channel_head, t->channel_tail, aux);
702 }
703
704
705 /**
706  * Remove a channel from a tunnel.
707  *
708  * @param t Tunnel.
709  * @param ch Channel.
710  */
711 void
712 GMT_remove_channel (struct MeshTunnel3 *t, struct MeshChannel *ch)
713 {
714   struct MeshTChannel *aux;
715
716   for (aux = t->channel_head; aux != NULL; aux = aux->next)
717     if (aux->ch == ch)
718     {
719       GNUNET_CONTAINER_DLL_remove (t->channel_head, t->channel_tail, aux);
720       GNUNET_free (aux);
721       return;
722     }
723 }
724
725
726 /**
727  * Search for a channel by global ID.
728  *
729  * @param t Tunnel containing the channel.
730  * @param chid Public channel number.
731  *
732  * @return channel handler, NULL if doesn't exist
733  */
734 struct MeshChannel *
735 GMT_get_channel (struct MeshTunnel3 *t, MESH_ChannelNumber chid)
736 {
737   struct MeshTChannel *iter;
738
739   if (NULL == t)
740     return NULL;
741
742   for (iter = t->channel_head; NULL != iter; iter = iter->next)
743   {
744     if (GMCH_get_id (iter->ch) == chid)
745       break;
746   }
747
748   return NULL == iter ? NULL : iter->ch;
749 }
750
751
752 /**
753  * Tunnel is empty: destroy it.
754  *
755  * Notifies all connections about the destruction.
756  *
757  * @param t Tunnel to destroy.
758  */
759 void
760 GMT_destroy_empty (struct MeshTunnel3 *t)
761 {
762   struct MeshTConnection *iter;
763
764   for (iter = t->connection_head; NULL != iter; iter = iter->next)
765   {
766     GMC_send_destroy (iter->c);
767   }
768
769   if (0 == t->pending_messages)
770     GMT_destroy (t);
771   else
772     t->destroy = GNUNET_YES;
773 }
774
775
776 /**
777  * Destroy tunnel if empty (no more channels).
778  *
779  * @param t Tunnel to destroy if empty.
780  */
781 void
782 GMT_destroy_if_empty (struct MeshTunnel3 *t)
783 {
784   if (1 < GMT_count_channels (t))
785     return;
786
787   GMT_destroy_empty (t);
788 }
789
790
791 /**
792  * Destroy the tunnel.
793  *
794  * This function does not generate any warning traffic to clients or peers.
795  *
796  * Tasks:
797  * Cancel messages belonging to this tunnel queued to neighbors.
798  * Free any allocated resources linked to the tunnel.
799  *
800  * @param t The tunnel to destroy.
801  */
802 void
803 GMT_destroy (struct MeshTunnel3 *t)
804 {
805   struct MeshTConnection *iter;
806   struct MeshTConnection *next;
807
808   if (NULL == t)
809     return;
810
811   LOG (GNUNET_ERROR_TYPE_DEBUG, "destroying tunnel %s\n", GMP_2s (t->peer));
812
813 //   if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (tunnels, &t->id, t))
814 //     GNUNET_break (0);
815
816   for (iter = t->connection_head; NULL != iter; iter = next)
817   {
818     next = iter->next;
819     GMC_destroy (iter->c);
820     GNUNET_free (iter);
821   }
822
823   GNUNET_STATISTICS_update (stats, "# tunnels", -1, GNUNET_NO);
824   GMP_set_tunnel (t->peer, NULL);
825
826   GNUNET_free (t);
827 }
828
829
830 /**
831  * Notifies a tunnel that a connection has broken that affects at least
832  * some of its peers. Sends a notification towards the root of the tree.
833  * In case the peer is the owner of the tree, notifies the client that owns
834  * the tunnel and tries to reconnect.
835  *
836  * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
837  *
838  * @param t Tunnel affected.
839  * @param p1 Peer that got disconnected from p2.
840  * @param p2 Peer that got disconnected from p1.
841  *
842  * @return Short ID of the peer disconnected (either p1 or p2).
843  *         0 if the tunnel remained unaffected.
844  */
845 GNUNET_PEER_Id
846 GMT_notify_connection_broken (struct MeshTunnel3* t,
847                               GNUNET_PEER_Id p1, GNUNET_PEER_Id p2)
848 {
849 //   if (myid != p1 && myid != p2) FIXME
850 //   {
851 //     return;
852 //   }
853 //
854 //   if (tree_get_predecessor (t->tree) != 0)
855 //   {
856 //     /* We are the peer still connected, notify owner of the disconnection. */
857 //     struct GNUNET_MESH_PathBroken msg;
858 //     struct GNUNET_PeerIdentity neighbor;
859 //
860 //     msg.header.size = htons (sizeof (msg));
861 //     msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_BROKEN);
862 //     GNUNET_PEER_resolve (t->id.oid, &msg.oid);
863 //     msg.tid = htonl (t->id.tid);
864 //     msg.peer1 = my_full_id;
865 //     GNUNET_PEER_resolve (pid, &msg.peer2);
866 //     GNUNET_PEER_resolve (tree_get_predecessor (t->tree), &neighbor);
867 //     send_prebuilt_message (&msg.header, &neighbor, t);
868 //   }
869   return 0;
870 }
871
872 /**
873  * @brief Use the given path for the tunnel.
874  * Update the next and prev hops (and RCs).
875  * (Re)start the path refresh in case the tunnel is locally owned.
876  *
877  * @param t Tunnel to update.
878  * @param p Path to use.
879  *
880  * @return Connection created.
881  */
882 struct MeshConnection *
883 GMT_use_path (struct MeshTunnel3 *t, struct MeshPeerPath *p)
884 {
885   struct MeshConnection *c;
886   struct GNUNET_HashCode cid;
887   unsigned int own_pos;
888
889   if (NULL == t || NULL == p)
890   {
891     GNUNET_break (0);
892     return NULL;
893   }
894
895   for (own_pos = 0; own_pos < p->length; own_pos++)
896   {
897     if (p->peers[own_pos] == myid)
898       break;
899   }
900   if (own_pos > p->length - 1)
901   {
902     GNUNET_break (0);
903     return NULL;
904   }
905
906   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_NONCE, &cid);
907   c = GMC_new (&cid, t, p, own_pos);
908   GMT_add_connection (t, c);
909   return c;
910 }
911
912
913 /**
914  * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
915  * Encrypt data with the tunnel key.
916  * Make static?
917  *
918  * @param t Tunnel whose key to use.
919  * @param dst Destination for the encrypted data.
920  * @param src Source of the plaintext.
921  * @param size Size of the plaintext.
922  * @param iv Initialization Vector to use.
923  * @param fwd Is this a fwd message?
924  */
925 void
926 GMT_encrypt (struct MeshTunnel3 *t,
927              void *dst, const void *src,
928              size_t size, uint64_t iv, int fwd)
929 {
930   memcpy (dst, src, size);
931 }
932
933
934 /**
935  * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
936  * Decrypt data with the tunnel key.
937  * Make static?
938  *
939  * @param t Tunnel whose key to use.
940  * @param dst Destination for the plaintext.
941  * @param src Source of the encrypted data.
942  * @param size Size of the encrypted data.
943  * @param iv Initialization Vector to use.
944  * @param fwd Is this a fwd message?
945  */
946 void
947 GMT_decrypt (struct MeshTunnel3 *t,
948              void *dst, const void *src,
949              size_t size, uint64_t iv, int fwd)
950 {
951   memcpy (dst, src, size);
952 }
953
954
955 /**
956  * Count established (ready) connections of a tunnel.
957  *
958  * @param t Tunnel on which to count.
959  *
960  * @return Number of connections.
961  */
962 unsigned int
963 GMT_count_connections (struct MeshTunnel3 *t)
964 {
965   struct MeshTConnection *iter;
966   unsigned int count;
967
968   for (count = 0, iter = t->connection_head;
969        NULL != iter;
970        iter = iter->next, count++);
971
972   return count;
973 }
974
975 /**
976  * Count channels of a tunnel.
977  *
978  * @param t Tunnel on which to count.
979  *
980  * @return Number of channels.
981  */
982 unsigned int
983 GMT_count_channels (struct MeshTunnel3 *t)
984 {
985   struct MeshTChannel *iter;
986   unsigned int count;
987
988   for (count = 0, iter = t->channel_head;
989        NULL != iter;
990   iter = iter->next, count++);
991
992   return count;
993 }
994
995
996 /**
997  * Get the state of a tunnel.
998  *
999  * @param t Tunnel.
1000  *
1001  * @return Tunnel's state.
1002  */
1003 enum MeshTunnel3State
1004 GMT_get_state (struct MeshTunnel3 *t)
1005 {
1006   if (NULL == t)
1007     return (enum MeshTunnel3State) -1;
1008   return t->state;
1009 }
1010
1011 /**
1012  * Get the total buffer space for a tunnel.
1013  *
1014  * @param t Tunnel.
1015  * @param fwd Is this for FWD traffic?
1016  *
1017  * @return Buffer space offered by all connections in the tunnel.
1018  */
1019 unsigned int
1020 GMT_get_buffer (struct MeshTunnel3 *t, int fwd)
1021 {
1022   struct MeshTConnection *iter;
1023   unsigned int buffer;
1024
1025   iter = t->connection_head;
1026   buffer = 0;
1027
1028   /* If terminal, return biggest channel buffer */
1029   if (NULL == iter || GMC_is_terminal (iter->c, fwd))
1030   {
1031     struct MeshTChannel *iter_ch;
1032     unsigned int ch_buf;
1033
1034     if (NULL == t->channel_head)
1035       return 64;
1036
1037     for (iter_ch = t->channel_head; NULL != iter_ch; iter_ch = iter_ch->next)
1038     {
1039       ch_buf = GMCH_get_buffer (iter_ch->ch, fwd);
1040       if (ch_buf > buffer)
1041         buffer = ch_buf;
1042     }
1043     return buffer;
1044   }
1045
1046   /* If not terminal, return sum of connection buffers */
1047   while (NULL != iter)
1048   {
1049     if (GMC_get_state (iter->c) != MESH_CONNECTION_READY)
1050     {
1051       iter = iter->next;
1052       continue;
1053     }
1054
1055     buffer += GMC_get_buffer (iter->c, fwd);
1056     iter = iter->next;
1057   }
1058
1059   return buffer;
1060 }
1061
1062
1063 /**
1064  * Get the tunnel's destination.
1065  *
1066  * @param t Tunnel.
1067  *
1068  * @return ID of the destination peer.
1069  */
1070 const struct GNUNET_PeerIdentity *
1071 GMT_get_destination (struct MeshTunnel3 *t)
1072 {
1073   return GMP_get_id (t->peer);
1074 }
1075
1076
1077 /**
1078  * Get the tunnel's next free global channel ID.
1079  *
1080  * @param t Tunnel.
1081  *
1082  * @return GID of a channel free to use.
1083  */
1084 MESH_ChannelNumber
1085 GMT_get_next_chid (struct MeshTunnel3 *t)
1086 {
1087   MESH_ChannelNumber chid;
1088
1089   while (NULL != GMT_get_channel (t, t->next_chid))
1090   {
1091     LOG (GNUNET_ERROR_TYPE_DEBUG, "Channel %u exists...\n", t->next_chid);
1092     t->next_chid = (t->next_chid + 1) & ~GNUNET_MESH_LOCAL_CHANNEL_ID_CLI;
1093   }
1094   chid = t->next_chid;
1095   t->next_chid = (t->next_chid + 1) & ~GNUNET_MESH_LOCAL_CHANNEL_ID_CLI;
1096
1097   return chid;
1098 }
1099
1100
1101 /**
1102  * Sends an already built message on a tunnel, encrypting it and
1103  * choosing the best connection.
1104  *
1105  * @param message Message to send. Function modifies it.
1106  * @param t Tunnel on which this message is transmitted.
1107  * @param ch Channel on which this message is transmitted.
1108  * @param fwd Is this a fwd message?
1109  */
1110 void
1111 GMT_send_prebuilt_message (const struct GNUNET_MessageHeader *message,
1112                            struct MeshTunnel3 *t,
1113                            struct MeshChannel *ch,
1114                            int fwd)
1115 {
1116   struct MeshConnection *c;
1117   struct GNUNET_MESH_Encrypted *msg;
1118   size_t size = ntohs (message->size);
1119   char *cbuf[sizeof (struct GNUNET_MESH_Encrypted) + size];
1120   uint64_t iv;
1121   uint16_t type;
1122
1123   LOG (GNUNET_ERROR_TYPE_DEBUG, "Send on Tunnel %s\n", GMP_2s (t->peer));
1124
1125   iv = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_NONCE, UINT64_MAX);
1126   msg = (struct GNUNET_MESH_Encrypted *) cbuf;
1127   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_ENCRYPTED);
1128   msg->header.size = htons (sizeof (struct GNUNET_MESH_Encrypted) + size);
1129   msg->iv = GNUNET_htonll (iv);
1130   GMT_encrypt (t, &msg[1], message, size, iv, fwd);
1131   c = tunnel_get_connection (t, fwd);
1132   if (NULL == c)
1133   {
1134     GNUNET_break (GNUNET_YES == t->destroy);
1135     return;
1136   }
1137   type = ntohs (message->type);
1138   switch (type)
1139   {
1140     case GNUNET_MESSAGE_TYPE_MESH_FWD:
1141     case GNUNET_MESSAGE_TYPE_MESH_BCK:
1142     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE:
1143     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY:
1144       msg->cid = *GMC_get_id (c);
1145       msg->ttl = htonl (default_ttl);
1146       break;
1147     default:
1148       LOG (GNUNET_ERROR_TYPE_DEBUG, "unkown type %s\n",
1149            GNUNET_MESH_DEBUG_M2S (type));
1150       GNUNET_break (0);
1151   }
1152   msg->reserved = 0;
1153
1154   t->pending_messages++;
1155   GMC_send_prebuilt_message (&msg->header, c, ch, fwd);
1156 }
1157
1158 /**
1159  * Is the tunnel directed towards the local peer?
1160  *
1161  * @param t Tunnel.
1162  *
1163  * @return GNUNET_YES if it is loopback.
1164  */
1165 int
1166 GMT_is_loopback (const struct MeshTunnel3 *t)
1167 {
1168   return (myid == GMP_get_short_id(t->peer));
1169 }
1170
1171
1172 /**
1173  * Is the tunnel using this path already?
1174  *
1175  * @param t Tunnel.
1176  * @param p Path.
1177  *
1178  * @return GNUNET_YES a connection uses this path.
1179  */
1180 int
1181 GMT_is_path_used (const struct MeshTunnel3 *t, const struct MeshPeerPath *p)
1182 {
1183   struct MeshTConnection *c;
1184
1185   for (c = t->connection_head; NULL != c; c = c->next)
1186     if (GMC_get_path (c) == p)
1187       return GNUNET_YES;
1188
1189   return GNUNET_NO;
1190 }
1191
1192
1193 /**
1194  * Get a cost of a path for a tunnel considering existing connections.
1195  *
1196  * @param t Tunnel.
1197  * @param path Candidate path.
1198  *
1199  * @return Cost of the path (path length + number of overlapping nodes)
1200  */
1201 unsigned int
1202 GMT_get_path_cost (const struct MeshTunnel3 *t,
1203                    const struct MeshPeerPath *path)
1204 {
1205   struct MeshTConnection *iter;
1206   unsigned int overlap;
1207   unsigned int i;
1208   unsigned int j;
1209
1210   if (NULL == path)
1211     return 0;
1212
1213   overlap = 0;
1214   GNUNET_assert (NULL != t);
1215
1216   for (i = 0; i < path->length; i++)
1217   {
1218     for (iter = t->connection_head; NULL != iter; iter = iter->next)
1219     {
1220       for (j = 0; j < GMC_get_path (iter->c)->length; j++)
1221       {
1222         if (path->peers[i] == GMC_get_path (iter->c)->peers[j])
1223         {
1224           overlap++;
1225           break;
1226         }
1227       }
1228     }
1229   }
1230   return (path->length + overlap) * (path->score * -1);
1231 }
1232
1233
1234 /**
1235  * Get the static string for the peer this tunnel is directed.
1236  *
1237  * @param t Tunnel.
1238  *
1239  * @return Static string the destination peer's ID.
1240  */
1241 const char *
1242 GMT_2s (const struct MeshTunnel3 *t)
1243 {
1244   return GMP_2s (t->peer);
1245 }