Don't pass NULL to destroy_route
[oweals/gnunet.git] / src / cadet / gnunet-service-cadet-new.c
1 /*
2      This file is part of GNUnet.
3      Copyright (C) 2001-2013, 2017 GNUnet e.V.
4
5      GNUnet is free software; you can redistribute it and/or modify
6      it under the terms of the GNU General Public License as published
7      by the Free Software Foundation; either version 3, or (at your
8      option) any later version.
9
10      GNUnet is distributed in the hope that it will be useful, but
11      WITHOUT ANY WARRANTY; without even the implied warranty of
12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13      General Public License for more details.
14
15      You should have received a copy of the GNU General Public License
16      along with GNUnet; see the file COPYING.  If not, write to the
17      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18      Boston, MA 02110-1301, USA.
19 */
20
21 /**
22  * @file cadet/gnunet-service-cadet-new.c
23  * @brief GNUnet CADET service with encryption
24  * @author Bartlomiej Polot
25  * @author Christian Grothoff
26  *
27  * Dictionary:
28  * - peer: other cadet instance. If there is direct connection it's a neighbor.
29  * - path: series of directly connected peer from one peer to another.
30  * - connection: path which is being used in a tunnel.
31  * - tunnel: encrypted connection to a peer, neighbor or not.
32  * - channel: logical link between two clients, on the same or different peers.
33  *            have properties like reliability.
34  */
35
36 #include "platform.h"
37 #include "gnunet_util_lib.h"
38 #include "cadet.h"
39 #include "gnunet_statistics_service.h"
40 #include "gnunet-service-cadet-new.h"
41 #include "gnunet-service-cadet-new_channel.h"
42 #include "gnunet-service-cadet-new_connection.h"
43 #include "gnunet-service-cadet-new_core.h"
44 #include "gnunet-service-cadet-new_dht.h"
45 #include "gnunet-service-cadet-new_hello.h"
46 #include "gnunet-service-cadet-new_tunnels.h"
47 #include "gnunet-service-cadet-new_peer.h"
48 #include "gnunet-service-cadet-new_paths.h"
49
50 #define LOG(level, ...) GNUNET_log (level,__VA_ARGS__)
51
52
53 /**
54  * Struct containing information about a client of the service
55  */
56 struct CadetClient
57 {
58   /**
59    * Linked list next
60    */
61   struct CadetClient *next;
62
63   /**
64    * Linked list prev
65    */
66   struct CadetClient *prev;
67
68   /**
69    * Tunnels that belong to this client, indexed by local id,
70    * value is a `struct CadetChannel`.
71    */
72   struct GNUNET_CONTAINER_MultiHashMap32 *channels;
73
74   /**
75    * Handle to communicate with the client
76    */
77   struct GNUNET_MQ_Handle *mq;
78
79   /**
80    * Client handle.
81    */
82   struct GNUNET_SERVICE_Client *client;
83
84   /**
85    * Ports that this client has declared interest in.
86    * Indexed by port, contains *Client.
87    */
88   struct GNUNET_CONTAINER_MultiHashMap *ports;
89
90   /**
91    * Channel ID to use for the next incoming channel for this client.
92    * Wraps around (in theory).
93    */
94   struct GNUNET_CADET_ClientChannelNumber next_ccn;
95
96   /**
97    * ID of the client, mainly for debug messages. Purely internal to this file.
98    */
99   unsigned int id;
100 };
101
102 /******************************************************************************/
103 /***********************      GLOBAL VARIABLES     ****************************/
104 /******************************************************************************/
105
106 /****************************** Global variables ******************************/
107
108 /**
109  * Handle to our configuration.
110  */
111 const struct GNUNET_CONFIGURATION_Handle *cfg;
112
113 /**
114  * Handle to the statistics service.
115  */
116 struct GNUNET_STATISTICS_Handle *stats;
117
118 /**
119  * Handle to communicate with ATS.
120  */
121 struct GNUNET_ATS_ConnectivityHandle *ats_ch;
122
123 /**
124  * Local peer own ID.
125  */
126 struct GNUNET_PeerIdentity my_full_id;
127
128 /**
129  * Own private key.
130  */
131 struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
132
133 /**
134  * Signal that shutdown is happening: prevent recovery measures.
135  */
136 int shutting_down;
137
138 /**
139  * DLL with all the clients, head.
140  */
141 static struct CadetClient *clients_head;
142
143 /**
144  * DLL with all the clients, tail.
145  */
146 static struct CadetClient *clients_tail;
147
148 /**
149  * Next ID to assign to a client.
150  */
151 static unsigned int next_client_id;
152
153 /**
154  * All ports clients of this peer have opened.
155  */
156 struct GNUNET_CONTAINER_MultiHashMap *open_ports;
157
158 /**
159  * Map from ports to channels where the ports were closed at the
160  * time we got the inbound connection.
161  * Indexed by port, contains `struct CadetChannel`.
162  */
163 struct GNUNET_CONTAINER_MultiHashMap *loose_channels;
164
165 /**
166  * Map from PIDs to `struct CadetPeer` entries.
167  */
168 struct GNUNET_CONTAINER_MultiPeerMap *peers;
169
170 /**
171  * Map from `struct GNUNET_CADET_ConnectionTunnelIdentifier`
172  * hash codes to `struct CadetConnection` objects.
173  */
174 struct GNUNET_CONTAINER_MultiShortmap *connections;
175
176 /**
177  * How many messages are needed to trigger an AXOLOTL ratchet advance.
178  */
179 unsigned long long ratchet_messages;
180
181 /**
182  * How long until we trigger a ratched advance due to time.
183  */
184 struct GNUNET_TIME_Relative ratchet_time;
185
186 /**
187  * How frequently do we send KEEPALIVE messages on idle connections?
188  */
189 struct GNUNET_TIME_Relative keepalive_period;
190
191 /**
192  * Set to non-zero values to create random drops to test retransmissions.
193  */
194 unsigned long long drop_percent;
195
196
197 /**
198  * Send a message to a client.
199  *
200  * @param c client to get the message
201  * @param env envelope with the message
202  */
203 void
204 GSC_send_to_client (struct CadetClient *c,
205                     struct GNUNET_MQ_Envelope *env)
206 {
207   GNUNET_MQ_send (c->mq,
208                   env);
209 }
210
211
212 /**
213  * Return identifier for a client as a string.
214  *
215  * @param c client to identify
216  * @return string for debugging
217  */
218 const char *
219 GSC_2s (struct CadetClient *c)
220 {
221   static char buf[32];
222
223   GNUNET_snprintf (buf,
224                    sizeof (buf),
225                    "Client(%u)",
226                    c->id);
227   return buf;
228 }
229
230
231 /**
232  * Lookup channel of client @a c by @a ccn.
233  *
234  * @param c client to look in
235  * @param ccn channel ID to look up
236  * @return NULL if no such channel exists
237  */
238 static struct CadetChannel *
239 lookup_channel (struct CadetClient *c,
240                 struct GNUNET_CADET_ClientChannelNumber ccn)
241 {
242   return GNUNET_CONTAINER_multihashmap32_get (c->channels,
243                                               ntohl (ccn.channel_of_client));
244 }
245
246
247 /**
248  * Obtain the next LID to use for incoming connections to
249  * the given client.
250  *
251  * @param c client handle
252  */
253 static struct GNUNET_CADET_ClientChannelNumber
254 client_get_next_ccn (struct CadetClient *c)
255 {
256   struct GNUNET_CADET_ClientChannelNumber ccn = c->next_ccn;
257
258   /* increment until we have a free one... */
259   while (NULL !=
260          lookup_channel (c,
261                          ccn))
262   {
263     ccn.channel_of_client
264       = htonl (1 + (ntohl (ccn.channel_of_client)));
265     if (ntohl (ccn.channel_of_client) >=
266         GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
267       ccn.channel_of_client = htonl (0);
268   }
269   c->next_ccn.channel_of_client
270     = htonl (1 + (ntohl (ccn.channel_of_client)));
271   return ccn;
272 }
273
274
275 /**
276  * Bind incoming channel to this client, and notify client about
277  * incoming connection.  Caller is responsible for notifying the other
278  * peer about our acceptance of the channel.
279  *
280  * @param c client to bind to
281  * @param ch channel to be bound
282  * @param dest peer that establishes the connection
283  * @param port port number
284  * @param options options
285  * @return local channel number assigned to the new client
286  */
287 struct GNUNET_CADET_ClientChannelNumber
288 GSC_bind (struct CadetClient *c,
289           struct CadetChannel *ch,
290           struct CadetPeer *dest,
291           const struct GNUNET_HashCode *port,
292           uint32_t options)
293 {
294   struct GNUNET_MQ_Envelope *env;
295   struct GNUNET_CADET_LocalChannelCreateMessage *cm;
296   struct GNUNET_CADET_ClientChannelNumber ccn;
297
298   ccn = client_get_next_ccn (c);
299   GNUNET_assert (GNUNET_YES ==
300                  GNUNET_CONTAINER_multihashmap32_put (c->channels,
301                                                       ntohl (ccn.channel_of_client),
302                                                       ch,
303                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
304   LOG (GNUNET_ERROR_TYPE_DEBUG,
305        "Accepting incoming %s from %s on open port %s (%u), assigning ccn %X\n",
306        GCCH_2s (ch),
307        GCP_2s (dest),
308        GNUNET_h2s (port),
309        ntohl (options),
310        ntohl (ccn.channel_of_client));
311   /* notify local client about incoming connection! */
312   env = GNUNET_MQ_msg (cm,
313                        GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE);
314   cm->ccn = ccn;
315   cm->port = *port;
316   cm->opt = htonl (options);
317   cm->peer = *GCP_get_id (dest);
318   GSC_send_to_client (c,
319                       env);
320   return ccn;
321 }
322
323
324 /**
325  * Callback invoked on all peers to destroy all tunnels
326  * that may still exist.
327  *
328  * @param cls NULL
329  * @param pid identify of a peer
330  * @param value a `struct CadetPeer` that may still have a tunnel
331  * @return #GNUNET_OK (iterate over all entries)
332  */
333 static int
334 destroy_tunnels_now (void *cls,
335                      const struct GNUNET_PeerIdentity *pid,
336                      void *value)
337 {
338   struct CadetPeer *cp = value;
339   struct CadetTunnel *t = GCP_get_tunnel (cp,
340                                           GNUNET_NO);
341
342   if (NULL != t)
343     GCT_destroy_tunnel_now (t);
344   return GNUNET_OK;
345 }
346
347
348 /**
349  * Callback invoked on all peers to destroy all tunnels
350  * that may still exist.
351  *
352  * @param cls NULL
353  * @param pid identify of a peer
354  * @param value a `struct CadetPeer` that may still have a tunnel
355  * @return #GNUNET_OK (iterate over all entries)
356  */
357 static int
358 destroy_paths_now (void *cls,
359                    const struct GNUNET_PeerIdentity *pid,
360                    void *value)
361 {
362   struct CadetPeer *cp = value;
363
364   GCP_drop_owned_paths (cp);
365   return GNUNET_OK;
366 }
367
368
369 /**
370  * Shutdown everything once the clients have disconnected.
371  */
372 static void
373 shutdown_rest ()
374 {
375   if (NULL != stats)
376   {
377     GNUNET_STATISTICS_destroy (stats,
378                                GNUNET_NO);
379     stats = NULL;
380   }
381   if (NULL != open_ports)
382   {
383     GNUNET_CONTAINER_multihashmap_destroy (open_ports);
384     open_ports = NULL;
385   }
386   if (NULL != loose_channels)
387   {
388     GNUNET_CONTAINER_multihashmap_destroy (loose_channels);
389     loose_channels = NULL;
390   }
391   /* Destroy tunnels.  Note that all channels must be destroyed first! */
392   GCP_iterate_all (&destroy_tunnels_now,
393                    NULL);
394   /* All tunnels, channels, connections and CORE must be down before this point. */
395   GCP_iterate_all (&destroy_paths_now,
396                    NULL);
397   /* All paths, tunnels, channels, connections and CORE must be down before this point. */
398   GCP_destroy_all_peers ();
399   if (NULL != peers)
400   {
401     GNUNET_CONTAINER_multipeermap_destroy (peers);
402     peers = NULL;
403   }
404   if (NULL != connections)
405   {
406     GNUNET_CONTAINER_multishortmap_destroy (connections);
407     connections = NULL;
408   }
409   if (NULL != ats_ch)
410   {
411     GNUNET_ATS_connectivity_done (ats_ch);
412     ats_ch = NULL;
413   }
414   GCD_shutdown ();
415   GCH_shutdown ();
416   GNUNET_free_non_null (my_private_key);
417   my_private_key = NULL;
418 }
419
420
421 /**
422  * Task run during shutdown.
423  *
424  * @param cls unused
425  */
426 static void
427 shutdown_task (void *cls)
428 {
429   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
430               "Shutting down\n");
431   shutting_down = GNUNET_YES;
432   GCO_shutdown ();
433   if (NULL == clients_head)
434     shutdown_rest ();
435 }
436
437
438 /**
439  * We had a remote connection @a value to port @a port before
440  * client @a cls opened port @a port.  Bind them now.
441  *
442  * @param cls the `struct CadetClient`
443  * @param port the port
444  * @param value the `struct CadetChannel`
445  * @return #GNUNET_YES (iterate over all such channels)
446  */
447 static int
448 bind_loose_channel (void *cls,
449                     const struct GNUNET_HashCode *port,
450                     void *value)
451 {
452   struct CadetClient *c = cls;
453   struct CadetChannel *ch = value;
454
455   GCCH_bind (ch,
456              c);
457   GNUNET_assert (GNUNET_YES ==
458                  GNUNET_CONTAINER_multihashmap_remove (loose_channels,
459                                                        port,
460                                                        value));
461   return GNUNET_YES;
462 }
463
464
465 /**
466  * Handle port open request.  Creates a mapping from the
467  * port to the respective client and checks whether we have
468  * loose channels trying to bind to the port.  If so, those
469  * are bound.
470  *
471  * @param cls Identification of the client.
472  * @param pmsg The actual message.
473  */
474 static void
475 handle_port_open (void *cls,
476                   const struct GNUNET_CADET_PortMessage *pmsg)
477 {
478   struct CadetClient *c = cls;
479
480   LOG (GNUNET_ERROR_TYPE_DEBUG,
481        "Open port %s requested by %s\n",
482        GNUNET_h2s (&pmsg->port),
483        GSC_2s (c));
484   if (NULL == c->ports)
485     c->ports = GNUNET_CONTAINER_multihashmap_create (4,
486                                                       GNUNET_NO);
487   if (GNUNET_OK !=
488       GNUNET_CONTAINER_multihashmap_put (c->ports,
489                                          &pmsg->port,
490                                          c,
491                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
492   {
493     GNUNET_break (0);
494     GNUNET_SERVICE_client_drop (c->client);
495     return;
496   }
497   (void) GNUNET_CONTAINER_multihashmap_put (open_ports,
498                                             &pmsg->port,
499                                             c,
500                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
501   GNUNET_CONTAINER_multihashmap_get_multiple (loose_channels,
502                                               &pmsg->port,
503                                               &bind_loose_channel,
504                                               c);
505   GNUNET_SERVICE_client_continue (c->client);
506 }
507
508
509 /**
510  * Handler for port close requests.  Marks this port as closed
511  * (unless of course we have another client with the same port
512  * open).  Note that existing channels accepted on the port are
513  * not affected.
514  *
515  * @param cls Identification of the client.
516  * @param pmsg The actual message.
517  */
518 static void
519 handle_port_close (void *cls,
520                    const struct GNUNET_CADET_PortMessage *pmsg)
521 {
522   struct CadetClient *c = cls;
523
524   LOG (GNUNET_ERROR_TYPE_DEBUG,
525        "Closing port %s as requested by %s\n",
526        GNUNET_h2s (&pmsg->port),
527        GSC_2s (c));
528   if (GNUNET_YES !=
529       GNUNET_CONTAINER_multihashmap_remove (c->ports,
530                                             &pmsg->port,
531                                             c))
532   {
533     GNUNET_break (0);
534     GNUNET_SERVICE_client_drop (c->client);
535     return;
536   }
537   GNUNET_assert (GNUNET_YES ==
538                  GNUNET_CONTAINER_multihashmap_remove (open_ports,
539                                                        &pmsg->port,
540                                                        c));
541   GNUNET_SERVICE_client_continue (c->client);
542 }
543
544
545 /**
546  * Handler for requests for us creating a new channel to another peer and port.
547  *
548  * @param cls Identification of the client.
549  * @param tcm The actual message.
550  */
551 static void
552 handle_channel_create (void *cls,
553                        const struct GNUNET_CADET_LocalChannelCreateMessage *tcm)
554 {
555   struct CadetClient *c = cls;
556   struct CadetChannel *ch;
557
558   if (ntohl (tcm->ccn.channel_of_client) < GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
559   {
560     /* Channel ID not in allowed range. */
561     GNUNET_break (0);
562     GNUNET_SERVICE_client_drop (c->client);
563     return;
564   }
565   ch = lookup_channel (c,
566                        tcm->ccn);
567   if (NULL != ch)
568   {
569     /* Channel ID already in use. Not allowed. */
570     GNUNET_break (0);
571     GNUNET_SERVICE_client_drop (c->client);
572     return;
573   }
574   LOG (GNUNET_ERROR_TYPE_DEBUG,
575        "New channel to %s at port %s requested by %s\n",
576        GNUNET_i2s (&tcm->peer),
577        GNUNET_h2s (&tcm->port),
578        GSC_2s (c));
579
580   /* Create channel */
581   ch = GCCH_channel_local_new (c,
582                                tcm->ccn,
583                                GCP_get (&tcm->peer,
584                                         GNUNET_YES),
585                                &tcm->port,
586                                ntohl (tcm->opt));
587   if (NULL == ch)
588   {
589     GNUNET_break (0);
590     GNUNET_SERVICE_client_drop (c->client);
591     return;
592   }
593   GNUNET_assert (GNUNET_YES ==
594                  GNUNET_CONTAINER_multihashmap32_put (c->channels,
595                                                       ntohl (tcm->ccn.channel_of_client),
596                                                       ch,
597                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
598
599   GNUNET_SERVICE_client_continue (c->client);
600 }
601
602
603 /**
604  * Handler for requests of destroying an existing channel.
605  *
606  * @param cls client identification of the client
607  * @param msg the actual message
608  */
609 static void
610 handle_channel_destroy (void *cls,
611                         const struct GNUNET_CADET_LocalChannelDestroyMessage *msg)
612 {
613   struct CadetClient *c = cls;
614   struct CadetChannel *ch;
615
616   ch = lookup_channel (c,
617                        msg->ccn);
618   if (NULL == ch)
619   {
620     /* Client attempted to destroy unknown channel */
621     GNUNET_break (0);
622     GNUNET_SERVICE_client_drop (c->client);
623     return;
624   }
625   LOG (GNUNET_ERROR_TYPE_INFO,
626        "%s is destroying %s\n",
627        GSC_2s(c),
628        GCCH_2s (ch));
629   GNUNET_assert (GNUNET_YES ==
630                  GNUNET_CONTAINER_multihashmap32_remove (c->channels,
631                                                          ntohl (msg->ccn.channel_of_client),
632                                                          ch));
633   GCCH_channel_local_destroy (ch,
634                               c,
635                               msg->ccn);
636   GNUNET_SERVICE_client_continue (c->client);
637 }
638
639
640 /**
641  * Check for client traffic data message is well-formed.
642  *
643  * @param cls identification of the client
644  * @param msg the actual message
645  * @return #GNUNET_OK if @a msg is OK, #GNUNET_SYSERR if not
646  */
647 static int
648 check_local_data (void *cls,
649                   const struct GNUNET_CADET_LocalData *msg)
650 {
651   size_t payload_size;
652   size_t payload_claimed_size;
653   const char *buf;
654   struct GNUNET_MessageHeader pa;
655
656   /* FIXME: what is the format we shall allow for @a msg?
657      ONE payload item or multiple? Seems current cadet_api
658      at least in theory allows more than one. Next-gen
659      cadet_api will likely no more, so we could then
660      simplify this mess again. */
661   /* Sanity check for message size */
662   payload_size = ntohs (msg->header.size) - sizeof (*msg);
663   buf = (const char *) &msg[1];
664   while (payload_size >= sizeof (struct GNUNET_MessageHeader))
665   {
666     /* need to memcpy() for alignment */
667     GNUNET_memcpy (&pa,
668                    buf,
669                    sizeof (pa));
670     payload_claimed_size = ntohs (pa.size);
671     if ( (payload_size < payload_claimed_size) ||
672          (payload_claimed_size < sizeof (struct GNUNET_MessageHeader)) ||
673          (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE < payload_claimed_size) )
674     {
675       GNUNET_break (0);
676       LOG (GNUNET_ERROR_TYPE_DEBUG,
677            "Local data of %u total size had sub-message %u at %u with %u bytes\n",
678            ntohs (msg->header.size),
679            ntohs (pa.type),
680            (unsigned int) (buf - (const char *) &msg[1]),
681            (unsigned int) payload_claimed_size);
682       return GNUNET_SYSERR;
683     }
684     payload_size -= payload_claimed_size;
685     buf += payload_claimed_size;
686   }
687   if (0 != payload_size)
688   {
689     GNUNET_break_op (0);
690     return GNUNET_SYSERR;
691   }
692   return GNUNET_OK;
693 }
694
695
696 /**
697  * Handler for client payload traffic to be send on a channel to
698  * another peer.
699  *
700  * @param cls identification of the client
701  * @param msg the actual message
702  */
703 static void
704 handle_local_data (void *cls,
705                    const struct GNUNET_CADET_LocalData *msg)
706 {
707   struct CadetClient *c = cls;
708   struct CadetChannel *ch;
709   size_t payload_size;
710   const char *buf;
711
712   ch = lookup_channel (c,
713                        msg->ccn);
714   if (NULL == ch)
715   {
716     /* Channel does not exist! */
717     GNUNET_break (0);
718     GNUNET_SERVICE_client_drop (c->client);
719     return;
720   }
721   payload_size = ntohs (msg->header.size) - sizeof (*msg);
722   buf = (const char *) &msg[1];
723   LOG (GNUNET_ERROR_TYPE_DEBUG,
724        "Received %u bytes payload from %s for %s\n",
725        (unsigned int) payload_size,
726        GSC_2s (c),
727        GCCH_2s (ch));
728   if (GNUNET_OK !=
729       GCCH_handle_local_data (ch,
730                               msg->ccn,
731                               buf,
732                               payload_size))
733   {
734     GNUNET_SERVICE_client_drop (c->client);
735     return;
736   }
737   GNUNET_SERVICE_client_continue (c->client);
738 }
739
740
741 /**
742  * Handler for client's ACKs for payload traffic.
743  *
744  * @param cls identification of the client.
745  * @param msg The actual message.
746  */
747 static void
748 handle_local_ack (void *cls,
749                   const struct GNUNET_CADET_LocalAck *msg)
750 {
751   struct CadetClient *c = cls;
752   struct CadetChannel *ch;
753
754   ch = lookup_channel (c,
755                        msg->ccn);
756   if (NULL == ch)
757   {
758     /* Channel does not exist! */
759     GNUNET_break (0);
760     GNUNET_SERVICE_client_drop (c->client);
761     return;
762   }
763   LOG (GNUNET_ERROR_TYPE_DEBUG,
764        "Got a local ACK from %s for %s\n",
765        GSC_2s(c),
766        GCCH_2s (ch));
767   GCCH_handle_local_ack (ch,
768                          msg->ccn);
769   GNUNET_SERVICE_client_continue (c->client);
770 }
771
772
773 /**
774  * Iterator over all peers to send a monitoring client info about each peer.
775  *
776  * @param cls Closure ().
777  * @param peer Peer ID (tunnel remote peer).
778  * @param value Peer info.
779  * @return #GNUNET_YES, to keep iterating.
780  */
781 static int
782 get_all_peers_iterator (void *cls,
783                         const struct GNUNET_PeerIdentity *peer,
784                         void *value)
785 {
786   struct CadetClient *c = cls;
787   struct CadetPeer *p = value;
788   struct GNUNET_MQ_Envelope *env;
789   struct GNUNET_CADET_LocalInfoPeer *msg;
790
791   env = GNUNET_MQ_msg (msg,
792                        GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS);
793   msg->destination = *peer;
794   msg->paths = htons (GCP_count_paths (p));
795   msg->tunnel = htons (NULL != GCP_get_tunnel (p,
796                                                GNUNET_NO));
797   GNUNET_MQ_send (c->mq,
798                   env);
799   return GNUNET_YES;
800 }
801
802
803 /**
804  * Handler for client's INFO PEERS request.
805  *
806  * @param cls Identification of the client.
807  * @param message The actual message.
808  */
809 static void
810 handle_get_peers (void *cls,
811                   const struct GNUNET_MessageHeader *message)
812 {
813   struct CadetClient *c = cls;
814   struct GNUNET_MQ_Envelope *env;
815   struct GNUNET_MessageHeader *reply;
816
817   GCP_iterate_all (&get_all_peers_iterator,
818                    c);
819   env = GNUNET_MQ_msg (reply,
820                        GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS);
821   GNUNET_MQ_send (c->mq,
822                   env);
823   GNUNET_SERVICE_client_continue (c->client);
824 }
825
826
827 /**
828  * Iterator over all paths of a peer to build an InfoPeer message.
829  * Message contains blocks of peers, first not included.
830  *
831  * @param cls message queue for transmission
832  * @param path Path itself
833  * @param off offset of the peer on @a path
834  * @return #GNUNET_YES if should keep iterating.
835  *         #GNUNET_NO otherwise.
836  */
837 static int
838 path_info_iterator (void *cls,
839                     struct CadetPeerPath *path,
840                     unsigned int off)
841 {
842   struct GNUNET_MQ_Handle *mq = cls;
843   struct GNUNET_MQ_Envelope *env;
844   struct GNUNET_MessageHeader *resp;
845   struct GNUNET_PeerIdentity *id;
846   uint16_t path_size;
847   unsigned int i;
848   unsigned int path_length;
849
850   path_length = GCPP_get_length (path);
851   path_size = sizeof (struct GNUNET_PeerIdentity) * (path_length - 1);
852   if (sizeof (*resp) + path_size > UINT16_MAX)
853   {
854     LOG (GNUNET_ERROR_TYPE_WARNING,
855          "Path of %u entries is too long for info message\n",
856          path_length);
857     return GNUNET_YES;
858   }
859   env = GNUNET_MQ_msg_extra (resp,
860                              path_size,
861                              GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER);
862   id = (struct GNUNET_PeerIdentity *) &resp[1];
863
864   /* Don't copy first peer.  First peer is always the local one.  Last
865    * peer is always the destination (leave as 0, EOL).
866    */
867   for (i = 0; i < off; i++)
868     id[i] = *GCP_get_id (GCPP_get_peer_at_offset (path,
869                                                   i + 1));
870   GNUNET_MQ_send (mq,
871                   env);
872   return GNUNET_YES;
873 }
874
875
876 /**
877  * Handler for client's SHOW_PEER request.
878  *
879  * @param cls Identification of the client.
880  * @param msg The actual message.
881  */
882 static void
883 handle_show_peer (void *cls,
884                   const struct GNUNET_CADET_LocalInfo *msg)
885 {
886   struct CadetClient *c = cls;
887   struct CadetPeer *p;
888   struct GNUNET_MQ_Envelope *env;
889   struct GNUNET_MessageHeader *resp;
890
891   p = GCP_get (&msg->peer,
892                GNUNET_NO);
893   if (NULL != p)
894     GCP_iterate_paths (p,
895                        &path_info_iterator,
896                        c->mq);
897   /* Send message with 0/0 to indicate the end */
898   env = GNUNET_MQ_msg (resp,
899                        GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER_END);
900   GNUNET_MQ_send (c->mq,
901                   env);
902   GNUNET_SERVICE_client_continue (c->client);
903 }
904
905
906 /**
907  * Iterator over all tunnels to send a monitoring client info about each tunnel.
908  *
909  * @param cls Closure ().
910  * @param peer Peer ID (tunnel remote peer).
911  * @param value a `struct CadetPeer`
912  * @return #GNUNET_YES, to keep iterating.
913  */
914 static int
915 get_all_tunnels_iterator (void *cls,
916                           const struct GNUNET_PeerIdentity *peer,
917                           void *value)
918 {
919   struct CadetClient *c = cls;
920   struct CadetPeer *p = value;
921   struct GNUNET_MQ_Envelope *env;
922   struct GNUNET_CADET_LocalInfoTunnel *msg;
923   struct CadetTunnel *t;
924
925   t = GCP_get_tunnel (p,
926                       GNUNET_NO);
927   if (NULL == t)
928     return GNUNET_YES;
929   env = GNUNET_MQ_msg (msg,
930                        GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS);
931   msg->destination = *peer;
932   msg->channels = htonl (GCT_count_channels (t));
933   msg->connections = htonl (GCT_count_any_connections (t));
934   msg->cstate = htons (0);
935   msg->estate = htons ((uint16_t) GCT_get_estate (t));
936   GNUNET_MQ_send (c->mq,
937                   env);
938   return GNUNET_YES;
939 }
940
941
942 /**
943  * Handler for client's #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS request.
944  *
945  * @param cls client Identification of the client.
946  * @param message The actual message.
947  */
948 static void
949 handle_info_tunnels (void *cls,
950                      const struct GNUNET_MessageHeader *message)
951 {
952   struct CadetClient *c = cls;
953   struct GNUNET_MQ_Envelope *env;
954   struct GNUNET_MessageHeader *reply;
955
956   GCP_iterate_all (&get_all_tunnels_iterator,
957                    c);
958   env = GNUNET_MQ_msg (reply,
959                        GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS);
960   GNUNET_MQ_send (c->mq,
961                   env);
962   GNUNET_SERVICE_client_continue (c->client);
963 }
964
965
966 /**
967  * Update the message with information about the connection.
968  *
969  * @param cls a `struct GNUNET_CADET_LocalInfoTunnel` message to update
970  * @param ct a connection about which we should store information in @a cls
971  */
972 static void
973 iter_connection (void *cls,
974                  struct CadetTConnection *ct)
975 {
976   struct GNUNET_CADET_LocalInfoTunnel *msg = cls;
977   struct CadetConnection *cc = ct->cc;
978   struct GNUNET_CADET_ConnectionTunnelIdentifier *h;
979
980   h = (struct GNUNET_CADET_ConnectionTunnelIdentifier *) &msg[1];
981   h[msg->connections++] = *(GCC_get_id (cc));
982 }
983
984
985 /**
986  * Update the message with information about the channel.
987  *
988  * @param cls a `struct GNUNET_CADET_LocalInfoTunnel` message to update
989  * @param ch a channel about which we should store information in @a cls
990  */
991 static void
992 iter_channel (void *cls,
993               struct CadetChannel *ch)
994 {
995   struct GNUNET_CADET_LocalInfoTunnel *msg = cls;
996   struct GNUNET_CADET_ConnectionTunnelIdentifier *h = (struct GNUNET_CADET_ConnectionTunnelIdentifier *) &msg[1];
997   struct GNUNET_CADET_ChannelTunnelNumber *chn
998     = (struct GNUNET_CADET_ChannelTunnelNumber *) &h[msg->connections];
999
1000   chn[msg->channels++] = GCCH_get_id (ch);
1001 }
1002
1003
1004 /**
1005  * Handler for client's #GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL request.
1006  *
1007  * @param cls Identification of the client.
1008  * @param msg The actual message.
1009  */
1010 static void
1011 handle_info_tunnel (void *cls,
1012                     const struct GNUNET_CADET_LocalInfo *msg)
1013 {
1014   struct CadetClient *c = cls;
1015   struct GNUNET_MQ_Envelope *env;
1016   struct GNUNET_CADET_LocalInfoTunnel *resp;
1017   struct CadetTunnel *t;
1018   struct CadetPeer *p;
1019   unsigned int ch_n;
1020   unsigned int c_n;
1021
1022   p = GCP_get (&msg->peer,
1023                GNUNET_NO);
1024   t = GCP_get_tunnel (p,
1025                       GNUNET_NO);
1026   if (NULL == t)
1027   {
1028     /* We don't know the tunnel */
1029     struct GNUNET_MQ_Envelope *env;
1030     struct GNUNET_CADET_LocalInfoTunnel *warn;
1031
1032     LOG (GNUNET_ERROR_TYPE_INFO,
1033          "Tunnel to %s unknown\n",
1034          GNUNET_i2s_full (&msg->peer));
1035     env = GNUNET_MQ_msg (warn,
1036                          GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL);
1037     warn->destination = msg->peer;
1038     GNUNET_MQ_send (c->mq,
1039                     env);
1040     GNUNET_SERVICE_client_continue (c->client);
1041     return;
1042   }
1043
1044   /* Initialize context */
1045   ch_n = GCT_count_channels (t);
1046   c_n = GCT_count_any_connections (t);
1047   env = GNUNET_MQ_msg_extra (resp,
1048                              c_n * sizeof (struct GNUNET_CADET_ConnectionTunnelIdentifier) +
1049                              ch_n * sizeof (struct GNUNET_CADET_ChannelTunnelNumber),
1050                              GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL);
1051   resp->destination = msg->peer;
1052   /* Do not reorder! #iter_channel needs counters in HBO! */
1053   GCT_iterate_connections (t,
1054                            &iter_connection,
1055                            resp);
1056   GCT_iterate_channels (t,
1057                         &iter_channel,
1058                         resp);
1059   resp->connections = htonl (resp->connections);
1060   resp->channels = htonl (resp->channels);
1061   resp->cstate = htons (0);
1062   resp->estate = htons (GCT_get_estate (t));
1063   GNUNET_MQ_send (c->mq,
1064                   env);
1065   GNUNET_SERVICE_client_continue (c->client);
1066 }
1067
1068
1069 /**
1070  * Iterator over all peers to dump info for each peer.
1071  *
1072  * @param cls Closure (unused).
1073  * @param peer Peer ID (tunnel remote peer).
1074  * @param value Peer info.
1075  *
1076  * @return #GNUNET_YES, to keep iterating.
1077  */
1078 static int
1079 show_peer_iterator (void *cls,
1080                     const struct GNUNET_PeerIdentity *peer,
1081                     void *value)
1082 {
1083   struct CadetPeer *p = value;
1084   struct CadetTunnel *t;
1085
1086   t = GCP_get_tunnel (p,
1087                       GNUNET_NO);
1088   if (NULL != t)
1089     GCT_debug (t,
1090                GNUNET_ERROR_TYPE_ERROR);
1091   LOG (GNUNET_ERROR_TYPE_ERROR, "\n");
1092   return GNUNET_YES;
1093 }
1094
1095
1096 /**
1097  * Handler for client's INFO_DUMP request.
1098  *
1099  * @param cls Identification of the client.
1100  * @param message The actual message.
1101  */
1102 static void
1103 handle_info_dump (void *cls,
1104                   const struct GNUNET_MessageHeader *message)
1105 {
1106   struct CadetClient *c = cls;
1107
1108   LOG (GNUNET_ERROR_TYPE_INFO,
1109        "Received dump info request from client %u\n",
1110        c->id);
1111
1112   LOG (GNUNET_ERROR_TYPE_ERROR,
1113        "*************************** DUMP START ***************************\n");
1114   for (struct CadetClient *ci = clients_head;
1115        NULL != ci;
1116        ci = ci->next)
1117   {
1118     LOG (GNUNET_ERROR_TYPE_ERROR,
1119          "Client %u (%p), handle: %p, ports: %u, channels: %u\n",
1120          ci->id,
1121          ci,
1122          ci->client,
1123          (NULL != c->ports)
1124          ? GNUNET_CONTAINER_multihashmap_size (ci->ports)
1125          : 0,
1126          GNUNET_CONTAINER_multihashmap32_size (ci->channels));
1127   }
1128   LOG (GNUNET_ERROR_TYPE_ERROR, "***************************\n");
1129   GCP_iterate_all (&show_peer_iterator,
1130                    NULL);
1131
1132   LOG (GNUNET_ERROR_TYPE_ERROR,
1133        "**************************** DUMP END ****************************\n");
1134
1135   GNUNET_SERVICE_client_continue (c->client);
1136 }
1137
1138
1139
1140 /**
1141  * Callback called when a client connects to the service.
1142  *
1143  * @param cls closure for the service
1144  * @param client the new client that connected to the service
1145  * @param mq the message queue used to send messages to the client
1146  * @return @a c
1147  */
1148 static void *
1149 client_connect_cb (void *cls,
1150                    struct GNUNET_SERVICE_Client *client,
1151                    struct GNUNET_MQ_Handle *mq)
1152 {
1153   struct CadetClient *c;
1154
1155   c = GNUNET_new (struct CadetClient);
1156   c->client = client;
1157   c->mq = mq;
1158   c->id = next_client_id++; /* overflow not important: just for debug */
1159   c->channels
1160     = GNUNET_CONTAINER_multihashmap32_create (32);
1161   GNUNET_CONTAINER_DLL_insert (clients_head,
1162                                clients_tail,
1163                                c);
1164   GNUNET_STATISTICS_update (stats,
1165                             "# clients",
1166                             +1,
1167                             GNUNET_NO);
1168   LOG (GNUNET_ERROR_TYPE_DEBUG,
1169        "%s connected\n",
1170        GSC_2s (c));
1171   return c;
1172 }
1173
1174
1175 /**
1176  * A channel was destroyed by the other peer. Tell our client.
1177  *
1178  * @param c client that lost a channel
1179  * @param ccn channel identification number for the client
1180  * @param ch the channel object
1181  */
1182 void
1183 GSC_handle_remote_channel_destroy (struct CadetClient *c,
1184                                    struct GNUNET_CADET_ClientChannelNumber ccn,
1185                                    struct CadetChannel *ch)
1186 {
1187   struct GNUNET_MQ_Envelope *env;
1188   struct GNUNET_CADET_LocalChannelDestroyMessage *tdm;
1189
1190   env = GNUNET_MQ_msg (tdm,
1191                        GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
1192   tdm->ccn = ccn;
1193   GSC_send_to_client (c,
1194                       env);
1195   GNUNET_assert (GNUNET_YES ==
1196                  GNUNET_CONTAINER_multihashmap32_remove (c->channels,
1197                                                          ntohl (ccn.channel_of_client),
1198                                                          ch));
1199 }
1200
1201
1202 /**
1203  * Iterator for deleting each channel whose client endpoint disconnected.
1204  *
1205  * @param cls Closure (client that has disconnected).
1206  * @param key The local channel id in host byte order
1207  * @param value The value stored at the key (channel to destroy).
1208  * @return #GNUNET_OK, keep iterating.
1209  */
1210 static int
1211 channel_destroy_iterator (void *cls,
1212                           uint32_t key,
1213                           void *value)
1214 {
1215   struct CadetClient *c = cls;
1216   struct GNUNET_CADET_ClientChannelNumber ccn;
1217   struct CadetChannel *ch = value;
1218
1219   LOG (GNUNET_ERROR_TYPE_DEBUG,
1220        "Destroying %s, due to %s disconnecting.\n",
1221        GCCH_2s (ch),
1222        GSC_2s (c));
1223   GNUNET_assert (GNUNET_YES ==
1224                  GNUNET_CONTAINER_multihashmap32_remove (c->channels,
1225                                                          key,
1226                                                          ch));
1227   ccn.channel_of_client = htonl (key);
1228   GCCH_channel_local_destroy (ch,
1229                               c,
1230                               ccn);
1231   return GNUNET_OK;
1232 }
1233
1234
1235 /**
1236  * Remove client's ports from the global hashmap on disconnect.
1237  *
1238  * @param cls Closure (unused).
1239  * @param key the port.
1240  * @param value the `struct CadetClient` to remove
1241  * @return #GNUNET_OK, keep iterating.
1242  */
1243 static int
1244 client_release_ports (void *cls,
1245                       const struct GNUNET_HashCode *key,
1246                       void *value)
1247 {
1248   struct CadetClient *c = value;
1249
1250   LOG (GNUNET_ERROR_TYPE_DEBUG,
1251        "Closing port %s due to %s disconnect.\n",
1252        GNUNET_h2s (key),
1253        GSC_2s (c));
1254   GNUNET_assert (GNUNET_YES ==
1255                  GNUNET_CONTAINER_multihashmap_remove (open_ports,
1256                                                        key,
1257                                                        value));
1258   GNUNET_assert (GNUNET_YES ==
1259                  GNUNET_CONTAINER_multihashmap_remove (c->ports,
1260                                                        key,
1261                                                        value));
1262   return GNUNET_OK;
1263 }
1264
1265
1266 /**
1267  * Callback called when a client disconnected from the service
1268  *
1269  * @param cls closure for the service
1270  * @param client the client that disconnected
1271  * @param internal_cls should be equal to @a c
1272  */
1273 static void
1274 client_disconnect_cb (void *cls,
1275                       struct GNUNET_SERVICE_Client *client,
1276                       void *internal_cls)
1277 {
1278   struct CadetClient *c = internal_cls;
1279
1280   GNUNET_assert (c->client == client);
1281   LOG (GNUNET_ERROR_TYPE_DEBUG,
1282        "%s is disconnecting.\n",
1283        GSC_2s (c));
1284   if (NULL != c->channels)
1285   {
1286     GNUNET_CONTAINER_multihashmap32_iterate (c->channels,
1287                                              &channel_destroy_iterator,
1288                                              c);
1289     GNUNET_CONTAINER_multihashmap32_destroy (c->channels);
1290   }
1291   if (NULL != c->ports)
1292   {
1293     GNUNET_CONTAINER_multihashmap_iterate (c->ports,
1294                                            &client_release_ports,
1295                                            c);
1296     GNUNET_CONTAINER_multihashmap_destroy (c->ports);
1297   }
1298   GNUNET_CONTAINER_DLL_remove (clients_head,
1299                                clients_tail,
1300                                c);
1301   GNUNET_STATISTICS_update (stats,
1302                             "# clients",
1303                             -1,
1304                             GNUNET_NO);
1305   GNUNET_free (c);
1306   if ( (NULL == clients_head) &&
1307        (GNUNET_YES == shutting_down) )
1308     shutdown_rest ();
1309 }
1310
1311
1312 /**
1313  * Setup CADET internals.
1314  *
1315  * @param cls closure
1316  * @param server the initialized server
1317  * @param c configuration to use
1318  */
1319 static void
1320 run (void *cls,
1321      const struct GNUNET_CONFIGURATION_Handle *c,
1322      struct GNUNET_SERVICE_Handle *service)
1323 {
1324   cfg = c;
1325   if (GNUNET_OK !=
1326       GNUNET_CONFIGURATION_get_value_number (c,
1327                                              "CADET",
1328                                              "RATCHET_MESSAGES",
1329                                              &ratchet_messages))
1330   {
1331     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
1332                                "CADET",
1333                                "RATCHET_MESSAGES",
1334                                "needs to be a number");
1335     ratchet_messages = 64;
1336   }
1337   if (GNUNET_OK !=
1338       GNUNET_CONFIGURATION_get_value_time (c,
1339                                            "CADET",
1340                                            "RATCHET_TIME",
1341                                            &ratchet_time))
1342   {
1343     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
1344                                "CADET",
1345                                "RATCHET_TIME",
1346                                "need delay value");
1347     ratchet_time = GNUNET_TIME_UNIT_HOURS;
1348   }
1349   if (GNUNET_OK !=
1350       GNUNET_CONFIGURATION_get_value_time (c,
1351                                            "CADET",
1352                                            "REFRESH_CONNECTION_TIME",
1353                                            &keepalive_period))
1354   {
1355     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
1356                                "CADET",
1357                                "REFRESH_CONNECTION_TIME",
1358                                "need delay value");
1359     keepalive_period = GNUNET_TIME_UNIT_MINUTES;
1360   }
1361   if (GNUNET_OK !=
1362       GNUNET_CONFIGURATION_get_value_number (c,
1363                                              "CADET",
1364                                              "DROP_PERCENT",
1365                                              &drop_percent))
1366   {
1367     drop_percent = 0;
1368   }
1369   else
1370   {
1371     LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1372     LOG (GNUNET_ERROR_TYPE_WARNING, "Cadet is running with DROP enabled.\n");
1373     LOG (GNUNET_ERROR_TYPE_WARNING, "This is NOT a good idea!\n");
1374     LOG (GNUNET_ERROR_TYPE_WARNING, "Remove DROP_PERCENT from config file.\n");
1375     LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
1376   }
1377   my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (c);
1378   if (NULL == my_private_key)
1379   {
1380     GNUNET_break (0);
1381     GNUNET_SCHEDULER_shutdown ();
1382     return;
1383   }
1384   GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
1385                                       &my_full_id.public_key);
1386   stats = GNUNET_STATISTICS_create ("cadet",
1387                                     c);
1388   GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
1389                                  NULL);
1390   ats_ch = GNUNET_ATS_connectivity_init (c);
1391   /* FIXME: optimize code to allow GNUNET_YES here! */
1392   open_ports = GNUNET_CONTAINER_multihashmap_create (16,
1393                                                      GNUNET_NO);
1394   loose_channels = GNUNET_CONTAINER_multihashmap_create (16,
1395                                                          GNUNET_NO);
1396   peers = GNUNET_CONTAINER_multipeermap_create (16,
1397                                                 GNUNET_YES);
1398   connections = GNUNET_CONTAINER_multishortmap_create (256,
1399                                                        GNUNET_YES);
1400   GCH_init (c);
1401   GCD_init (c);
1402   GCO_init (c);
1403   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1404               "CADET started for peer %s\n",
1405               GNUNET_i2s (&my_full_id));
1406
1407 }
1408
1409
1410 /**
1411  * Define "main" method using service macro.
1412  */
1413 GNUNET_SERVICE_MAIN
1414 ("cadet",
1415  GNUNET_SERVICE_OPTION_NONE,
1416  &run,
1417  &client_connect_cb,
1418  &client_disconnect_cb,
1419  NULL,
1420  GNUNET_MQ_hd_fixed_size (port_open,
1421                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN,
1422                           struct GNUNET_CADET_PortMessage,
1423                           NULL),
1424  GNUNET_MQ_hd_fixed_size (port_close,
1425                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE,
1426                           struct GNUNET_CADET_PortMessage,
1427                           NULL),
1428  GNUNET_MQ_hd_fixed_size (channel_create,
1429                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE,
1430                           struct GNUNET_CADET_LocalChannelCreateMessage,
1431                           NULL),
1432  GNUNET_MQ_hd_fixed_size (channel_destroy,
1433                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY,
1434                           struct GNUNET_CADET_LocalChannelDestroyMessage,
1435                           NULL),
1436  GNUNET_MQ_hd_var_size (local_data,
1437                         GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
1438                         struct GNUNET_CADET_LocalData,
1439                         NULL),
1440  GNUNET_MQ_hd_fixed_size (local_ack,
1441                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK,
1442                           struct GNUNET_CADET_LocalAck,
1443                           NULL),
1444  GNUNET_MQ_hd_fixed_size (get_peers,
1445                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS,
1446                           struct GNUNET_MessageHeader,
1447                           NULL),
1448  GNUNET_MQ_hd_fixed_size (show_peer,
1449                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER,
1450                           struct GNUNET_CADET_LocalInfo,
1451                           NULL),
1452  GNUNET_MQ_hd_fixed_size (info_tunnels,
1453                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS,
1454                           struct GNUNET_MessageHeader,
1455                           NULL),
1456  GNUNET_MQ_hd_fixed_size (info_tunnel,
1457                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL,
1458                           struct GNUNET_CADET_LocalInfo,
1459                           NULL),
1460  GNUNET_MQ_hd_fixed_size (info_dump,
1461                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_DUMP,
1462                           struct GNUNET_MessageHeader,
1463                           NULL),
1464  GNUNET_MQ_handler_end ());
1465
1466 /* end of gnunet-service-cadet-new.c */