5d616739eeeb28f8d74997e3819a994807a04266
[oweals/gnunet.git] / src / mesh / gnunet-service-mesh.c
1 /*
2      This file is part of GNUnet.
3      (C) 2001-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 /**
22  * @file mesh/gnunet-service-mesh.c
23  * @brief GNUnet MESH service
24  * @author Bartlomiej Polot
25  *
26  *  FIXME in progress:
27  * - keep queues until receiving ACK
28  *
29  * TODO:
30  * - relay corking down to core
31  * - set ttl relative to path length
32  * - add signatures
33  * - add encryption
34  * TODO END
35  */
36
37 #include "platform.h"
38 #include "mesh.h"
39 #include "mesh_protocol.h"
40 #include "mesh_path.h"
41 #include "block_mesh.h"
42 #include "gnunet_dht_service.h"
43 #include "gnunet_statistics_service.h"
44
45 #define MESH_BLOOM_SIZE         128
46
47 #define MESH_DEBUG_DHT          GNUNET_NO
48 #define MESH_DEBUG_CONNECTION   GNUNET_NO
49 #define MESH_DEBUG_TIMING       __LINUX__ && GNUNET_NO
50
51 #define MESH_MAX_POLL_TIME      GNUNET_TIME_relative_multiply (\
52                                   GNUNET_TIME_UNIT_MINUTES,\
53                                   10)
54 #define MESH_RETRANSMIT_TIME    GNUNET_TIME_UNIT_SECONDS
55 #define MESH_RETRANSMIT_MARGIN  4
56
57 #if MESH_DEBUG_CONNECTION
58 #define DEBUG_CONN(...) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
59 #else
60 #define DEBUG_CONN(...)
61 #endif
62
63 #if MESH_DEBUG_DHT
64 #define DEBUG_DHT(...) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
65 #else
66 #define DEBUG_DHT(...)
67 #endif
68
69 #if MESH_DEBUG_TIMING
70 #include <time.h>
71 double __sum;
72 uint64_t __count;
73 struct timespec __mesh_start;
74 struct timespec __mesh_end;
75 #define INTERVAL_START clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &(__mesh_start))
76 #define INTERVAL_END \
77 do {\
78   clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &(__mesh_end));\
79   double __diff = __mesh_end.tv_nsec - __mesh_start.tv_nsec;\
80   if (__diff < 0) __diff += 1000000000;\
81   __sum += __diff;\
82   __count++;\
83 } while (0)
84 #define INTERVAL_SHOW \
85 if (0 < __count)\
86   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "AVG process time: %f ns\n", __sum/__count)
87 #else
88 #define INTERVAL_START
89 #define INTERVAL_END
90 #define INTERVAL_SHOW
91 #endif
92
93 /******************************************************************************/
94 /************************      DATA STRUCTURES     ****************************/
95 /******************************************************************************/
96
97 /** FWD declaration */
98 struct MeshPeerInfo;
99 struct MeshClient;
100
101
102 /**
103  * Struct containing info about a queued transmission to this peer
104  */
105 struct MeshPeerQueue
106 {
107     /**
108       * DLL next
109       */
110   struct MeshPeerQueue *next;
111
112     /**
113       * DLL previous
114       */
115   struct MeshPeerQueue *prev;
116
117     /**
118      * Peer this transmission is directed to.
119      */
120   struct MeshPeerInfo *peer;
121
122     /**
123      * Tunnel this message belongs to.
124      */
125   struct MeshTunnel *tunnel;
126
127     /**
128      * Pointer to info stucture used as cls.
129      */
130   void *cls;
131
132     /**
133      * Type of message
134      */
135   uint16_t type;
136
137     /**
138      * Size of the message
139      */
140   size_t size;
141 };
142
143
144 /**
145  * Struct containing all information regarding a given peer
146  */
147 struct MeshPeerInfo
148 {
149     /**
150      * ID of the peer
151      */
152   GNUNET_PEER_Id id;
153
154     /**
155      * Last time we heard from this peer
156      */
157   struct GNUNET_TIME_Absolute last_contact;
158
159     /**
160      * Number of attempts to reconnect so far
161      */
162   int n_reconnect_attempts;
163
164     /**
165      * Paths to reach the peer, ordered by ascending hop count
166      */
167   struct MeshPeerPath *path_head;
168
169     /**
170      * Paths to reach the peer, ordered by ascending hop count
171      */
172   struct MeshPeerPath *path_tail;
173
174     /**
175      * Handle to stop the DHT search for a path to this peer
176      */
177   struct GNUNET_DHT_GetHandle *dhtget;
178
179     /**
180      * Array of tunnels this peer is the target of.
181      * Most probably a small amount, therefore not a hashmap.
182      * When the path to the peer changes, notify these tunnels to let them
183      * re-adjust their path trees.
184      */
185   struct MeshTunnel **tunnels;
186
187     /**
188      * Number of tunnels this peers participates in
189      */
190   unsigned int ntunnels;
191
192    /**
193     * Transmission queue to core DLL head
194     */
195   struct MeshPeerQueue *queue_head;
196
197    /**
198     * Transmission queue to core DLL tail
199     */
200    struct MeshPeerQueue *queue_tail;
201
202    /**
203     * How many messages are in the queue to this peer.
204     */
205    unsigned int queue_n;
206
207    /**
208     * Handle for queued transmissions
209     */
210   struct GNUNET_CORE_TransmitHandle *core_transmit;
211 };
212
213
214 /**
215  * Struct to encapsulate all the Flow Control information to a peer in the
216  * context of a tunnel: Same peer in different tunnels will have independent
217  * flow control structures, allowing to choke/free tunnels according to its
218  * own criteria.
219  */
220 struct MeshFlowControl
221 {
222   /**
223    * ID of the last packet sent towards the peer.
224    */
225   uint32_t last_pid_sent;
226
227   /**
228    * ID of the last packet received from the peer.
229    */
230   uint32_t last_pid_recv;
231
232   /**
233    * Last ACK sent to the peer (peer can't send more than this PID).
234    */
235   uint32_t last_ack_sent;
236
237   /**
238    * Last ACK sent towards the origin (for traffic towards leaf node).
239    */
240   uint32_t last_ack_recv;
241
242   /**
243    * How many payload messages are in the queue towards this peer.
244    */
245   uint32_t queue_n;
246
247   /**
248    * Task to poll the peer in case of a lost ACK causes stall.
249    */
250   GNUNET_SCHEDULER_TaskIdentifier poll_task;
251
252   /**
253    * How frequently to poll for ACKs.
254    */
255   struct GNUNET_TIME_Relative poll_time;
256
257   /**
258    * On which tunnel to poll.
259    * Using an explicit poll_ctx would not help memory wise,
260    * since the allocated context would have to be stored in the
261    * fc struct in order to free it upon cancelling poll_task.
262    */
263   struct MeshTunnel *t;
264 };
265
266
267 /**
268  * Globally unique tunnel identification (owner + number)
269  * DO NOT USE OVER THE NETWORK
270  */
271 struct MESH_TunnelID
272 {
273     /**
274      * Node that owns the tunnel
275      */
276   GNUNET_PEER_Id oid;
277
278     /**
279      * Tunnel number to differentiate all the tunnels owned by the node oid
280      * ( tid < GNUNET_MESH_LOCAL_TUNNEL_ID_CLI )
281      */
282   MESH_TunnelNumber tid;
283 };
284
285
286 /**
287  * Data needed for reliable tunnel endpoint retransmission management.
288  */
289 struct MeshTunnelReliability;
290
291
292 /**
293  * Info needed to retry a message in case it gets lost.
294  */
295 struct MeshReliableMessage
296 {
297     /**
298      * Double linked list, FIFO style
299      */
300   struct MeshReliableMessage    *next;
301   struct MeshReliableMessage    *prev;
302
303     /**
304      * Tunnel Reliability queue this message is in.
305      */
306   struct MeshTunnelReliability  *rel;
307
308     /**
309      * ID of the message (ACK needed to free)
310      */
311   uint64_t                      mid;
312
313     /**
314      * When was this message issued (to calculate ACK delay) FIXME update with traffic
315      */
316   struct GNUNET_TIME_Absolute   timestamp;
317
318   /* struct GNUNET_MESH_Data with payload */
319 };
320
321
322 struct MeshTunnelReliability
323 {
324     /**
325      * Tunnel this is about.
326      */
327   struct MeshTunnel *t;
328
329     /**
330      * DLL of messages sent and not yet ACK'd.
331      */
332   struct MeshReliableMessage        *head_sent;
333   struct MeshReliableMessage        *tail_sent;
334
335     /**
336      * Messages pending
337      */
338   unsigned int                      n_sent;
339
340     /**
341      * Next MID to use.
342      */
343   uint64_t                          mid_sent;
344
345     /**
346      * DLL of messages received out of order.
347      */
348   struct MeshReliableMessage        *head_recv;
349   struct MeshReliableMessage        *tail_recv;
350
351     /**
352      * Next MID expected.
353      */
354   uint64_t                          mid_recv;
355
356     /**
357      * Task to resend/poll in case no ACK is received.
358      */
359   GNUNET_SCHEDULER_TaskIdentifier   retry_task;
360
361     /**
362      * Counter for exponential backoff.
363      */
364   struct GNUNET_TIME_Relative       retry_timer;
365
366     /**
367      * How long does it usually take to get an ACK. FIXME update with traffic
368      */
369   struct GNUNET_TIME_Relative       expected_delay;
370 };
371
372
373 /**
374  * Struct containing all information regarding a tunnel
375  * For an intermediate node the improtant info used will be:
376  * - id        Tunnel unique identification
377  * - paths[0]  To know where to send it next
378  * - metainfo: ready, speeds, accounting
379  */
380 struct MeshTunnel
381 {
382     /**
383      * Tunnel ID
384      */
385   struct MESH_TunnelID id;
386
387     /**
388      * Port of the tunnel.
389      */
390   uint32_t port;
391
392     /**
393      * State of the tunnel.
394      */
395   enum MeshTunnelState state;
396
397     /**
398      * Local tunnel number ( >= GNUNET_MESH_LOCAL_TUNNEL_ID_CLI or 0 )
399      */
400   MESH_TunnelNumber local_tid;
401
402     /**
403      * Local tunnel number for local destination clients (incoming number)
404      * ( >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV or 0). All clients share the same
405      * number.
406      */
407   MESH_TunnelNumber local_tid_dest;
408
409     /**
410      * Is the tunnel bufferless (minimum latency)?
411      */
412   int nobuffer;
413
414     /**
415      * Is the tunnel reliable?
416      */
417   int reliable;
418
419     /**
420      * Force sending ACK? Flag to allow duplicate ACK on POLL.
421      */
422   int force_ack;
423
424     /**
425      * How many messages do we accept in the forward queue.
426      */
427   unsigned int queue_max;
428
429     /**
430      * Last time the tunnel was used
431      */
432   struct GNUNET_TIME_Absolute timestamp;
433
434     /**
435      * Destination of the tunnel.
436      */
437   GNUNET_PEER_Id dest;
438
439     /**
440      * Next hop in the tunnel. If 0, @c client must be set.
441      */
442   GNUNET_PEER_Id next_hop;
443
444     /**
445      * Previous hop in the tunnel. If 0, @c owner must be set.
446      */
447   GNUNET_PEER_Id prev_hop;
448
449     /**
450      * Flow control information about @c next_hop or @c client.
451      */
452   struct MeshFlowControl next_fc;
453
454   /**
455    * Flow control information about @c prev_hop or @c owner.
456    */
457   struct MeshFlowControl prev_fc;
458
459     /**
460      * Client owner of the tunnel, if any
461      */
462   struct MeshClient *owner;
463
464     /**
465      * Client destination of the tunnel, if any.
466      */
467   struct MeshClient *client;
468
469     /**
470      * Task to keep the used paths alive at the owner,
471      * time tunnel out on all the other peers.
472      */
473   GNUNET_SCHEDULER_TaskIdentifier maintenance_task;
474
475     /**
476      * Path being used for the tunnel.
477      */
478   struct MeshPeerPath *path;
479
480     /**
481      * Flag to signal the destruction of the tunnel.
482      * If this is set GNUNET_YES the tunnel will be destroyed
483      * when the queue is empty.
484      */
485   int destroy;
486
487     /**
488      * Total messages pending for this tunnels, payload or not.
489      */
490   unsigned int pending_messages;
491
492     /**
493      * Reliability data.
494      * Only present (non-NULL) at the owner of a tunnel.
495      */
496   struct MeshTunnelReliability *fwd_rel;
497
498     /**
499      * Reliability data.
500      * Only present (non-NULL) at the destination of a tunnel.
501      */
502   struct MeshTunnelReliability *bck_rel;
503 };
504
505
506 /**
507  * Struct containing information about a client of the service
508  * 
509  * TODO: add a list of 'waiting' ports
510  */
511 struct MeshClient
512 {
513     /**
514      * Linked list next
515      */
516   struct MeshClient *next;
517
518     /**
519      * Linked list prev
520      */
521   struct MeshClient *prev;
522
523     /**
524      * Tunnels that belong to this client, indexed by local id
525      */
526   struct GNUNET_CONTAINER_MultiHashMap32 *own_tunnels;
527
528    /**
529      * Tunnels this client has accepted, indexed by incoming local id
530      */
531   struct GNUNET_CONTAINER_MultiHashMap32 *incoming_tunnels;
532
533     /**
534      * Handle to communicate with the client
535      */
536   struct GNUNET_SERVER_Client *handle;
537
538     /**
539      * Ports that this client has declared interest in.
540      * Indexed by port, contains *Client.
541      */
542   struct GNUNET_CONTAINER_MultiHashMap32 *ports;
543
544     /**
545      * Whether the client is active or shutting down (don't send confirmations
546      * to a client that is shutting down.
547      */
548   int shutting_down;
549
550     /**
551      * ID of the client, mainly for debug messages
552      */
553   unsigned int id;
554
555 };
556
557
558 /******************************************************************************/
559 /************************      DEBUG FUNCTIONS     ****************************/
560 /******************************************************************************/
561
562 #if MESH_DEBUG
563 /**
564  * GNUNET_SCHEDULER_Task for printing a message after some operation is done
565  * @param cls string to print
566  * @param success  GNUNET_OK if the PUT was transmitted,
567  *                GNUNET_NO on timeout,
568  *                GNUNET_SYSERR on disconnect from service
569  *                after the PUT message was transmitted
570  *                (so we don't know if it was received or not)
571  */
572
573 #if 0
574 static void
575 mesh_debug (void *cls, int success)
576 {
577   char *s = cls;
578
579   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s (%d)\n", s, success);
580 }
581 #endif
582
583 /* FIXME */
584 unsigned int debug_fwd_ack;
585 unsigned int debug_bck_ack;
586
587 #endif
588
589 /******************************************************************************/
590 /***********************      GLOBAL VARIABLES     ****************************/
591 /******************************************************************************/
592
593 /************************** Configuration parameters **************************/
594
595 /**
596  * How often to send tunnel keepalives. Tunnels timeout after 4 missed.
597  */
598 static struct GNUNET_TIME_Relative refresh_path_time;
599
600 /**
601  * How often to PUT own ID in the DHT.
602  */
603 static struct GNUNET_TIME_Relative id_announce_time;
604
605 /**
606  * Maximum time allowed to connect to a peer found by string.
607  */
608 static struct GNUNET_TIME_Relative connect_timeout;
609
610 /**
611  * Default TTL for payload packets.
612  */
613 static unsigned long long default_ttl;
614
615 /**
616  * DHT replication level, see DHT API: GNUNET_DHT_get_start, GNUNET_DHT_put.
617  */
618 static unsigned long long dht_replication_level;
619
620 /**
621  * How many tunnels are we willing to maintain.
622  * Local tunnels are always allowed, even if there are more tunnels than max.
623  */
624 static unsigned long long max_tunnels;
625
626 /**
627  * How many messages *in total* are we willing to queue, divided by number of 
628  * tunnels to get tunnel queue size.
629  */
630 static unsigned long long max_msgs_queue;
631
632 /**
633  * How many peers do we want to remember?
634  */
635 static unsigned long long max_peers;
636
637 /**
638  * Percentage of messages that will be dropped (for test purposes only).
639  */
640 static unsigned long long drop_percent;
641
642 /*************************** Static global variables **************************/
643
644 /**
645  * DLL with all the clients, head.
646  */
647 static struct MeshClient *clients_head;
648
649 /**
650  * DLL with all the clients, tail.
651  */
652 static struct MeshClient *clients_tail;
653
654 /**
655  * Tunnels known, indexed by MESH_TunnelID (MeshTunnel).
656  */
657 static struct GNUNET_CONTAINER_MultiHashMap *tunnels;
658
659 /**
660  * Number of tunnels known.
661  */
662 static unsigned long long n_tunnels;
663
664 /**
665  * Tunnels incoming, indexed by MESH_TunnelNumber
666  * (which is greater than GNUNET_MESH_LOCAL_TUNNEL_ID_SERV).
667  */
668 static struct GNUNET_CONTAINER_MultiHashMap32 *incoming_tunnels;
669
670 /**
671  * Peers known, indexed by PeerIdentity (MeshPeerInfo).
672  */
673 static struct GNUNET_CONTAINER_MultiHashMap *peers;
674
675 /*
676  * Handle to communicate with transport
677  */
678 // static struct GNUNET_TRANSPORT_Handle *transport_handle;
679
680 /**
681  * Handle to communicate with core.
682  */
683 static struct GNUNET_CORE_Handle *core_handle;
684
685 /**
686  * Handle to use DHT.
687  */
688 static struct GNUNET_DHT_Handle *dht_handle;
689
690 /**
691  * Handle to server.
692  */
693 static struct GNUNET_SERVER_Handle *server_handle;
694
695 /**
696  * Handle to the statistics service.
697  */
698 static struct GNUNET_STATISTICS_Handle *stats;
699
700 /**
701  * Notification context, to send messages to local clients.
702  */
703 static struct GNUNET_SERVER_NotificationContext *nc;
704
705 /**
706  * Local peer own ID (memory efficient handle).
707  */
708 static GNUNET_PEER_Id myid;
709
710 /**
711  * Local peer own ID (full value).
712  */
713 static struct GNUNET_PeerIdentity my_full_id;
714
715 /**
716  * Own private key.
717  */
718 static struct GNUNET_CRYPTO_EccPrivateKey *my_private_key;
719
720 /**
721  * Own public key.
722  */
723 static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded my_public_key;
724
725 /**
726  * Tunnel ID for the next created tunnel (global tunnel number).
727  */
728 static MESH_TunnelNumber next_tid;
729
730 /**
731  * Tunnel ID for the next incoming tunnel (local tunnel number).
732  */
733 static MESH_TunnelNumber next_local_tid;
734
735 /**
736  * All ports clients of this peer have opened.
737  */
738 static struct GNUNET_CONTAINER_MultiHashMap32 *ports;
739
740 /**
741  * Task to periodically announce itself in the network.
742  */
743 GNUNET_SCHEDULER_TaskIdentifier announce_id_task;
744
745 /**
746  * Next ID to assign to a client.
747  */
748 unsigned int next_client_id;
749
750
751 /******************************************************************************/
752 /***********************         DECLARATIONS        **************************/
753 /******************************************************************************/
754
755 /**
756  * Function to process paths received for a new peer addition. The recorded
757  * paths form the initial tunnel, which can be optimized later.
758  * Called on each result obtained for the DHT search.
759  *
760  * @param cls closure
761  * @param exp when will this value expire
762  * @param key key of the result
763  * @param type type of the result
764  * @param size number of bytes in data
765  * @param data pointer to the result data
766  */
767 static void
768 dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp,
769                     const struct GNUNET_HashCode * key,
770                     const struct GNUNET_PeerIdentity *get_path,
771                     unsigned int get_path_length,
772                     const struct GNUNET_PeerIdentity *put_path,
773                     unsigned int put_path_length, enum GNUNET_BLOCK_Type type,
774                     size_t size, const void *data);
775
776
777 /**
778  * Retrieve the MeshPeerInfo stucture associated with the peer, create one
779  * and insert it in the appropriate structures if the peer is not known yet.
780  *
781  * @param peer Full identity of the peer.
782  *
783  * @return Existing or newly created peer info.
784  */
785 static struct MeshPeerInfo *
786 peer_get (const struct GNUNET_PeerIdentity *peer);
787
788
789 /**
790  * Retrieve the MeshPeerInfo stucture associated with the peer, create one
791  * and insert it in the appropriate structures if the peer is not known yet.
792  *
793  * @param peer Short identity of the peer.
794  *
795  * @return Existing or newly created peer info.
796  */
797 static struct MeshPeerInfo *
798 peer_get_short (const GNUNET_PEER_Id peer);
799
800
801 /**
802  * Build a PeerPath from the paths returned from the DHT, reversing the paths
803  * to obtain a local peer -> destination path and interning the peer ids.
804  *
805  * @return Newly allocated and created path
806  */
807 static struct MeshPeerPath *
808 path_build_from_dht (const struct GNUNET_PeerIdentity *get_path,
809                      unsigned int get_path_length,
810                      const struct GNUNET_PeerIdentity *put_path,
811                      unsigned int put_path_length);
812
813
814 /**
815  * Adds a path to the peer_infos of all the peers in the path
816  *
817  * @param p Path to process.
818  * @param confirmed Whether we know if the path works or not.
819  */
820 static void
821 path_add_to_peers (struct MeshPeerPath *p, int confirmed);
822
823
824
825 /**
826  * Search for a tunnel by global ID using full PeerIdentities.
827  *
828  * @param oid owner of the tunnel.
829  * @param tid global tunnel number.
830  *
831  * @return tunnel handler, NULL if doesn't exist.
832  */
833 static struct MeshTunnel *
834 tunnel_get (const struct GNUNET_PeerIdentity *oid, MESH_TunnelNumber tid);
835
836
837 /**
838  * Notify a tunnel that a connection has broken that affects at least
839  * some of its peers.
840  *
841  * @param t Tunnel affected.
842  * @param p1 Peer that got disconnected from p2.
843  * @param p2 Peer that got disconnected from p1.
844  *
845  * @return Short ID of the peer disconnected (either p1 or p2).
846  *         0 if the tunnel remained unaffected.
847  */
848 static GNUNET_PEER_Id
849 tunnel_notify_connection_broken (struct MeshTunnel *t, GNUNET_PEER_Id p1,
850                                  GNUNET_PEER_Id p2);
851
852
853 /**
854  * @brief Use the given path for the tunnel.
855  * Update the next and prev hops (and RCs).
856  * (Re)start the path refresh in case the tunnel is locally owned.
857  * 
858  * @param t Tunnel to update.
859  * @param p Path to use.
860  */
861 static void
862 tunnel_use_path (struct MeshTunnel *t, struct MeshPeerPath *p);
863
864 /**
865  * Tunnel is empty: destroy it.
866  * 
867  * Notifies all participants (peers, cleints) about the destruction.
868  * 
869  * @param t Tunnel to destroy. 
870  */
871 static void
872 tunnel_destroy_empty (struct MeshTunnel *t);
873
874 /**
875  * @brief Queue and pass message to core when possible.
876  * 
877  * If type is payload (UNICAST, TO_ORIGIN, MULTICAST) checks for queue status
878  * and accounts for it. In case the queue is full, the message is dropped and
879  * a break issued.
880  * 
881  * Otherwise, message is treated as internal and allowed to go regardless of 
882  * queue status.
883  *
884  * @param cls Closure (@c type dependant). It will be used by queue_send to
885  *            build the message to be sent if not already prebuilt.
886  * @param type Type of the message, 0 for a raw message.
887  * @param size Size of the message.
888  * @param dst Neighbor to send message to.
889  * @param t Tunnel this message belongs to.
890  */
891 static void
892 queue_add (void *cls, uint16_t type, size_t size,
893            struct MeshPeerInfo *dst, struct MeshTunnel *t);
894
895
896 /**
897  * Free a transmission that was already queued with all resources
898  * associated to the request.
899  *
900  * @param queue Queue handler to cancel.
901  * @param clear_cls Is it necessary to free associated cls?
902  */
903 static void
904 queue_destroy (struct MeshPeerQueue *queue, int clear_cls);
905
906
907 /**
908  * @brief Get the next transmittable message from the queue.
909  *
910  * This will be the head, except in the case of being a data packet
911  * not allowed by the destination peer.
912  *
913  * @param peer Destination peer.
914  *
915  * @return The next viable MeshPeerQueue element to send to that peer.
916  *         NULL when there are no transmittable messages.
917  */
918 struct MeshPeerQueue *
919 queue_get_next (const struct MeshPeerInfo *peer);
920
921
922 /**
923  * Core callback to write a queued packet to core buffer
924  *
925  * @param cls Closure (peer info).
926  * @param size Number of bytes available in buf.
927  * @param buf Where the to write the message.
928  *
929  * @return number of bytes written to buf
930  */
931 static size_t
932 queue_send (void *cls, size_t size, void *buf);
933
934
935 /******************************************************************************/
936 /************************    PERIODIC FUNCTIONS    ****************************/
937 /******************************************************************************/
938
939 /**
940  * Periodically announce self id in the DHT
941  *
942  * @param cls closure
943  * @param tc task context
944  */
945 static void
946 announce_id (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
947 {
948   struct PBlock block;
949
950   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
951   {
952     announce_id_task = GNUNET_SCHEDULER_NO_TASK;
953     return;
954   }
955   /* TODO
956    * - Set data expiration in function of X
957    * - Adapt X to churn
958    */
959   DEBUG_DHT ("DHT_put for ID %s started.\n", GNUNET_i2s (&my_full_id));
960
961   block.id = my_full_id;
962   GNUNET_DHT_put (dht_handle,   /* DHT handle */
963                   &my_full_id.hashPubKey,       /* Key to use */
964                   dht_replication_level,     /* Replication level */
965                   GNUNET_DHT_RO_RECORD_ROUTE | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,    /* DHT options */
966                   GNUNET_BLOCK_TYPE_MESH_PEER,       /* Block type */
967                   sizeof (block),  /* Size of the data */
968                   (const char *) &block, /* Data itself */
969                   GNUNET_TIME_UNIT_FOREVER_ABS,  /* Data expiration */
970                   GNUNET_TIME_UNIT_FOREVER_REL, /* Retry time */
971                   NULL,         /* Continuation */
972                   NULL);        /* Continuation closure */
973   announce_id_task =
974       GNUNET_SCHEDULER_add_delayed (id_announce_time, &announce_id, cls);
975 }
976
977
978 /******************************************************************************/
979 /******************      GENERAL HELPER FUNCTIONS      ************************/
980 /******************************************************************************/
981
982
983 /**
984  * Check if client has registered with the service and has not disconnected
985  *
986  * @param client the client to check
987  *
988  * @return non-NULL if client exists in the global DLL
989  */
990 static struct MeshClient *
991 client_get (struct GNUNET_SERVER_Client *client)
992 {
993   return GNUNET_SERVER_client_get_user_context (client, struct MeshClient);
994 }
995
996
997 /**
998  * Deletes a tunnel from a client (either owner or destination). To be used on
999  * tunnel destroy.
1000  *
1001  * @param c Client whose tunnel to delete.
1002  * @param t Tunnel which should be deleted.
1003  */
1004 static void
1005 client_delete_tunnel (struct MeshClient *c, struct MeshTunnel *t)
1006 {
1007   if (c == t->owner)
1008   {
1009     GNUNET_assert (GNUNET_YES ==
1010                    GNUNET_CONTAINER_multihashmap32_remove (c->own_tunnels,
1011                                                            t->local_tid,
1012                                                            t));
1013   }
1014   if (c == t->client)
1015   {
1016     GNUNET_assert (GNUNET_YES ==
1017                    GNUNET_CONTAINER_multihashmap32_remove (c->incoming_tunnels,
1018                                                            t->local_tid_dest,
1019                                                            t));
1020   }
1021 }
1022
1023 /**
1024  * Notify the appropriate client that a new incoming tunnel was created.
1025  *
1026  * @param t Tunnel that was created.
1027  */
1028 static void
1029 send_client_tunnel_create (struct MeshTunnel *t)
1030 {
1031   struct GNUNET_MESH_TunnelMessage msg;
1032
1033   if (NULL == t->client)
1034     return;
1035   msg.header.size = htons (sizeof (msg));
1036   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_CREATE);
1037   msg.tunnel_id = htonl (t->local_tid_dest);
1038   msg.port = htonl (t->port);
1039   msg.options = 0;
1040   msg.options |= GNUNET_YES == t->reliable ? GNUNET_MESH_OPTION_RELIABLE : 0;
1041   msg.options |= GNUNET_YES == t->nobuffer ? GNUNET_MESH_OPTION_NOBUFFER : 0;
1042   msg.options = htonl (msg.options);
1043   GNUNET_PEER_resolve (t->id.oid, &msg.peer);
1044   GNUNET_SERVER_notification_context_unicast (nc, t->client->handle,
1045                                               &msg.header, GNUNET_NO);
1046 }
1047
1048
1049 /**
1050  * Notify dest client that the incoming tunnel is no longer valid.
1051  *
1052  * @param c Client to notify..
1053  * @param t Tunnel that is destroyed.
1054  */
1055 static void
1056 send_client_tunnel_destroy (struct MeshClient *c, struct MeshTunnel *t)
1057 {
1058   struct GNUNET_MESH_TunnelMessage msg;
1059
1060   if (NULL == c)
1061   {
1062     GNUNET_break (0);
1063     return;
1064   }
1065   if (c != t->client && c != t->owner)
1066   {
1067     GNUNET_break (0);
1068     return;
1069   }
1070   msg.header.size = htons (sizeof (msg));
1071   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_DESTROY);
1072   msg.tunnel_id = htonl (t->local_tid_dest);
1073   msg.port = htonl (0);
1074   memset(&msg.peer, 0, sizeof (msg.peer));
1075   GNUNET_SERVER_notification_context_unicast (nc, c->handle,
1076                                               &msg.header, GNUNET_NO);
1077 }
1078
1079
1080 /**
1081  * Iterator over all the peers to remove the oldest not-used entry.
1082  *
1083  * @param cls Closure (unsued).
1084  * @param key ID of the peer.
1085  * @param value Peer_Info of the peer.
1086  *
1087  * FIXME implement
1088  */
1089 static int
1090 peer_info_timeout (void *cls,
1091                    const struct GNUNET_HashCode *key,
1092                    void *value)
1093 {
1094   return GNUNET_YES;
1095 }
1096
1097 /**
1098  * Retrieve the MeshPeerInfo stucture associated with the peer, create one
1099  * and insert it in the appropriate structures if the peer is not known yet.
1100  *
1101  * @param peer Full identity of the peer.
1102  *
1103  * @return Existing or newly created peer info.
1104  */
1105 static struct MeshPeerInfo *
1106 peer_get (const struct GNUNET_PeerIdentity *peer)
1107 {
1108   struct MeshPeerInfo *peer_info;
1109
1110   peer_info = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
1111   if (NULL == peer_info)
1112   {
1113     peer_info =
1114         (struct MeshPeerInfo *) GNUNET_malloc (sizeof (struct MeshPeerInfo));
1115     if (GNUNET_CONTAINER_multihashmap_size (peers) > max_peers)
1116     {
1117       GNUNET_CONTAINER_multihashmap_iterate (peers,
1118                                              &peer_info_timeout,
1119                                              NULL);
1120     }
1121     GNUNET_CONTAINER_multihashmap_put (peers, &peer->hashPubKey, peer_info,
1122                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
1123     peer_info->id = GNUNET_PEER_intern (peer);
1124   }
1125   peer_info->last_contact = GNUNET_TIME_absolute_get();
1126
1127   return peer_info;
1128 }
1129
1130
1131 /**
1132  * Retrieve the MeshPeerInfo stucture associated with the peer, create one
1133  * and insert it in the appropriate structures if the peer is not known yet.
1134  *
1135  * @param peer Short identity of the peer.
1136  *
1137  * @return Existing or newly created peer info.
1138  */
1139 static struct MeshPeerInfo *
1140 peer_get_short (const GNUNET_PEER_Id peer)
1141 {
1142   struct GNUNET_PeerIdentity id;
1143
1144   GNUNET_PEER_resolve (peer, &id);
1145   return peer_get (&id);
1146 }
1147
1148
1149 /**
1150  * Choose the best path towards a peer considering the tunnel properties.
1151  * 
1152  * @param peer The destination peer.
1153  * @param t The tunnel the path is for.
1154  *
1155  * @return Best current known path towards the peer, if any.
1156  */
1157 static struct MeshPeerPath *
1158 peer_get_best_path (const struct MeshPeerInfo *peer, const struct MeshTunnel *t)
1159 {
1160   struct MeshPeerPath *best_p;
1161   struct MeshPeerPath *p;
1162   unsigned int best_cost;
1163   unsigned int cost;
1164
1165   best_p = p = peer->path_head;
1166   best_cost = cost = p->length;
1167   while (NULL != p)
1168   {
1169     if ((cost = p->length) < best_cost)
1170     {
1171       best_cost = cost;
1172       best_p = p;
1173     }
1174         p = p->next;
1175   }
1176   return best_p;
1177 }
1178
1179 /**
1180   * Core callback to write a pre-constructed data packet to core buffer
1181   *
1182   * @param cls Closure (MeshTransmissionDescriptor with data in "data" member).
1183   * @param size Number of bytes available in buf.
1184   * @param buf Where the to write the message.
1185   *
1186   * @return number of bytes written to buf
1187   */
1188 static size_t
1189 send_core_data_raw (void *cls, size_t size, void *buf)
1190 {
1191   struct GNUNET_MessageHeader *msg = cls;
1192   size_t total_size;
1193
1194   GNUNET_assert (NULL != msg);
1195   total_size = ntohs (msg->size);
1196
1197   if (total_size > size)
1198   {
1199     GNUNET_break (0);
1200     return 0;
1201   }
1202   memcpy (buf, msg, total_size);
1203   GNUNET_free (cls);
1204   return total_size;
1205 }
1206
1207
1208 /**
1209  * Sends an already built message to a peer, properly registrating
1210  * all used resources.
1211  *
1212  * @param message Message to send. Function makes a copy of it.
1213  * @param peer Short ID of the neighbor whom to send the message.
1214  * @param t Tunnel on which this message is transmitted.
1215  */
1216 static void
1217 send_prebuilt_message (const struct GNUNET_MessageHeader *message,
1218                        GNUNET_PEER_Id peer,
1219                        struct MeshTunnel *t)
1220 {
1221   struct GNUNET_PeerIdentity id;
1222   struct MeshPeerInfo *neighbor;
1223   struct MeshPeerPath *p;
1224   void *data;
1225   size_t size;
1226   uint16_t type;
1227
1228 //   GNUNET_TRANSPORT_try_connect(); FIXME use?
1229
1230   if (0 == peer)
1231     return;
1232
1233   size = ntohs (message->size);
1234   data = GNUNET_malloc (size);
1235   memcpy (data, message, size);
1236   type = ntohs(message->type);
1237   if (GNUNET_MESSAGE_TYPE_MESH_UNICAST == type ||
1238       GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN == type)
1239   {
1240     struct GNUNET_MESH_Data *u;
1241
1242     u = (struct GNUNET_MESH_Data *) data;
1243     u->ttl = htonl (ntohl (u->ttl) - 1);
1244   }
1245   GNUNET_PEER_resolve (peer, &id);
1246   neighbor = peer_get (&id);
1247   for (p = neighbor->path_head; NULL != p; p = p->next)
1248   {
1249     if (2 >= p->length)
1250     {
1251       break;
1252     }
1253   }
1254   if (NULL == p)
1255   {
1256 #if MESH_DEBUG
1257     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1258                 "  %s IS NOT DIRECTLY CONNECTED\n",
1259                 GNUNET_i2s(&id));
1260     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1261                 "  PATHS TO %s:\n",
1262                 GNUNET_i2s(&id));
1263     for (p = neighbor->path_head; NULL != p; p = p->next)
1264     {
1265       struct GNUNET_PeerIdentity debug_id;
1266       unsigned int i;
1267
1268       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1269                   "    path with %u hops through:\n",
1270                   p->length);
1271       for (i = 0; i < p->length; i++)
1272       {
1273         GNUNET_PEER_resolve(p->peers[i], &debug_id);
1274         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1275                     "      hop %u: %s\n",
1276                     i, GNUNET_i2s(&debug_id));
1277       }
1278     }
1279 #endif
1280     GNUNET_break (0); // FIXME sometimes fails (testing disconnect?)
1281     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1282                     " no direct connection to %s\n",
1283                     GNUNET_i2s (&id));
1284     GNUNET_free (data);
1285     return;
1286   }
1287   if (GNUNET_MESSAGE_TYPE_MESH_PATH_ACK == type)
1288     type = 0;
1289   queue_add (data,
1290              type,
1291              size,
1292              neighbor,
1293              t);
1294 }
1295
1296
1297 /**
1298  * Sends a CREATE PATH message for a path to a peer, properly registrating
1299  * all used resources.
1300  *
1301  * @param t Tunnel for which the path is created.
1302  */
1303 static void
1304 send_create_path (struct MeshTunnel *t)
1305 {
1306   struct MeshPeerInfo *neighbor;
1307
1308   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Send create path\n");
1309   neighbor = peer_get_short (t->next_hop);
1310   queue_add (t,
1311              GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE,
1312              sizeof (struct GNUNET_MESH_CreateTunnel) +
1313                 (t->path->length * sizeof (struct GNUNET_PeerIdentity)),
1314              neighbor,
1315              t);
1316   t->state = MESH_TUNNEL_WAITING;
1317 }
1318
1319
1320 /**
1321  * Sends a PATH ACK message in reponse to a received PATH_CREATE directed to us.
1322  *
1323  * @param t Tunnel which to confirm.
1324  */
1325 static void
1326 send_path_ack (struct MeshTunnel *t) 
1327 {
1328   struct MeshPeerInfo *peer;
1329
1330   peer = peer_get_short (t->prev_hop);
1331
1332   queue_add (t,
1333              GNUNET_MESSAGE_TYPE_MESH_PATH_ACK,
1334              sizeof (struct GNUNET_MESH_PathACK),
1335              peer,
1336              t);
1337 }
1338
1339
1340 /**
1341  * Try to establish a new connection to this peer in the given tunnel.
1342  * If the peer doesn't have any path to it yet, try to get one.
1343  * If the peer already has some path, send a CREATE PATH towards it.
1344  *
1345  * @param peer PeerInfo of the peer.
1346  * @param t Tunnel for which to create the path, if possible.
1347  */
1348 static void
1349 peer_connect (struct MeshPeerInfo *peer, struct MeshTunnel *t)
1350 {
1351   struct MeshPeerPath *p;
1352
1353   if (NULL != peer->path_head)
1354   {
1355     p = peer_get_best_path (peer, t);
1356     tunnel_use_path (t, p);
1357     send_create_path (t);
1358   }
1359   else if (NULL == peer->dhtget)
1360   {
1361     struct GNUNET_PeerIdentity id;
1362
1363     GNUNET_PEER_resolve (peer->id, &id);
1364     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1365                 "  Starting DHT GET for peer %s\n", GNUNET_i2s (&id));
1366     peer->dhtget = GNUNET_DHT_get_start (dht_handle,    /* handle */
1367                                          GNUNET_BLOCK_TYPE_MESH_PEER, /* type */
1368                                          &id.hashPubKey,     /* key to search */
1369                                          dht_replication_level, /* replication level */
1370                                          GNUNET_DHT_RO_RECORD_ROUTE |
1371                                          GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
1372                                          NULL,       /* xquery */
1373                                          0,     /* xquery bits */
1374                                          &dht_get_id_handler, peer);
1375     t->state = MESH_TUNNEL_SEARCHING;
1376   }
1377   else
1378   {
1379     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1380                 "There is no path but the DHT GET is already started.\n");
1381   }
1382 }
1383
1384
1385 /**
1386  * Destroy the peer_info and free any allocated resources linked to it
1387  *
1388  * @param pi The peer_info to destroy.
1389  *
1390  * @return GNUNET_OK on success
1391  */
1392 static int
1393 peer_info_destroy (struct MeshPeerInfo *pi)
1394 {
1395   struct GNUNET_PeerIdentity id;
1396   struct MeshPeerPath *p;
1397   struct MeshPeerPath *nextp;
1398   unsigned int i;
1399
1400   GNUNET_PEER_resolve (pi->id, &id);
1401   GNUNET_PEER_change_rc (pi->id, -1);
1402
1403   if (GNUNET_YES !=
1404       GNUNET_CONTAINER_multihashmap_remove (peers, &id.hashPubKey, pi))
1405   {
1406     GNUNET_break (0);
1407     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1408                 "removing peer %s, not in hashmap\n", GNUNET_i2s (&id));
1409   }
1410   if (NULL != pi->dhtget)
1411   {
1412     GNUNET_DHT_get_stop (pi->dhtget);
1413   }
1414   p = pi->path_head;
1415   while (NULL != p)
1416   {
1417     nextp = p->next;
1418     GNUNET_CONTAINER_DLL_remove (pi->path_head, pi->path_tail, p);
1419     path_destroy (p);
1420     p = nextp;
1421   }
1422   for (i = 0; i < pi->ntunnels; i++)
1423     tunnel_destroy_empty (pi->tunnels[i]);
1424   GNUNET_array_grow (pi->tunnels, pi->ntunnels, 0);
1425   GNUNET_free (pi);
1426   return GNUNET_OK;
1427 }
1428
1429
1430 /**
1431  * Remove all paths that rely on a direct connection between p1 and p2
1432  * from the peer itself and notify all tunnels about it.
1433  *
1434  * @param peer PeerInfo of affected peer.
1435  * @param p1 GNUNET_PEER_Id of one peer.
1436  * @param p2 GNUNET_PEER_Id of another peer that was connected to the first and
1437  *           no longer is.
1438  *
1439  * TODO: optimize (see below)
1440  */
1441 static void
1442 peer_remove_path (struct MeshPeerInfo *peer, GNUNET_PEER_Id p1,
1443                        GNUNET_PEER_Id p2)
1444 {
1445   struct MeshPeerPath *p;
1446   struct MeshPeerPath *next;
1447   struct MeshPeerInfo *peer_d;
1448   GNUNET_PEER_Id d;
1449   unsigned int destroyed;
1450   unsigned int i;
1451
1452   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "peer_info_remove_path\n");
1453   destroyed = 0;
1454   for (p = peer->path_head; NULL != p; p = next)
1455   {
1456     next = p->next;
1457     for (i = 0; i < (p->length - 1); i++)
1458     {
1459       if ((p->peers[i] == p1 && p->peers[i + 1] == p2) ||
1460           (p->peers[i] == p2 && p->peers[i + 1] == p1))
1461       {
1462         GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, p);
1463         path_destroy (p);
1464         destroyed++;
1465         break;
1466       }
1467     }
1468   }
1469   if (0 == destroyed)
1470     return;
1471
1472   for (i = 0; i < peer->ntunnels; i++)
1473   {
1474     d = tunnel_notify_connection_broken (peer->tunnels[i], p1, p2);
1475     if (0 == d)
1476       continue;
1477
1478     peer_d = peer_get_short (d);
1479     next = peer_get_best_path (peer_d, peer->tunnels[i]);
1480     tunnel_use_path (peer->tunnels[i], next);
1481     peer_connect (peer_d, peer->tunnels[i]);
1482   }
1483   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "peer_info_remove_path END\n");
1484 }
1485
1486
1487 /**
1488  * Add the path to the peer and update the path used to reach it in case this
1489  * is the shortest.
1490  *
1491  * @param peer_info Destination peer to add the path to.
1492  * @param path New path to add. Last peer must be the peer in arg 1.
1493  *             Path will be either used of freed if already known.
1494  * @param trusted Do we trust that this path is real?
1495  */
1496 void
1497 peer_info_add_path (struct MeshPeerInfo *peer_info, struct MeshPeerPath *path,
1498                     int trusted)
1499 {
1500   struct MeshPeerPath *aux;
1501   unsigned int l;
1502   unsigned int l2;
1503
1504   if ((NULL == peer_info) || (NULL == path))
1505   {
1506     GNUNET_break (0);
1507     path_destroy (path);
1508     return;
1509   }
1510   if (path->peers[path->length - 1] != peer_info->id)
1511   {
1512     GNUNET_break (0);
1513     path_destroy (path);
1514     return;
1515   }
1516   if (2 >= path->length && GNUNET_NO == trusted)
1517   {
1518     /* Only allow CORE to tell us about direct paths */
1519     path_destroy (path);
1520     return;
1521   }
1522   for (l = 1; l < path->length; l++)
1523   {
1524     if (path->peers[l] == myid)
1525     {
1526       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "shortening path by %u\n", l);
1527       for (l2 = 0; l2 < path->length - l; l2++)
1528       {
1529         path->peers[l2] = path->peers[l + l2];
1530       }
1531       path->length -= l;
1532       l = 1;
1533       path->peers =
1534           GNUNET_realloc (path->peers, path->length * sizeof (GNUNET_PEER_Id));
1535     }
1536   }
1537 #if MESH_DEBUG
1538   {
1539     struct GNUNET_PeerIdentity id;
1540
1541     GNUNET_PEER_resolve (peer_info->id, &id);
1542     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "adding path [%u] to peer %s\n",
1543                 path->length, GNUNET_i2s (&id));
1544   }
1545 #endif
1546   l = path_get_length (path);
1547   if (0 == l)
1548   {
1549     path_destroy (path);
1550     return;
1551   }
1552
1553   GNUNET_assert (peer_info->id == path->peers[path->length - 1]);
1554   for (aux = peer_info->path_head; aux != NULL; aux = aux->next)
1555   {
1556     l2 = path_get_length (aux);
1557     if (l2 > l)
1558     {
1559       GNUNET_CONTAINER_DLL_insert_before (peer_info->path_head,
1560                                           peer_info->path_tail, aux, path);
1561       return;
1562     }
1563     else
1564     {
1565       if (l2 == l && memcmp (path->peers, aux->peers, l) == 0)
1566       {
1567         path_destroy (path);
1568         return;
1569       }
1570     }
1571   }
1572   GNUNET_CONTAINER_DLL_insert_tail (peer_info->path_head, peer_info->path_tail,
1573                                     path);
1574   return;
1575 }
1576
1577
1578 /**
1579  * Add the path to the origin peer and update the path used to reach it in case
1580  * this is the shortest.
1581  * The path is given in peer_info -> destination, therefore we turn the path
1582  * upside down first.
1583  *
1584  * @param peer_info Peer to add the path to, being the origin of the path.
1585  * @param path New path to add after being inversed.
1586  *             Path will be either used or freed.
1587  * @param trusted Do we trust that this path is real?
1588  */
1589 static void
1590 peer_info_add_path_to_origin (struct MeshPeerInfo *peer_info,
1591                               struct MeshPeerPath *path, int trusted)
1592 {
1593   path_invert (path);
1594   peer_info_add_path (peer_info, path, trusted);
1595 }
1596
1597
1598 /**
1599  * Add a tunnel to the list of tunnels a peer participates in.
1600  * Update the tunnel's destination.
1601  * 
1602  * @param p Peer to add to.
1603  * @param t Tunnel to add.
1604  */
1605 static void
1606 peer_info_add_tunnel (struct MeshPeerInfo *p, struct MeshTunnel *t)
1607 {
1608   if (0 != t->dest)
1609   {
1610     GNUNET_break (t->dest == p->id);
1611     return;
1612   }
1613   t->dest = p->id;
1614   GNUNET_PEER_change_rc (t->dest, 1);
1615   GNUNET_array_append (p->tunnels, p->ntunnels, t);
1616 }
1617
1618
1619 /**
1620  * Remove a tunnel from the list of tunnels a peer participates in.
1621  * Free the tunnel's destination.
1622  * 
1623  * @param p Peer to clean.
1624  * @param t Tunnel to remove.
1625  */
1626 static void
1627 peer_info_remove_tunnel (struct MeshPeerInfo *p, struct MeshTunnel *t)
1628 {
1629   unsigned int i;
1630
1631   if (t->dest == p->id)
1632   {
1633       GNUNET_PEER_change_rc (t->dest, -1);
1634       t->dest = 0;
1635   }
1636   for (i = 0; i < p->ntunnels; i++)
1637   {
1638     if (p->tunnels[i] == t)
1639     {
1640       p->tunnels[i] = p->tunnels[p->ntunnels - 1];
1641       GNUNET_array_grow (p->tunnels, p->ntunnels, p->ntunnels - 1);
1642       return;
1643     }
1644   }
1645 }
1646
1647
1648 /**
1649  * Function called if the connection to the peer has been stalled for a while,
1650  * possibly due to a missed ACK. Poll the peer about its ACK status.
1651  *
1652  * @param cls Closure (poll ctx).
1653  * @param tc TaskContext.
1654  */
1655 static void
1656 tunnel_poll (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1657 {
1658   struct MeshFlowControl *fc = cls;
1659   struct GNUNET_MESH_Poll msg;
1660   struct MeshTunnel *t = fc->t;
1661   GNUNET_PEER_Id peer;
1662
1663   fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
1664   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1665   {
1666     return;
1667   }
1668
1669   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " *** Polling!\n");
1670
1671   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_POLL);
1672   msg.header.size = htons (sizeof (msg));
1673   msg.tid = htonl (t->id.tid);
1674   msg.pid = htonl (fc->last_pid_sent);
1675   GNUNET_PEER_resolve (t->id.oid, &msg.oid);
1676
1677   if (fc == &t->prev_fc)
1678   {
1679     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " *** prev peer!\n");
1680     peer = t->prev_hop;
1681   }
1682   else if (fc == &t->next_fc)
1683   {
1684     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " *** next peer!\n");
1685     peer = t->next_hop;
1686   }
1687   else
1688   {
1689     GNUNET_break (0);
1690     return;
1691   }
1692   send_prebuilt_message (&msg.header, peer, t);
1693   fc->poll_time = GNUNET_TIME_STD_BACKOFF (fc->poll_time);
1694   fc->poll_task = GNUNET_SCHEDULER_add_delayed (fc->poll_time,
1695                                                 &tunnel_poll, fc);
1696 }
1697
1698
1699 /**
1700  * Build a PeerPath from the paths returned from the DHT, reversing the paths
1701  * to obtain a local peer -> destination path and interning the peer ids.
1702  *
1703  * @return Newly allocated and created path
1704  */
1705 static struct MeshPeerPath *
1706 path_build_from_dht (const struct GNUNET_PeerIdentity *get_path,
1707                      unsigned int get_path_length,
1708                      const struct GNUNET_PeerIdentity *put_path,
1709                      unsigned int put_path_length)
1710 {
1711   struct MeshPeerPath *p;
1712   GNUNET_PEER_Id id;
1713   int i;
1714
1715   p = path_new (1);
1716   p->peers[0] = myid;
1717   GNUNET_PEER_change_rc (myid, 1);
1718   i = get_path_length;
1719   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   GET has %d hops.\n", i);
1720   for (i--; i >= 0; i--)
1721   {
1722     id = GNUNET_PEER_intern (&get_path[i]);
1723     if (p->length > 0 && id == p->peers[p->length - 1])
1724     {
1725       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   Optimizing 1 hop out.\n");
1726       GNUNET_PEER_change_rc (id, -1);
1727     }
1728     else
1729     {
1730       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   Adding from GET: %s.\n",
1731                   GNUNET_i2s (&get_path[i]));
1732       p->length++;
1733       p->peers = GNUNET_realloc (p->peers, sizeof (GNUNET_PEER_Id) * p->length);
1734       p->peers[p->length - 1] = id;
1735     }
1736   }
1737   i = put_path_length;
1738   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   PUT has %d hops.\n", i);
1739   for (i--; i >= 0; i--)
1740   {
1741     id = GNUNET_PEER_intern (&put_path[i]);
1742     if (id == myid)
1743     {
1744       /* PUT path went through us, so discard the path up until now and start
1745        * from here to get a much shorter (and loop-free) path.
1746        */
1747       path_destroy (p);
1748       p = path_new (0);
1749     }
1750     if (p->length > 0 && id == p->peers[p->length - 1])
1751     {
1752       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   Optimizing 1 hop out.\n");
1753       GNUNET_PEER_change_rc (id, -1);
1754     }
1755     else
1756     {
1757       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   Adding from PUT: %s.\n",
1758                   GNUNET_i2s (&put_path[i]));
1759       p->length++;
1760       p->peers = GNUNET_realloc (p->peers, sizeof (GNUNET_PEER_Id) * p->length);
1761       p->peers[p->length - 1] = id;
1762     }
1763   }
1764 #if MESH_DEBUG
1765   if (get_path_length > 0)
1766     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   (first of GET: %s)\n",
1767                 GNUNET_i2s (&get_path[0]));
1768   if (put_path_length > 0)
1769     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   (first of PUT: %s)\n",
1770                 GNUNET_i2s (&put_path[0]));
1771   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   In total: %d hops\n",
1772               p->length);
1773   for (i = 0; i < p->length; i++)
1774   {
1775     struct GNUNET_PeerIdentity peer_id;
1776
1777     GNUNET_PEER_resolve (p->peers[i], &peer_id);
1778     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "       %u: %s\n", p->peers[i],
1779                 GNUNET_i2s (&peer_id));
1780   }
1781 #endif
1782   return p;
1783 }
1784
1785
1786 /**
1787  * Adds a path to the peer_infos of all the peers in the path
1788  *
1789  * @param p Path to process.
1790  * @param confirmed Whether we know if the path works or not.
1791  */
1792 static void
1793 path_add_to_peers (struct MeshPeerPath *p, int confirmed)
1794 {
1795   unsigned int i;
1796
1797   /* TODO: invert and add */
1798   for (i = 0; i < p->length && p->peers[i] != myid; i++) /* skip'em */ ;
1799   for (i++; i < p->length; i++)
1800   {
1801     struct MeshPeerInfo *aux;
1802     struct MeshPeerPath *copy;
1803
1804     aux = peer_get_short (p->peers[i]);
1805     copy = path_duplicate (p);
1806     copy->length = i + 1;
1807     peer_info_add_path (aux, copy, p->length < 3 ? GNUNET_NO : confirmed);
1808   }
1809 }
1810
1811
1812 /**
1813  * Send keepalive packets for a peer
1814  *
1815  * @param cls Closure (tunnel for which to send the keepalive).
1816  * @param tc Notification context.
1817  */
1818 static void
1819 path_refresh (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
1820
1821
1822 /**
1823  * Search for a tunnel among the incoming tunnels
1824  *
1825  * @param tid the local id of the tunnel
1826  *
1827  * @return tunnel handler, NULL if doesn't exist
1828  */
1829 static struct MeshTunnel *
1830 tunnel_get_incoming (MESH_TunnelNumber tid)
1831 {
1832   GNUNET_assert (tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV);
1833   return GNUNET_CONTAINER_multihashmap32_get (incoming_tunnels, tid);
1834 }
1835
1836
1837 /**
1838  * Search for a tunnel among the tunnels for a client
1839  *
1840  * @param c the client whose tunnels to search in
1841  * @param tid the local id of the tunnel
1842  *
1843  * @return tunnel handler, NULL if doesn't exist
1844  */
1845 static struct MeshTunnel *
1846 tunnel_get_by_local_id (struct MeshClient *c, MESH_TunnelNumber tid)
1847 {
1848   if (tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV)
1849   {
1850     return tunnel_get_incoming (tid);
1851   }
1852   else
1853   {
1854     GNUNET_assert (tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_CLI);
1855     return GNUNET_CONTAINER_multihashmap32_get (c->own_tunnels, tid);
1856   }
1857 }
1858
1859
1860 /**
1861  * Search for a tunnel by global ID using PEER_ID
1862  *
1863  * @param pi owner of the tunnel
1864  * @param tid global tunnel number
1865  *
1866  * @return tunnel handler, NULL if doesn't exist
1867  */
1868 static struct MeshTunnel *
1869 tunnel_get_by_pi (GNUNET_PEER_Id pi, MESH_TunnelNumber tid)
1870 {
1871   struct MESH_TunnelID id;
1872   struct GNUNET_HashCode hash;
1873
1874   id.oid = pi;
1875   id.tid = tid;
1876
1877   GNUNET_CRYPTO_hash (&id, sizeof (struct MESH_TunnelID), &hash);
1878   return GNUNET_CONTAINER_multihashmap_get (tunnels, &hash);
1879 }
1880
1881
1882 /**
1883  * Search for a tunnel by global ID using full PeerIdentities
1884  *
1885  * @param oid owner of the tunnel
1886  * @param tid global tunnel number
1887  *
1888  * @return tunnel handler, NULL if doesn't exist
1889  */
1890 static struct MeshTunnel *
1891 tunnel_get (const struct GNUNET_PeerIdentity *oid, MESH_TunnelNumber tid)
1892 {
1893   return tunnel_get_by_pi (GNUNET_PEER_search (oid), tid);
1894 }
1895
1896
1897 /**
1898  * Add a client to a tunnel, initializing all needed data structures.
1899  * 
1900  * @param t Tunnel to which add the client.
1901  * @param c Client which to add to the tunnel.
1902  */
1903 static void
1904 tunnel_add_client (struct MeshTunnel *t, struct MeshClient *c)
1905 {
1906   if (NULL != t->client)
1907   {
1908     GNUNET_break(0);
1909     return;
1910   }
1911   if (GNUNET_OK !=
1912       GNUNET_CONTAINER_multihashmap32_put (c->incoming_tunnels,
1913                                            t->local_tid_dest, t,
1914                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
1915   {
1916     GNUNET_break (0);
1917     return;
1918   }
1919   if (GNUNET_OK !=
1920       GNUNET_CONTAINER_multihashmap32_put (incoming_tunnels,
1921                                            t->local_tid_dest, t,
1922                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
1923   {
1924     GNUNET_break (0);
1925     return;
1926   }
1927   t->client = c;
1928 }
1929
1930
1931 static void
1932 tunnel_use_path (struct MeshTunnel *t, struct MeshPeerPath *p)
1933 {
1934   unsigned int own_pos;
1935
1936   for (own_pos = 0; own_pos < p->length; own_pos++)
1937   {
1938     if (p->peers[own_pos] == myid)
1939       break;
1940   }
1941   if (own_pos > p->length - 1)
1942   {
1943     GNUNET_break (0);
1944     return;
1945   }
1946
1947   if (own_pos < p->length - 1)
1948     t->next_hop = p->peers[own_pos + 1];
1949   else
1950     t->next_hop = p->peers[own_pos];
1951   GNUNET_PEER_change_rc (t->next_hop, 1);
1952   if (0 < own_pos)
1953     t->prev_hop = p->peers[own_pos - 1];
1954   else
1955     t->prev_hop = p->peers[0];
1956   GNUNET_PEER_change_rc (t->prev_hop, 1);
1957
1958   if (NULL != t->path)
1959     path_destroy (t->path);
1960   t->path = path_duplicate (p);
1961   if (0 == own_pos)
1962   {
1963     if (GNUNET_SCHEDULER_NO_TASK != t->maintenance_task)
1964       GNUNET_SCHEDULER_cancel (t->maintenance_task);
1965     t->maintenance_task = GNUNET_SCHEDULER_add_delayed (refresh_path_time,
1966                                                         &path_refresh, t);
1967   }
1968 }
1969
1970
1971 /**
1972  * Notifies a tunnel that a connection has broken that affects at least
1973  * some of its peers. Sends a notification towards the root of the tree.
1974  * In case the peer is the owner of the tree, notifies the client that owns
1975  * the tunnel and tries to reconnect.
1976  *
1977  * @param t Tunnel affected.
1978  * @param p1 Peer that got disconnected from p2.
1979  * @param p2 Peer that got disconnected from p1.
1980  *
1981  * @return Short ID of the peer disconnected (either p1 or p2).
1982  *         0 if the tunnel remained unaffected.
1983  */
1984 static GNUNET_PEER_Id
1985 tunnel_notify_connection_broken (struct MeshTunnel *t, GNUNET_PEER_Id p1,
1986                                  GNUNET_PEER_Id p2)
1987 {
1988 //   if (myid != p1 && myid != p2) FIXME
1989 //   {
1990 //     return;
1991 //   }
1992 // 
1993 //   if (tree_get_predecessor (t->tree) != 0)
1994 //   {
1995 //     /* We are the peer still connected, notify owner of the disconnection. */
1996 //     struct GNUNET_MESH_PathBroken msg;
1997 //     struct GNUNET_PeerIdentity neighbor;
1998 // 
1999 //     msg.header.size = htons (sizeof (msg));
2000 //     msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_BROKEN);
2001 //     GNUNET_PEER_resolve (t->id.oid, &msg.oid);
2002 //     msg.tid = htonl (t->id.tid);
2003 //     msg.peer1 = my_full_id;
2004 //     GNUNET_PEER_resolve (pid, &msg.peer2);
2005 //     GNUNET_PEER_resolve (tree_get_predecessor (t->tree), &neighbor);
2006 //     send_prebuilt_message (&msg.header, &neighbor, t);
2007 //   }
2008   return 0;
2009 }
2010
2011
2012 /**
2013  * Build a local ACK message and send it to a local client.
2014  * 
2015  * @param t Tunnel on which to send the ACK.
2016  * @param c Client to whom send the ACK.
2017  * @param is_fwd Set to GNUNET_YES for FWD ACK (dest->owner)
2018  */
2019 static void
2020 send_local_ack (struct MeshTunnel *t,
2021                 struct MeshClient *c,
2022                 int is_fwd)
2023 {
2024   struct GNUNET_MESH_LocalAck msg;
2025
2026   msg.header.size = htons (sizeof (msg));
2027   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_ACK);
2028   msg.tunnel_id = htonl (is_fwd ? t->local_tid : t->local_tid_dest);
2029   GNUNET_SERVER_notification_context_unicast (nc,
2030                                               c->handle,
2031                                               &msg.header,
2032                                               GNUNET_NO);
2033 }
2034
2035 /**
2036  * Build an ACK message and queue it to send to the given peer.
2037  * 
2038  * @param t Tunnel on which to send the ACK.
2039  * @param peer Peer to whom send the ACK.
2040  * @param ack Value of the ACK.
2041  */
2042 static void
2043 send_ack (struct MeshTunnel *t, GNUNET_PEER_Id peer,  uint32_t ack)
2044 {
2045   struct GNUNET_MESH_ACK msg;
2046
2047   GNUNET_PEER_resolve (t->id.oid, &msg.oid);
2048   msg.header.size = htons (sizeof (msg));
2049   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_ACK);
2050   msg.pid = htonl (ack);
2051   msg.tid = htonl (t->id.tid);
2052
2053   send_prebuilt_message (&msg.header, peer, t);
2054 }
2055
2056
2057 /**
2058  * Send an end-to-end FWD ACK message for the most recent in-sequence payload.
2059  * 
2060  * @param t Tunnel this is about.
2061  */
2062 static void
2063 tunnel_send_fwd_data_ack (struct MeshTunnel *t)
2064 {
2065   struct GNUNET_MESH_DataACK msg;
2066
2067   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_UNICAST_ACK);
2068   msg.header.size = htons (sizeof (msg));
2069   msg.tid = htonl (t->id.tid);
2070   GNUNET_PEER_resolve (t->id.oid, &msg.oid);
2071   msg.mid = GNUNET_htonll (t->bck_rel->mid_recv - 1);
2072   msg.futures = 0; // FIXME set bits of other newer messages received
2073
2074   send_prebuilt_message (&msg.header, t->prev_hop, t);
2075 }
2076
2077
2078 /**
2079  * Send an end-to-end BCK ACK message for the most recent in-sequence payload.
2080  * 
2081  * @param t Tunnel this is about.
2082  */
2083 static void
2084 tunnel_send_bck_data_ack (struct MeshTunnel *t)
2085 {
2086   struct GNUNET_MESH_DataACK msg;
2087
2088   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_TO_ORIG_ACK);
2089   msg.header.size = htons (sizeof (msg));
2090   msg.tid = htonl (t->id.tid);
2091   GNUNET_PEER_resolve (t->id.oid, &msg.oid);
2092   msg.mid = GNUNET_htonll (t->fwd_rel->mid_recv - 1);
2093   msg.futures = 0; // FIXME set bits of other newer messages received
2094
2095   send_prebuilt_message (&msg.header, t->next_hop, t);
2096 }
2097
2098
2099 /**
2100  * Send an ACK informing the predecessor about the available buffer space.
2101  * In case there is no predecessor, inform the owning client.
2102  * If buffering is off, send only on behalf of children or self if endpoint.
2103  * If buffering is on, send when sent to children and buffer space is free.
2104  * Note that although the name is fwd_ack, the FWD mean forward *traffic*,
2105  * the ACK itself goes "back" (towards root).
2106  * 
2107  * @param t Tunnel on which to send the ACK.
2108  * @param type Type of message that triggered the ACK transmission.
2109  */
2110 static void
2111 tunnel_send_fwd_ack (struct MeshTunnel *t, uint16_t type)
2112 {
2113   uint32_t ack;
2114   int delta;
2115
2116   /* Is it after unicast retransmission? */
2117   switch (type)
2118   {
2119     case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
2120       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2121                   "ACK due to FWD DATA retransmission\n");
2122       if (GNUNET_YES == t->nobuffer)
2123       {
2124         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Not sending ACK, nobuffer\n");
2125         return;
2126       }
2127       if (GNUNET_YES == t->reliable && NULL != t->client)
2128         tunnel_send_fwd_data_ack (t);
2129       break;
2130     case GNUNET_MESSAGE_TYPE_MESH_ACK:
2131     case GNUNET_MESSAGE_TYPE_MESH_LOCAL_ACK:
2132       break;
2133     case GNUNET_MESSAGE_TYPE_MESH_POLL:
2134     case GNUNET_MESSAGE_TYPE_MESH_PATH_ACK:
2135       t->force_ack = GNUNET_YES;
2136       break;
2137     default:
2138       GNUNET_break (0);
2139   }
2140
2141   /* Check if we need to transmit the ACK */
2142   if (0 && NULL == t->owner && 
2143       t->queue_max > t->next_fc.queue_n * 4 &&
2144       GMC_is_pid_bigger(t->prev_fc.last_ack_sent, t->prev_fc.last_pid_recv) &&
2145       GNUNET_NO == t->force_ack)
2146   {
2147     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Not sending FWD ACK, buffer free\n");
2148     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2149                 "  t->qmax: %u, t->qn: %u\n",
2150                 t->queue_max, t->next_fc.queue_n);
2151     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2152                 "  t->pid: %u, t->ack: %u\n",
2153                 t->prev_fc.last_pid_recv, t->prev_fc.last_ack_sent);
2154     return;
2155   }
2156
2157   /* Ok, ACK might be necessary, what PID to ACK? */
2158   delta = t->queue_max - t->next_fc.queue_n;
2159   if (0 > delta)
2160     delta = 0;
2161   if (NULL != t->owner && delta > 1)
2162     delta = 1;
2163   ack = t->prev_fc.last_pid_recv + delta;
2164   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " FWD ACK %u\n", ack);
2165   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2166               " last %u, qmax %u, q %u\n",
2167               t->prev_fc.last_pid_recv, t->queue_max, t->next_fc.queue_n);
2168   if (ack == t->prev_fc.last_ack_sent && GNUNET_NO == t->force_ack)
2169   {
2170     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Not sending FWD ACK, not needed\n");
2171     return;
2172   }
2173
2174   t->prev_fc.last_ack_sent = ack;
2175   if (NULL != t->owner)
2176     send_local_ack (t, t->owner, GNUNET_YES);
2177   else if (0 != t->prev_hop)
2178     send_ack (t, t->prev_hop, ack);
2179   else
2180     GNUNET_break (0);
2181   debug_fwd_ack++;
2182   t->force_ack = GNUNET_NO;
2183 }
2184
2185
2186 /**
2187  * Send an ACK informing the children node/client about the available
2188  * buffer space.
2189  * If buffering is off, send only on behalf of root (can be self).
2190  * If buffering is on, send when sent to predecessor and buffer space is free.
2191  * Note that although the name is bck_ack, the BCK mean backwards *traffic*,
2192  * the ACK itself goes "forward" (towards children/clients).
2193  * 
2194  * @param t Tunnel on which to send the ACK.
2195  * @param type Type of message that triggered the ACK transmission.
2196  */
2197 static void
2198 tunnel_send_bck_ack (struct MeshTunnel *t, uint16_t type)
2199 {
2200   uint32_t ack;
2201   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2202               "Sending BCK ACK on tunnel %u [%u] due to %s\n",
2203               t->id.oid, t->id.tid, GNUNET_MESH_DEBUG_M2S(type));
2204   /* Is it after data to_origin retransmission? */
2205   switch (type)
2206   {
2207     case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
2208       if (GNUNET_YES == t->nobuffer)
2209       {
2210         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2211                     "    Not sending ACK, nobuffer + traffic\n");
2212         return;
2213       }
2214       if (GNUNET_YES == t->reliable && NULL != t->owner)
2215         tunnel_send_bck_data_ack (t);
2216       break;
2217     case GNUNET_MESSAGE_TYPE_MESH_ACK:
2218     case GNUNET_MESSAGE_TYPE_MESH_LOCAL_ACK:
2219       break;
2220     case GNUNET_MESSAGE_TYPE_MESH_PATH_ACK:
2221     case GNUNET_MESSAGE_TYPE_MESH_POLL:
2222       t->force_ack = GNUNET_YES;
2223       break;
2224     default:
2225       GNUNET_break (0);
2226   }
2227
2228   /* TODO: Check if we need to transmit the ACK (as in fwd) */
2229
2230   ack = t->next_fc.last_pid_recv + t->queue_max - t->prev_fc.queue_n;
2231
2232   if (t->next_fc.last_ack_sent == ack && GNUNET_NO == t->force_ack)
2233   {
2234     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2235                 "    Not sending ACK, not needed, last ack sent was %u\n",
2236                 t->next_fc.last_ack_sent);
2237     return;
2238   }
2239   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2240               "    Sending BCK ACK %u (last sent: %u)\n",
2241               ack, t->next_fc.last_ack_sent);
2242   t->next_fc.last_ack_sent = ack;
2243
2244   if (NULL != t->client)
2245     send_local_ack (t, t->client, GNUNET_NO);
2246   else if (0 != t->next_hop)
2247     send_ack (t, t->next_hop, ack);
2248   else
2249     GNUNET_break (0);
2250   t->force_ack = GNUNET_NO;
2251 }
2252
2253
2254 /**
2255  * Modify the mesh message TID from global to local and send to client.
2256  * 
2257  * @param t Tunnel on which to send the message.
2258  * @param msg Message to modify and send.
2259  * @param c Client to send to.
2260  * @param tid Tunnel ID to use (c can be both owner and client).
2261  */
2262 static void
2263 tunnel_send_client_data (struct MeshTunnel *t,
2264                          const struct GNUNET_MESH_Data *msg,
2265                          struct MeshClient *c, MESH_TunnelNumber tid)
2266 {
2267   struct GNUNET_MESH_LocalData *copy;
2268   uint16_t size = ntohs (msg->header.size) - sizeof (struct GNUNET_MESH_Data);
2269   char cbuf[size + sizeof (struct GNUNET_MESH_LocalData)];
2270
2271   if (size < sizeof (struct GNUNET_MessageHeader))
2272   {
2273     GNUNET_break_op (0);
2274     return;
2275   }
2276   if (NULL == c)
2277   {
2278     GNUNET_break (0);
2279     return;
2280   }
2281   copy = (struct GNUNET_MESH_LocalData *) cbuf;
2282   memcpy (&copy[1], &msg[1], size);
2283   copy->header.size = htons (sizeof (struct GNUNET_MESH_LocalData) + size);
2284   copy->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_DATA);
2285   copy->tid = htonl (tid);
2286   GNUNET_SERVER_notification_context_unicast (nc, c->handle,
2287                                               &copy->header, GNUNET_NO);
2288 }
2289
2290 /**
2291  * Modify the unicast message TID from global to local and send to client.
2292  * 
2293  * @param t Tunnel on which to send the message.
2294  * @param msg Message to modify and send.
2295  */
2296 static void
2297 tunnel_send_client_ucast (struct MeshTunnel *t,
2298                           const struct GNUNET_MESH_Data *msg)
2299 {
2300   tunnel_send_client_data (t, msg, t->client, t->local_tid_dest);
2301 }
2302
2303
2304 /**
2305  * Modify the to_origin  message TID from global to local and send to client.
2306  * 
2307  * @param t Tunnel on which to send the message.
2308  * @param msg Message to modify and send.
2309  */
2310 static void
2311 tunnel_send_client_to_orig (struct MeshTunnel *t,
2312                             const struct GNUNET_MESH_Data *msg)
2313 {
2314   tunnel_send_client_data (t, msg, t->owner, t->local_tid);
2315 }
2316
2317
2318 /**
2319  * We haven't received an ACK after a certain time: restransmit the message.
2320  *
2321  * @param cls Closure (MeshReliableMessage with the message to restransmit)
2322  * @param tc TaskContext.
2323  */
2324 static void
2325 tunnel_retransmit_message (void *cls,
2326                            const struct GNUNET_SCHEDULER_TaskContext *tc)
2327 {
2328   struct MeshTunnelReliability *rel = cls;
2329   struct MeshReliableMessage *copy;
2330   struct MeshFlowControl *fc;
2331   struct MeshPeerQueue *q;
2332   struct MeshPeerInfo *pi;
2333   struct MeshTunnel *t;
2334   struct GNUNET_MESH_Data *payload;
2335   GNUNET_PEER_Id hop;
2336
2337   rel->retry_task = GNUNET_SCHEDULER_NO_TASK;
2338   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
2339     return;
2340
2341   t = rel->t;
2342   copy = rel->head_sent;
2343   if (NULL == copy)
2344   {
2345     GNUNET_break (0);
2346     return;
2347   }
2348
2349   /* Search the message to be retransmitted in the outgoing queue */
2350   payload = (struct GNUNET_MESH_Data *) &copy[1];
2351   hop = rel == t->fwd_rel ? t->next_hop : t->prev_hop;
2352   fc = rel == t->fwd_rel ? &t->prev_fc : &t->next_fc;
2353   pi = peer_get_short (hop);
2354   for (q = pi->queue_head; NULL != q; q = q->next)
2355   {
2356     if (ntohs (payload->header.type) == q->type)
2357     {
2358       struct GNUNET_MESH_Data *queued_data = q->cls;
2359
2360       if (queued_data->mid == payload->mid)
2361         break;
2362     }
2363   }
2364
2365   /* Message not found in the queue */
2366   if (NULL == q)
2367   {
2368     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!! RETRANSMIT %llu\n", copy->mid);
2369     copy->timestamp = GNUNET_TIME_absolute_get ();
2370
2371     fc->last_ack_sent++;
2372     payload->pid = htonl (fc->last_pid_recv + 1);
2373     fc->last_pid_recv++;
2374     send_prebuilt_message (&payload->header, hop, t);
2375     GNUNET_STATISTICS_update (stats, "# data retransmitted", 1, GNUNET_NO);
2376   }
2377   else
2378   {
2379     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!! STILL IN QUEUE %llu\n", copy->mid);
2380   }
2381
2382   rel->retry_timer = GNUNET_TIME_STD_BACKOFF (rel->retry_timer);
2383   rel->retry_task = GNUNET_SCHEDULER_add_delayed (rel->retry_timer,
2384                                                   &tunnel_retransmit_message,
2385                                                   cls);
2386 }
2387
2388
2389 /**
2390  * @brief Re-initiate traffic to this peer if necessary.
2391  *
2392  * Check if there is traffic queued towards this peer
2393  * and the core transmit handle is NULL (traffic was stalled).
2394  * If so, call core tmt rdy.
2395  *
2396  * @param peer_id Short ID of peer to which initiate traffic.
2397  */
2398 static void
2399 peer_unlock_queue(GNUNET_PEER_Id peer_id)
2400 {
2401   struct MeshPeerInfo *peer;
2402   struct GNUNET_PeerIdentity id;
2403   struct MeshPeerQueue *q;
2404   size_t size;
2405
2406   peer = peer_get_short (peer_id);
2407   if (NULL != peer->core_transmit)
2408     return;
2409
2410   q = queue_get_next (peer);
2411   if (NULL == q)
2412   {
2413     /* Might br multicast traffic already sent to this particular peer but
2414      * not to other children in this tunnel.
2415      * This way t->queue_n would be > 0 but the queue of this particular peer
2416      * would be empty.
2417      */
2418     return;
2419   }
2420   size = q->size;
2421   GNUNET_PEER_resolve (peer->id, &id);
2422   peer->core_transmit =
2423         GNUNET_CORE_notify_transmit_ready(core_handle,
2424                                           0,
2425                                           0,
2426                                           GNUNET_TIME_UNIT_FOREVER_REL,
2427                                           &id,
2428                                           size,
2429                                           &queue_send,
2430                                           peer);
2431         return;
2432 }
2433
2434
2435 /**
2436  * Send a message to all peers and clients in this tunnel that the tunnel
2437  * is no longer valid. If some peer or client should not receive the message,
2438  * should be zero'ed out before calling this function.
2439  *
2440  * @param t The tunnel whose peers and clients to notify.
2441  */
2442 static void
2443 tunnel_send_destroy (struct MeshTunnel *t)
2444 {
2445   struct GNUNET_MESH_TunnelDestroy msg;
2446   struct GNUNET_PeerIdentity id;
2447
2448   msg.header.size = htons (sizeof (msg));
2449   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY);
2450   GNUNET_PEER_resolve (t->id.oid, &msg.oid);
2451   msg.tid = htonl (t->id.tid);
2452   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2453               "  sending tunnel destroy for tunnel: %s [%X]\n",
2454               GNUNET_i2s (&msg.oid), t->id.tid);
2455
2456   if (NULL == t->client && 0 != t->next_hop)
2457   {
2458     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  child: %u\n", t->next_hop);
2459     GNUNET_PEER_resolve (t->next_hop, &id);
2460     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2461                 "  sending forward to %s\n",
2462                 GNUNET_i2s (&id));
2463     send_prebuilt_message (&msg.header, t->next_hop, t);
2464   }
2465   if (NULL == t->owner && 0 != t->prev_hop)
2466   {
2467     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  parent: %u\n", t->prev_hop);
2468     GNUNET_PEER_resolve (t->prev_hop, &id);
2469     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2470                 "  sending back to %s\n",
2471                 GNUNET_i2s (&id));
2472     send_prebuilt_message (&msg.header, t->prev_hop, t);
2473   }
2474   if (NULL != t->owner)
2475   {
2476     send_client_tunnel_destroy (t->owner, t);
2477   }
2478   if (NULL != t->client)
2479   {
2480     send_client_tunnel_destroy (t->client, t);
2481   }
2482 }
2483
2484
2485 /**
2486  * Cancel all transmissions towards a neighbor that belongs to a certain tunnel.
2487  *
2488  * @param t Tunnel which to cancel.
2489  * @param neighbor Short ID of the neighbor to whom cancel the transmissions.
2490  */
2491 static void
2492 peer_cancel_queues (GNUNET_PEER_Id neighbor, struct MeshTunnel *t)
2493 {
2494   struct MeshPeerInfo *peer_info;
2495   struct MeshPeerQueue *pq;
2496   struct MeshPeerQueue *next;
2497
2498   if (0 == neighbor)
2499     return; /* Was local peer, 0'ed in tunnel_destroy_iterator */
2500   peer_info = peer_get_short (neighbor);
2501   for (pq = peer_info->queue_head; NULL != pq; pq = next)
2502   {
2503     next = pq->next;
2504     if (pq->tunnel == t)
2505     {
2506       if (GNUNET_MESSAGE_TYPE_MESH_UNICAST == pq->type ||
2507           GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN == pq->type)
2508       {
2509         /* Should have been removed on destroy children */
2510         GNUNET_break (0);
2511       }
2512       queue_destroy (pq, GNUNET_YES);
2513     }
2514   }
2515   if (NULL == peer_info->queue_head && NULL != peer_info->core_transmit)
2516   {
2517     GNUNET_CORE_notify_transmit_ready_cancel(peer_info->core_transmit);
2518     peer_info->core_transmit = NULL;
2519   }
2520 }
2521
2522
2523 /**
2524  * Destroy the tunnel.
2525  * 
2526  * This function does not generate any warning traffic to clients or peers.
2527  * 
2528  * Tasks:
2529  * Remove the tunnel from peer_info's and clients' hashmaps.
2530  * Cancel messages belonging to this tunnel queued to neighbors.
2531  * Free any allocated resources linked to the tunnel.
2532  *
2533  * @param t the tunnel to destroy
2534  *
2535  * @return GNUNET_OK on success
2536  */
2537 static int
2538 tunnel_destroy (struct MeshTunnel *t)
2539 {
2540   struct MeshClient *c;
2541   struct GNUNET_HashCode hash;
2542   int r;
2543
2544   if (NULL == t)
2545     return GNUNET_OK;
2546
2547   r = GNUNET_OK;
2548   c = t->owner;
2549 #if MESH_DEBUG
2550   {
2551     struct GNUNET_PeerIdentity id;
2552
2553     GNUNET_PEER_resolve (t->id.oid, &id);
2554     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "destroying tunnel %s [%x]\n",
2555                 GNUNET_i2s (&id), t->id.tid);
2556     if (NULL != c)
2557       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  by client %u\n", c->id);
2558   }
2559 #endif
2560
2561   GNUNET_CRYPTO_hash (&t->id, sizeof (struct MESH_TunnelID), &hash);
2562   if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (tunnels, &hash, t))
2563   {
2564     GNUNET_break (0);
2565     r = GNUNET_SYSERR;
2566   }
2567
2568   if (NULL != c)
2569   {
2570     if (GNUNET_YES !=
2571       GNUNET_CONTAINER_multihashmap32_remove (c->own_tunnels, t->local_tid, t))
2572     {
2573       GNUNET_break (0);
2574       r = GNUNET_SYSERR;
2575     }
2576   }
2577
2578   if (NULL != t->client)
2579   {
2580     c = t->client;
2581     if (GNUNET_YES !=
2582         GNUNET_CONTAINER_multihashmap32_remove (c->incoming_tunnels,
2583                                                 t->local_tid_dest, t))
2584     {
2585       GNUNET_break (0);
2586       r = GNUNET_SYSERR;
2587     }
2588     if (GNUNET_YES != 
2589         GNUNET_CONTAINER_multihashmap32_remove (incoming_tunnels,
2590                                                 t->local_tid_dest, t))
2591     {
2592       GNUNET_break (0);
2593       r = GNUNET_SYSERR;
2594     }
2595   }
2596
2597   if (0 != t->prev_hop)
2598   {
2599     peer_cancel_queues (t->prev_hop, t);
2600     GNUNET_PEER_change_rc (t->prev_hop, -1);
2601   }
2602   if (0 != t->next_hop)
2603   {
2604     peer_cancel_queues (t->next_hop, t);
2605     GNUNET_PEER_change_rc (t->next_hop, -1);
2606   }
2607   if (0 != t->dest) {
2608       peer_info_remove_tunnel (peer_get_short (t->dest), t);
2609   }
2610
2611   if (GNUNET_SCHEDULER_NO_TASK != t->maintenance_task)
2612     GNUNET_SCHEDULER_cancel (t->maintenance_task);
2613
2614   n_tunnels--;
2615   GNUNET_STATISTICS_update (stats, "# tunnels", -1, GNUNET_NO);
2616   path_destroy (t->path);
2617   GNUNET_free (t);
2618   return r;
2619 }
2620
2621 /**
2622  * Tunnel is empty: destroy it.
2623  * 
2624  * Notifies all participants (peers, cleints) about the destruction.
2625  * 
2626  * @param t Tunnel to destroy. 
2627  */
2628 static void
2629 tunnel_destroy_empty (struct MeshTunnel *t)
2630 {
2631   #if MESH_DEBUG
2632   {
2633     struct GNUNET_PeerIdentity id;
2634
2635     GNUNET_PEER_resolve (t->id.oid, &id);
2636     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2637                 "executing destruction of empty tunnel %s [%X]\n",
2638                 GNUNET_i2s (&id), t->id.tid);
2639   }
2640   #endif
2641
2642   if (GNUNET_NO == t->destroy)
2643     tunnel_send_destroy (t);
2644   if (0 == t->pending_messages)
2645     tunnel_destroy (t);
2646   else
2647     t->destroy = GNUNET_YES;
2648 }
2649
2650 /**
2651  * Initialize a Flow Control structure to the initial state.
2652  * 
2653  * @param fc Flow Control structure to initialize.
2654  */
2655 static void
2656 fc_init (struct MeshFlowControl *fc)
2657 {
2658   fc->last_pid_sent = (uint32_t) -1; /* Next (expected) = 0 */
2659   fc->last_pid_recv = (uint32_t) -1;
2660   fc->last_ack_sent = (uint32_t) -1; /* No traffic allowed yet */
2661   fc->last_ack_recv = (uint32_t) -1;
2662   fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
2663   fc->poll_time = GNUNET_TIME_UNIT_SECONDS;
2664   fc->queue_n = 0;
2665 }
2666
2667 /**
2668  * Create a new tunnel
2669  * 
2670  * @param owner Who is the owner of the tunnel (short ID).
2671  * @param tid Tunnel Number of the tunnel.
2672  * @param client Clients that owns the tunnel, NULL for foreign tunnels.
2673  * @param local Tunnel Number for the tunnel, for the client point of view.
2674  * 
2675  * @return A new initialized tunnel. NULL on error.
2676  */
2677 static struct MeshTunnel *
2678 tunnel_new (GNUNET_PEER_Id owner,
2679             MESH_TunnelNumber tid,
2680             struct MeshClient *client,
2681             MESH_TunnelNumber local)
2682 {
2683   struct MeshTunnel *t;
2684   struct GNUNET_HashCode hash;
2685
2686   if (n_tunnels >= max_tunnels && NULL == client)
2687     return NULL;
2688
2689   t = GNUNET_malloc (sizeof (struct MeshTunnel));
2690   t->id.oid = owner;
2691   t->id.tid = tid;
2692   t->queue_max = (max_msgs_queue / max_tunnels) + 1;
2693   t->owner = client;
2694   fc_init (&t->next_fc);
2695   fc_init (&t->prev_fc);
2696   t->local_tid = local;
2697   n_tunnels++;
2698   GNUNET_STATISTICS_update (stats, "# tunnels", 1, GNUNET_NO);
2699
2700   GNUNET_CRYPTO_hash (&t->id, sizeof (struct MESH_TunnelID), &hash);
2701   if (GNUNET_OK !=
2702       GNUNET_CONTAINER_multihashmap_put (tunnels, &hash, t,
2703                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
2704   {
2705     GNUNET_break (0);
2706     tunnel_destroy (t);
2707     if (NULL != client)
2708     {
2709       GNUNET_break (0);
2710       GNUNET_SERVER_receive_done (client->handle, GNUNET_SYSERR);
2711     }
2712     return NULL;
2713   }
2714
2715   if (NULL != client)
2716   {
2717     if (GNUNET_OK !=
2718         GNUNET_CONTAINER_multihashmap32_put (client->own_tunnels,
2719                                              t->local_tid, t,
2720                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
2721     {
2722       tunnel_destroy (t);
2723       GNUNET_break (0);
2724       GNUNET_SERVER_receive_done (client->handle, GNUNET_SYSERR);
2725       return NULL;
2726     }
2727   }
2728
2729   return t;
2730 }
2731
2732
2733 /**
2734  * Set options in a tunnel, extracted from a bit flag field
2735  * 
2736  * @param t Tunnel to set options to.
2737  * @param options Bit array in host byte order.
2738  */
2739 static void
2740 tunnel_set_options (struct MeshTunnel *t, uint32_t options)
2741 {
2742   t->nobuffer = (options & GNUNET_MESH_OPTION_NOBUFFER) != 0 ?
2743                  GNUNET_YES : GNUNET_NO;
2744   t->reliable = (options & GNUNET_MESH_OPTION_RELIABLE) != 0 ?
2745                  GNUNET_YES : GNUNET_NO;
2746 }
2747
2748
2749 /**
2750  * Iterator for deleting each tunnel whose client endpoint disconnected.
2751  *
2752  * @param cls Closure (client that has disconnected).
2753  * @param key The local tunnel id (used to access the hashmap).
2754  * @param value The value stored at the key (tunnel to destroy).
2755  *
2756  * @return GNUNET_OK, keep iterating.
2757  */
2758 static int
2759 tunnel_destroy_iterator (void *cls,
2760                          uint32_t key,
2761                          void *value)
2762 {
2763   struct MeshTunnel *t = value;
2764   struct MeshClient *c = cls;
2765
2766   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2767               " Tunnel %X / %X destroy, due to client %u shutdown.\n",
2768               t->local_tid, t->local_tid_dest, c->id);
2769   client_delete_tunnel (c, t);
2770   if (c == t->client)
2771   {
2772     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " Client %u is destination.\n", c->id);
2773     t->client = NULL;
2774     if (0 != t->next_hop) { /* destroy could come before a path is used */
2775         GNUNET_PEER_change_rc (t->next_hop, -1);
2776         t->next_hop = 0;
2777     }
2778   }
2779   if (c == t->owner)
2780   {
2781     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " Client %u is owner.\n", c->id);
2782     t->owner = NULL;
2783     if (0 != t->prev_hop) { /* destroy could come before a path is used */
2784         GNUNET_PEER_change_rc (t->prev_hop, -1);
2785         t->prev_hop = 0;
2786     }
2787   }
2788
2789   tunnel_destroy_empty (t);
2790
2791   return GNUNET_OK;
2792 }
2793
2794
2795 /**
2796  * Timeout function, destroys tunnel if called
2797  *
2798  * @param cls Closure (tunnel to destroy).
2799  * @param tc TaskContext
2800  */
2801 static void
2802 tunnel_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
2803 {
2804   struct MeshTunnel *t = cls;
2805   struct GNUNET_PeerIdentity id;
2806
2807   t->maintenance_task = GNUNET_SCHEDULER_NO_TASK;
2808   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
2809     return;
2810   GNUNET_PEER_resolve(t->id.oid, &id);
2811   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2812               "Tunnel %s [%X] timed out. Destroying.\n",
2813               GNUNET_i2s(&id), t->id.tid);
2814   if (NULL != t->client)
2815     send_client_tunnel_destroy (t->client, t);
2816   tunnel_destroy (t); /* Do not notify other */
2817 }
2818
2819
2820 /**
2821  * Resets the tunnel timeout. Starts it if no timeout was running.
2822  *
2823  * @param t Tunnel whose timeout to reset.
2824  *
2825  * TODO use heap to improve efficiency of scheduler.
2826  */
2827 static void
2828 tunnel_reset_timeout (struct MeshTunnel *t)
2829 {
2830   if (NULL != t->owner || 0 != t->local_tid || 0 == t->prev_hop)
2831     return;
2832   if (GNUNET_SCHEDULER_NO_TASK != t->maintenance_task)
2833     GNUNET_SCHEDULER_cancel (t->maintenance_task);
2834   t->maintenance_task =
2835       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
2836                                     (refresh_path_time, 4), &tunnel_timeout, t);
2837 }
2838
2839
2840 /******************************************************************************/
2841 /****************      MESH NETWORK HANDLER HELPERS     ***********************/
2842 /******************************************************************************/
2843
2844 /**
2845  * Function to send a create path packet to a peer.
2846  *
2847  * @param cls closure
2848  * @param size number of bytes available in buf
2849  * @param buf where the callee should write the message
2850  * @return number of bytes written to buf
2851  */
2852 static size_t
2853 send_core_path_create (void *cls, size_t size, void *buf)
2854 {
2855   struct MeshTunnel *t = cls;
2856   struct GNUNET_MESH_CreateTunnel *msg;
2857   struct GNUNET_PeerIdentity *peer_ptr;
2858   struct MeshPeerPath *p = t->path;
2859   size_t size_needed;
2860   uint32_t opt;
2861   int i;
2862
2863   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CREATE PATH sending...\n");
2864   size_needed =
2865       sizeof (struct GNUNET_MESH_CreateTunnel) +
2866       p->length * sizeof (struct GNUNET_PeerIdentity);
2867
2868   if (size < size_needed || NULL == buf)
2869   {
2870     GNUNET_break (0);
2871     return 0;
2872   }
2873   msg = (struct GNUNET_MESH_CreateTunnel *) buf;
2874   msg->header.size = htons (size_needed);
2875   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE);
2876   msg->tid = ntohl (t->id.tid);
2877
2878   opt = 0;
2879   if (GNUNET_YES == t->nobuffer)
2880     opt |= GNUNET_MESH_OPTION_NOBUFFER;
2881   if (GNUNET_YES == t->reliable)
2882     opt |= GNUNET_MESH_OPTION_RELIABLE;
2883   msg->opt = htonl (opt);
2884   msg->port = htonl (t->port);
2885
2886   peer_ptr = (struct GNUNET_PeerIdentity *) &msg[1];
2887   for (i = 0; i < p->length; i++)
2888   {
2889     GNUNET_PEER_resolve (p->peers[i], peer_ptr++);
2890   }
2891
2892   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2893               "CREATE PATH (%u bytes long) sent!\n", size_needed);
2894   return size_needed;
2895 }
2896
2897
2898 /**
2899  * Creates a path ack message in buf and frees all unused resources.
2900  *
2901  * @param cls closure (MeshTransmissionDescriptor)
2902  * @param size number of bytes available in buf
2903  * @param buf where the callee should write the message
2904  * @return number of bytes written to buf
2905  */
2906 static size_t
2907 send_core_path_ack (void *cls, size_t size, void *buf)
2908 {
2909   struct MeshTunnel *t = cls;
2910   struct GNUNET_MESH_PathACK *msg = buf;
2911
2912   GNUNET_assert (NULL != t);
2913   if (sizeof (struct GNUNET_MESH_PathACK) > size)
2914   {
2915     GNUNET_break (0);
2916     return 0;
2917   }
2918   t->prev_fc.last_ack_sent = t->nobuffer ? 0 : t->queue_max - 1;
2919   msg->header.size = htons (sizeof (struct GNUNET_MESH_PathACK));
2920   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_ACK);
2921   GNUNET_PEER_resolve (t->id.oid, &msg->oid);
2922   msg->tid = htonl (t->id.tid);
2923   msg->peer_id = my_full_id;
2924   msg->ack = htonl (t->prev_fc.last_ack_sent);
2925
2926   /* TODO add signature */
2927
2928   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "PATH ACK sent!\n");
2929   return sizeof (struct GNUNET_MESH_PathACK);
2930 }
2931
2932
2933 /**
2934  * Free a transmission that was already queued with all resources
2935  * associated to the request.
2936  *
2937  * @param queue Queue handler to cancel.
2938  * @param clear_cls Is it necessary to free associated cls?
2939  */
2940 static void
2941 queue_destroy (struct MeshPeerQueue *queue, int clear_cls)
2942 {
2943   struct MeshFlowControl *fc;
2944
2945   if (GNUNET_YES == clear_cls)
2946   {
2947     switch (queue->type)
2948     {
2949       case GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY:
2950         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "   cancelling TUNNEL_DESTROY\n");
2951         GNUNET_break (GNUNET_YES == queue->tunnel->destroy);
2952         /* fall through */
2953       case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
2954       case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
2955       case GNUNET_MESSAGE_TYPE_MESH_ACK:
2956       case GNUNET_MESSAGE_TYPE_MESH_POLL:
2957       case GNUNET_MESSAGE_TYPE_MESH_PATH_KEEPALIVE:
2958         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2959                     "   prebuilt message\n");
2960         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2961                     "   type %s\n",
2962                     GNUNET_MESH_DEBUG_M2S (queue->type));
2963         break;
2964       case GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE:
2965         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   type create path\n");
2966         break;
2967       default:
2968         GNUNET_break (0);
2969         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2970                     "   type %s unknown!\n",
2971                     GNUNET_MESH_DEBUG_M2S (queue->type));
2972     }
2973     GNUNET_free_non_null (queue->cls);
2974   }
2975   GNUNET_CONTAINER_DLL_remove (queue->peer->queue_head,
2976                                queue->peer->queue_tail,
2977                                queue);
2978
2979   /* Delete from appropriate fc in the tunnel */
2980   if (GNUNET_MESSAGE_TYPE_MESH_UNICAST == queue->type ||
2981       GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN == queue->type )
2982   {
2983     if (queue->peer->id == queue->tunnel->prev_hop)
2984       fc = &queue->tunnel->prev_fc;
2985     else if (queue->peer->id == queue->tunnel->next_hop)
2986       fc = &queue->tunnel->next_fc;
2987     else
2988     {
2989       GNUNET_break (0);
2990       GNUNET_free (queue);
2991       return;
2992     }
2993     fc->queue_n--;
2994   }
2995   GNUNET_free (queue);
2996 }
2997
2998
2999 /**
3000  * @brief Get the next transmittable message from the queue.
3001  *
3002  * This will be the head, except in the case of being a data packet
3003  * not allowed by the destination peer.
3004  *
3005  * @param peer Destination peer.
3006  *
3007  * @return The next viable MeshPeerQueue element to send to that peer.
3008  *         NULL when there are no transmittable messages.
3009  */
3010 struct MeshPeerQueue *
3011 queue_get_next (const struct MeshPeerInfo *peer)
3012 {
3013   struct MeshPeerQueue *q;
3014
3015   struct GNUNET_MESH_Data *dmsg;
3016   struct MeshTunnel* t;
3017   uint32_t pid;
3018   uint32_t ack;
3019
3020   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   selecting message\n");
3021   for (q = peer->queue_head; NULL != q; q = q->next)
3022   {
3023     t = q->tunnel;
3024     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3025                 "*     %s\n",
3026                 GNUNET_MESH_DEBUG_M2S (q->type));
3027     dmsg = (struct GNUNET_MESH_Data *) q->cls;
3028     pid = ntohl (dmsg->pid);
3029     switch (q->type)
3030     {
3031       case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
3032         ack = t->next_fc.last_ack_recv;
3033         break;
3034       case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
3035         ack = t->prev_fc.last_ack_recv;
3036         break;
3037       default:
3038         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3039                     "*   OK!\n");
3040         return q;
3041     }
3042     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3043                 "*     ACK: %u, PID: %u, MID: %llu\n",
3044                 ack, pid, GNUNET_ntohll (dmsg->mid));
3045     if (GNUNET_NO == GMC_is_pid_bigger (pid, ack))
3046     {
3047       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3048                   "*   OK!\n");
3049       return q;
3050     }
3051     else
3052     {
3053       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3054                   "*     NEXT!\n");
3055     }
3056   }
3057   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3058                 "*   nothing found\n");
3059   return NULL;
3060 }
3061
3062
3063 static size_t
3064 queue_send (void *cls, size_t size, void *buf)
3065 {
3066   struct MeshPeerInfo *peer = cls;
3067   struct GNUNET_MessageHeader *msg;
3068   struct MeshPeerQueue *queue;
3069   struct MeshTunnel *t;
3070   struct GNUNET_PeerIdentity dst_id;
3071   struct MeshFlowControl *fc;
3072   size_t data_size;
3073   uint32_t pid;
3074   uint16_t type;
3075
3076   peer->core_transmit = NULL;
3077
3078   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* Queue send\n");
3079   queue = queue_get_next (peer);
3080
3081   /* Queue has no internal mesh traffic nor sendable payload */
3082   if (NULL == queue)
3083   {
3084     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   not ready, return\n");
3085     if (NULL == peer->queue_head)
3086       GNUNET_break (0); /* Core tmt_rdy should've been canceled */
3087     return 0;
3088   }
3089   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   not empty\n");
3090
3091   GNUNET_PEER_resolve (peer->id, &dst_id);
3092   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3093               "*   towards %s\n",
3094               GNUNET_i2s (&dst_id));
3095   /* Check if buffer size is enough for the message */
3096   if (queue->size > size)
3097   {
3098       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3099                   "*   not enough room, reissue\n");
3100       peer->core_transmit =
3101           GNUNET_CORE_notify_transmit_ready (core_handle,
3102                                              GNUNET_NO,
3103                                              0,
3104                                              GNUNET_TIME_UNIT_FOREVER_REL,
3105                                              &dst_id,
3106                                              queue->size,
3107                                              &queue_send,
3108                                              peer);
3109       return 0;
3110   }
3111   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   size ok\n");
3112
3113   t = queue->tunnel;
3114   GNUNET_assert (0 < t->pending_messages);
3115   t->pending_messages--;
3116   type = 0;
3117
3118   /* Fill buf */
3119   switch (queue->type)
3120   {
3121     case 0:
3122     case GNUNET_MESSAGE_TYPE_MESH_ACK:
3123     case GNUNET_MESSAGE_TYPE_MESH_UNICAST_ACK:
3124     case GNUNET_MESSAGE_TYPE_MESH_TO_ORIG_ACK:
3125     case GNUNET_MESSAGE_TYPE_MESH_POLL:
3126     case GNUNET_MESSAGE_TYPE_MESH_PATH_BROKEN:
3127     case GNUNET_MESSAGE_TYPE_MESH_PATH_DESTROY:
3128     case GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY:
3129     case GNUNET_MESSAGE_TYPE_MESH_PATH_KEEPALIVE:
3130       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3131                   "*   raw: %s\n",
3132                   GNUNET_MESH_DEBUG_M2S (queue->type));
3133       /* Fall through */
3134     case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
3135     case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
3136       data_size = send_core_data_raw (queue->cls, size, buf);
3137       msg = (struct GNUNET_MessageHeader *) buf;
3138       type = ntohs (msg->type);
3139       break;
3140     case GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE:
3141       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   path create\n");
3142       data_size = send_core_path_create (queue->cls, size, buf);
3143       break;
3144     case GNUNET_MESSAGE_TYPE_MESH_PATH_ACK:
3145       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   path ack\n");
3146       data_size = send_core_path_ack (queue->cls, size, buf);
3147       break;
3148     default:
3149       GNUNET_break (0);
3150       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3151                   "*   type unknown: %u\n",
3152                   queue->type);
3153       data_size = 0;
3154   }
3155
3156   if (0 < drop_percent &&
3157       GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 101) < drop_percent)
3158   {
3159     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3160                 "Dropping message of type %s\n",
3161                 GNUNET_MESH_DEBUG_M2S(queue->type));
3162     data_size = 0;
3163   }
3164   /* Free queue, but cls was freed by send_core_* */
3165   queue_destroy (queue, GNUNET_NO);
3166
3167   /* Send ACK if needed, after accounting for sent ID in fc->queue_n */
3168   pid = ((struct GNUNET_MESH_Data *) buf)->pid;
3169   pid = ntohl (pid);
3170   switch (type)
3171   {
3172     case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
3173       t->next_fc.last_pid_sent = pid;
3174       tunnel_send_fwd_ack (t, GNUNET_MESSAGE_TYPE_MESH_UNICAST);
3175       break;
3176     case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
3177       t->prev_fc.last_pid_sent = pid;
3178       tunnel_send_bck_ack (t, GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN);
3179       break;
3180     default:
3181       break;
3182   }
3183
3184   if (GNUNET_YES == t->destroy && 0 == t->pending_messages)
3185   {
3186     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*  destroying tunnel!\n");
3187     tunnel_destroy (t);
3188   }
3189
3190   /* If more data in queue, send next */
3191   queue = queue_get_next (peer);
3192   if (NULL != queue)
3193   {
3194       struct GNUNET_PeerIdentity id;
3195
3196       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   more data!\n");
3197       GNUNET_PEER_resolve (peer->id, &id);
3198       peer->core_transmit =
3199           GNUNET_CORE_notify_transmit_ready(core_handle,
3200                                             0,
3201                                             0,
3202                                             GNUNET_TIME_UNIT_FOREVER_REL,
3203                                             &id,
3204                                             queue->size,
3205                                             &queue_send,
3206                                             peer);
3207   }
3208   else if (NULL != peer->queue_head)
3209   {
3210     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3211                 "*   %s stalled\n",
3212                 GNUNET_i2s (&my_full_id));
3213     if (peer->id == t->next_hop)
3214       fc = &t->next_fc;
3215     else if (peer->id == t->prev_hop)
3216       fc = &t->prev_fc;
3217     else
3218     {
3219       GNUNET_break (0);
3220       return data_size;
3221     }
3222     if (NULL != fc && GNUNET_SCHEDULER_NO_TASK == fc->poll_task)
3223     {
3224       fc->t = t;
3225       fc->poll_task = GNUNET_SCHEDULER_add_delayed (fc->poll_time,
3226                                                     &tunnel_poll, fc);
3227     }
3228   }
3229   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*  Return %d\n", data_size);
3230   return data_size;
3231 }
3232
3233
3234 /**
3235  * @brief Queue and pass message to core when possible.
3236  * 
3237  * If type is payload (UNICAST, TO_ORIGIN) checks for queue status and
3238  * accounts for it. In case the queue is full, the message is dropped and
3239  * a break issued.
3240  * 
3241  * Otherwise, message is treated as internal and allowed to go regardless of 
3242  * queue status.
3243  *
3244  * @param cls Closure (@c type dependant). It will be used by queue_send to
3245  *            build the message to be sent if not already prebuilt.
3246  * @param type Type of the message, 0 for a raw message.
3247  * @param size Size of the message.
3248  * @param dst Neighbor to send message to.
3249  * @param t Tunnel this message belongs to.
3250  */
3251 static void
3252 queue_add (void *cls, uint16_t type, size_t size,
3253            struct MeshPeerInfo *dst, struct MeshTunnel *t)
3254 {
3255   struct MeshPeerQueue *queue;
3256   struct GNUNET_PeerIdentity id;
3257   struct MeshFlowControl *fc;
3258   int priority;
3259
3260   fc = NULL;
3261   priority = GNUNET_NO;
3262   if (GNUNET_MESSAGE_TYPE_MESH_UNICAST == type)
3263   {
3264     fc = &t->next_fc;
3265   }
3266   else if (GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN == type)
3267   {
3268     fc = &t->prev_fc;
3269   }
3270   if (NULL != fc)
3271   {
3272     if (fc->queue_n >= t->queue_max)
3273     {
3274       /* If this isn't a retransmission, drop the message */
3275       if (GNUNET_NO == t->reliable ||
3276           (NULL == t->owner && GNUNET_MESSAGE_TYPE_MESH_UNICAST == type) ||
3277           (NULL == t->client && GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN == type))
3278       {
3279         GNUNET_STATISTICS_update (stats, "# messages dropped (buffer full)",
3280                                   1, GNUNET_NO);
3281         GNUNET_break (0);
3282         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3283                     "queue full: %u/%u\n",
3284                     fc->queue_n, t->queue_max);
3285         return; /* Drop this message */
3286       }
3287       priority = GNUNET_YES;
3288     }
3289     fc->queue_n++;
3290   }
3291   queue = GNUNET_malloc (sizeof (struct MeshPeerQueue));
3292   queue->cls = cls;
3293   queue->type = type;
3294   queue->size = size;
3295   queue->peer = dst;
3296   queue->tunnel = t;
3297   if (GNUNET_YES == priority)
3298   {
3299     struct GNUNET_MESH_Data *d;
3300     uint32_t prev;
3301     uint32_t next;
3302
3303     GNUNET_CONTAINER_DLL_insert (dst->queue_head, dst->queue_tail, queue);
3304     d = (struct GNUNET_MESH_Data *) queue->cls;
3305     prev = d->pid;
3306     for (queue = dst->queue_tail; NULL != queue; queue = queue->prev)
3307     {
3308       if (queue->type != type)
3309         continue;
3310       d = (struct GNUNET_MESH_Data *) queue->cls;
3311       next = d->pid;
3312       d->pid = prev;
3313       prev = next;
3314     }
3315   }
3316   else
3317     GNUNET_CONTAINER_DLL_insert_tail (dst->queue_head, dst->queue_tail, queue);
3318   if (NULL == dst->core_transmit)
3319   {
3320     GNUNET_PEER_resolve (dst->id, &id);
3321     dst->core_transmit =
3322         GNUNET_CORE_notify_transmit_ready (core_handle,
3323                                            0,
3324                                            0,
3325                                            GNUNET_TIME_UNIT_FOREVER_REL,
3326                                            &id,
3327                                            size,
3328                                            &queue_send,
3329                                            dst);
3330   }
3331   t->pending_messages++;
3332 }
3333
3334
3335 /******************************************************************************/
3336 /********************      MESH NETWORK HANDLERS     **************************/
3337 /******************************************************************************/
3338
3339
3340 /**
3341  * Core handler for path creation
3342  *
3343  * @param cls closure
3344  * @param message message
3345  * @param peer peer identity this notification is about
3346  *
3347  * @return GNUNET_OK to keep the connection open,
3348  *         GNUNET_SYSERR to close it (signal serious error)
3349  */
3350 static int
3351 handle_mesh_path_create (void *cls, const struct GNUNET_PeerIdentity *peer,
3352                          const struct GNUNET_MessageHeader *message)
3353 {
3354   unsigned int own_pos;
3355   uint16_t size;
3356   uint16_t i;
3357   MESH_TunnelNumber tid;
3358   struct GNUNET_MESH_CreateTunnel *msg;
3359   struct GNUNET_PeerIdentity *pi;
3360   struct MeshPeerPath *path;
3361   struct MeshPeerInfo *dest_peer_info;
3362   struct MeshPeerInfo *orig_peer_info;
3363   struct MeshTunnel *t;
3364
3365   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3366               "Received a path create msg [%s]\n",
3367               GNUNET_i2s (&my_full_id));
3368   size = ntohs (message->size);
3369   if (size < sizeof (struct GNUNET_MESH_CreateTunnel))
3370   {
3371     GNUNET_break_op (0);
3372     return GNUNET_OK;
3373   }
3374
3375   size -= sizeof (struct GNUNET_MESH_CreateTunnel);
3376   if (size % sizeof (struct GNUNET_PeerIdentity))
3377   {
3378     GNUNET_break_op (0);
3379     return GNUNET_OK;
3380   }
3381   size /= sizeof (struct GNUNET_PeerIdentity);
3382   if (size < 1)
3383   {
3384     GNUNET_break_op (0);
3385     return GNUNET_OK;
3386   }
3387   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "    path has %u hops.\n", size);
3388   msg = (struct GNUNET_MESH_CreateTunnel *) message;
3389
3390   tid = ntohl (msg->tid);
3391   pi = (struct GNUNET_PeerIdentity *) &msg[1];
3392   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3393               "    path is for tunnel %s[%X].\n", GNUNET_i2s (pi), tid);
3394   t = tunnel_get (pi, tid);
3395   if (NULL == t) /* might be a local tunnel */
3396   {
3397     uint32_t opt;
3398
3399     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  Creating tunnel\n");
3400     t = tunnel_new (GNUNET_PEER_intern (pi), tid, NULL, 0);
3401     if (NULL == t)
3402     {
3403       GNUNET_break (0);
3404       return GNUNET_OK;
3405     }
3406     t->port = ntohl (msg->port);
3407     opt = ntohl (msg->opt);
3408     if (0 != (opt & GNUNET_MESH_OPTION_NOBUFFER))
3409     {
3410       t->nobuffer = GNUNET_YES;
3411       t->queue_max = 1;
3412     }
3413     if (0 != (opt & GNUNET_MESH_OPTION_RELIABLE))
3414     {
3415       t->reliable = GNUNET_YES;
3416     }
3417     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  nobuffer:%d\n", t->nobuffer);
3418
3419     tunnel_reset_timeout (t);
3420   }
3421   t->state = MESH_TUNNEL_WAITING;
3422   dest_peer_info =
3423       GNUNET_CONTAINER_multihashmap_get (peers, &pi[size - 1].hashPubKey);
3424   if (NULL == dest_peer_info)
3425   {
3426     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3427                 "  Creating PeerInfo for destination.\n");
3428     dest_peer_info = GNUNET_malloc (sizeof (struct MeshPeerInfo));
3429     dest_peer_info->id = GNUNET_PEER_intern (&pi[size - 1]);
3430     GNUNET_CONTAINER_multihashmap_put (peers, &pi[size - 1].hashPubKey,
3431                                        dest_peer_info,
3432                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
3433   }
3434   orig_peer_info = GNUNET_CONTAINER_multihashmap_get (peers, &pi->hashPubKey);
3435   if (NULL == orig_peer_info)
3436   {
3437     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3438                 "  Creating PeerInfo for origin.\n");
3439     orig_peer_info = GNUNET_malloc (sizeof (struct MeshPeerInfo));
3440     orig_peer_info->id = GNUNET_PEER_intern (pi);
3441     GNUNET_CONTAINER_multihashmap_put (peers, &pi->hashPubKey, orig_peer_info,
3442                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
3443   }
3444   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  Creating path...\n");
3445   path = path_new (size);
3446   own_pos = 0;
3447   for (i = 0; i < size; i++)
3448   {
3449     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  ... adding %s\n",
3450                 GNUNET_i2s (&pi[i]));
3451     path->peers[i] = GNUNET_PEER_intern (&pi[i]);
3452     if (path->peers[i] == myid)
3453       own_pos = i;
3454   }
3455   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  Own position: %u\n", own_pos);
3456   if (own_pos == 0 && path->peers[own_pos] != myid)
3457   {
3458     /* create path: self not found in path through self */
3459     GNUNET_break_op (0);
3460     path_destroy (path);
3461     tunnel_destroy (t);
3462     return GNUNET_OK;
3463   }
3464   path_add_to_peers (path, GNUNET_NO);
3465   tunnel_use_path (t, path);
3466
3467   peer_info_add_tunnel (dest_peer_info, t);
3468
3469   if (own_pos == size - 1)
3470   {
3471     struct MeshClient *c;
3472
3473     /* Find target client */
3474     c = GNUNET_CONTAINER_multihashmap32_get (ports, t->port);
3475     if (NULL == c)
3476     {
3477       /* TODO send reject */
3478       return GNUNET_OK;
3479     }
3480
3481     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  It's for us!\n");
3482     peer_info_add_path_to_origin (orig_peer_info, path, GNUNET_YES);
3483
3484     /* Assign local tid */
3485     while (NULL != tunnel_get_incoming (next_local_tid))
3486       next_local_tid = (next_local_tid + 1) | GNUNET_MESH_LOCAL_TUNNEL_ID_SERV;
3487     t->local_tid_dest = next_local_tid++;
3488     next_local_tid = next_local_tid | GNUNET_MESH_LOCAL_TUNNEL_ID_SERV;
3489
3490     if (GNUNET_YES == t->reliable)
3491     {
3492       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!! Reliable\n");
3493       t->bck_rel = GNUNET_malloc (sizeof (struct MeshTunnelReliability));
3494       t->bck_rel->t = t;
3495       t->bck_rel->expected_delay = MESH_RETRANSMIT_TIME;
3496     }
3497
3498     tunnel_add_client (t, c);
3499     send_client_tunnel_create (t);
3500     send_path_ack (t);
3501   }
3502   else
3503   {
3504     struct MeshPeerPath *path2;
3505
3506     t->next_hop = path->peers[own_pos + 1];
3507     GNUNET_PEER_change_rc(t->next_hop, 1);
3508
3509     /* It's for somebody else! Retransmit. */
3510     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  Retransmitting.\n");
3511     path2 = path_duplicate (path);
3512     peer_info_add_path (dest_peer_info, path2, GNUNET_NO);
3513     peer_info_add_path_to_origin (orig_peer_info, path, GNUNET_NO);
3514     send_create_path (t);
3515   }
3516   return GNUNET_OK;
3517 }
3518
3519
3520
3521 /**
3522  * Core handler for path ACKs
3523  *
3524  * @param cls closure
3525  * @param message message
3526  * @param peer peer identity this notification is about
3527  *
3528  * @return GNUNET_OK to keep the connection open,
3529  *         GNUNET_SYSERR to close it (signal serious error)
3530  */
3531 static int
3532 handle_mesh_path_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
3533                       const struct GNUNET_MessageHeader *message)
3534 {
3535   struct GNUNET_MESH_PathACK *msg;
3536   struct MeshPeerInfo *peer_info;
3537   struct MeshPeerPath *p;
3538   struct MeshTunnel *t;
3539
3540   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received a path ACK msg [%s]\n",
3541               GNUNET_i2s (&my_full_id));
3542   msg = (struct GNUNET_MESH_PathACK *) message;
3543   t = tunnel_get (&msg->oid, ntohl(msg->tid));
3544   if (NULL == t)
3545   {
3546     /* TODO notify that we don't know the tunnel */
3547     GNUNET_STATISTICS_update (stats, "# control on unknown tunnel", 1, GNUNET_NO);
3548     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  don't know the tunnel %s [%X]!\n",
3549                 GNUNET_i2s (&msg->oid), ntohl(msg->tid));
3550     return GNUNET_OK;
3551   }
3552   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  on tunnel %s [%X]\n",
3553               GNUNET_i2s (&msg->oid), ntohl(msg->tid));
3554
3555   peer_info = peer_get (&msg->peer_id);
3556   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  by peer %s\n",
3557               GNUNET_i2s (&msg->peer_id));
3558   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  via peer %s\n",
3559               GNUNET_i2s (peer));
3560
3561   /* Add path to peers? */
3562   p = t->path;
3563   if (NULL != p)
3564   {
3565     path_add_to_peers (p, GNUNET_YES);
3566   }
3567   else
3568   {
3569     GNUNET_break (0);
3570   }
3571   t->state = MESH_TUNNEL_READY;
3572   t->next_fc.last_ack_recv = (NULL == t->client) ? ntohl (msg->ack) : 0;
3573   t->prev_fc.last_ack_sent = ntohl (msg->ack);
3574
3575   /* Message for us? */
3576   if (0 == memcmp (&msg->oid, &my_full_id, sizeof (struct GNUNET_PeerIdentity)))
3577   {
3578     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  It's for us!\n");
3579     if (NULL == t->owner)
3580     {
3581       GNUNET_break_op (0);
3582       return GNUNET_OK;
3583     }
3584     if (NULL != peer_info->dhtget)
3585     {
3586       GNUNET_DHT_get_stop (peer_info->dhtget);
3587       peer_info->dhtget = NULL;
3588     }
3589     tunnel_send_bck_ack (t, GNUNET_MESSAGE_TYPE_MESH_PATH_ACK);
3590     tunnel_send_fwd_ack (t, GNUNET_MESSAGE_TYPE_MESH_PATH_ACK);
3591     return GNUNET_OK;
3592   }
3593
3594   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3595               "  not for us, retransmitting...\n");
3596   peer_info = peer_get (&msg->oid);
3597   send_prebuilt_message (message, t->prev_hop, t);
3598   return GNUNET_OK;
3599 }
3600
3601
3602 /**
3603  * Core handler for notifications of broken paths
3604  *
3605  * @param cls closure
3606  * @param message message
3607  * @param peer peer identity this notification is about
3608  *
3609  * @return GNUNET_OK to keep the connection open,
3610  *         GNUNET_SYSERR to close it (signal serious error)
3611  */
3612 static int
3613 handle_mesh_path_broken (void *cls, const struct GNUNET_PeerIdentity *peer,
3614                          const struct GNUNET_MessageHeader *message)
3615 {
3616   struct GNUNET_MESH_PathBroken *msg;
3617   struct MeshTunnel *t;
3618
3619   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3620               "Received a PATH BROKEN msg from %s\n", GNUNET_i2s (peer));
3621   msg = (struct GNUNET_MESH_PathBroken *) message;
3622   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  regarding %s\n",
3623               GNUNET_i2s (&msg->peer1));
3624   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  regarding %s\n",
3625               GNUNET_i2s (&msg->peer2));
3626   t = tunnel_get (&msg->oid, ntohl (msg->tid));
3627   if (NULL == t)
3628   {
3629     GNUNET_break_op (0);
3630     return GNUNET_OK;
3631   }
3632   tunnel_notify_connection_broken (t, GNUNET_PEER_search (&msg->peer1),
3633                                    GNUNET_PEER_search (&msg->peer2));
3634   return GNUNET_OK;
3635
3636 }
3637
3638
3639 /**
3640  * Core handler for tunnel destruction
3641  *
3642  * @param cls closure
3643  * @param message message
3644  * @param peer peer identity this notification is about
3645  *
3646  * @return GNUNET_OK to keep the connection open,
3647  *         GNUNET_SYSERR to close it (signal serious error)
3648  */
3649 static int
3650 handle_mesh_tunnel_destroy (void *cls, const struct GNUNET_PeerIdentity *peer,
3651                             const struct GNUNET_MessageHeader *message)
3652 {
3653   struct GNUNET_MESH_TunnelDestroy *msg;
3654   struct MeshTunnel *t;
3655
3656   msg = (struct GNUNET_MESH_TunnelDestroy *) message;
3657   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3658               "Got a TUNNEL DESTROY packet from %s\n",
3659               GNUNET_i2s (peer));
3660   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3661               "  for tunnel %s [%u]\n",
3662               GNUNET_i2s (&msg->oid), ntohl (msg->tid));
3663   t = tunnel_get (&msg->oid, ntohl (msg->tid));
3664   if (NULL == t)
3665   {
3666     /* Probably already got the message from another path,
3667      * destroyed the tunnel and retransmitted to children.
3668      * Safe to ignore.
3669      */
3670     GNUNET_STATISTICS_update (stats, "# control on unknown tunnel",
3671                               1, GNUNET_NO);
3672     return GNUNET_OK;
3673   }
3674   if (t->local_tid_dest >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV)
3675   {
3676     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "INCOMING TUNNEL %X %X\n",
3677                 t->local_tid, t->local_tid_dest);
3678   }
3679   if (GNUNET_PEER_search (peer) == t->prev_hop)
3680   {
3681     // TODO check owner's signature
3682     // TODO add owner's signatue to tunnel for retransmission
3683     peer_cancel_queues (t->prev_hop, t);
3684     GNUNET_PEER_change_rc (t->prev_hop, -1);
3685     t->prev_hop = 0;
3686   }
3687   else if (GNUNET_PEER_search (peer) == t->next_hop)
3688   {
3689     // TODO check dest's signature
3690     // TODO add dest's signatue to tunnel for retransmission
3691     peer_cancel_queues (t->next_hop, t);
3692     GNUNET_PEER_change_rc (t->next_hop, -1);
3693     t->next_hop = 0;
3694   }
3695   else
3696   {
3697     GNUNET_break_op (0);
3698     // TODO check both owner AND destination's signature to see which matches
3699     // TODO restransmit in appropriate direction
3700     return GNUNET_OK;
3701   }
3702   tunnel_destroy_empty (t);
3703
3704   // TODO: add timeout to destroy the tunnel anyway
3705   return GNUNET_OK;
3706 }
3707
3708
3709 /**
3710  * Core handler for mesh network traffic going from the origin to a peer
3711  *
3712  * @param cls closure
3713  * @param peer peer identity this notification is about
3714  * @param message message
3715  * @return GNUNET_OK to keep the connection open,
3716  *         GNUNET_SYSERR to close it (signal serious error)
3717  */
3718 static int
3719 handle_mesh_unicast (void *cls, const struct GNUNET_PeerIdentity *peer,
3720                           const struct GNUNET_MessageHeader *message)
3721 {
3722   struct GNUNET_MESH_Data *msg;
3723   struct MeshTunnel *t;
3724   uint32_t pid;
3725   uint32_t ttl;
3726   size_t size;
3727
3728   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got a unicast packet from %s\n",
3729               GNUNET_i2s (peer));
3730   /* Check size */
3731   size = ntohs (message->size);
3732   if (size <
3733       sizeof (struct GNUNET_MESH_Data) +
3734       sizeof (struct GNUNET_MessageHeader))
3735   {
3736     GNUNET_break (0);
3737     return GNUNET_OK;
3738   }
3739   msg = (struct GNUNET_MESH_Data *) message;
3740   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " of type %s\n",
3741               GNUNET_MESH_DEBUG_M2S (ntohs (msg[1].header.type)));
3742   /* Check tunnel */
3743   t = tunnel_get (&msg->oid, ntohl (msg->tid));
3744   if (NULL == t)
3745   {
3746     /* TODO notify back: we don't know this tunnel */
3747     GNUNET_STATISTICS_update (stats, "# data on unknown tunnel", 1, GNUNET_NO);
3748     GNUNET_break_op (0);
3749     return GNUNET_OK;
3750   }
3751   pid = ntohl (msg->pid);
3752   if (GMC_is_pid_bigger (pid, t->prev_fc.last_ack_sent))
3753   {
3754     GNUNET_STATISTICS_update (stats, "# unsolicited unicast", 1, GNUNET_NO);
3755     GNUNET_break_op (0);
3756     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3757                 "Received PID %u, (prev %u), ACK %u\n",
3758                 pid, t->prev_fc.last_pid_recv, t->prev_fc.last_ack_sent);
3759     tunnel_send_fwd_ack(t, GNUNET_MESSAGE_TYPE_MESH_POLL);
3760     return GNUNET_OK;
3761   }
3762
3763   tunnel_reset_timeout (t);
3764   if (t->dest == myid)
3765   {
3766     /* TODO signature verification */
3767     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3768                 "  it's for us! sending to clients...\n");
3769     GNUNET_STATISTICS_update (stats, "# unicast received", 1, GNUNET_NO);
3770 //     if (GMC_is_pid_bigger(pid, t->prev_fc.last_pid_recv)) FIXME use
3771     if (GMC_is_pid_bigger (pid, t->prev_fc.last_pid_recv))
3772     {
3773       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3774                   " pid %u not seen yet\n", pid);
3775       t->prev_fc.last_pid_recv = pid;
3776
3777       if (GNUNET_NO == t->reliable ||
3778           GNUNET_ntohll (msg->mid) == t->bck_rel->mid_recv)
3779       {
3780         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3781                     "!!! RECV %llu\n", GNUNET_ntohll(msg->mid));
3782         if (GNUNET_YES == t->reliable)
3783           t->bck_rel->mid_recv++;
3784         tunnel_send_client_ucast (t, msg);
3785       }
3786     }
3787     else
3788     {
3789 //       GNUNET_STATISTICS_update (stats, "# duplicate PID", 1, GNUNET_NO);
3790       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3791                   " Pid %u not expected (%u), dropping!\n",
3792                   pid, t->prev_fc.last_pid_recv + 1);
3793     }
3794     tunnel_send_fwd_ack (t, GNUNET_MESSAGE_TYPE_MESH_UNICAST);
3795     return GNUNET_OK;
3796   }
3797   t->prev_fc.last_pid_recv = pid;
3798   if (0 == t->next_hop)
3799   {
3800     GNUNET_break (0);
3801     return GNUNET_OK;
3802   }
3803   ttl = ntohl (msg->ttl);
3804   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   ttl: %u\n", ttl);
3805   if (ttl == 0)
3806   {
3807     GNUNET_STATISTICS_update (stats, "# TTL drops", 1, GNUNET_NO);
3808     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, " TTL is 0, DROPPING!\n");
3809     tunnel_send_fwd_ack (t, GNUNET_MESSAGE_TYPE_MESH_ACK);
3810     return GNUNET_OK;
3811   }
3812   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3813               "  not for us, retransmitting...\n");
3814
3815   send_prebuilt_message (message, t->next_hop, t);
3816   GNUNET_STATISTICS_update (stats, "# unicast forwarded", 1, GNUNET_NO);
3817   return GNUNET_OK;
3818 }
3819
3820
3821 /**
3822  * Core handler for mesh network traffic toward the owner of a tunnel
3823  *
3824  * @param cls closure
3825  * @param message message
3826  * @param peer peer identity this notification is about
3827  *
3828  * @return GNUNET_OK to keep the connection open,
3829  *         GNUNET_SYSERR to close it (signal serious error)
3830  */
3831 static int
3832 handle_mesh_to_orig (void *cls, const struct GNUNET_PeerIdentity *peer,
3833                           const struct GNUNET_MessageHeader *message)
3834 {
3835   struct GNUNET_MESH_Data *msg;
3836   struct MeshTunnel *t;
3837   size_t size;
3838   uint32_t pid;
3839   uint32_t ttl;
3840
3841   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got a ToOrigin packet from %s\n",
3842               GNUNET_i2s (peer));
3843   size = ntohs (message->size);
3844   if (size < sizeof (struct GNUNET_MESH_Data) +     /* Payload must be */
3845       sizeof (struct GNUNET_MessageHeader))     /* at least a header */
3846   {
3847     GNUNET_break_op (0);
3848     return GNUNET_OK;
3849   }
3850   msg = (struct GNUNET_MESH_Data *) message;
3851   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " of type %s\n",
3852               GNUNET_MESH_DEBUG_M2S (ntohs (msg[1].header.type)));
3853   t = tunnel_get (&msg->oid, ntohl (msg->tid));
3854   pid = ntohl (msg->pid);
3855   if (NULL == t)
3856   {
3857     /* TODO notify that we dont know this tunnel (whom)? */
3858     GNUNET_STATISTICS_update (stats, "# data on unknown tunnel", 1, GNUNET_NO);
3859     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3860                 "Received to_origin with PID %u on unknown tunnel %s [%u]\n",
3861                 pid, GNUNET_i2s (&msg->oid), ntohl (msg->tid));
3862     return GNUNET_OK;
3863   }
3864
3865   if (GMC_is_pid_bigger (pid, t->next_fc.last_ack_sent))
3866   {
3867     GNUNET_STATISTICS_update (stats, "# unsolicited to_orig", 1, GNUNET_NO);
3868     GNUNET_break_op (0);
3869     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3870                 "Received PID %u, ACK %u\n",
3871                 pid, t->next_fc.last_ack_sent);
3872     tunnel_send_bck_ack (t, GNUNET_MESSAGE_TYPE_MESH_POLL);
3873     return GNUNET_OK;
3874   }
3875
3876   if (myid == t->id.oid)
3877   {
3878     /* TODO signature verification */
3879     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3880                 "  it's for us! sending to clients...\n");
3881     GNUNET_STATISTICS_update (stats, "# to origin received", 1, GNUNET_NO);
3882     if ( (GNUNET_NO == t->reliable &&
3883           GMC_is_pid_bigger(pid, t->next_fc.last_pid_recv))
3884         ||
3885           (GNUNET_YES == t->reliable &&
3886            pid == t->next_fc.last_pid_recv + 1) ) // FIXME use "futures" as accepting
3887     {
3888       t->next_fc.last_pid_recv = pid;
3889       tunnel_send_client_to_orig (t, msg);
3890     }
3891     else
3892     {
3893 //       GNUNET_STATISTICS_update (stats, "# duplicate PID drops BCK", 1, GNUNET_NO);
3894       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3895                   " Pid %u not expected, sending FWD ACK!\n", pid);
3896     }
3897     tunnel_send_bck_ack (t, GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN);
3898     return GNUNET_OK;
3899   }
3900   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3901               "  not for us, retransmitting...\n");
3902   t->next_fc.last_pid_recv = pid;
3903   if (0 == t->prev_hop) /* No owner AND no prev hop */
3904   {
3905     if (GNUNET_YES == t->destroy)
3906     {
3907       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3908                   "to orig received on a dying tunnel %s [%X]\n",
3909                   GNUNET_i2s (&msg->oid), ntohl(msg->tid));
3910       return GNUNET_OK;
3911     }
3912     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
3913                 "unknown to origin at %s\n",
3914                 GNUNET_i2s (&my_full_id));
3915     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
3916                 "from peer %s\n",
3917                 GNUNET_i2s (peer));
3918     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
3919                 "on tunnel %s [%X]\n",
3920                 GNUNET_i2s (&msg->oid), ntohl(msg->tid));
3921     return GNUNET_OK;
3922   }
3923   ttl = ntohl (msg->ttl);
3924   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   ttl: %u\n", ttl);
3925   if (ttl == 0)
3926   {
3927     GNUNET_STATISTICS_update (stats, "# TTL drops", 1, GNUNET_NO);
3928     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, " TTL is 0, DROPPING!\n");
3929     tunnel_send_bck_ack (t, GNUNET_MESSAGE_TYPE_MESH_ACK);
3930     return GNUNET_OK;
3931   }
3932   send_prebuilt_message (message, t->prev_hop, t);
3933   GNUNET_STATISTICS_update (stats, "# to origin forwarded", 1, GNUNET_NO);
3934
3935   return GNUNET_OK;
3936 }
3937
3938
3939 /**
3940  * Core handler for mesh network traffic end-to-end ACKs.
3941  *
3942  * @param cls Closure.
3943  * @param message Message.
3944  * @param peer Peer identity this notification is about.
3945  *
3946  * @return GNUNET_OK to keep the connection open,
3947  *         GNUNET_SYSERR to close it (signal serious error)
3948  */
3949 static int
3950 handle_mesh_data_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
3951                       const struct GNUNET_MessageHeader *message)
3952 {
3953   struct GNUNET_MESH_DataACK *msg;
3954   struct MeshTunnelReliability *rel;
3955   struct MeshReliableMessage *copy;
3956   struct MeshReliableMessage *next;
3957   struct MeshTunnel *t;
3958   GNUNET_PEER_Id id;
3959   uint64_t ack;
3960   uint16_t type;
3961   int work;
3962
3963   type = ntohs (message->type);
3964   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got a %s message from %s!\n",
3965               GNUNET_MESH_DEBUG_M2S (type), GNUNET_i2s (peer));
3966   msg = (struct GNUNET_MESH_DataACK *) message;
3967
3968   t = tunnel_get (&msg->oid, ntohl (msg->tid));
3969   if (NULL == t)
3970   {
3971     /* TODO notify that we dont know this tunnel (whom)? */
3972     GNUNET_STATISTICS_update (stats, "# ack on unknown tunnel", 1, GNUNET_NO);
3973     return GNUNET_OK;
3974   }
3975   ack = GNUNET_ntohll (msg->mid);
3976   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  ACK %llu\n", ack);
3977
3978   /* Is this a forward or backward ACK? */
3979   id = GNUNET_PEER_search (peer);
3980   if (t->next_hop == id && GNUNET_MESSAGE_TYPE_MESH_UNICAST_ACK == type)
3981   {
3982     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  FWD ACK\n");
3983     if (NULL == t->owner)
3984     {
3985       send_prebuilt_message (message, t->prev_hop, t);
3986       return GNUNET_OK;
3987     }
3988     rel = t->fwd_rel;
3989     tunnel_send_fwd_ack (t, GNUNET_MESSAGE_TYPE_MESH_UNICAST);
3990   }
3991   else if (t->prev_hop == id && GNUNET_MESSAGE_TYPE_MESH_TO_ORIG_ACK == type)
3992   {
3993     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  BCK ACK\n");
3994     if (NULL == t->client)
3995     {
3996       send_prebuilt_message (message, t->next_hop, t);
3997       return GNUNET_OK;
3998     }
3999     rel = t->bck_rel;
4000     tunnel_send_bck_ack (t, GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN);
4001   }
4002   else
4003   {
4004     GNUNET_break_op (0);
4005     return GNUNET_OK;
4006   }
4007
4008   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!! ACK %llu\n", ack);
4009   for (work = GNUNET_NO, copy = rel->head_sent; copy != NULL; copy = next)
4010   {
4011     struct GNUNET_TIME_Relative time;
4012
4013     if (copy->mid > ack)
4014     {
4015       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!!  head %llu, out!\n", copy->mid);
4016       break;
4017     }
4018     work = GNUNET_YES;
4019     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!!  id %llu\n", copy->mid);
4020     next = copy->next;
4021     time = GNUNET_TIME_absolute_get_duration (copy->timestamp);
4022     rel->expected_delay.rel_value += time.rel_value;
4023     rel->expected_delay.rel_value /= 2;
4024     rel->n_sent--;
4025     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!!  new expected delay %s\n",
4026                 GNUNET_STRINGS_relative_time_to_string (rel->expected_delay,
4027                                                         GNUNET_NO));
4028     rel->retry_timer = rel->expected_delay;
4029     GNUNET_CONTAINER_DLL_remove (rel->head_sent, rel->tail_sent, copy);
4030     GNUNET_free (copy);
4031   }
4032
4033   if (GNUNET_YES == work)
4034   {
4035     if (GNUNET_SCHEDULER_NO_TASK != rel->retry_task)
4036     {
4037       GNUNET_SCHEDULER_cancel (rel->retry_task);
4038       if (NULL == rel->head_sent)
4039       {
4040         rel->retry_task = GNUNET_SCHEDULER_NO_TASK;
4041       }
4042       else
4043       {
4044         struct GNUNET_TIME_Absolute new_target;
4045         struct GNUNET_TIME_Relative delay;
4046
4047         new_target = GNUNET_TIME_absolute_add (rel->head_sent->timestamp,
4048                                                rel->retry_timer);
4049         delay = GNUNET_TIME_absolute_get_remaining (new_target);
4050         rel->retry_task =
4051             GNUNET_SCHEDULER_add_delayed (delay,
4052                                           &tunnel_retransmit_message,
4053                                           rel);
4054       }
4055     }
4056     else
4057       GNUNET_break (0);
4058   }
4059   return GNUNET_OK;
4060 }
4061
4062 /**
4063  * Core handler for mesh network traffic point-to-point acks.
4064  *
4065  * @param cls closure
4066  * @param message message
4067  * @param peer peer identity this notification is about
4068  *
4069  * @return GNUNET_OK to keep the connection open,
4070  *         GNUNET_SYSERR to close it (signal serious error)
4071  */
4072 static int
4073 handle_mesh_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
4074                  const struct GNUNET_MessageHeader *message)
4075 {
4076   struct GNUNET_MESH_ACK *msg;
4077   struct MeshTunnel *t;
4078   struct MeshFlowControl *fc;
4079   GNUNET_PEER_Id id;
4080   uint32_t ack;
4081
4082   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got an ACK packet from %s!\n",
4083               GNUNET_i2s (peer));
4084   msg = (struct GNUNET_MESH_ACK *) message;
4085
4086   t = tunnel_get (&msg->oid, ntohl (msg->tid));
4087
4088   if (NULL == t)
4089   {
4090     /* TODO notify that we dont know this tunnel (whom)? */
4091     GNUNET_STATISTICS_update (stats, "# ack on unknown tunnel", 1, GNUNET_NO);
4092     return GNUNET_OK;
4093   }
4094   ack = ntohl (msg->pid);
4095   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  ACK %u\n", ack);
4096
4097   /* Is this a forward or backward ACK? */
4098   id = GNUNET_PEER_search (peer);
4099   if (t->next_hop == id)
4100   {
4101     debug_fwd_ack++;
4102     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  FWD ACK\n");
4103     fc = &t->next_fc;
4104   }
4105   else if (t->prev_hop == id)
4106   {
4107     debug_bck_ack++;
4108     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  BCK ACK\n");
4109     fc = &t->prev_fc;
4110   }
4111   else
4112   {
4113     GNUNET_break_op (0);
4114     return GNUNET_OK;
4115   }
4116
4117   if (GNUNET_SCHEDULER_NO_TASK != fc->poll_task &&
4118       GMC_is_pid_bigger (ack, fc->last_ack_recv))
4119   {
4120     GNUNET_SCHEDULER_cancel (fc->poll_task);
4121     fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
4122     fc->poll_time = GNUNET_TIME_UNIT_SECONDS;
4123   }
4124   fc->last_ack_recv = ack;
4125   peer_unlock_queue (id);
4126
4127   if (t->next_hop == id)
4128     tunnel_send_fwd_ack (t, GNUNET_MESSAGE_TYPE_MESH_ACK);
4129   else
4130     tunnel_send_bck_ack (t, GNUNET_MESSAGE_TYPE_MESH_ACK);
4131
4132   return GNUNET_OK;
4133 }
4134
4135
4136 /**
4137  * Core handler for mesh network traffic point-to-point ack polls.
4138  *
4139  * @param cls closure
4140  * @param message message
4141  * @param peer peer identity this notification is about
4142  *
4143  * @return GNUNET_OK to keep the connection open,
4144  *         GNUNET_SYSERR to close it (signal serious error)
4145  */
4146 static int
4147 handle_mesh_poll (void *cls, const struct GNUNET_PeerIdentity *peer,
4148                   const struct GNUNET_MessageHeader *message)
4149 {
4150   struct GNUNET_MESH_Poll *msg;
4151   struct MeshTunnel *t;
4152   struct MeshFlowControl *fc;
4153   GNUNET_PEER_Id id;
4154   uint32_t pid;
4155   uint32_t old;
4156
4157   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got an POLL packet from %s!\n",
4158               GNUNET_i2s (peer));
4159
4160   msg = (struct GNUNET_MESH_Poll *) message;
4161
4162   t = tunnel_get (&msg->oid, ntohl (msg->tid));
4163
4164   if (NULL == t)
4165   {
4166     /* TODO notify that we dont know this tunnel (whom)? */
4167     GNUNET_STATISTICS_update (stats, "# poll on unknown tunnel", 1, GNUNET_NO);
4168     GNUNET_break_op (0);
4169     return GNUNET_OK;
4170   }
4171
4172   /* Is this a forward or backward ACK? */
4173   id = GNUNET_PEER_search(peer);
4174   pid = ntohl (msg->pid);
4175   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  PID %u\n", pid);
4176   if (t->next_hop == id)
4177   {
4178     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  from FWD\n");
4179     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  was %u\n", t->next_fc.last_pid_recv);
4180     fc = &t->next_fc;
4181     old = fc->last_pid_recv;
4182     fc->last_pid_recv = pid;
4183     tunnel_send_bck_ack (t, GNUNET_MESSAGE_TYPE_MESH_POLL);
4184   }
4185   else if (t->prev_hop == id)
4186   {
4187     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  from BCK\n");
4188     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  was %u\n", t->prev_fc.last_pid_recv);
4189     fc = &t->prev_fc;
4190     old = fc->last_pid_recv;
4191     fc->last_pid_recv = pid;
4192     tunnel_send_fwd_ack (t, GNUNET_MESSAGE_TYPE_MESH_POLL);
4193   }
4194   else
4195     GNUNET_break (0);
4196   
4197   if (GNUNET_YES == t->reliable)
4198     fc->last_pid_recv = old;
4199
4200   return GNUNET_OK;
4201 }
4202
4203
4204 /**
4205  * Core handler for mesh keepalives.
4206  *
4207  * @param cls closure
4208  * @param message message
4209  * @param peer peer identity this notification is about
4210  * @return GNUNET_OK to keep the connection open,
4211  *         GNUNET_SYSERR to close it (signal serious error)
4212  *
4213  * TODO: Check who we got this from, to validate route.
4214  */
4215 static int
4216 handle_mesh_keepalive (void *cls, const struct GNUNET_PeerIdentity *peer,
4217                        const struct GNUNET_MessageHeader *message)
4218 {
4219   struct GNUNET_MESH_TunnelKeepAlive *msg;
4220   struct MeshTunnel *t;
4221
4222   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got a keepalive packet from %s\n",
4223               GNUNET_i2s (peer));
4224
4225   msg = (struct GNUNET_MESH_TunnelKeepAlive *) message;
4226   t = tunnel_get (&msg->oid, ntohl (msg->tid));
4227
4228   if (NULL == t)
4229   {
4230     /* TODO notify that we dont know that tunnel */
4231     GNUNET_STATISTICS_update (stats, "# keepalive on unknown tunnel", 1,
4232                               GNUNET_NO);
4233     return GNUNET_OK;
4234   }
4235
4236   tunnel_reset_timeout (t);
4237   if (NULL != t->client || 0 == t->next_hop || myid == t->next_hop)
4238     return GNUNET_OK;
4239
4240   GNUNET_STATISTICS_update (stats, "# keepalives forwarded", 1, GNUNET_NO);
4241   send_prebuilt_message (message, t->next_hop, t);
4242   return GNUNET_OK;
4243   }
4244
4245
4246
4247 /**
4248  * Functions to handle messages from core
4249  */
4250 static struct GNUNET_CORE_MessageHandler core_handlers[] = {
4251   {&handle_mesh_path_create, GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE, 0},
4252   {&handle_mesh_path_broken, GNUNET_MESSAGE_TYPE_MESH_PATH_BROKEN,
4253    sizeof (struct GNUNET_MESH_PathBroken)},
4254   {&handle_mesh_tunnel_destroy, GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY,
4255    sizeof (struct GNUNET_MESH_TunnelDestroy)},
4256   {&handle_mesh_unicast, GNUNET_MESSAGE_TYPE_MESH_UNICAST, 0},
4257   {&handle_mesh_to_orig, GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN, 0},
4258   {&handle_mesh_data_ack, GNUNET_MESSAGE_TYPE_MESH_UNICAST_ACK,
4259     sizeof (struct GNUNET_MESH_DataACK)},
4260   {&handle_mesh_data_ack, GNUNET_MESSAGE_TYPE_MESH_TO_ORIG_ACK,
4261     sizeof (struct GNUNET_MESH_DataACK)},
4262   {&handle_mesh_keepalive, GNUNET_MESSAGE_TYPE_MESH_PATH_KEEPALIVE,
4263     sizeof (struct GNUNET_MESH_TunnelKeepAlive)},
4264   {&handle_mesh_ack, GNUNET_MESSAGE_TYPE_MESH_ACK,
4265     sizeof (struct GNUNET_MESH_ACK)},
4266   {&handle_mesh_poll, GNUNET_MESSAGE_TYPE_MESH_POLL,
4267     sizeof (struct GNUNET_MESH_Poll)},
4268   {&handle_mesh_path_ack, GNUNET_MESSAGE_TYPE_MESH_PATH_ACK,
4269    sizeof (struct GNUNET_MESH_PathACK)},
4270   {NULL, 0, 0}
4271 };
4272
4273
4274
4275 /******************************************************************************/
4276 /****************       MESH LOCAL HANDLER HELPERS      ***********************/
4277 /******************************************************************************/
4278
4279
4280 #if LATER
4281 /**
4282  * notify_client_connection_failure: notify a client that the connection to the
4283  * requested remote peer is not possible (for instance, no route found)
4284  * Function called when the socket is ready to queue more data. "buf" will be
4285  * NULL and "size" zero if the socket was closed for writing in the meantime.
4286  *
4287  * @param cls closure
4288  * @param size number of bytes available in buf
4289  * @param buf where the callee should write the message
4290  * @return number of bytes written to buf
4291  */
4292 static size_t
4293 notify_client_connection_failure (void *cls, size_t size, void *buf)
4294 {
4295   int size_needed;
4296   struct MeshPeerInfo *peer_info;
4297   struct GNUNET_MESH_PeerControl *msg;
4298   struct GNUNET_PeerIdentity id;
4299
4300   if (0 == size && NULL == buf)
4301   {
4302     // TODO retry? cancel?
4303     return 0;
4304   }
4305
4306   size_needed = sizeof (struct GNUNET_MESH_PeerControl);
4307   peer_info = (struct MeshPeerInfo *) cls;
4308   msg = (struct GNUNET_MESH_PeerControl *) buf;
4309   msg->header.size = htons (sizeof (struct GNUNET_MESH_PeerControl));
4310   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_DISCONNECTED);
4311 //     msg->tunnel_id = htonl(peer_info->t->tid);
4312   GNUNET_PEER_resolve (peer_info->id, &id);
4313   memcpy (&msg->peer, &id, sizeof (struct GNUNET_PeerIdentity));
4314
4315   return size_needed;
4316 }
4317 #endif
4318
4319
4320 /**
4321  * Send keepalive packets for a tunnel.
4322  *
4323  * @param cls Closure (tunnel for which to send the keepalive).
4324  * @param tc Notification context.
4325  * 
4326  * FIXME: add a refresh reset in case of normal unicast traffic is doing the job
4327  */
4328 static void
4329 path_refresh (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
4330 {
4331   struct MeshTunnel *t = cls;
4332   struct GNUNET_MESH_TunnelKeepAlive *msg;
4333   size_t size = sizeof (struct GNUNET_MESH_TunnelKeepAlive);
4334   char cbuf[size];
4335
4336   t->maintenance_task = GNUNET_SCHEDULER_NO_TASK;
4337   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) ||
4338       NULL == t->owner || 0 == t->local_tid)
4339   {
4340     return;
4341   }
4342
4343   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4344               "sending keepalive for tunnel %d\n", t->id.tid);
4345
4346   msg = (struct GNUNET_MESH_TunnelKeepAlive *) cbuf;
4347   msg->header.size = htons (size);
4348   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_KEEPALIVE);
4349   msg->oid = my_full_id;
4350   msg->tid = htonl (t->id.tid);
4351   send_prebuilt_message (&msg->header, t->next_hop, t);
4352
4353   t->maintenance_task =
4354       GNUNET_SCHEDULER_add_delayed (refresh_path_time, &path_refresh, t);
4355 }
4356
4357
4358 /**
4359  * Function to process paths received for a new peer addition. The recorded
4360  * paths form the initial tunnel, which can be optimized later.
4361  * Called on each result obtained for the DHT search.
4362  *
4363  * @param cls closure
4364  * @param exp when will this value expire
4365  * @param key key of the result
4366  * @param get_path path of the get request
4367  * @param get_path_length lenght of get_path
4368  * @param put_path path of the put request
4369  * @param put_path_length length of the put_path
4370  * @param type type of the result
4371  * @param size number of bytes in data
4372  * @param data pointer to the result data
4373  */
4374 static void
4375 dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp,
4376                     const struct GNUNET_HashCode * key,
4377                     const struct GNUNET_PeerIdentity *get_path,
4378                     unsigned int get_path_length,
4379                     const struct GNUNET_PeerIdentity *put_path,
4380                     unsigned int put_path_length, enum GNUNET_BLOCK_Type type,
4381                     size_t size, const void *data)
4382 {
4383   struct MeshPeerInfo *peer = cls;
4384   struct MeshPeerPath *p;
4385   struct GNUNET_PeerIdentity pi;
4386   int i;
4387
4388   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got results from DHT!\n");
4389   GNUNET_PEER_resolve (peer->id, &pi);
4390   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  for %s\n", GNUNET_i2s (&pi));
4391
4392   p = path_build_from_dht (get_path, get_path_length,
4393                            put_path, put_path_length);
4394   path_add_to_peers (p, GNUNET_NO);
4395   path_destroy (p);
4396   for (i = 0; i < peer->ntunnels; i++)
4397   {
4398     struct GNUNET_PeerIdentity id;
4399
4400     GNUNET_PEER_resolve (peer->tunnels[i]->id.oid, &id);
4401     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " ... tunnel %s:%X (%X / %X)\n",
4402                 GNUNET_i2s (&id), peer->tunnels[i]->id.tid,
4403                 peer->tunnels[i]->local_tid, 
4404                 peer->tunnels[i]->local_tid_dest);
4405     if (peer->tunnels[i]->state == MESH_TUNNEL_SEARCHING)
4406     {
4407       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " ... connect!\n");
4408       peer_connect (peer, peer->tunnels[i]);
4409     }
4410   }
4411
4412   return;
4413 }
4414
4415
4416 /******************************************************************************/
4417 /*********************       MESH LOCAL HANDLES      **************************/
4418 /******************************************************************************/
4419
4420
4421 /**
4422  * Handler for client connection.
4423  *
4424  * @param cls Closure (unused).
4425  * @param client Client handler.
4426  */
4427 static void
4428 handle_local_client_connect (void *cls, struct GNUNET_SERVER_Client *client)
4429 {
4430   struct MeshClient *c;
4431
4432   if (NULL == client)
4433     return;
4434   c = GNUNET_malloc (sizeof (struct MeshClient));
4435   c->handle = client;
4436   GNUNET_SERVER_client_keep (client);
4437   GNUNET_SERVER_client_set_user_context (client, c);
4438   GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, c);
4439 }
4440
4441
4442 /**
4443  * Handler for client disconnection
4444  *
4445  * @param cls closure
4446  * @param client identification of the client; NULL
4447  *        for the last call when the server is destroyed
4448  */
4449 static void
4450 handle_local_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
4451 {
4452   struct MeshClient *c;
4453   struct MeshClient *next;
4454
4455   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "client disconnected: %p\n", client);
4456   if (client == NULL)
4457   {
4458     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   (SERVER DOWN)\n");
4459     return;
4460   }
4461
4462   c = client_get (client);
4463   if (NULL != c)
4464   {
4465     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "matching client found (%u)\n",
4466                 c->id);
4467     GNUNET_SERVER_client_drop (c->handle);
4468     c->shutting_down = GNUNET_YES;
4469     if (NULL != c->own_tunnels)
4470     {
4471       GNUNET_CONTAINER_multihashmap32_iterate (c->own_tunnels,
4472                                                &tunnel_destroy_iterator, c);
4473       GNUNET_CONTAINER_multihashmap32_destroy (c->own_tunnels);
4474     }
4475
4476     if (NULL != c->incoming_tunnels)
4477     {
4478       GNUNET_CONTAINER_multihashmap32_iterate (c->incoming_tunnels,
4479                                              &tunnel_destroy_iterator, c);
4480       GNUNET_CONTAINER_multihashmap32_destroy (c->incoming_tunnels);
4481     }
4482
4483     if (NULL != c->ports)
4484       GNUNET_CONTAINER_multihashmap32_destroy (c->ports);
4485     next = c->next;
4486     GNUNET_CONTAINER_DLL_remove (clients_head, clients_tail, c);
4487     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  CLIENT FREE at %p\n", c);
4488     GNUNET_free (c);
4489     GNUNET_STATISTICS_update (stats, "# clients", -1, GNUNET_NO);
4490     c = next;
4491   }
4492   else
4493   {
4494     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, " context NULL!\n");
4495   }
4496   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "done!\n");
4497   return;
4498 }
4499
4500
4501 /**
4502  * Handler for new clients
4503  *
4504  * @param cls closure
4505  * @param client identification of the client
4506  * @param message the actual message, which includes messages the client wants
4507  */
4508 static void
4509 handle_local_new_client (void *cls, struct GNUNET_SERVER_Client *client,
4510                          const struct GNUNET_MessageHeader *message)
4511 {
4512   struct GNUNET_MESH_ClientConnect *cc_msg;
4513   struct MeshClient *c;
4514   unsigned int size;
4515   uint32_t *p;
4516   unsigned int i;
4517
4518   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "new client connected %p\n", client);
4519
4520   /* Check data sanity */
4521   size = ntohs (message->size) - sizeof (struct GNUNET_MESH_ClientConnect);
4522   cc_msg = (struct GNUNET_MESH_ClientConnect *) message;
4523   if (0 != (size % sizeof (uint32_t)))
4524   {
4525     GNUNET_break (0);
4526     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4527     return;
4528   }
4529   size /= sizeof (uint32_t);
4530
4531   /* Initialize new client structure */
4532   c = GNUNET_SERVER_client_get_user_context (client, struct MeshClient);
4533   c->id = next_client_id++; /* overflow not important: just for debug */
4534   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  client id %u\n", c->id);
4535   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  client has %u ports\n", size);
4536   if (size > 0)
4537   {
4538     uint32_t u32;
4539
4540     p = (uint32_t *) &cc_msg[1];
4541     c->ports = GNUNET_CONTAINER_multihashmap32_create (size);
4542     for (i = 0; i < size; i++)
4543     {
4544       u32 = ntohl (p[i]);
4545       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "    port: %u\n", u32);
4546
4547       /* store in client's hashmap */
4548       GNUNET_CONTAINER_multihashmap32_put (c->ports, u32, c,
4549                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
4550       /* store in global hashmap */
4551       /* FIXME only allow one client to have the port open,
4552        *       have a backup hashmap with waiting clients */
4553       GNUNET_CONTAINER_multihashmap32_put (ports, u32, c,
4554                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
4555     }
4556   }
4557
4558   c->own_tunnels = GNUNET_CONTAINER_multihashmap32_create (32);
4559   c->incoming_tunnels = GNUNET_CONTAINER_multihashmap32_create (32);
4560   GNUNET_SERVER_notification_context_add (nc, client);
4561   GNUNET_STATISTICS_update (stats, "# clients", 1, GNUNET_NO);
4562
4563   GNUNET_SERVER_receive_done (client, GNUNET_OK);
4564   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "new client processed\n");
4565 }
4566
4567
4568 /**
4569  * Handler for requests of new tunnels
4570  *
4571  * @param cls Closure.
4572  * @param client Identification of the client.
4573  * @param message The actual message.
4574  */
4575 static void
4576 handle_local_tunnel_create (void *cls, struct GNUNET_SERVER_Client *client,
4577                             const struct GNUNET_MessageHeader *message)
4578 {
4579   struct GNUNET_MESH_TunnelMessage *t_msg;
4580   struct MeshPeerInfo *peer_info;
4581   struct MeshTunnel *t;
4582   struct MeshClient *c;
4583   MESH_TunnelNumber tid;
4584
4585   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "new tunnel requested\n");
4586
4587   /* Sanity check for client registration */
4588   if (NULL == (c = client_get (client)))
4589   {
4590     GNUNET_break (0);
4591     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4592     return;
4593   }
4594   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  by client %u\n", c->id);
4595
4596   /* Message size sanity check */
4597   if (sizeof (struct GNUNET_MESH_TunnelMessage) != ntohs (message->size))
4598   {
4599     GNUNET_break (0);
4600     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4601     return;
4602   }
4603
4604   t_msg = (struct GNUNET_MESH_TunnelMessage *) message;
4605   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  towards %s\n",
4606               GNUNET_i2s (&t_msg->peer));
4607   /* Sanity check for tunnel numbering */
4608   tid = ntohl (t_msg->tunnel_id);
4609   if (0 == (tid & GNUNET_MESH_LOCAL_TUNNEL_ID_CLI))
4610   {
4611     GNUNET_break (0);
4612     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4613     return;
4614   }
4615   /* Sanity check for duplicate tunnel IDs */
4616   if (NULL != tunnel_get_by_local_id (c, tid))
4617   {
4618     GNUNET_break (0);
4619     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4620     return;
4621   }
4622
4623   /* Create tunnel */
4624   while (NULL != tunnel_get_by_pi (myid, next_tid))
4625     next_tid = (next_tid + 1) & ~GNUNET_MESH_LOCAL_TUNNEL_ID_CLI;
4626   t = tunnel_new (myid, next_tid, c, tid);
4627   next_tid = (next_tid + 1) & ~GNUNET_MESH_LOCAL_TUNNEL_ID_CLI;
4628   if (NULL == t)
4629   {
4630     GNUNET_break (0);
4631     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4632     return;
4633   }
4634   t->port = ntohl (t_msg->port);
4635   tunnel_set_options (t, ntohl (t_msg->options));
4636   if (GNUNET_YES == t->reliable)
4637   {
4638     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!! Reliable\n");
4639     t->fwd_rel = GNUNET_malloc (sizeof (struct MeshTunnelReliability));
4640     t->fwd_rel->t = t;
4641     t->fwd_rel->expected_delay = MESH_RETRANSMIT_TIME;
4642   }
4643
4644   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CREATED TUNNEL %s[%x]:%u (%x)\n",
4645               GNUNET_i2s (&my_full_id), t->id.tid, t->port, t->local_tid);
4646
4647   peer_info = peer_get (&t_msg->peer);
4648   peer_info_add_tunnel (peer_info, t);
4649   peer_connect (peer_info, t);
4650   GNUNET_SERVER_receive_done (client, GNUNET_OK);
4651   return;
4652 }
4653
4654
4655 /**
4656  * Handler for requests of deleting tunnels
4657  *
4658  * @param cls closure
4659  * @param client identification of the client
4660  * @param message the actual message
4661  */
4662 static void
4663 handle_local_tunnel_destroy (void *cls, struct GNUNET_SERVER_Client *client,
4664                              const struct GNUNET_MessageHeader *message)
4665 {
4666   struct GNUNET_MESH_TunnelMessage *tunnel_msg;
4667   struct MeshClient *c;
4668   struct MeshTunnel *t;
4669   MESH_TunnelNumber tid;
4670
4671   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4672               "Got a DESTROY TUNNEL from client!\n");
4673
4674   /* Sanity check for client registration */
4675   if (NULL == (c = client_get (client)))
4676   {
4677     GNUNET_break (0);
4678     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4679     return;
4680   }
4681   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  by client %u\n", c->id);
4682
4683   /* Message sanity check */
4684   if (sizeof (struct GNUNET_MESH_TunnelMessage) != ntohs (message->size))
4685   {
4686     GNUNET_break (0);
4687     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4688     return;
4689   }
4690
4691   tunnel_msg = (struct GNUNET_MESH_TunnelMessage *) message;
4692
4693   /* Retrieve tunnel */
4694   tid = ntohl (tunnel_msg->tunnel_id);
4695   t = tunnel_get_by_local_id(c, tid);
4696   if (NULL == t)
4697   {
4698     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "  tunnel %X not found\n", tid);
4699     GNUNET_break (0);
4700     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4701     return;
4702   }
4703
4704   /* Cleanup after the tunnel */
4705   client_delete_tunnel (c, t);
4706   if (c == t->client)
4707   {
4708     t->client = NULL;
4709   }
4710   if (c == t->owner)
4711   {
4712     peer_info_remove_tunnel (peer_get_short (t->dest), t);
4713     t->owner = NULL;
4714   }
4715
4716   /* The tunnel will be destroyed when the last message is transmitted. */
4717   tunnel_destroy_empty (t);
4718
4719   GNUNET_SERVER_receive_done (client, GNUNET_OK);
4720   return;
4721 }
4722
4723
4724 /**
4725  * Handler for client traffic
4726  *
4727  * @param cls closure
4728  * @param client identification of the client
4729  * @param message the actual message
4730  */
4731 static void
4732 handle_local_data (void *cls, struct GNUNET_SERVER_Client *client,
4733                    const struct GNUNET_MessageHeader *message)
4734 {
4735   struct GNUNET_MESH_LocalData *data_msg;
4736   struct MeshClient *c;
4737   struct MeshTunnel *t;
4738   struct MeshFlowControl *fc;
4739   MESH_TunnelNumber tid;
4740   size_t size;
4741
4742   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4743               "Got data from a client!\n");
4744
4745   /* Sanity check for client registration */
4746   if (NULL == (c = client_get (client)))
4747   {
4748     GNUNET_break (0);
4749     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4750     return;
4751   }
4752   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  by client %u\n", c->id);
4753
4754   data_msg = (struct GNUNET_MESH_LocalData *) message;
4755
4756   /* Sanity check for message size */
4757   size = ntohs (message->size) - sizeof (struct GNUNET_MESH_LocalData);
4758   if (size < sizeof (struct GNUNET_MessageHeader))
4759   {
4760     GNUNET_break (0);
4761     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4762     return;
4763   }
4764
4765   /* Tunnel exists? */
4766   tid = ntohl (data_msg->tid);
4767   if (tid < GNUNET_MESH_LOCAL_TUNNEL_ID_CLI)
4768   {
4769     GNUNET_break (0);
4770     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4771     return;
4772   }
4773   t = tunnel_get_by_local_id (c, tid);
4774   if (NULL == t)
4775   {
4776     GNUNET_break (0);
4777     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4778     return;
4779   }
4780
4781   /* Is the client in the tunnel? */
4782   if ( !( (tid < GNUNET_MESH_LOCAL_TUNNEL_ID_SERV &&
4783            t->owner &&
4784            t->owner->handle == client)
4785          ||
4786           (tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV &&
4787            t->client && 
4788            t->client->handle == client) ) )
4789   {
4790     GNUNET_break (0);
4791     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4792     return;
4793   }
4794
4795   /* Ok, everything is correct, send the message
4796    * (pretend we got it from a mesh peer)
4797    */
4798   {
4799     struct GNUNET_MESH_Data *payload;
4800     char cbuf[sizeof(struct GNUNET_MESH_Data) + size];
4801
4802     fc = tid < GNUNET_MESH_LOCAL_TUNNEL_ID_SERV ? &t->prev_fc : &t->next_fc;
4803     if (GNUNET_YES == t->reliable)
4804     {
4805       struct MeshTunnelReliability *rel;
4806       struct MeshReliableMessage *copy;
4807
4808       rel = (tid < GNUNET_MESH_LOCAL_TUNNEL_ID_SERV) ? t->fwd_rel : t->bck_rel;
4809       copy = GNUNET_malloc (sizeof (struct MeshReliableMessage)
4810                             + sizeof(struct GNUNET_MESH_Data)
4811                             + size);
4812       copy->mid = rel->mid_sent++;
4813       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!! DATA %llu\n", copy->mid);
4814       copy->timestamp = GNUNET_TIME_absolute_get ();
4815       copy->rel = rel;
4816       rel->n_sent++;
4817       GNUNET_CONTAINER_DLL_insert_tail (rel->head_sent, rel->tail_sent, copy);
4818       if (GNUNET_SCHEDULER_NO_TASK == rel->retry_task)
4819       {
4820         rel->retry_timer =
4821             GNUNET_TIME_relative_multiply (rel->expected_delay,
4822                                            MESH_RETRANSMIT_MARGIN);
4823         rel->retry_task =
4824             GNUNET_SCHEDULER_add_delayed (rel->retry_timer,
4825                                           &tunnel_retransmit_message,
4826                                           rel);
4827       }
4828       payload = (struct GNUNET_MESH_Data *) &copy[1];
4829       payload->mid = GNUNET_htonll (copy->mid);
4830     }
4831     else
4832     {
4833       payload = (struct GNUNET_MESH_Data *) cbuf;
4834       payload->mid = 0;
4835       // FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME 
4836       // use different struct for unreliable traffic, save 8 bytes
4837     }
4838     memcpy (&payload[1], &data_msg[1], size);
4839     payload->header.size = htons (sizeof (struct GNUNET_MESH_Data) + size);
4840     payload->header.type = htons (tid < GNUNET_MESH_LOCAL_TUNNEL_ID_SERV ?
4841                                   GNUNET_MESSAGE_TYPE_MESH_UNICAST :
4842                                   GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN);
4843     GNUNET_PEER_resolve(t->id.oid, &payload->oid);;
4844     payload->tid = htonl (t->id.tid);
4845     payload->ttl = htonl (default_ttl);
4846     payload->pid = htonl (fc->last_pid_recv + 1);
4847     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4848                 "  calling generic handler...\n");
4849     if (tid < GNUNET_MESH_LOCAL_TUNNEL_ID_SERV)
4850       handle_mesh_unicast (NULL, &my_full_id, &payload->header);
4851     else
4852       handle_mesh_to_orig (NULL, &my_full_id, &payload->header);
4853   }
4854   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "receive done OK\n");
4855   GNUNET_SERVER_receive_done (client, GNUNET_OK);
4856
4857   return;
4858 }
4859
4860
4861 /**
4862  * Handler for client's ACKs for payload traffic.
4863  *
4864  * @param cls Closure (unused).
4865  * @param client Identification of the client.
4866  * @param message The actual message.
4867  */
4868 static void
4869 handle_local_ack (void *cls, struct GNUNET_SERVER_Client *client,
4870                   const struct GNUNET_MessageHeader *message)
4871 {
4872   struct GNUNET_MESH_LocalAck *msg;
4873   struct MeshTunnel *t;
4874   struct MeshClient *c;
4875   MESH_TunnelNumber tid;
4876
4877   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got a local ACK\n");
4878   /* Sanity check for client registration */
4879   if (NULL == (c = client_get (client)))
4880   {
4881     GNUNET_break (0);
4882     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4883     return;
4884   }
4885   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  by client %u\n", c->id);
4886
4887   msg = (struct GNUNET_MESH_LocalAck *) message;
4888
4889   /* Tunnel exists? */
4890   tid = ntohl (msg->tunnel_id);
4891   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  on tunnel %X\n", tid);
4892   t = tunnel_get_by_local_id (c, tid);
4893   if (NULL == t)
4894   {
4895     GNUNET_break (0);
4896     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Tunnel %X unknown.\n", tid);
4897     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "  for client %u.\n", c->id);
4898     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4899     return;
4900   }
4901
4902   /* Does client own tunnel? I.E: Is this an ACK for BCK traffic? */
4903   if (t->owner == c)
4904   {
4905     /* The client owns the tunnel, ACK is for data to_origin, send BCK ACK. */
4906     t->prev_fc.last_ack_recv++;
4907     tunnel_send_bck_ack (t, GNUNET_MESSAGE_TYPE_MESH_LOCAL_ACK);
4908   }
4909   else
4910   {
4911     /* The client doesn't own the tunnel, this ACK is for FWD traffic. */
4912     t->next_fc.last_ack_recv++;
4913     tunnel_send_fwd_ack (t, GNUNET_MESSAGE_TYPE_MESH_LOCAL_ACK);
4914   }
4915
4916   GNUNET_SERVER_receive_done (client, GNUNET_OK);
4917
4918   return;
4919 }
4920
4921
4922
4923 /**
4924  * Iterator over all tunnels to send a monitoring client info about each tunnel.
4925  *
4926  * @param cls Closure (client handle).
4927  * @param key Key (hashed tunnel ID, unused).
4928  * @param value Tunnel info.
4929  *
4930  * @return GNUNET_YES, to keep iterating.
4931  */
4932 static int
4933 monitor_all_tunnels_iterator (void *cls,
4934                               const struct GNUNET_HashCode * key,
4935                               void *value)
4936 {
4937   struct GNUNET_SERVER_Client *client = cls;
4938   struct MeshTunnel *t = value;
4939   struct GNUNET_MESH_LocalMonitor *msg;
4940
4941   msg = GNUNET_malloc (sizeof(struct GNUNET_MESH_LocalMonitor));
4942   GNUNET_PEER_resolve(t->id.oid, &msg->owner);
4943   msg->tunnel_id = htonl (t->id.tid);
4944   msg->header.size = htons (sizeof (struct GNUNET_MESH_LocalMonitor));
4945   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNELS);
4946   GNUNET_PEER_resolve (t->dest, &msg->destination);
4947
4948   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
4949               "*  sending info about tunnel %s [%u]\n",
4950               GNUNET_i2s (&msg->owner), t->id.tid);
4951
4952   GNUNET_SERVER_notification_context_unicast (nc, client,
4953                                               &msg->header, GNUNET_NO);
4954   return GNUNET_YES;
4955 }
4956
4957
4958 /**
4959  * Handler for client's MONITOR request.
4960  *
4961  * @param cls Closure (unused).
4962  * @param client Identification of the client.
4963  * @param message The actual message.
4964  */
4965 static void
4966 handle_local_get_tunnels (void *cls, struct GNUNET_SERVER_Client *client,
4967                           const struct GNUNET_MessageHeader *message)
4968 {
4969   struct MeshClient *c;
4970
4971   /* Sanity check for client registration */
4972   if (NULL == (c = client_get (client)))
4973   {
4974     GNUNET_break (0);
4975     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4976     return;
4977   }
4978
4979   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
4980               "Received get tunnels request from client %u\n",
4981               c->id);
4982   GNUNET_CONTAINER_multihashmap_iterate (tunnels,
4983                                          monitor_all_tunnels_iterator,
4984                                          client);
4985   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
4986               "Get tunnels request from client %u completed\n",
4987               c->id);
4988   GNUNET_SERVER_receive_done (client, GNUNET_OK);
4989 }
4990
4991
4992 /**
4993  * Handler for client's MONITOR_TUNNEL request.
4994  *
4995  * @param cls Closure (unused).
4996  * @param client Identification of the client.
4997  * @param message The actual message.
4998  */
4999 static void
5000 handle_local_show_tunnel (void *cls, struct GNUNET_SERVER_Client *client,
5001                           const struct GNUNET_MessageHeader *message)
5002 {
5003   const struct GNUNET_MESH_LocalMonitor *msg;
5004   struct GNUNET_MESH_LocalMonitor *resp;
5005   struct MeshClient *c;
5006   struct MeshTunnel *t;
5007
5008   /* Sanity check for client registration */
5009   if (NULL == (c = client_get (client)))
5010   {
5011     GNUNET_break (0);
5012     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5013     return;
5014   }
5015
5016   msg = (struct GNUNET_MESH_LocalMonitor *) message;
5017   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
5018               "Received tunnel info request from client %u for tunnel %s[%X]\n",
5019               c->id,
5020               &msg->owner,
5021               ntohl (msg->tunnel_id));
5022   t = tunnel_get (&msg->owner, ntohl (msg->tunnel_id));
5023   if (NULL == t)
5024   {
5025     /* We don't know the tunnel FIXME */
5026     struct GNUNET_MESH_LocalMonitor warn;
5027
5028     warn = *msg;
5029     GNUNET_SERVER_notification_context_unicast (nc, client,
5030                                                 &warn.header,
5031                                                 GNUNET_NO);
5032     GNUNET_SERVER_receive_done (client, GNUNET_OK);
5033     return;
5034   }
5035
5036   /* Initialize context */
5037   resp = GNUNET_malloc (sizeof (struct GNUNET_MESH_LocalMonitor));
5038   *resp = *msg;
5039   GNUNET_PEER_resolve (t->dest, &resp->destination);
5040   resp->header.size = htons (sizeof (struct GNUNET_MESH_LocalMonitor));
5041   GNUNET_SERVER_notification_context_unicast (nc, c->handle,
5042                                               &resp->header, GNUNET_NO);
5043   GNUNET_free (resp);
5044
5045   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
5046               "Monitor tunnel request from client %u completed\n",
5047               c->id);
5048   GNUNET_SERVER_receive_done (client, GNUNET_OK);
5049 }
5050
5051
5052 /**
5053  * Functions to handle messages from clients
5054  */
5055 static struct GNUNET_SERVER_MessageHandler client_handlers[] = {
5056   {&handle_local_new_client, NULL,
5057    GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT, 0},
5058   {&handle_local_tunnel_create, NULL,
5059    GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_CREATE,
5060    sizeof (struct GNUNET_MESH_TunnelMessage)},
5061   {&handle_local_tunnel_destroy, NULL,
5062    GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_DESTROY,
5063    sizeof (struct GNUNET_MESH_TunnelMessage)},
5064   {&handle_local_data, NULL,
5065    GNUNET_MESSAGE_TYPE_MESH_LOCAL_DATA, 0},
5066   {&handle_local_ack, NULL,
5067    GNUNET_MESSAGE_TYPE_MESH_LOCAL_ACK,
5068    sizeof (struct GNUNET_MESH_LocalAck)},
5069   {&handle_local_get_tunnels, NULL,
5070    GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNELS,
5071    sizeof (struct GNUNET_MessageHeader)},
5072   {&handle_local_show_tunnel, NULL,
5073    GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNEL,
5074      sizeof (struct GNUNET_MESH_LocalMonitor)},
5075   {NULL, NULL, 0, 0}
5076 };
5077
5078
5079 /**
5080  * Method called whenever a given peer connects.
5081  *
5082  * @param cls closure
5083  * @param peer peer identity this notification is about
5084  */
5085 static void
5086 core_connect (void *cls, const struct GNUNET_PeerIdentity *peer)
5087 {
5088   struct MeshPeerInfo *peer_info;
5089   struct MeshPeerPath *path;
5090
5091   DEBUG_CONN ("Peer connected\n");
5092   DEBUG_CONN ("     %s\n", GNUNET_i2s (&my_full_id));
5093   peer_info = peer_get (peer);
5094   if (myid == peer_info->id)
5095   {
5096     DEBUG_CONN ("     (self)\n");
5097     path = path_new (1);
5098   }
5099   else
5100   {
5101     DEBUG_CONN ("     %s\n", GNUNET_i2s (peer));
5102     path = path_new (2);
5103     path->peers[1] = peer_info->id;
5104     GNUNET_PEER_change_rc (peer_info->id, 1);
5105     GNUNET_STATISTICS_update (stats, "# peers", 1, GNUNET_NO);
5106   }
5107   path->peers[0] = myid;
5108   GNUNET_PEER_change_rc (myid, 1);
5109   peer_info_add_path (peer_info, path, GNUNET_YES);
5110   return;
5111 }
5112
5113
5114 /**
5115  * Method called whenever a peer disconnects.
5116  *
5117  * @param cls closure
5118  * @param peer peer identity this notification is about
5119  */
5120 static void
5121 core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
5122 {
5123   struct MeshPeerInfo *pi;
5124   struct MeshPeerQueue *q;
5125   struct MeshPeerQueue *n;
5126
5127   DEBUG_CONN ("Peer disconnected\n");
5128   pi = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
5129   if (NULL == pi)
5130   {
5131     GNUNET_break (0);
5132     return;
5133   }
5134   q = pi->queue_head;
5135   while (NULL != q)
5136   {
5137       n = q->next;
5138       /* TODO try to reroute this traffic instead */
5139       queue_destroy(q, GNUNET_YES);
5140       q = n;
5141   }
5142   if (NULL != pi->core_transmit)
5143   {
5144     GNUNET_CORE_notify_transmit_ready_cancel(pi->core_transmit);
5145     pi->core_transmit = NULL;
5146   }
5147     peer_remove_path (pi, pi->id, myid);
5148   if (myid == pi->id)
5149   {
5150     DEBUG_CONN ("     (self)\n");
5151   }
5152   GNUNET_STATISTICS_update (stats, "# peers", -1, GNUNET_NO);
5153   return;
5154 }
5155
5156
5157 /**
5158  * Install server (service) handlers and start listening to clients.
5159  */
5160 static void
5161 server_init (void)
5162 {
5163   GNUNET_SERVER_add_handlers (server_handle, client_handlers);
5164   GNUNET_SERVER_connect_notify (server_handle,
5165                                 &handle_local_client_connect, NULL);
5166   GNUNET_SERVER_disconnect_notify (server_handle,
5167                                    &handle_local_client_disconnect, NULL);
5168   nc = GNUNET_SERVER_notification_context_create (server_handle, 1);
5169
5170   clients_head = NULL;
5171   clients_tail = NULL;
5172   next_client_id = 0;
5173   GNUNET_SERVER_resume (server_handle);
5174 }
5175
5176
5177 /**
5178  * To be called on core init/fail.
5179  *
5180  * @param cls Closure (config)
5181  * @param server handle to the server for this service
5182  * @param identity the public identity of this peer
5183  */
5184 static void
5185 core_init (void *cls, struct GNUNET_CORE_Handle *server,
5186            const struct GNUNET_PeerIdentity *identity)
5187 {
5188   const struct GNUNET_CONFIGURATION_Handle *c = cls;
5189   static int i = 0;
5190
5191   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Core init\n");
5192   GNUNET_break (core_handle == server);
5193   if (0 != memcmp (identity, &my_full_id, sizeof (my_full_id)) ||
5194     NULL == server)
5195   {
5196     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Wrong CORE service\n"));
5197     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5198                 " core id %s\n",
5199                 GNUNET_i2s (identity));
5200     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5201                 " my id %s\n",
5202                 GNUNET_i2s (&my_full_id));
5203     GNUNET_CORE_disconnect (core_handle);
5204     core_handle = GNUNET_CORE_connect (c, /* Main configuration */
5205                                        NULL,      /* Closure passed to MESH functions */
5206                                        &core_init,        /* Call core_init once connected */
5207                                        &core_connect,     /* Handle connects */
5208                                        &core_disconnect,  /* remove peers on disconnects */
5209                                        NULL,      /* Don't notify about all incoming messages */
5210                                        GNUNET_NO, /* For header only in notification */
5211                                        NULL,      /* Don't notify about all outbound messages */
5212                                        GNUNET_NO, /* For header-only out notification */
5213                                        core_handlers);    /* Register these handlers */
5214     if (10 < i++)
5215       GNUNET_abort();
5216   }
5217   server_init ();
5218   return;
5219 }
5220
5221
5222 /******************************************************************************/
5223 /************************      MAIN FUNCTIONS      ****************************/
5224 /******************************************************************************/
5225
5226 /**
5227  * Iterator over tunnel hash map entries to destroy the tunnel during shutdown.
5228  *
5229  * @param cls closure
5230  * @param key current key code
5231  * @param value value in the hash map
5232  * @return GNUNET_YES if we should continue to iterate,
5233  *         GNUNET_NO if not.
5234  */
5235 static int
5236 shutdown_tunnel (void *cls, const struct GNUNET_HashCode * key, void *value)
5237 {
5238   struct MeshTunnel *t = value;
5239
5240   tunnel_destroy (t);
5241   return GNUNET_YES;
5242 }
5243
5244 /**
5245  * Iterator over peer hash map entries to destroy the tunnel during shutdown.
5246  *
5247  * @param cls closure
5248  * @param key current key code
5249  * @param value value in the hash map
5250  * @return GNUNET_YES if we should continue to iterate,
5251  *         GNUNET_NO if not.
5252  */
5253 static int
5254 shutdown_peer (void *cls, const struct GNUNET_HashCode * key, void *value)
5255 {
5256   struct MeshPeerInfo *p = value;
5257   struct MeshPeerQueue *q;
5258   struct MeshPeerQueue *n;
5259
5260   q = p->queue_head;
5261   while (NULL != q)
5262   {
5263       n = q->next;
5264       if (q->peer == p)
5265       {
5266         queue_destroy(q, GNUNET_YES);
5267       }
5268       q = n;
5269   }
5270   peer_info_destroy (p);
5271   return GNUNET_YES;
5272 }
5273
5274
5275 /**
5276  * Task run during shutdown.
5277  *
5278  * @param cls unused
5279  * @param tc unused
5280  */
5281 static void
5282 shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
5283 {
5284   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "shutting down\n");
5285
5286   if (core_handle != NULL)
5287   {
5288     GNUNET_CORE_disconnect (core_handle);
5289     core_handle = NULL;
5290   }
5291   GNUNET_CONTAINER_multihashmap_iterate (tunnels, &shutdown_tunnel, NULL);
5292   GNUNET_CONTAINER_multihashmap_iterate (peers, &shutdown_peer, NULL);
5293   if (dht_handle != NULL)
5294   {
5295     GNUNET_DHT_disconnect (dht_handle);
5296     dht_handle = NULL;
5297   }
5298   if (nc != NULL)
5299   {
5300     GNUNET_SERVER_notification_context_destroy (nc);
5301     nc = NULL;
5302   }
5303   if (GNUNET_SCHEDULER_NO_TASK != announce_id_task)
5304   {
5305     GNUNET_SCHEDULER_cancel (announce_id_task);
5306     announce_id_task = GNUNET_SCHEDULER_NO_TASK;
5307   }
5308   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "shut down\n");
5309 }
5310
5311
5312 /**
5313  * Process mesh requests.
5314  *
5315  * @param cls closure
5316  * @param server the initialized server
5317  * @param c configuration to use
5318  */
5319 static void
5320 run (void *cls, struct GNUNET_SERVER_Handle *server,
5321      const struct GNUNET_CONFIGURATION_Handle *c)
5322 {
5323   char *keyfile;
5324   struct GNUNET_CRYPTO_EccPrivateKey *pk;
5325
5326   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "starting to run\n");
5327   server_handle = server;
5328   GNUNET_SERVER_suspend (server_handle);
5329
5330   if (GNUNET_OK !=
5331       GNUNET_CONFIGURATION_get_value_filename (c, "PEER", "PRIVATE_KEY",
5332                                                &keyfile))
5333   {
5334     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5335                 _
5336                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
5337                 "mesh", "peer/privatekey");
5338     GNUNET_SCHEDULER_shutdown ();
5339     return;
5340   }
5341
5342   if (GNUNET_OK !=
5343       GNUNET_CONFIGURATION_get_value_time (c, "MESH", "REFRESH_PATH_TIME",
5344                                            &refresh_path_time))
5345   {
5346     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5347                 _
5348                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
5349                 "mesh", "refresh path time");
5350     GNUNET_SCHEDULER_shutdown ();
5351     return;
5352   }
5353
5354   if (GNUNET_OK !=
5355       GNUNET_CONFIGURATION_get_value_time (c, "MESH", "ID_ANNOUNCE_TIME",
5356                                            &id_announce_time))
5357   {
5358     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5359                 _
5360                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
5361                 "mesh", "id announce time");
5362     GNUNET_SCHEDULER_shutdown ();
5363     return;
5364   }
5365
5366   if (GNUNET_OK !=
5367       GNUNET_CONFIGURATION_get_value_time (c, "MESH", "CONNECT_TIMEOUT",
5368                                            &connect_timeout))
5369   {
5370     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5371                 _
5372                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
5373                 "mesh", "connect timeout");
5374     GNUNET_SCHEDULER_shutdown ();
5375     return;
5376   }
5377
5378   if (GNUNET_OK !=
5379       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "MAX_MSGS_QUEUE",
5380                                              &max_msgs_queue))
5381   {
5382     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5383                 _
5384                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
5385                 "mesh", "max msgs queue");
5386     GNUNET_SCHEDULER_shutdown ();
5387     return;
5388   }
5389
5390   if (GNUNET_OK !=
5391       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "MAX_TUNNELS",
5392                                              &max_tunnels))
5393   {
5394     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5395                 _
5396                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
5397                 "mesh", "max tunnels");
5398     GNUNET_SCHEDULER_shutdown ();
5399     return;
5400   }
5401
5402   if (GNUNET_OK !=
5403       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "DEFAULT_TTL",
5404                                              &default_ttl))
5405   {
5406     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
5407                 _
5408                 ("%s service is lacking key configuration settings (%s). Using default (%u).\n"),
5409                 "mesh", "default ttl", 64);
5410     default_ttl = 64;
5411   }
5412
5413   if (GNUNET_OK !=
5414       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "MAX_PEERS",
5415                                              &max_peers))
5416   {
5417     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
5418                 _("%s service is lacking key configuration settings (%s). Using default (%u).\n"),
5419                 "mesh", "max peers", 1000);
5420     max_peers = 1000;
5421   }
5422
5423   if (GNUNET_OK !=
5424       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "DROP_PERCENT",
5425                                              &drop_percent))
5426   {
5427     drop_percent = 0;
5428   }
5429   else
5430   {
5431     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
5432                 "Mesh is running with drop mode enabled. "
5433                 "This is NOT a good idea! "
5434                 "Remove the DROP_PERCENT option from your configuration.\n");
5435   }
5436
5437   if (GNUNET_OK !=
5438       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "DHT_REPLICATION_LEVEL",
5439                                              &dht_replication_level))
5440   {
5441     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
5442                 _
5443                 ("%s service is lacking key configuration settings (%s). Using default (%u).\n"),
5444                 "mesh", "dht replication level", 3);
5445     dht_replication_level = 3;
5446   }
5447
5448   tunnels = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
5449   incoming_tunnels = GNUNET_CONTAINER_multihashmap32_create (32);
5450   peers = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
5451   ports = GNUNET_CONTAINER_multihashmap32_create (32);
5452
5453   dht_handle = GNUNET_DHT_connect (c, 64);
5454   if (NULL == dht_handle)
5455   {
5456     GNUNET_break (0);
5457   }
5458   stats = GNUNET_STATISTICS_create ("mesh", c);
5459
5460   /* Scheduled the task to clean up when shutdown is called */
5461   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
5462                                 NULL);
5463   pk = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
5464   GNUNET_free (keyfile);
5465   GNUNET_assert (NULL != pk);
5466   my_private_key = pk;
5467   GNUNET_CRYPTO_ecc_key_get_public (my_private_key, &my_public_key);
5468   GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
5469                       &my_full_id.hashPubKey);
5470   myid = GNUNET_PEER_intern (&my_full_id);
5471   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
5472               "Mesh for peer [%s] starting\n",
5473               GNUNET_i2s(&my_full_id));
5474
5475   core_handle = GNUNET_CORE_connect (c, /* Main configuration */
5476                                      NULL,      /* Closure passed to MESH functions */
5477                                      &core_init,        /* Call core_init once connected */
5478                                      &core_connect,     /* Handle connects */
5479                                      &core_disconnect,  /* remove peers on disconnects */
5480                                      NULL,      /* Don't notify about all incoming messages */
5481                                      GNUNET_NO, /* For header only in notification */
5482                                      NULL,      /* Don't notify about all outbound messages */
5483                                      GNUNET_NO, /* For header-only out notification */
5484                                      core_handlers);    /* Register these handlers */
5485   if (NULL == core_handle)
5486   {
5487     GNUNET_break (0);
5488     GNUNET_SCHEDULER_shutdown ();
5489     return;
5490   }
5491   next_tid = 0;
5492   next_local_tid = GNUNET_MESH_LOCAL_TUNNEL_ID_SERV;
5493   announce_id_task = GNUNET_SCHEDULER_add_now (&announce_id, cls);
5494   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Mesh service running\n");
5495 }
5496
5497
5498 /**
5499  * The main function for the mesh service.
5500  *
5501  * @param argc number of arguments from the command line
5502  * @param argv command line arguments
5503  * @return 0 ok, 1 on error
5504  */
5505 int
5506 main (int argc, char *const *argv)
5507 {
5508   int ret;
5509   int r;
5510
5511   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "main()\n");
5512   r = GNUNET_SERVICE_run (argc, argv, "mesh", GNUNET_SERVICE_OPTION_NONE, &run,
5513                           NULL);
5514   ret = (GNUNET_OK == r) ? 0 : 1;
5515   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "main() END\n");
5516
5517   INTERVAL_SHOW;
5518
5519   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
5520               "Mesh for peer [%s] FWD ACKs %u, BCK ACKs %u\n",
5521               GNUNET_i2s(&my_full_id), debug_fwd_ack, debug_bck_ack);
5522
5523   return ret;
5524 }