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