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