src/cadet/cadet_api.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2011, 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  * @file cadet/cadet_api.c
  22  * @brief cadet api: client implementation of cadet service
  23  * @author Bartlomiej Polot
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet_constants.h"
  29 #include "gnunet_cadet_service.h"
  30 #include "cadet.h"
  31 #include "cadet_protocol.h"
  32
  33 #define LOG(kind,...) GNUNET_log_from (kind, "cadet-api",__VA_ARGS__)
  34
  35 /**
  36  * Ugly legacy hack.
  37  */
  38 union CadetInfoCB
  39 {
  40
  41   /**
  42    * Channel callback.
  43    */
  44   GNUNET_CADET_ChannelCB channel_cb;
  45
  46   /**
  47    * Monitor callback
  48    */
  49   GNUNET_CADET_PeersCB peers_cb;
  50
  51   /**
  52    * Monitor callback
  53    */
  54   GNUNET_CADET_PeerCB peer_cb;
  55
  56   /**
  57    * Monitor callback
  58    */
  59   GNUNET_CADET_TunnelsCB tunnels_cb;
  60
  61   /**
  62    * Tunnel callback.
  63    */
  64   GNUNET_CADET_TunnelCB tunnel_cb;
  65 };
  66
  67
  68 /**
  69  * Opaque handle to the service.
  70  */
  71 struct GNUNET_CADET_Handle
  72 {
  73   /**
  74    * Message queue.
  75    */
  76   struct GNUNET_MQ_Handle *mq;
  77
  78   /**
  79    * Ports open.
  80    */
  81   struct GNUNET_CONTAINER_MultiHashMap *ports;
  82
  83   /**
  84    * Channels open.
  85    */
  86   struct GNUNET_CONTAINER_MultiHashMap32 *channels;
  87
  88   /**
  89    * child of the next channel to create (to avoid reusing IDs often)
  90    */
  91   struct GNUNET_CADET_ClientChannelNumber next_ccn;
  92
  93   /**
  94    * Configuration given by the client, in case of reconnection
  95    */
  96   const struct GNUNET_CONFIGURATION_Handle *cfg;
  97
  98   /**
  99    * Task for trying to reconnect.
 100    */
 101   struct GNUNET_SCHEDULER_Task *reconnect_task;
 102
 103   /**
 104    * Callback for an info task (only one active at a time).
 105    */
 106   union CadetInfoCB info_cb;
 107
 108   /**
 109    * Info callback closure for @c info_cb.
 110    */
 111   void *info_cls;
 112
 113   /**
 114    * Time to the next reconnect in case one reconnect fails
 115    */
 116   struct GNUNET_TIME_Relative reconnect_time;
 117
 118 };
 119
 120
 121 /**
 122  * Opaque handle to a channel.
 123  */
 124 struct GNUNET_CADET_Channel
 125 {
 126
 127   /**
 128    * Other end of the channel.
 129    */
 130   struct GNUNET_PeerIdentity peer;
 131
 132   /**
 133    * Handle to the cadet this channel belongs to
 134    */
 135   struct GNUNET_CADET_Handle *cadet;
 136
 137   /**
 138    * Channel's port, if incoming.
 139    */
 140   struct GNUNET_CADET_Port *incoming_port;
 141
 142   /**
 143    * Any data the caller wants to put in here, used for the
 144    * various callbacks (@e disconnects, @e window_changes, handlers).
 145    */
 146   void *ctx;
 147
 148   /**
 149    * Message Queue for the channel (which we are implementing).
 150    */
 151   struct GNUNET_MQ_Handle *mq;
 152
 153   /**
 154    * Task to allow mq to send more traffic.
 155    */
 156   struct GNUNET_SCHEDULER_Task *mq_cont;
 157
 158   /**
 159    * Pending envelope with a message to be transmitted to the
 160    * service as soon as we are allowed to.  Should only be
 161    * non-NULL if @e allow_send is 0.
 162    */
 163   struct GNUNET_MQ_Envelope *pending_env;
 164
 165   /**
 166    * Window change handler.
 167    */
 168   GNUNET_CADET_WindowSizeEventHandler window_changes;
 169
 170   /**
 171    * Disconnect handler.
 172    */
 173   GNUNET_CADET_DisconnectEventHandler disconnects;
 174
 175   /**
 176    * Local ID of the channel, #GNUNET_CADET_LOCAL_CHANNEL_ID_CLI bit is set if outbound.
 177    */
 178   struct GNUNET_CADET_ClientChannelNumber ccn;
 179
 180   /**
 181    * Channel options: reliability, etc.
 182    */
 183   enum GNUNET_CADET_ChannelOption options;
 184
 185   /**
 186    * How many messages are we allowed to send to the service right now?
 187    */
 188   unsigned int allow_send;
 189
 190 };
 191
 192
 193 /**
 194  * Opaque handle to a port.
 195  */
 196 struct GNUNET_CADET_Port
 197 {
 198
 199   /**
 200    * Port "number"
 201    */
 202   struct GNUNET_HashCode id;
 203
 204   /**
 205    * Handle to the CADET session this port belongs to.
 206    */
 207   struct GNUNET_CADET_Handle *cadet;
 208
 209   /**
 210    * Closure for @a handler.
 211    */
 212   void *cls;
 213
 214   /**
 215    * Handler for incoming channels on this port
 216    */
 217   GNUNET_CADET_ConnectEventHandler connects;
 218
 219   /**
 220    * Closure for @ref connects
 221    */
 222   void *connects_cls;
 223
 224   /**
 225    * Window size change handler.
 226    */
 227   GNUNET_CADET_WindowSizeEventHandler window_changes;
 228
 229   /**
 230    * Handler called when an incoming channel is destroyed.
 231    */
 232   GNUNET_CADET_DisconnectEventHandler disconnects;
 233
 234   /**
 235    * Payload handlers for incoming channels.
 236    */
 237   struct GNUNET_MQ_MessageHandler *handlers;
 238 };
 239
 240
 241 /**
 242  * Find the Port struct for a hash.
 243  *
 244  * @param h CADET handle.
 245  * @param hash HashCode for the port number.
 246  * @return The port handle if known, NULL otherwise.
 247  */
 248 static struct GNUNET_CADET_Port *
 249 find_port (const struct GNUNET_CADET_Handle *h,
 250            const struct GNUNET_HashCode *hash)
 251 {
 252   return GNUNET_CONTAINER_multihashmap_get (h->ports,
 253                                             hash);
 254 }
 255
 256
 257 /**
 258  * Get the channel handler for the channel specified by id from the given handle
 259  *
 260  * @param h Cadet handle
 261  * @param ccn ID of the wanted channel
 262  * @return handle to the required channel or NULL if not found
 263  */
 264 static struct GNUNET_CADET_Channel *
 265 find_channel (struct GNUNET_CADET_Handle *h,
 266               struct GNUNET_CADET_ClientChannelNumber ccn)
 267 {
 268   return GNUNET_CONTAINER_multihashmap32_get (h->channels,
 269                                               ntohl (ccn.channel_of_client));
 270 }
 271
 272
 273 /**
 274  * Create a new channel and insert it in the channel list of the cadet handle
 275  *
 276  * @param h Cadet handle
 277  * @param ccnp pointer to desired ccn of the channel, NULL to assign one automatically.
 278  * @return Handle to the created channel.
 279  */
 280 static struct GNUNET_CADET_Channel *
 281 create_channel (struct GNUNET_CADET_Handle *h,
 282                 const struct GNUNET_CADET_ClientChannelNumber *ccnp)
 283 {
 284   struct GNUNET_CADET_Channel *ch;
 285   struct GNUNET_CADET_ClientChannelNumber ccn;
 286
 287   ch = GNUNET_new (struct GNUNET_CADET_Channel);
 288   ch->cadet = h;
 289   if (NULL == ccnp)
 290   {
 291     while (NULL !=
 292            find_channel (h,
 293                          h->next_ccn))
 294       h->next_ccn.channel_of_client
 295         = htonl (GNUNET_CADET_LOCAL_CHANNEL_ID_CLI | (1 + ntohl (h->next_ccn.channel_of_client)));
 296     ccn = h->next_ccn;
 297   }
 298   else
 299   {
 300     ccn = *ccnp;
 301   }
 302   ch->ccn = ccn;
 303   GNUNET_assert (GNUNET_OK ==
 304                  GNUNET_CONTAINER_multihashmap32_put (h->channels,
 305                                                       ntohl (ch->ccn.channel_of_client),
 306                                                       ch,
 307                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 308   return ch;
 309 }
 310
 311
 312 /**
 313  * Destroy the specified channel.
 314  * - Destroys all peers, calling the disconnect callback on each if needed
 315  * - Cancels all outgoing traffic for that channel, calling respective notifys
 316  * - Calls cleaner if channel was inbound
 317  * - Frees all memory used
 318  *
 319  * @param ch Pointer to the channel.
 320  * @param call_cleaner Whether to call the cleaner handler.
 321  */
 322 static void
 323 destroy_channel (struct GNUNET_CADET_Channel *ch)
 324 {
 325   struct GNUNET_CADET_Handle *h = ch->cadet;
 326
 327   LOG (GNUNET_ERROR_TYPE_DEBUG,
 328        "Destroying channel %X of %p\n",
 329        htonl (ch->ccn.channel_of_client),
 330        h);
 331   GNUNET_assert (GNUNET_YES ==
 332                  GNUNET_CONTAINER_multihashmap32_remove (h->channels,
 333                                                          ntohl (ch->ccn.channel_of_client),
 334                                                          ch));
 335   if (NULL != ch->mq_cont)
 336   {
 337     GNUNET_SCHEDULER_cancel (ch->mq_cont);
 338     ch->mq_cont = NULL;
 339   }
 340   /* signal channel destruction */
 341   if (NULL != ch->disconnects)
 342     ch->disconnects (ch->ctx,
 343                      ch);
 344   if (NULL != ch->pending_env)
 345     GNUNET_MQ_discard (ch->pending_env);
 346   GNUNET_MQ_destroy (ch->mq);
 347   GNUNET_free (ch);
 348 }
 349
 350
 351 /**
 352  * Reconnect to the service, retransmit all infomation to try to restore the
 353  * original state.
 354  *
 355  * @param h handle to the cadet
 356  */
 357 static void
 358 reconnect (struct GNUNET_CADET_Handle *h);
 359
 360
 361 /**
 362  * Reconnect callback: tries to reconnect again after a failer previous
 363  * reconnecttion
 364  *
 365  * @param cls closure (cadet handle)
 366  */
 367 static void
 368 reconnect_cbk (void *cls)
 369 {
 370   struct GNUNET_CADET_Handle *h = cls;
 371
 372   h->reconnect_task = NULL;
 373   reconnect (h);
 374 }
 375
 376
 377 /**
 378  * Function called during #reconnect() to destroy
 379  * all channels that are still open.
 380  *
 381  * @param cls the `struct GNUNET_CADET_Handle`
 382  * @param cid chanenl ID
 383  * @param value a `struct GNUNET_CADET_Channel` to destroy
 384  * @return #GNUNET_OK (continue to iterate)
 385  */
 386 static int
 387 destroy_channel_on_reconnect_cb (void *cls,
 388                                  uint32_t cid,
 389                                  void *value)
 390 {
 391   /* struct GNUNET_CADET_Handle *handle = cls; */
 392   struct GNUNET_CADET_Channel *ch = value;
 393
 394   destroy_channel (ch);
 395   return GNUNET_OK;
 396 }
 397
 398
 399 /**
 400  * Reconnect to the service, retransmit all infomation to try to restore the
 401  * original state.
 402  *
 403  * @param h handle to the cadet
 404  *
 405  * @return #GNUNET_YES in case of sucess, #GNUNET_NO otherwise (service down...)
 406  */
 407 static void
 408 schedule_reconnect (struct GNUNET_CADET_Handle *h)
 409 {
 410   if (NULL != h->reconnect_task)
 411     return;
 412   GNUNET_CONTAINER_multihashmap32_iterate (h->channels,
 413                                            &destroy_channel_on_reconnect_cb,
 414                                            h);
 415   h->reconnect_task
 416     = GNUNET_SCHEDULER_add_delayed (h->reconnect_time,
 417                                     &reconnect_cbk,
 418                                     h);
 419   h->reconnect_time
 420     = GNUNET_TIME_STD_BACKOFF (h->reconnect_time);
 421 }
 422
 423
 424 /**
 425  * Notify the application about a change in the window size (if needed).
 426  *
 427  * @param ch Channel to notify about.
 428  */
 429 static void
 430 notify_window_size (struct GNUNET_CADET_Channel *ch)
 431 {
 432   if (NULL != ch->window_changes)
 433     ch->window_changes (ch->ctx,
 434                         ch, /* FIXME: remove 'ch'? */
 435                         ch->allow_send);
 436 }
 437
 438
 439 /**
 440  * Transmit the next message from our queue.
 441  *
 442  * @param cls Closure (channel whose mq to activate).
 443  */
 444 static void
 445 cadet_mq_send_now (void *cls)
 446 {
 447   struct GNUNET_CADET_Channel *ch = cls;
 448   struct GNUNET_MQ_Envelope *env = ch->pending_env;
 449
 450   ch->mq_cont = NULL;
 451   if (0 == ch->allow_send)
 452   {
 453     /* how did we get here? */
 454     GNUNET_break (0);
 455     return;
 456   }
 457   if (NULL == env)
 458   {
 459     /* how did we get here? */
 460     GNUNET_break (0);
 461     return;
 462   }
 463   ch->allow_send--;
 464   ch->pending_env = NULL;
 465   GNUNET_MQ_send (ch->cadet->mq,
 466                   env);
 467   GNUNET_MQ_impl_send_continue (ch->mq);
 468 }
 469
 470
 471 /**
 472  * Implement sending functionality of a message queue for
 473  * us sending messages to a peer.
 474  *
 475  * Encapsulates the payload message in a #GNUNET_CADET_LocalData message
 476  * in order to label the message with the channel ID and send the
 477  * encapsulated message to the service.
 478  *
 479  * @param mq the message queue
 480  * @param msg the message to send
 481  * @param impl_state state of the implementation
 482  */
 483 static void
 484 cadet_mq_send_impl (struct GNUNET_MQ_Handle *mq,
 485                     const struct GNUNET_MessageHeader *msg,
 486                     void *impl_state)
 487 {
 488   struct GNUNET_CADET_Channel *ch = impl_state;
 489   struct GNUNET_CADET_Handle *h = ch->cadet;
 490   uint16_t msize;
 491   struct GNUNET_MQ_Envelope *env;
 492   struct GNUNET_CADET_LocalData *cadet_msg;
 493
 494   if (NULL == h->mq)
 495   {
 496     /* We're currently reconnecting, pretend this worked */
 497     GNUNET_MQ_impl_send_continue (mq);
 498     return;
 499   }
 500
 501   /* check message size for sanity */
 502   msize = ntohs (msg->size);
 503   if (msize > GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE)
 504   {
 505     GNUNET_break (0);
 506     GNUNET_MQ_impl_send_continue (mq);
 507     return;
 508   }
 509   env = GNUNET_MQ_msg_nested_mh (cadet_msg,
 510                                  GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
 511                                  msg);
 512   cadet_msg->ccn = ch->ccn;
 513   GNUNET_assert (NULL == ch->pending_env);
 514   ch->pending_env = env;
 515   if (0 < ch->allow_send)
 516     ch->mq_cont
 517       = GNUNET_SCHEDULER_add_now (&cadet_mq_send_now,
 518                                   ch);
 519 }
 520
 521
 522 /**
 523  * Handle destruction of a message queue.  Implementations must not
 524  * free @a mq, but should take care of @a impl_state.
 525  *
 526  * @param mq the message queue to destroy
 527  * @param impl_state state of the implementation
 528  */
 529 static void
 530 cadet_mq_destroy_impl (struct GNUNET_MQ_Handle *mq,
 531                        void *impl_state)
 532 {
 533   struct GNUNET_CADET_Channel *ch = impl_state;
 534
 535   GNUNET_assert (mq == ch->mq);
 536   ch->mq = NULL;
 537 }
 538
 539
 540 /**
 541  * We had an error processing a message we forwarded from a peer to
 542  * the CADET service.  We should just complain about it but otherwise
 543  * continue processing.
 544  *
 545  * @param cls closure with our `struct GNUNET_CADET_Channel`
 546  * @param error error code
 547  */
 548 static void
 549 cadet_mq_error_handler (void *cls,
 550                         enum GNUNET_MQ_Error error)
 551 {
 552   struct GNUNET_CADET_Channel *ch = cls;
 553
 554   GNUNET_break (0);
 555   if (GNUNET_MQ_ERROR_NO_MATCH == error)
 556   {
 557     /* Got a message we did not understand, still try to continue! */
 558     GNUNET_CADET_receive_done (ch);
 559   }
 560   else
 561   {
 562     schedule_reconnect (ch->cadet);
 563   }
 564 }
 565
 566
 567 /**
 568  * Implementation function that cancels the currently sent message.
 569  * Should basically undo whatever #mq_send_impl() did.
 570  *
 571  * @param mq message queue
 572  * @param impl_state state specific to the implementation
 573  */
 574 static void
 575 cadet_mq_cancel_impl (struct GNUNET_MQ_Handle *mq,
 576                      void *impl_state)
 577 {
 578   struct GNUNET_CADET_Channel *ch = impl_state;
 579
 580   GNUNET_assert (NULL != ch->pending_env);
 581   GNUNET_MQ_discard (ch->pending_env);
 582   ch->pending_env = NULL;
 583   if (NULL != ch->mq_cont)
 584   {
 585     GNUNET_SCHEDULER_cancel (ch->mq_cont);
 586     ch->mq_cont = NULL;
 587   }
 588 }
 589
 590
 591 /**
 592  * Process the new channel notification and add it to the channels in the handle
 593  *
 594  * @param h     The cadet handle
 595  * @param msg   A message with the details of the new incoming channel
 596  */
 597 static void
 598 handle_channel_created (void *cls,
 599                         const struct GNUNET_CADET_LocalChannelCreateMessage *msg)
 600 {
 601   struct GNUNET_CADET_Handle *h = cls;
 602   struct GNUNET_CADET_Channel *ch;
 603   struct GNUNET_CADET_Port *port;
 604   const struct GNUNET_HashCode *port_number;
 605   struct GNUNET_CADET_ClientChannelNumber ccn;
 606
 607   ccn = msg->ccn;
 608   port_number = &msg->port;
 609   if (ntohl (ccn.channel_of_client) >= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
 610   {
 611     GNUNET_break (0);
 612     return;
 613   }
 614   port = find_port (h,
 615                     port_number);
 616   if (NULL == port)
 617   {
 618     /* We could have closed the port but the service didn't know about it yet
 619      * This is not an error.
 620      */
 621     struct GNUNET_CADET_LocalChannelDestroyMessage *d_msg;
 622     struct GNUNET_MQ_Envelope *env;
 623
 624     LOG (GNUNET_ERROR_TYPE_DEBUG,
 625          "No handler for incoming channel %X (on port %s, recently closed?)\n",
 626          ntohl (ccn.channel_of_client),
 627          GNUNET_h2s (port_number));
 628     env = GNUNET_MQ_msg (d_msg,
 629                          GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
 630     d_msg->ccn = msg->ccn;
 631     GNUNET_MQ_send (h->mq,
 632                     env);
 633     return;
 634   }
 635
 636   ch = create_channel (h,
 637                        &ccn);
 638   ch->peer = msg->peer;
 639   ch->cadet = h;
 640   ch->incoming_port = port;
 641   ch->options = ntohl (msg->opt);
 642   LOG (GNUNET_ERROR_TYPE_DEBUG,
 643        "Creating incoming channel %X [%s] %p\n",
 644        ntohl (ccn.channel_of_client),
 645        GNUNET_h2s (port_number),
 646        ch);
 647
 648   GNUNET_assert (NULL != port->connects);
 649   ch->window_changes = port->window_changes;
 650   ch->disconnects = port->disconnects;
 651   ch->mq = GNUNET_MQ_queue_for_callbacks (&cadet_mq_send_impl,
 652                                           &cadet_mq_destroy_impl,
 653                                           &cadet_mq_cancel_impl,
 654                                           ch,
 655                                           port->handlers,
 656                                           &cadet_mq_error_handler,
 657                                           ch);
 658   ch->ctx = port->connects (port->cls,
 659                             ch,
 660                             &msg->peer);
 661   GNUNET_MQ_set_handlers_closure (ch->mq,
 662                                   ch->ctx);
 663 }
 664
 665
 666 /**
 667  * Process the channel destroy notification and free associated resources
 668  *
 669  * @param h     The cadet handle
 670  * @param msg   A message with the details of the channel being destroyed
 671  */
 672 static void
 673 handle_channel_destroy (void *cls,
 674                         const struct GNUNET_CADET_LocalChannelDestroyMessage *msg)
 675 {
 676   struct GNUNET_CADET_Handle *h = cls;
 677   struct GNUNET_CADET_Channel *ch;
 678
 679   ch = find_channel (h,
 680                      msg->ccn);
 681   if (NULL == ch)
 682   {
 683     LOG (GNUNET_ERROR_TYPE_DEBUG,
 684          "Received channel destroy for unknown channel %X from CADET service (recently close?)\n",
 685          ntohl (msg->ccn.channel_of_client));
 686     return;
 687   }
 688   LOG (GNUNET_ERROR_TYPE_DEBUG,
 689        "Received channel destroy for channel %X from CADET service\n",
 690        ntohl (msg->ccn.channel_of_client));
 691   destroy_channel (ch);
 692 }
 693
 694
 695 /**
 696  * Check that message received from CADET service is well-formed.
 697  *
 698  * @param cls the `struct GNUNET_CADET_Handle`
 699  * @param message the message we got
 700  * @return #GNUNET_OK if the message is well-formed,
 701  *         #GNUNET_SYSERR otherwise
 702  */
 703 static int
 704 check_local_data (void *cls,
 705                   const struct GNUNET_CADET_LocalData *message)
 706 {
 707   uint16_t size;
 708
 709   size = ntohs (message->header.size);
 710   if (sizeof (*message) + sizeof (struct GNUNET_MessageHeader) > size)
 711   {
 712     GNUNET_break (0);
 713     return GNUNET_SYSERR;
 714   }
 715   return GNUNET_OK;
 716 }
 717
 718
 719 /**
 720  * Process the incoming data packets, call appropriate handlers.
 721  *
 722  * @param h       The cadet handle
 723  * @param message A message encapsulating the data
 724  */
 725 static void
 726 handle_local_data (void *cls,
 727                    const struct GNUNET_CADET_LocalData *message)
 728 {
 729   struct GNUNET_CADET_Handle *h = cls;
 730   const struct GNUNET_MessageHeader *payload;
 731   struct GNUNET_CADET_Channel *ch;
 732   uint16_t type;
 733   int fwd;
 734
 735   ch = find_channel (h,
 736                      message->ccn);
 737   if (NULL == ch)
 738   {
 739     LOG (GNUNET_ERROR_TYPE_DEBUG,
 740          "Unknown channel %X for incoming data (recently closed?)\n",
 741          ntohl (message->ccn.channel_of_client));
 742     return;
 743   }
 744
 745   payload = (const struct GNUNET_MessageHeader *) &message[1];
 746   type = ntohs (payload->type);
 747   fwd = ntohl (ch->ccn.channel_of_client) <= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI;
 748   LOG (GNUNET_ERROR_TYPE_DEBUG,
 749        "Got a %s data on channel %s [%X] of type %u\n",
 750        fwd ? "FWD" : "BWD",
 751        GNUNET_i2s (&ch->peer),
 752        ntohl (message->ccn.channel_of_client),
 753        type);
 754   GNUNET_MQ_inject_message (ch->mq,
 755                             payload);
 756 }
 757
 758
 759 /**
 760  * Process a local ACK message, enabling the client to send
 761  * more data to the service.
 762  *
 763  * @param h Cadet handle.
 764  * @param message Message itself.
 765  */
 766 static void
 767 handle_local_ack (void *cls,
 768                   const struct GNUNET_CADET_LocalAck *message)
 769 {
 770   struct GNUNET_CADET_Handle *h = cls;
 771   struct GNUNET_CADET_Channel *ch;
 772
 773   ch = find_channel (h,
 774                      message->ccn);
 775   if (NULL == ch)
 776   {
 777     LOG (GNUNET_ERROR_TYPE_DEBUG,
 778          "ACK on unknown channel %X\n",
 779          ntohl (message->ccn.channel_of_client));
 780     return;
 781   }
 782   ch->allow_send++;
 783   if (NULL == ch->pending_env)
 784   {
 785     LOG (GNUNET_ERROR_TYPE_DEBUG,
 786          "Got an ACK on mq channel %X, allow send now %u!\n",
 787          ntohl (ch->ccn.channel_of_client),
 788          ch->allow_send);
 789     notify_window_size (ch);
 790     return;
 791   }
 792   if (NULL != ch->mq_cont)
 793     return; /* already working on it! */
 794   LOG (GNUNET_ERROR_TYPE_DEBUG,
 795        "Got an ACK on mq channel %X, sending pending message!\n",
 796        ntohl (ch->ccn.channel_of_client));
 797   ch->mq_cont
 798     = GNUNET_SCHEDULER_add_now (&cadet_mq_send_now,
 799                                 ch);
 800 }
 801
 802
 803 /**
 804  * Generic error handler, called with the appropriate error code and
 805  * the same closure specified at the creation of the message queue.
 806  * Not every message queue implementation supports an error handler.
 807  *
 808  * @param cls closure, a `struct GNUNET_CORE_Handle *`
 809  * @param error error code
 810  */
 811 static void
 812 handle_mq_error (void *cls,
 813                  enum GNUNET_MQ_Error error)
 814 {
 815   struct GNUNET_CADET_Handle *h = cls;
 816
 817   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 818               "MQ ERROR: %u\n",
 819               error);
 820   GNUNET_MQ_destroy (h->mq);
 821   h->mq = NULL;
 822   reconnect (h);
 823 }
 824
 825
 826 /**
 827  * Check that message received from CADET service is well-formed.
 828  *
 829  * @param cls the `struct GNUNET_CADET_Handle`
 830  * @param message the message we got
 831  * @return #GNUNET_OK if the message is well-formed,
 832  *         #GNUNET_SYSERR otherwise
 833  */
 834 static int
 835 check_get_peers (void *cls,
 836                  const struct GNUNET_MessageHeader *message)
 837 {
 838   size_t esize;
 839
 840   esize = ntohs (message->size);
 841   if (sizeof (struct GNUNET_CADET_LocalInfoPeer) == esize)
 842     return GNUNET_OK;
 843   if (sizeof (struct GNUNET_MessageHeader) == esize)
 844     return GNUNET_OK;
 845   return GNUNET_SYSERR;
 846 }
 847
 848
 849 /**
 850  * Process a local reply about info on all tunnels, pass info to the user.
 851  *
 852  * @param cls Closure (Cadet handle).
 853  * @param msg Message itself.
 854  */
 855 static void
 856 handle_get_peers (void *cls,
 857                   const struct GNUNET_MessageHeader *msg)
 858 {
 859   struct GNUNET_CADET_Handle *h = cls;
 860   const struct GNUNET_CADET_LocalInfoPeer *info =
 861     (const struct GNUNET_CADET_LocalInfoPeer *) msg;
 862
 863   if (NULL == h->info_cb.peers_cb)
 864     return;
 865   if (sizeof (struct GNUNET_CADET_LocalInfoPeer) == ntohs (msg->size))
 866     h->info_cb.peers_cb (h->info_cls,
 867                          &info->destination,
 868                          (int) ntohs (info->tunnel),
 869                          (unsigned int) ntohs (info->paths),
 870                          0);
 871   else
 872     h->info_cb.peers_cb (h->info_cls,
 873                          NULL,
 874                          0,
 875                          0,
 876                          0);
 877 }
 878
 879
 880 /**
 881  * Check that message received from CADET service is well-formed.
 882  *
 883  * @param cls the `struct GNUNET_CADET_Handle`
 884  * @param message the message we got
 885  * @return #GNUNET_OK if the message is well-formed,
 886  *         #GNUNET_SYSERR otherwise
 887  */
 888 static int
 889 check_get_peer (void *cls,
 890                 const struct GNUNET_CADET_LocalInfoPeer *message)
 891 {
 892   size_t msize = sizeof (struct GNUNET_CADET_LocalInfoPeer);
 893   const struct GNUNET_PeerIdentity *paths_array;
 894   size_t esize;
 895   unsigned int epaths;
 896   unsigned int paths;
 897   unsigned int peers;
 898
 899   esize = ntohs (message->header.size);
 900   if (esize < msize)
 901   {
 902     GNUNET_break (0);
 903     return GNUNET_SYSERR;
 904   }
 905   if (0 != ((esize - msize) % sizeof (struct GNUNET_PeerIdentity)))
 906   {
 907     GNUNET_break (0);
 908     return GNUNET_SYSERR;
 909   }
 910   peers = (esize - msize) / sizeof (struct GNUNET_PeerIdentity);
 911   epaths = ntohs (message->paths);
 912   paths_array = (const struct GNUNET_PeerIdentity *) &message[1];
 913   paths = 0;
 914   for (unsigned int i = 0; i < peers; i++)
 915     if (0 == memcmp (&paths_array[i],
 916                      &message->destination,
 917                      sizeof (struct GNUNET_PeerIdentity)))
 918       paths++;
 919   if (paths != epaths)
 920   {
 921     GNUNET_break (0);
 922     return GNUNET_SYSERR;
 923   }
 924   return GNUNET_OK;
 925 }
 926
 927
 928 /**
 929  * Process a local peer info reply, pass info to the user.
 930  *
 931  * @param cls Closure (Cadet handle).
 932  * @param message Message itself.
 933  */
 934 static void
 935 handle_get_peer (void *cls,
 936                  const struct GNUNET_CADET_LocalInfoPeer *message)
 937 {
 938   struct GNUNET_CADET_Handle *h = cls;
 939   const struct GNUNET_PeerIdentity *paths_array;
 940   unsigned int paths;
 941   unsigned int path_length;
 942   int neighbor;
 943   unsigned int peers;
 944
 945   if (NULL == h->info_cb.peer_cb)
 946     return;
 947   paths = ntohs (message->paths);
 948   paths_array = (const struct GNUNET_PeerIdentity *) &message[1];
 949   peers = (ntohs (message->header.size) - sizeof (*message))
 950           / sizeof (struct GNUNET_PeerIdentity);
 951   path_length = 0;
 952   neighbor = GNUNET_NO;
 953
 954   for (unsigned int i = 0; i < peers; i++)
 955   {
 956     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 957                 " %s\n",
 958                 GNUNET_i2s (&paths_array[i]));
 959     path_length++;
 960     if (0 == memcmp (&paths_array[i], &message->destination,
 961                      sizeof (struct GNUNET_PeerIdentity)))
 962     {
 963       if (1 == path_length)
 964         neighbor = GNUNET_YES;
 965       path_length = 0;
 966     }
 967   }
 968
 969   /* Call Callback with tunnel info. */
 970   paths_array = (const struct GNUNET_PeerIdentity *) &message[1];
 971   h->info_cb.peer_cb (h->info_cls,
 972                       &message->destination,
 973                       (int) ntohs (message->tunnel),
 974                       neighbor,
 975                       paths,
 976                       paths_array);
 977 }
 978
 979
 980 /**
 981  * Process a local reply about info on all tunnels, pass info to the user.
 982  *
 983  * @param cls Closure (Cadet handle).
 984  * @param message Message itself.
 985  */
 986 static void
 987 handle_get_tunnels (void *cls,
 988                     const struct GNUNET_CADET_LocalInfoTunnel *msg)
 989 {
 990   struct GNUNET_CADET_Handle *h = cls;
 991
 992   if (NULL == h->info_cb.tunnels_cb)
 993     return;
 994   h->info_cb.tunnels_cb (h->info_cls,
 995                          &msg->destination,
 996                          ntohl (msg->channels),
 997                          ntohl (msg->connections),
 998                          ntohs (msg->estate),
 999                          ntohs (msg->cstate));
1000
1001 }
1002
1003
1004 /**
1005  * Check that message received from CADET service is well-formed.
1006  *
1007  * @param cls the `struct GNUNET_CADET_Handle`
1008  * @param msg the message we got
1009  * @return #GNUNET_OK if the message is well-formed,
1010  *         #GNUNET_SYSERR otherwise
1011  */
1012 static int
1013 check_get_tunnel (void *cls,
1014                   const struct GNUNET_CADET_LocalInfoTunnel *msg)
1015 {
1016   unsigned int ch_n;
1017   unsigned int c_n;
1018   size_t esize;
1019   size_t msize;
1020
1021   /* Verify message sanity */
1022   msize = ntohs (msg->header.size);
1023   esize = sizeof (struct GNUNET_CADET_LocalInfoTunnel);
1024   if (esize > msize)
1025   {
1026     GNUNET_break (0);
1027     return GNUNET_SYSERR;
1028   }
1029   ch_n = ntohl (msg->channels);
1030   c_n = ntohl (msg->connections);
1031   esize += ch_n * sizeof (struct GNUNET_CADET_ChannelTunnelNumber);
1032   esize += c_n * sizeof (struct GNUNET_CADET_ConnectionTunnelIdentifier);
1033   if (msize != esize)
1034   {
1035     GNUNET_break_op (0);
1036     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1037                 "m:%u, e: %u (%u ch, %u conn)\n",
1038                 (unsigned int) msize,
1039                 (unsigned int) esize,
1040                 ch_n,
1041                 c_n);
1042     return GNUNET_SYSERR;
1043   }
1044   return GNUNET_OK;
1045 }
1046
1047
1048 /**
1049  * Process a local tunnel info reply, pass info to the user.
1050  *
1051  * @param cls Closure (Cadet handle).
1052  * @param msg Message itself.
1053  */
1054 static void
1055 handle_get_tunnel (void *cls,
1056                    const struct GNUNET_CADET_LocalInfoTunnel *msg)
1057 {
1058   struct GNUNET_CADET_Handle *h = cls;
1059   unsigned int ch_n;
1060   unsigned int c_n;
1061   const struct GNUNET_CADET_ConnectionTunnelIdentifier *conns;
1062   const struct GNUNET_CADET_ChannelTunnelNumber *chns;
1063
1064   if (NULL == h->info_cb.tunnel_cb)
1065     return;
1066
1067   ch_n = ntohl (msg->channels);
1068   c_n = ntohl (msg->connections);
1069
1070   /* Call Callback with tunnel info. */
1071   conns = (const struct GNUNET_CADET_ConnectionTunnelIdentifier *) &msg[1];
1072   chns = (const struct GNUNET_CADET_ChannelTunnelNumber *) &conns[c_n];
1073   h->info_cb.tunnel_cb (h->info_cls,
1074                         &msg->destination,
1075                         ch_n,
1076                         c_n,
1077                         chns,
1078                         conns,
1079                         ntohs (msg->estate),
1080                         ntohs (msg->cstate));
1081 }
1082
1083
1084 /**
1085  * Reconnect to the service, retransmit all infomation to try to restore the
1086  * original state.
1087  *
1088  * @param h handle to the cadet
1089  */
1090 static void
1091 reconnect (struct GNUNET_CADET_Handle *h)
1092 {
1093   struct GNUNET_MQ_MessageHandler handlers[] = {
1094     GNUNET_MQ_hd_fixed_size (channel_created,
1095                              GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE,
1096                              struct GNUNET_CADET_LocalChannelCreateMessage,
1097                              h),
1098     GNUNET_MQ_hd_fixed_size (channel_destroy,
1099                              GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY,
1100                              struct GNUNET_CADET_LocalChannelDestroyMessage,
1101                              h),
1102     GNUNET_MQ_hd_var_size (local_data,
1103                            GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
1104                            struct GNUNET_CADET_LocalData,
1105                            h),
1106     GNUNET_MQ_hd_fixed_size (local_ack,
1107                              GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK,
1108                              struct GNUNET_CADET_LocalAck,
1109                              h),
1110     GNUNET_MQ_hd_var_size (get_peers,
1111                            GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS,
1112                            struct GNUNET_MessageHeader,
1113                            h),
1114     GNUNET_MQ_hd_var_size (get_peer,
1115                            GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER,
1116                            struct GNUNET_CADET_LocalInfoPeer,
1117                            h),
1118     GNUNET_MQ_hd_fixed_size (get_tunnels,
1119                              GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS,
1120                              struct GNUNET_CADET_LocalInfoTunnel,
1121                              h),
1122     GNUNET_MQ_hd_var_size (get_tunnel,
1123                            GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL,
1124                            struct GNUNET_CADET_LocalInfoTunnel,
1125                            h),
1126     GNUNET_MQ_handler_end ()
1127   };
1128
1129   h->mq = GNUNET_CLIENT_connect (h->cfg,
1130                                  "cadet",
1131                                  handlers,
1132                                  &handle_mq_error,
1133                                  h);
1134   if (NULL == h->mq)
1135   {
1136     schedule_reconnect (h);
1137     return;
1138   }
1139   h->reconnect_time = GNUNET_TIME_UNIT_MILLISECONDS;
1140 }
1141
1142
1143 /**
1144  * Function called during #GNUNET_CADET_disconnect() to destroy
1145  * all channels that are still open.
1146  *
1147  * @param cls the `struct GNUNET_CADET_Handle`
1148  * @param cid chanenl ID
1149  * @param value a `struct GNUNET_CADET_Channel` to destroy
1150  * @return #GNUNET_OK (continue to iterate)
1151  */
1152 static int
1153 destroy_channel_cb (void *cls,
1154                     uint32_t cid,
1155                     void *value)
1156 {
1157   /* struct GNUNET_CADET_Handle *handle = cls; */
1158   struct GNUNET_CADET_Channel *ch = value;
1159
1160   if (ntohl (ch->ccn.channel_of_client) >= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
1161   {
1162     GNUNET_break (0);
1163     LOG (GNUNET_ERROR_TYPE_DEBUG,
1164          "channel %X not destroyed\n",
1165          ntohl (ch->ccn.channel_of_client));
1166   }
1167   destroy_channel (ch);
1168   return GNUNET_OK;
1169 }
1170
1171
1172 /**
1173  * Function called during #GNUNET_CADET_disconnect() to destroy
1174  * all ports that are still open.
1175  *
1176  * @param cls the `struct GNUNET_CADET_Handle`
1177  * @param id port ID
1178  * @param value a `struct GNUNET_CADET_Channel` to destroy
1179  * @return #GNUNET_OK (continue to iterate)
1180  */
1181 static int
1182 destroy_port_cb (void *cls,
1183                  const struct GNUNET_HashCode *id,
1184                  void *value)
1185 {
1186   /* struct GNUNET_CADET_Handle *handle = cls; */
1187   struct GNUNET_CADET_Port *port = value;
1188
1189   /* This is a warning, the app should have cleanly closed all open ports */
1190   GNUNET_break (0);
1191   GNUNET_CADET_close_port (port);
1192   return GNUNET_OK;
1193 }
1194
1195
1196 /**
1197  * Disconnect from the cadet service. All channels will be destroyed. All channel
1198  * disconnect callbacks will be called on any still connected peers, notifying
1199  * about their disconnection. The registered inbound channel cleaner will be
1200  * called should any inbound channels still exist.
1201  *
1202  * @param handle connection to cadet to disconnect
1203  */
1204 void
1205 GNUNET_CADET_disconnect (struct GNUNET_CADET_Handle *handle)
1206 {
1207   GNUNET_CONTAINER_multihashmap_iterate (handle->ports,
1208                                          &destroy_port_cb,
1209                                          handle);
1210   GNUNET_CONTAINER_multihashmap_destroy (handle->ports);
1211   handle->ports = NULL;
1212   GNUNET_CONTAINER_multihashmap32_iterate (handle->channels,
1213                                            &destroy_channel_cb,
1214                                            handle);
1215   GNUNET_CONTAINER_multihashmap32_destroy (handle->channels);
1216   handle->channels = NULL;
1217   if (NULL != handle->mq)
1218   {
1219     GNUNET_MQ_destroy (handle->mq);
1220     handle->mq = NULL;
1221   }
1222   if (NULL != handle->reconnect_task)
1223   {
1224     GNUNET_SCHEDULER_cancel (handle->reconnect_task);
1225     handle->reconnect_task = NULL;
1226   }
1227   GNUNET_free (handle);
1228 }
1229
1230
1231 /**
1232  * Close a port opened with @a GNUNET_CADET_open_port().
1233  * The @a new_channel callback will no longer be called.
1234  *
1235  * @param p Port handle.
1236  */
1237 void
1238 GNUNET_CADET_close_port (struct GNUNET_CADET_Port *p)
1239 {
1240   struct GNUNET_CADET_PortMessage *msg;
1241   struct GNUNET_MQ_Envelope *env;
1242
1243   env = GNUNET_MQ_msg (msg,
1244                        GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE);
1245   msg->port = p->id;
1246   GNUNET_MQ_send (p->cadet->mq,
1247                   env);
1248   GNUNET_assert (GNUNET_YES ==
1249                  GNUNET_CONTAINER_multihashmap_remove (p->cadet->ports,
1250                                                        &p->id,
1251                                                        p));
1252   GNUNET_free_non_null (p->handlers);
1253   GNUNET_free (p);
1254 }
1255
1256
1257 /**
1258  * Destroy an existing channel.
1259  *
1260  * The existing end callback for the channel will be called immediately.
1261  * Any pending outgoing messages will be sent but no incoming messages will be
1262  * accepted and no data callbacks will be called.
1263  *
1264  * @param channel Channel handle, becomes invalid after this call.
1265  */
1266 void
1267 GNUNET_CADET_channel_destroy (struct GNUNET_CADET_Channel *channel)
1268 {
1269   struct GNUNET_CADET_Handle *h = channel->cadet;
1270   struct GNUNET_CADET_LocalChannelDestroyMessage *msg;
1271   struct GNUNET_MQ_Envelope *env;
1272
1273   if (NULL != h->mq)
1274   {
1275     env = GNUNET_MQ_msg (msg,
1276                          GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
1277     msg->ccn = channel->ccn;
1278     GNUNET_MQ_send (h->mq,
1279                     env);
1280   }
1281   destroy_channel (channel);
1282 }
1283
1284
1285 /**
1286  * Get information about a channel.
1287  *
1288  * @param channel Channel handle.
1289  * @param option Query (GNUNET_CADET_OPTION_*).
1290  * @param ... dependant on option, currently not used
1291  *
1292  * @return Union with an answer to the query.
1293  */
1294 const union GNUNET_CADET_ChannelInfo *
1295 GNUNET_CADET_channel_get_info (struct GNUNET_CADET_Channel *channel,
1296                                enum GNUNET_CADET_ChannelOption option,
1297                                ...)
1298 {
1299   static int bool_flag;
1300
1301   switch (option)
1302   {
1303     case GNUNET_CADET_OPTION_NOBUFFER:
1304     case GNUNET_CADET_OPTION_RELIABLE:
1305     case GNUNET_CADET_OPTION_OUT_OF_ORDER:
1306       if (0 != (option & channel->options))
1307         bool_flag = GNUNET_YES;
1308       else
1309         bool_flag = GNUNET_NO;
1310       return (const union GNUNET_CADET_ChannelInfo *) &bool_flag;
1311       break;
1312     case GNUNET_CADET_OPTION_PEER:
1313       return (const union GNUNET_CADET_ChannelInfo *) &channel->peer;
1314       break;
1315     default:
1316       GNUNET_break (0);
1317       return NULL;
1318   }
1319 }
1320
1321
1322 /**
1323  * Send an ack on the channel to confirm the processing of a message.
1324  *
1325  * @param ch Channel on which to send the ACK.
1326  */
1327 void
1328 GNUNET_CADET_receive_done (struct GNUNET_CADET_Channel *channel)
1329 {
1330   struct GNUNET_CADET_LocalAck *msg;
1331   struct GNUNET_MQ_Envelope *env;
1332
1333   env = GNUNET_MQ_msg (msg,
1334                        GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK);
1335   LOG (GNUNET_ERROR_TYPE_DEBUG,
1336        "Sending ACK on channel %X\n",
1337        ntohl (channel->ccn.channel_of_client));
1338   msg->ccn = channel->ccn;
1339   GNUNET_MQ_send (channel->cadet->mq,
1340                   env);
1341 }
1342
1343
1344 /**
1345  * Send message of @a type to CADET service of @a h
1346  *
1347  * @param h handle to CADET service
1348  * @param type message type of trivial information request to send
1349  */
1350 static void
1351 send_info_request (struct GNUNET_CADET_Handle *h,
1352                    uint16_t type)
1353 {
1354   struct GNUNET_MessageHeader *msg;
1355   struct GNUNET_MQ_Envelope *env;
1356
1357   env = GNUNET_MQ_msg (msg,
1358                        type);
1359   GNUNET_MQ_send (h->mq,
1360                   env);
1361 }
1362
1363
1364 /**
1365  * Request a debug dump on the service's STDERR.
1366  *
1367  * WARNING: unstable API, likely to change in the future!
1368  *
1369  * @param h cadet handle
1370  */
1371 void
1372 GNUNET_CADET_request_dump (struct GNUNET_CADET_Handle *h)
1373 {
1374   send_info_request (h,
1375                      GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_DUMP);
1376 }
1377
1378
1379 /**
1380  * Request information about peers known to the running cadet service.
1381  * The callback will be called for every peer known to the service.
1382  * Only one info request (of any kind) can be active at once.
1383  *
1384  * WARNING: unstable API, likely to change in the future!
1385  *
1386  * @param h Handle to the cadet peer.
1387  * @param callback Function to call with the requested data.
1388  * @param callback_cls Closure for @c callback.
1389  * @return #GNUNET_OK / #GNUNET_SYSERR
1390  */
1391 int
1392 GNUNET_CADET_get_peers (struct GNUNET_CADET_Handle *h,
1393                        GNUNET_CADET_PeersCB callback,
1394                        void *callback_cls)
1395 {
1396   if (NULL != h->info_cb.peers_cb)
1397   {
1398     GNUNET_break (0);
1399     return GNUNET_SYSERR;
1400   }
1401   send_info_request (h,
1402                      GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS);
1403   h->info_cb.peers_cb = callback;
1404   h->info_cls = callback_cls;
1405   return GNUNET_OK;
1406 }
1407
1408
1409 /**
1410  * Cancel a peer info request. The callback will not be called (anymore).
1411  *
1412  * WARNING: unstable API, likely to change in the future!
1413  *
1414  * @param h Cadet handle.
1415  * @return Closure given to GNUNET_CADET_get_peers().
1416  */
1417 void *
1418 GNUNET_CADET_get_peers_cancel (struct GNUNET_CADET_Handle *h)
1419 {
1420   void *cls = h->info_cls;
1421
1422   h->info_cb.peers_cb = NULL;
1423   h->info_cls = NULL;
1424   return cls;
1425 }
1426
1427
1428 /**
1429  * Request information about a peer known to the running cadet peer.
1430  * The callback will be called for the tunnel once.
1431  * Only one info request (of any kind) can be active at once.
1432  *
1433  * WARNING: unstable API, likely to change in the future!
1434  *
1435  * @param h Handle to the cadet peer.
1436  * @param id Peer whose tunnel to examine.
1437  * @param callback Function to call with the requested data.
1438  * @param callback_cls Closure for @c callback.
1439  * @return #GNUNET_OK / #GNUNET_SYSERR
1440  */
1441 int
1442 GNUNET_CADET_get_peer (struct GNUNET_CADET_Handle *h,
1443                        const struct GNUNET_PeerIdentity *id,
1444                        GNUNET_CADET_PeerCB callback,
1445                        void *callback_cls)
1446 {
1447   struct GNUNET_CADET_LocalInfo *msg;
1448   struct GNUNET_MQ_Envelope *env;
1449
1450   if (NULL != h->info_cb.peer_cb)
1451   {
1452     GNUNET_break (0);
1453     return GNUNET_SYSERR;
1454   }
1455   env = GNUNET_MQ_msg (msg,
1456                        GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER);
1457   msg->peer = *id;
1458   GNUNET_MQ_send (h->mq,
1459                   env);
1460   h->info_cb.peer_cb = callback;
1461   h->info_cls = callback_cls;
1462   return GNUNET_OK;
1463 }
1464
1465
1466 /**
1467  * Request information about tunnels of the running cadet peer.
1468  * The callback will be called for every tunnel of the service.
1469  * Only one info request (of any kind) can be active at once.
1470  *
1471  * WARNING: unstable API, likely to change in the future!
1472  *
1473  * @param h Handle to the cadet peer.
1474  * @param callback Function to call with the requested data.
1475  * @param callback_cls Closure for @c callback.
1476  * @return #GNUNET_OK / #GNUNET_SYSERR
1477  */
1478 int
1479 GNUNET_CADET_get_tunnels (struct GNUNET_CADET_Handle *h,
1480                          GNUNET_CADET_TunnelsCB callback,
1481                          void *callback_cls)
1482 {
1483   if (NULL != h->info_cb.tunnels_cb)
1484   {
1485     GNUNET_break (0);
1486     return GNUNET_SYSERR;
1487   }
1488   send_info_request (h,
1489                      GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS);
1490   h->info_cb.tunnels_cb = callback;
1491   h->info_cls = callback_cls;
1492   return GNUNET_OK;
1493 }
1494
1495
1496 /**
1497  * Cancel a monitor request. The monitor callback will not be called.
1498  *
1499  * @param h Cadet handle.
1500  * @return Closure given to GNUNET_CADET_get_tunnels().
1501  */
1502 void *
1503 GNUNET_CADET_get_tunnels_cancel (struct GNUNET_CADET_Handle *h)
1504 {
1505   void *cls = h->info_cls;
1506
1507   h->info_cb.tunnels_cb = NULL;
1508   h->info_cls = NULL;
1509   return cls;
1510 }
1511
1512
1513 /**
1514  * Request information about a tunnel of the running cadet peer.
1515  * The callback will be called for the tunnel once.
1516  * Only one info request (of any kind) can be active at once.
1517  *
1518  * WARNING: unstable API, likely to change in the future!
1519  *
1520  * @param h Handle to the cadet peer.
1521  * @param id Peer whose tunnel to examine.
1522  * @param callback Function to call with the requested data.
1523  * @param callback_cls Closure for @c callback.
1524  * @return #GNUNET_OK / #GNUNET_SYSERR
1525  */
1526 int
1527 GNUNET_CADET_get_tunnel (struct GNUNET_CADET_Handle *h,
1528                         const struct GNUNET_PeerIdentity *id,
1529                         GNUNET_CADET_TunnelCB callback,
1530                         void *callback_cls)
1531 {
1532   struct GNUNET_CADET_LocalInfo *msg;
1533   struct GNUNET_MQ_Envelope *env;
1534
1535   if (NULL != h->info_cb.tunnel_cb)
1536   {
1537     GNUNET_break (0);
1538     return GNUNET_SYSERR;
1539   }
1540   env = GNUNET_MQ_msg (msg,
1541                        GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL);
1542   msg->peer = *id;
1543   GNUNET_MQ_send (h->mq,
1544                   env);
1545   h->info_cb.tunnel_cb = callback;
1546   h->info_cls = callback_cls;
1547   return GNUNET_OK;
1548 }
1549
1550
1551 /**
1552  * Transitional function to convert an unsigned int port to a hash value.
1553  * WARNING: local static value returned, NOT reentrant!
1554  * WARNING: do not use this function for new code!
1555  *
1556  * @param port Numerical port (unsigned int format).
1557  *
1558  * @return A GNUNET_HashCode usable for the new CADET API.
1559  */
1560 const struct GNUNET_HashCode *
1561 GC_u2h (uint32_t port)
1562 {
1563   static struct GNUNET_HashCode hash;
1564
1565   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1566               "This is a transitional function, use proper crypto hashes as CADET ports\n");
1567   GNUNET_CRYPTO_hash (&port,
1568                       sizeof (port),
1569                       &hash);
1570   return &hash;
1571 }
1572
1573
1574 /**
1575  * Connect to the MQ-based cadet service.
1576  *
1577  * @param cfg Configuration to use.
1578  *
1579  * @return Handle to the cadet service NULL on error.
1580  */
1581 struct GNUNET_CADET_Handle *
1582 GNUNET_CADET_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
1583 {
1584   struct GNUNET_CADET_Handle *h;
1585
1586   LOG (GNUNET_ERROR_TYPE_DEBUG,
1587        "GNUNET_CADET_connect()\n");
1588   h = GNUNET_new (struct GNUNET_CADET_Handle);
1589   h->cfg = cfg;
1590   h->ports = GNUNET_CONTAINER_multihashmap_create (4,
1591                                                    GNUNET_YES);
1592   h->channels = GNUNET_CONTAINER_multihashmap32_create (4);
1593   reconnect (h);
1594   if (NULL == h->mq)
1595   {
1596     GNUNET_break (0);
1597     GNUNET_CADET_disconnect (h);
1598     return NULL;
1599   }
1600   h->next_ccn.channel_of_client = htonl (GNUNET_CADET_LOCAL_CHANNEL_ID_CLI);
1601   h->reconnect_time = GNUNET_TIME_UNIT_MILLISECONDS;
1602   h->reconnect_task = NULL;
1603
1604   return h;
1605 }
1606
1607
1608 /**
1609  * Open a port to receive incomming MQ-based channels.
1610  *
1611  * @param h CADET handle.
1612  * @param port Hash identifying the port.
1613  * @param connects Function called when an incoming channel is connected.
1614  * @param connects_cls Closure for the @a connects handler.
1615  * @param window_changes Function called when the transmit window size changes.
1616  * @param disconnects Function called when a channel is disconnected.
1617  * @param handlers Callbacks for messages we care about, NULL-terminated.
1618  * @return Port handle, NULL if port is in use
1619  */
1620 struct GNUNET_CADET_Port *
1621 GNUNET_CADET_open_port (struct GNUNET_CADET_Handle *h,
1622                         const struct GNUNET_HashCode *port,
1623                         GNUNET_CADET_ConnectEventHandler connects,
1624                         void * connects_cls,
1625                         GNUNET_CADET_WindowSizeEventHandler window_changes,
1626                         GNUNET_CADET_DisconnectEventHandler disconnects,
1627                         const struct GNUNET_MQ_MessageHandler *handlers)
1628 {
1629   struct GNUNET_CADET_PortMessage *msg;
1630   struct GNUNET_MQ_Envelope *env;
1631   struct GNUNET_CADET_Port *p;
1632
1633   GNUNET_assert (NULL != connects);
1634   GNUNET_assert (NULL != disconnects);
1635   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1636               "Listening to CADET port %s\n",
1637               GNUNET_h2s (port));
1638
1639   p = GNUNET_new (struct GNUNET_CADET_Port);
1640   p->cadet = h;
1641   p->id = *port;
1642   if (GNUNET_OK !=
1643       GNUNET_CONTAINER_multihashmap_put (h->ports,
1644                                          &p->id,
1645                                          p,
1646                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
1647   {
1648     GNUNET_free (p);
1649     return NULL;
1650   }
1651   p->connects = connects;
1652   p->cls = connects_cls;
1653   p->window_changes = window_changes;
1654   p->disconnects = disconnects;
1655   p->handlers = GNUNET_MQ_copy_handlers (handlers);
1656
1657
1658   env = GNUNET_MQ_msg (msg,
1659                        GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN);
1660   msg->port = p->id;
1661   GNUNET_MQ_send (h->mq,
1662                   env);
1663   return p;
1664 }
1665
1666
1667 /**
1668  * Create a new channel towards a remote peer.
1669  *
1670  * If the destination port is not open by any peer or the destination peer
1671  * does not accept the channel, #GNUNET_CADET_ChannelEndHandler will be called
1672  * for this channel.
1673  *
1674  * @param h CADET handle.
1675  * @param channel_cls Closure for the channel. It's given to:
1676  *                    - The disconnect handler @a disconnects
1677  *                    - Each message type callback in @a handlers
1678  * @param destination Peer identity the channel should go to.
1679  * @param port Identification of the destination port.
1680  * @param options CadetOption flag field, with all desired option bits set to 1.
1681  * @param window_changes Function called when the transmit window size changes.
1682  * @param disconnects Function called when the channel is disconnected.
1683  * @param handlers Callbacks for messages we care about, NULL-terminated.
1684  * @return Handle to the channel.
1685  */
1686 struct GNUNET_CADET_Channel *
1687 GNUNET_CADET_channel_create (struct GNUNET_CADET_Handle *h,
1688                              void *channel_cls,
1689                              const struct GNUNET_PeerIdentity *destination,
1690                              const struct GNUNET_HashCode *port,
1691                              enum GNUNET_CADET_ChannelOption options,
1692                              GNUNET_CADET_WindowSizeEventHandler window_changes,
1693                              GNUNET_CADET_DisconnectEventHandler disconnects,
1694                              const struct GNUNET_MQ_MessageHandler *handlers)
1695 {
1696   struct GNUNET_CADET_Channel *ch;
1697   struct GNUNET_CADET_LocalChannelCreateMessage *msg;
1698   struct GNUNET_MQ_Envelope *env;
1699
1700   GNUNET_assert (NULL != disconnects);
1701   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1702               "Creating channel to peer %s at port %s\n",
1703               GNUNET_i2s (destination),
1704               GNUNET_h2s (port));
1705   ch = create_channel (h,
1706                        NULL);
1707   ch->ctx = channel_cls;
1708   ch->peer = *destination;
1709   ch->options = options;
1710   ch->window_changes = window_changes;
1711   ch->disconnects = disconnects;
1712
1713   /* Create MQ for channel */
1714   ch->mq = GNUNET_MQ_queue_for_callbacks (&cadet_mq_send_impl,
1715                                           &cadet_mq_destroy_impl,
1716                                           &cadet_mq_cancel_impl,
1717                                           ch,
1718                                           handlers,
1719                                           &cadet_mq_error_handler,
1720                                           ch);
1721   GNUNET_MQ_set_handlers_closure (ch->mq, channel_cls);
1722
1723   /* Request channel creation to service */
1724   env = GNUNET_MQ_msg (msg,
1725                        GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE);
1726   msg->ccn = ch->ccn;
1727   msg->port = *port;
1728   msg->peer = *destination;
1729   msg->opt = htonl (options);
1730   GNUNET_MQ_send (h->mq,
1731                   env);
1732   return ch;
1733 }
1734
1735
1736 /**
1737  * Obtain the message queue for a connected peer.
1738  *
1739  * @param channel The channel handle from which to get the MQ.
1740  *
1741  * @return NULL if @a channel is not yet connected.
1742  */
1743 struct GNUNET_MQ_Handle *
1744 GNUNET_CADET_get_mq (const struct GNUNET_CADET_Channel *channel)
1745 {
1746   return channel->mq;
1747 }
1748
1749 /* end of cadet_api.c */