src/cadet/cadet_api.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2011 Christian Grothoff (and other contributing authors)
   4      GNUnet is free software; you can redistribute it and/or modify
   5      it under the terms of the GNU General Public License as published
   6      by the Free Software Foundation; either version 3, or (at your
   7      option) any later version.
   8      GNUnet is distributed in the hope that it will be useful, but
   9      WITHOUT ANY WARRANTY; without even the implied warranty of
  10      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11      General Public License for more details.
  12      You should have received a copy of the GNU General Public License
  13      along with GNUnet; see the file COPYING.  If not, write to the
  14      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  15      Boston, MA 02111-1307, USA.
  16 */
  17
  18 /**
  19  * @file cadet/cadet_api.c
  20  * @brief cadet api: client implementation of new cadet service
  21  * @author Bartlomiej Polot
  22  */
  23
  24 #include "platform.h"
  25 #include "gnunet_util_lib.h"
  26 #include "gnunet_cadet_service.h"
  27 #include "cadet.h"
  28 #include "cadet_protocol.h"
  29
  30 #define LOG(kind,...) GNUNET_log_from (kind, "cadet-api",__VA_ARGS__)
  31 #define DATA_OVERHEAD sizeof(struct GNUNET_CADET_LocalData)
  32
  33 /******************************************************************************/
  34 /************************      DATA STRUCTURES     ****************************/
  35 /******************************************************************************/
  36
  37 /**
  38  * Transmission queue to the service
  39  */
  40 struct GNUNET_CADET_TransmitHandle
  41 {
  42
  43     /**
  44      * Double Linked list
  45      */
  46   struct GNUNET_CADET_TransmitHandle *next;
  47
  48     /**
  49      * Double Linked list
  50      */
  51   struct GNUNET_CADET_TransmitHandle *prev;
  52
  53     /**
  54      * Channel this message is sent on / for (may be NULL for control messages).
  55      */
  56   struct GNUNET_CADET_Channel *channel;
  57
  58     /**
  59      * Callback to obtain the message to transmit, or NULL if we
  60      * got the message in 'data'.  Notice that messages built
  61      * by 'notify' need to be encapsulated with information about
  62      * the 'target'.
  63      */
  64   GNUNET_CONNECTION_TransmitReadyNotify notify;
  65
  66     /**
  67      * Closure for 'notify'
  68      */
  69   void *notify_cls;
  70
  71     /**
  72      * How long is this message valid.  Once the timeout has been
  73      * reached, the message must no longer be sent.  If this
  74      * is a message with a 'notify' callback set, the 'notify'
  75      * function should be called with 'buf' NULL and size 0.
  76      */
  77   struct GNUNET_TIME_Absolute timeout;
  78
  79     /**
  80      * Task triggering a timeout, can be NO_TASK if the timeout is FOREVER.
  81      */
  82   struct GNUNET_SCHEDULER_Task * timeout_task;
  83
  84     /**
  85      * Size of 'data' -- or the desired size of 'notify' if 'data' is NULL.
  86      */
  87   size_t size;
  88 };
  89
  90 union CadetInfoCB {
  91
  92   /**
  93    * Channel callback.
  94    */
  95   GNUNET_CADET_ChannelCB channel_cb;
  96
  97   /**
  98    * Monitor callback
  99    */
 100   GNUNET_CADET_PeersCB peers_cb;
 101
 102   /**
 103    * Monitor callback
 104    */
 105   GNUNET_CADET_PeerCB peer_cb;
 106
 107   /**
 108    * Monitor callback
 109    */
 110   GNUNET_CADET_TunnelsCB tunnels_cb;
 111
 112   /**
 113    * Tunnel callback.
 114    */
 115   GNUNET_CADET_TunnelCB tunnel_cb;
 116 };
 117
 118
 119 /**
 120  * Opaque handle to the service.
 121  */
 122 struct GNUNET_CADET_Handle
 123 {
 124
 125     /**
 126      * Handle to the server connection, to send messages later
 127      */
 128   struct GNUNET_CLIENT_Connection *client;
 129
 130     /**
 131      * Set of handlers used for processing incoming messages in the channels
 132      */
 133   const struct GNUNET_CADET_MessageHandler *message_handlers;
 134
 135   /**
 136    * Number of handlers in the handlers array.
 137    */
 138   unsigned int n_handlers;
 139
 140   /**
 141    * Ports open.
 142    */
 143   const uint32_t *ports;
 144
 145   /**
 146    * Number of ports.
 147    */
 148   unsigned int n_ports;
 149
 150     /**
 151      * Double linked list of the channels this client is connected to, head.
 152      */
 153   struct GNUNET_CADET_Channel *channels_head;
 154
 155     /**
 156      * Double linked list of the channels this client is connected to, tail.
 157      */
 158   struct GNUNET_CADET_Channel *channels_tail;
 159
 160     /**
 161      * Callback for inbound channel creation
 162      */
 163   GNUNET_CADET_InboundChannelNotificationHandler *new_channel;
 164
 165     /**
 166      * Callback for inbound channel disconnection
 167      */
 168   GNUNET_CADET_ChannelEndHandler *cleaner;
 169
 170     /**
 171      * Handle to cancel pending transmissions in case of disconnection
 172      */
 173   struct GNUNET_CLIENT_TransmitHandle *th;
 174
 175     /**
 176      * Closure for all the handlers given by the client
 177      */
 178   void *cls;
 179
 180     /**
 181      * Messages to send to the service, head.
 182      */
 183   struct GNUNET_CADET_TransmitHandle *th_head;
 184
 185     /**
 186      * Messages to send to the service, tail.
 187      */
 188   struct GNUNET_CADET_TransmitHandle *th_tail;
 189
 190     /**
 191      * chid of the next channel to create (to avoid reusing IDs often)
 192      */
 193   CADET_ChannelNumber next_chid;
 194
 195     /**
 196      * Have we started the task to receive messages from the service
 197      * yet? We do this after we send the 'CADET_LOCAL_CONNECT' message.
 198      */
 199   int in_receive;
 200
 201   /**
 202    * Configuration given by the client, in case of reconnection
 203    */
 204   const struct GNUNET_CONFIGURATION_Handle *cfg;
 205
 206   /**
 207    * Time to the next reconnect in case one reconnect fails
 208    */
 209   struct GNUNET_TIME_Relative reconnect_time;
 210
 211   /**
 212    * Task for trying to reconnect.
 213    */
 214   struct GNUNET_SCHEDULER_Task * reconnect_task;
 215
 216   /**
 217    * Callback for an info task (only one active at a time).
 218    */
 219   union CadetInfoCB info_cb;
 220
 221   /**
 222    * Info callback closure for @c info_cb.
 223    */
 224   void *info_cls;
 225 };
 226
 227
 228 /**
 229  * Description of a peer
 230  */
 231 struct GNUNET_CADET_Peer
 232 {
 233     /**
 234      * ID of the peer in short form
 235      */
 236   GNUNET_PEER_Id id;
 237
 238   /**
 239    * Channel this peer belongs to
 240    */
 241   struct GNUNET_CADET_Channel *t;
 242 };
 243
 244
 245 /**
 246  * Opaque handle to a channel.
 247  */
 248 struct GNUNET_CADET_Channel
 249 {
 250
 251     /**
 252      * DLL next
 253      */
 254   struct GNUNET_CADET_Channel *next;
 255
 256     /**
 257      * DLL prev
 258      */
 259   struct GNUNET_CADET_Channel *prev;
 260
 261     /**
 262      * Handle to the cadet this channel belongs to
 263      */
 264   struct GNUNET_CADET_Handle *cadet;
 265
 266     /**
 267      * Local ID of the channel
 268      */
 269   CADET_ChannelNumber chid;
 270
 271     /**
 272      * Port number.
 273      */
 274   uint32_t port;
 275
 276     /**
 277      * Other end of the channel.
 278      */
 279   GNUNET_PEER_Id peer;
 280
 281   /**
 282    * Any data the caller wants to put in here
 283    */
 284   void *ctx;
 285
 286     /**
 287      * Size of packet queued in this channel
 288      */
 289   unsigned int packet_size;
 290
 291     /**
 292      * Channel options: reliability, etc.
 293      */
 294   enum GNUNET_CADET_ChannelOption options;
 295
 296     /**
 297      * Are we allowed to send to the service?
 298      */
 299   int allow_send;
 300
 301 };
 302
 303
 304 /**
 305  * Implementation state for cadet's message queue.
 306  */
 307 struct CadetMQState
 308 {
 309   /**
 310    * The current transmit handle, or NULL
 311    * if no transmit is active.
 312    */
 313   struct GNUNET_CADET_TransmitHandle *th;
 314
 315   /**
 316    * Channel to send the data over.
 317    */
 318   struct GNUNET_CADET_Channel *channel;
 319 };
 320
 321
 322 /******************************************************************************/
 323 /***********************         DECLARATIONS         *************************/
 324 /******************************************************************************/
 325
 326 /**
 327  * Function called to send a message to the service.
 328  * "buf" will be NULL and "size" zero if the socket was closed for writing in
 329  * the meantime.
 330  *
 331  * @param cls closure, the cadet handle
 332  * @param size number of bytes available in buf
 333  * @param buf where the callee should write the connect message
 334  * @return number of bytes written to buf
 335  */
 336 static size_t
 337 send_callback (void *cls, size_t size, void *buf);
 338
 339
 340 /******************************************************************************/
 341 /***********************     AUXILIARY FUNCTIONS      *************************/
 342 /******************************************************************************/
 343
 344 /**
 345  * Check if transmission is a payload packet.
 346  *
 347  * @param th Transmission handle.
 348  *
 349  * @return #GNUNET_YES if it is a payload packet,
 350  *         #GNUNET_NO if it is a cadet management packet.
 351  */
 352 static int
 353 th_is_payload (struct GNUNET_CADET_TransmitHandle *th)
 354 {
 355   return (th->notify != NULL) ? GNUNET_YES : GNUNET_NO;
 356 }
 357
 358
 359 /**
 360  * Check whether there is any message ready in the queue and find the size.
 361  *
 362  * @param h Cadet handle.
 363  *
 364  * @return The size of the first ready message in the queue, including overhead.
 365  *         0 if there is none.
 366  */
 367 static size_t
 368 message_ready_size (struct GNUNET_CADET_Handle *h)
 369 {
 370   struct GNUNET_CADET_TransmitHandle *th;
 371   struct GNUNET_CADET_Channel *ch;
 372
 373   for (th = h->th_head; NULL != th; th = th->next)
 374   {
 375     ch = th->channel;
 376     if (GNUNET_NO == th_is_payload (th) || GNUNET_YES == ch->allow_send)
 377       return th->size;
 378   }
 379   return 0;
 380 }
 381
 382
 383 /**
 384  * Get the channel handler for the channel specified by id from the given handle
 385  * @param h Cadet handle
 386  * @param chid ID of the wanted channel
 387  * @return handle to the required channel or NULL if not found
 388  */
 389 static struct GNUNET_CADET_Channel *
 390 retrieve_channel (struct GNUNET_CADET_Handle *h, CADET_ChannelNumber chid)
 391 {
 392   struct GNUNET_CADET_Channel *ch;
 393
 394   ch = h->channels_head;
 395   while (ch != NULL)
 396   {
 397     if (ch->chid == chid)
 398       return ch;
 399     ch = ch->next;
 400   }
 401   return NULL;
 402 }
 403
 404
 405 /**
 406  * Create a new channel and insert it in the channel list of the cadet handle
 407  *
 408  * @param h Cadet handle
 409  * @param chid Desired chid of the channel, 0 to assign one automatically.
 410  *
 411  * @return Handle to the created channel.
 412  */
 413 static struct GNUNET_CADET_Channel *
 414 create_channel (struct GNUNET_CADET_Handle *h, CADET_ChannelNumber chid)
 415 {
 416   struct GNUNET_CADET_Channel *ch;
 417
 418   ch = GNUNET_new (struct GNUNET_CADET_Channel);
 419   GNUNET_CONTAINER_DLL_insert (h->channels_head, h->channels_tail, ch);
 420   ch->cadet = h;
 421   if (0 == chid)
 422   {
 423     ch->chid = h->next_chid;
 424     while (NULL != retrieve_channel (h, h->next_chid))
 425     {
 426       h->next_chid++;
 427       h->next_chid &= ~GNUNET_CADET_LOCAL_CHANNEL_ID_SERV;
 428       h->next_chid |= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI;
 429     }
 430   }
 431   else
 432   {
 433     ch->chid = chid;
 434   }
 435   ch->allow_send = GNUNET_NO;
 436   return ch;
 437 }
 438
 439
 440 /**
 441  * Destroy the specified channel.
 442  * - Destroys all peers, calling the disconnect callback on each if needed
 443  * - Cancels all outgoing traffic for that channel, calling respective notifys
 444  * - Calls cleaner if channel was inbound
 445  * - Frees all memory used
 446  *
 447  * @param ch Pointer to the channel.
 448  * @param call_cleaner Whether to call the cleaner handler.
 449  *
 450  * @return Handle to the required channel or NULL if not found.
 451  */
 452 static void
 453 destroy_channel (struct GNUNET_CADET_Channel *ch, int call_cleaner)
 454 {
 455   struct GNUNET_CADET_Handle *h;
 456   struct GNUNET_CADET_TransmitHandle *th;
 457   struct GNUNET_CADET_TransmitHandle *next;
 458
 459   LOG (GNUNET_ERROR_TYPE_DEBUG, " destroy_channel %X\n", ch->chid);
 460
 461   if (NULL == ch)
 462   {
 463     GNUNET_break (0);
 464     return;
 465   }
 466   h = ch->cadet;
 467
 468   GNUNET_CONTAINER_DLL_remove (h->channels_head, h->channels_tail, ch);
 469
 470   /* signal channel destruction */
 471   if ( (NULL != h->cleaner) && (0 != ch->peer) && (GNUNET_YES == call_cleaner) )
 472   {
 473     LOG (GNUNET_ERROR_TYPE_DEBUG, " calling cleaner\n");
 474     h->cleaner (h->cls, ch, ch->ctx);
 475   }
 476
 477   /* check that clients did not leave messages behind in the queue */
 478   for (th = h->th_head; NULL != th; th = next)
 479   {
 480     next = th->next;
 481     if (th->channel != ch)
 482       continue;
 483     /* Clients should have aborted their requests already.
 484      * Management traffic should be ok, as clients can't cancel that.
 485      * If the service crashed and we are reconnecting, it's ok.
 486      */
 487     GNUNET_break (GNUNET_NO == th_is_payload (th)
 488                   || GNUNET_NO == h->in_receive);
 489     GNUNET_CONTAINER_DLL_remove (h->th_head, h->th_tail, th);
 490
 491     /* clean up request */
 492     if (NULL != th->timeout_task)
 493       GNUNET_SCHEDULER_cancel (th->timeout_task);
 494     GNUNET_free (th);
 495   }
 496
 497   /* if there are no more pending requests with cadet service, cancel active request */
 498   /* Note: this should be unnecessary... */
 499   if ((0 == message_ready_size (h)) && (NULL != h->th))
 500   {
 501     GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
 502     h->th = NULL;
 503   }
 504
 505   if (0 != ch->peer)
 506     GNUNET_PEER_change_rc (ch->peer, -1);
 507   GNUNET_free (ch);
 508   return;
 509 }
 510
 511
 512 /**
 513  * Notify client that the transmission has timed out
 514  *
 515  * @param cls closure
 516  * @param tc task context
 517  */
 518 static void
 519 timeout_transmission (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 520 {
 521   struct GNUNET_CADET_TransmitHandle *th = cls;
 522   struct GNUNET_CADET_Handle *cadet = th->channel->cadet;
 523
 524   th->timeout_task = NULL;
 525   th->channel->packet_size = 0;
 526   GNUNET_CONTAINER_DLL_remove (cadet->th_head, cadet->th_tail, th);
 527   if (GNUNET_YES == th_is_payload (th))
 528     GNUNET_break (0 == th->notify (th->notify_cls, 0, NULL));
 529   GNUNET_free (th);
 530   if ((0 == message_ready_size (cadet)) && (NULL != cadet->th))
 531   {
 532     /* nothing ready to transmit, no point in asking for transmission */
 533     GNUNET_CLIENT_notify_transmit_ready_cancel (cadet->th);
 534     cadet->th = NULL;
 535   }
 536 }
 537
 538
 539 /**
 540  * Add a transmit handle to the transmission queue and set the
 541  * timeout if needed.
 542  *
 543  * @param h cadet handle with the queue head and tail
 544  * @param th handle to the packet to be transmitted
 545  */
 546 static void
 547 add_to_queue (struct GNUNET_CADET_Handle *h,
 548               struct GNUNET_CADET_TransmitHandle *th)
 549 {
 550   GNUNET_CONTAINER_DLL_insert_tail (h->th_head, h->th_tail, th);
 551   if (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us == th->timeout.abs_value_us)
 552     return;
 553   th->timeout_task =
 554       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
 555                                     (th->timeout), &timeout_transmission, th);
 556 }
 557
 558
 559 /**
 560  * Auxiliary function to send an already constructed packet to the service.
 561  * Takes care of creating a new queue element, copying the message and
 562  * calling the tmt_rdy function if necessary.
 563  *
 564  * @param h cadet handle
 565  * @param msg message to transmit
 566  * @param channel channel this send is related to (NULL if N/A)
 567  */
 568 static void
 569 send_packet (struct GNUNET_CADET_Handle *h,
 570              const struct GNUNET_MessageHeader *msg,
 571              struct GNUNET_CADET_Channel *channel);
 572
 573
 574 /**
 575  * Send an ack on the channel to confirm the processing of a message.
 576  *
 577  * @param ch Channel on which to send the ACK.
 578  */
 579 static void
 580 send_ack (struct GNUNET_CADET_Channel *ch)
 581 {
 582   struct GNUNET_CADET_LocalAck msg;
 583
 584   LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending ACK on channel %X\n", ch->chid);
 585   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK);
 586   msg.header.size = htons (sizeof (msg));
 587   msg.channel_id = htonl (ch->chid);
 588
 589   send_packet (ch->cadet, &msg.header, ch);
 590   return;
 591 }
 592
 593
 594
 595 /**
 596  * Reconnect callback: tries to reconnect again after a failer previous
 597  * reconnecttion
 598  * @param cls closure (cadet handle)
 599  * @param tc task context
 600  */
 601 static void
 602 reconnect_cbk (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 603
 604
 605 /**
 606  * Send a connect packet to the service with the applications and types
 607  * requested by the user.
 608  *
 609  * @param h The cadet handle.
 610  *
 611  */
 612 static void
 613 send_connect (struct GNUNET_CADET_Handle *h)
 614 {
 615   size_t size;
 616
 617   size = sizeof (struct GNUNET_CADET_ClientConnect);
 618   size += h->n_ports * sizeof (uint32_t);
 619   {
 620     char buf[size] GNUNET_ALIGN;
 621     struct GNUNET_CADET_ClientConnect *msg;
 622     uint32_t *ports;
 623     uint16_t i;
 624
 625     /* build connection packet */
 626     msg = (struct GNUNET_CADET_ClientConnect *) buf;
 627     msg->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_LOCAL_CONNECT);
 628     msg->header.size = htons (size);
 629     ports = (uint32_t *) &msg[1];
 630     for (i = 0; i < h->n_ports; i++)
 631     {
 632       ports[i] = htonl (h->ports[i]);
 633       LOG (GNUNET_ERROR_TYPE_DEBUG, " port %u\n",
 634            h->ports[i]);
 635     }
 636     LOG (GNUNET_ERROR_TYPE_DEBUG,
 637          "Sending %lu bytes long message with %u ports\n",
 638          ntohs (msg->header.size), h->n_ports);
 639     send_packet (h, &msg->header, NULL);
 640   }
 641 }
 642
 643
 644 /**
 645  * Reconnect to the service, retransmit all infomation to try to restore the
 646  * original state.
 647  *
 648  * @param h handle to the cadet
 649  *
 650  * @return GNUNET_YES in case of sucess, GNUNET_NO otherwise (service down...)
 651  */
 652 static int
 653 do_reconnect (struct GNUNET_CADET_Handle *h)
 654 {
 655   LOG (GNUNET_ERROR_TYPE_DEBUG, "*****************************\n");
 656   LOG (GNUNET_ERROR_TYPE_DEBUG, "*******   RECONNECT   *******\n");
 657   LOG (GNUNET_ERROR_TYPE_DEBUG, "*****************************\n");
 658   LOG (GNUNET_ERROR_TYPE_DEBUG, "******** on %p *******\n", h);
 659   LOG (GNUNET_ERROR_TYPE_DEBUG, "*****************************\n");
 660
 661   /* disconnect */
 662   if (NULL != h->th)
 663   {
 664     GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
 665     h->th = NULL;
 666   }
 667   if (NULL != h->client)
 668   {
 669     GNUNET_CLIENT_disconnect (h->client);
 670   }
 671
 672   /* connect again */
 673   h->client = GNUNET_CLIENT_connect ("cadet", h->cfg);
 674   if (h->client == NULL)
 675   {
 676     h->reconnect_task = GNUNET_SCHEDULER_add_delayed (h->reconnect_time,
 677                                                       &reconnect_cbk, h);
 678     h->reconnect_time =
 679         GNUNET_TIME_relative_min (GNUNET_TIME_UNIT_SECONDS,
 680                                   GNUNET_TIME_relative_multiply
 681                                   (h->reconnect_time, 2));
 682     LOG (GNUNET_ERROR_TYPE_DEBUG, "Next retry in %s\n",
 683          GNUNET_STRINGS_relative_time_to_string (h->reconnect_time,
 684                                                  GNUNET_NO));
 685     GNUNET_break (0);
 686     return GNUNET_NO;
 687   }
 688   else
 689   {
 690     h->reconnect_time = GNUNET_TIME_UNIT_MILLISECONDS;
 691   }
 692   send_connect (h);
 693   return GNUNET_YES;
 694 }
 695
 696 /**
 697  * Reconnect callback: tries to reconnect again after a failer previous
 698  * reconnecttion
 699  * @param cls closure (cadet handle)
 700  * @param tc task context
 701  */
 702 static void
 703 reconnect_cbk (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 704 {
 705   struct GNUNET_CADET_Handle *h = cls;
 706
 707   h->reconnect_task = NULL;
 708   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 709     return;
 710   do_reconnect (h);
 711 }
 712
 713
 714 /**
 715  * Reconnect to the service, retransmit all infomation to try to restore the
 716  * original state.
 717  *
 718  * @param h handle to the cadet
 719  *
 720  * @return GNUNET_YES in case of sucess, GNUNET_NO otherwise (service down...)
 721  */
 722 static void
 723 reconnect (struct GNUNET_CADET_Handle *h)
 724 {
 725   struct GNUNET_CADET_Channel *ch;
 726   struct GNUNET_CADET_Channel *next;
 727
 728   LOG (GNUNET_ERROR_TYPE_DEBUG,
 729        "Requested RECONNECT, destroying all channels\n");
 730   h->in_receive = GNUNET_NO;
 731   for (ch = h->channels_head; NULL != ch; ch = next)
 732   {
 733     next = ch->next;
 734     destroy_channel (ch, GNUNET_YES);
 735   }
 736   if (NULL == h->reconnect_task)
 737     h->reconnect_task = GNUNET_SCHEDULER_add_delayed (h->reconnect_time,
 738                                                       &reconnect_cbk, h);
 739 }
 740
 741
 742 /******************************************************************************/
 743 /***********************      RECEIVE HANDLERS     ****************************/
 744 /******************************************************************************/
 745
 746 /**
 747  * Process the new channel notification and add it to the channels in the handle
 748  *
 749  * @param h     The cadet handle
 750  * @param msg   A message with the details of the new incoming channel
 751  */
 752 static void
 753 process_channel_created (struct GNUNET_CADET_Handle *h,
 754                         const struct GNUNET_CADET_ChannelMessage *msg)
 755 {
 756   struct GNUNET_CADET_Channel *ch;
 757   CADET_ChannelNumber chid;
 758   uint32_t port;
 759
 760   chid = ntohl (msg->channel_id);
 761   port = ntohl (msg->port);
 762   LOG (GNUNET_ERROR_TYPE_DEBUG, "Creating incoming channel %X:%u\n", chid, port);
 763   if (chid < GNUNET_CADET_LOCAL_CHANNEL_ID_SERV)
 764   {
 765     GNUNET_break (0);
 766     return;
 767   }
 768   if (NULL != h->new_channel)
 769   {
 770     void *ctx;
 771
 772     ch = create_channel (h, chid);
 773     ch->allow_send = GNUNET_NO;
 774     ch->peer = GNUNET_PEER_intern (&msg->peer);
 775     ch->cadet = h;
 776     ch->chid = chid;
 777     ch->port = port;
 778     ch->options = ntohl (msg->opt);
 779
 780     LOG (GNUNET_ERROR_TYPE_DEBUG, "  created channel %p\n", ch);
 781     ctx = h->new_channel (h->cls, ch, &msg->peer, ch->port, ch->options);
 782     if (NULL != ctx)
 783       ch->ctx = ctx;
 784     LOG (GNUNET_ERROR_TYPE_DEBUG, "User notified\n");
 785   }
 786   else
 787   {
 788     struct GNUNET_CADET_ChannelMessage d_msg;
 789
 790     LOG (GNUNET_ERROR_TYPE_DEBUG, "No handler for incoming channels\n");
 791
 792     d_msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY);
 793     d_msg.header.size = htons (sizeof (struct GNUNET_CADET_ChannelMessage));
 794     d_msg.channel_id = msg->channel_id;
 795     memset (&d_msg.peer, 0, sizeof (struct GNUNET_PeerIdentity));
 796     d_msg.port = 0;
 797     d_msg.opt = 0;
 798
 799     send_packet (h, &d_msg.header, NULL);
 800   }
 801   return;
 802 }
 803
 804
 805 /**
 806  * Process the channel destroy notification and free associated resources
 807  *
 808  * @param h     The cadet handle
 809  * @param msg   A message with the details of the channel being destroyed
 810  */
 811 static void
 812 process_channel_destroy (struct GNUNET_CADET_Handle *h,
 813                          const struct GNUNET_CADET_ChannelMessage *msg)
 814 {
 815   struct GNUNET_CADET_Channel *ch;
 816   CADET_ChannelNumber chid;
 817
 818   LOG (GNUNET_ERROR_TYPE_DEBUG, "Channel Destroy received from service\n");
 819   chid = ntohl (msg->channel_id);
 820   ch = retrieve_channel (h, chid);
 821
 822   if (NULL == ch)
 823   {
 824     LOG (GNUNET_ERROR_TYPE_DEBUG, "channel %X unknown\n", chid);
 825     return;
 826   }
 827   LOG (GNUNET_ERROR_TYPE_DEBUG, " destroying channel %X\n", ch->chid);
 828   destroy_channel (ch, GNUNET_YES);
 829 }
 830
 831
 832 /**
 833  * Process the incoming data packets, call appropriate handlers.
 834  *
 835  * @param h         The cadet handle
 836  * @param message   A message encapsulating the data
 837  */
 838 static void
 839 process_incoming_data (struct GNUNET_CADET_Handle *h,
 840                        const struct GNUNET_MessageHeader *message)
 841 {
 842   const struct GNUNET_MessageHeader *payload;
 843   const struct GNUNET_CADET_MessageHandler *handler;
 844   struct GNUNET_CADET_LocalData *dmsg;
 845   struct GNUNET_CADET_Channel *ch;
 846   size_t size;
 847   unsigned int i;
 848   uint16_t type;
 849
 850   LOG (GNUNET_ERROR_TYPE_DEBUG, "Got a data message!\n");
 851   dmsg = (struct GNUNET_CADET_LocalData *) message;
 852   ch = retrieve_channel (h, ntohl (dmsg->id));
 853   if (NULL == ch)
 854   {
 855     GNUNET_break (0);
 856     return;
 857   }
 858
 859   payload = (struct GNUNET_MessageHeader *) &dmsg[1];
 860   LOG (GNUNET_ERROR_TYPE_DEBUG, "  %s data on channel %s [%X]\n",
 861        GC_f2s (ch->chid >= GNUNET_CADET_LOCAL_CHANNEL_ID_SERV),
 862        GNUNET_i2s (GNUNET_PEER_resolve2 (ch->peer)), ntohl (dmsg->id));
 863
 864   size = ntohs (message->size);
 865   LOG (GNUNET_ERROR_TYPE_DEBUG, "  %u bytes\n", size);
 866
 867   type = ntohs (payload->type);
 868   size = ntohs (payload->size);
 869   LOG (GNUNET_ERROR_TYPE_DEBUG, "  payload type %s\n", GC_m2s (type));
 870   for (i = 0; i < h->n_handlers; i++)
 871   {
 872     handler = &h->message_handlers[i];
 873     LOG (GNUNET_ERROR_TYPE_DEBUG, "    checking handler for type %u\n",
 874          handler->type);
 875     if (handler->type == type)
 876     {
 877       if (GNUNET_OK !=
 878           handler->callback (h->cls, ch, &ch->ctx, payload))
 879       {
 880         LOG (GNUNET_ERROR_TYPE_DEBUG, "callback caused disconnection\n");
 881         GNUNET_CADET_channel_destroy (ch);
 882         return;
 883       }
 884       else
 885       {
 886         LOG (GNUNET_ERROR_TYPE_DEBUG,
 887              "callback completed successfully\n");
 888         return;
 889       }
 890     }
 891   }
 892 }
 893
 894
 895 /**
 896  * Process a local ACK message, enabling the client to send
 897  * more data to the service.
 898  *
 899  * @param h Cadet handle.
 900  * @param message Message itself.
 901  */
 902 static void
 903 process_ack (struct GNUNET_CADET_Handle *h,
 904              const struct GNUNET_MessageHeader *message)
 905 {
 906   struct GNUNET_CADET_LocalAck *msg;
 907   struct GNUNET_CADET_Channel *ch;
 908   CADET_ChannelNumber chid;
 909
 910   LOG (GNUNET_ERROR_TYPE_DEBUG, "Got an ACK!\n");
 911   msg = (struct GNUNET_CADET_LocalAck *) message;
 912   chid = ntohl (msg->channel_id);
 913   ch = retrieve_channel (h, chid);
 914   if (NULL == ch)
 915   {
 916     LOG (GNUNET_ERROR_TYPE_DEBUG, "ACK on unknown channel %X\n", chid);
 917     return;
 918   }
 919   LOG (GNUNET_ERROR_TYPE_DEBUG, "  on channel %X!\n", ch->chid);
 920   ch->allow_send = GNUNET_YES;
 921   if (NULL == h->th && 0 < ch->packet_size)
 922   {
 923     LOG (GNUNET_ERROR_TYPE_DEBUG, "  tmt rdy was NULL, requesting!\n");
 924     h->th = GNUNET_CLIENT_notify_transmit_ready (h->client, ch->packet_size,
 925                                                  GNUNET_TIME_UNIT_FOREVER_REL,
 926                                                  GNUNET_YES, &send_callback, h);
 927   }
 928 }
 929
 930
 931 /*
 932  * Process a local reply about info on all channels, pass info to the user.
 933  *
 934  * @param h Cadet handle.
 935  * @param message Message itself.
 936  */
 937 // static void
 938 // process_get_channels (struct GNUNET_CADET_Handle *h,
 939 //                      const struct GNUNET_MessageHeader *message)
 940 // {
 941 //   struct GNUNET_CADET_LocalInfo *msg;
 942 //
 943 //   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Get Channels messasge received\n");
 944 //
 945 //   if (NULL == h->channels_cb)
 946 //   {
 947 //     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "  ignored\n");
 948 //     return;
 949 //   }
 950 //
 951 //   msg = (struct GNUNET_CADET_LocalInfo *) message;
 952 //   if (ntohs (message->size) !=
 953 //       (sizeof (struct GNUNET_CADET_LocalInfo) +
 954 //        sizeof (struct GNUNET_PeerIdentity)))
 955 //   {
 956 //     GNUNET_break_op (0);
 957 //     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 958 //                 "Get channels message: size %hu - expected %u\n",
 959 //                 ntohs (message->size),
 960 //                 sizeof (struct GNUNET_CADET_LocalInfo));
 961 //     return;
 962 //   }
 963 //   h->channels_cb (h->channels_cls,
 964 //                   ntohl (msg->channel_id),
 965 //                   &msg->owner,
 966 //                   &msg->destination);
 967 // }
 968
 969
 970
 971 /*
 972  * Process a local monitor_channel reply, pass info to the user.
 973  *
 974  * @param h Cadet handle.
 975  * @param message Message itself.
 976  */
 977 // static void
 978 // process_show_channel (struct GNUNET_CADET_Handle *h,
 979 //                      const struct GNUNET_MessageHeader *message)
 980 // {
 981 //   struct GNUNET_CADET_LocalInfo *msg;
 982 //   size_t esize;
 983 //
 984 //   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Show Channel messasge received\n");
 985 //
 986 //   if (NULL == h->channel_cb)
 987 //   {
 988 //     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "  ignored\n");
 989 //     return;
 990 //   }
 991 //
 992 //   /* Verify message sanity */
 993 //   msg = (struct GNUNET_CADET_LocalInfo *) message;
 994 //   esize = sizeof (struct GNUNET_CADET_LocalInfo);
 995 //   if (ntohs (message->size) != esize)
 996 //   {
 997 //     GNUNET_break_op (0);
 998 //     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 999 //                 "Show channel message: size %hu - expected %u\n",
1000 //                 ntohs (message->size),
1001 //                 esize);
1002 //
1003 //     h->channel_cb (h->channel_cls, NULL, NULL);
1004 //     h->channel_cb = NULL;
1005 //     h->channel_cls = NULL;
1006 //
1007 //     return;
1008 //   }
1009 //
1010 //   h->channel_cb (h->channel_cls,
1011 //                  &msg->destination,
1012 //                  &msg->owner);
1013 // }
1014
1015
1016
1017 /**
1018  * Process a local reply about info on all tunnels, pass info to the user.
1019  *
1020  * @param h Cadet handle.
1021  * @param message Message itself.
1022  */
1023 static void
1024 process_get_peers (struct GNUNET_CADET_Handle *h,
1025                      const struct GNUNET_MessageHeader *message)
1026 {
1027   struct GNUNET_CADET_LocalInfoPeer *msg;
1028   uint16_t size;
1029
1030   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Get Peer messasge received\n");
1031
1032   if (NULL == h->info_cb.peers_cb)
1033   {
1034     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  ignored\n");
1035     return;
1036   }
1037
1038   size = ntohs (message->size);
1039   if (sizeof (struct GNUNET_CADET_LocalInfoPeer) > size)
1040   {
1041     h->info_cb.peers_cb (h->info_cls, NULL, -1, 0, 0);
1042     h->info_cb.peers_cb = NULL;
1043     h->info_cls = NULL;
1044     return;
1045   }
1046
1047   msg = (struct GNUNET_CADET_LocalInfoPeer *) message;
1048   h->info_cb.peers_cb (h->info_cls, &msg->destination,
1049                        (int) ntohs (msg->tunnel),
1050                        (unsigned int ) ntohs (msg->paths),
1051                        0);
1052 }
1053
1054
1055 /**
1056  * Process a local peer info reply, pass info to the user.
1057  *
1058  * @param h Cadet handle.
1059  * @param message Message itself.
1060  */
1061 static void
1062 process_get_peer (struct GNUNET_CADET_Handle *h,
1063                   const struct GNUNET_MessageHeader *message)
1064 {
1065   struct GNUNET_CADET_LocalInfoTunnel *msg;
1066   size_t esize;
1067   size_t msize;
1068
1069   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Get Tunnel messasge received\n");
1070   if (NULL == h->info_cb.peer_cb)
1071   {
1072     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  ignored\n");
1073     return;
1074   }
1075
1076   /* Verify message sanity */
1077   msg = (struct GNUNET_CADET_LocalInfoTunnel *) message;
1078   msize = ntohs (message->size);
1079   esize = sizeof (struct GNUNET_CADET_LocalInfoPeer);
1080   if (esize > msize)
1081   {
1082     GNUNET_break_op (0);
1083     h->info_cb.peer_cb (h->info_cls, NULL, 0, 0, 0, NULL);
1084     goto clean_cls;
1085   }
1086 //   esize += ch_n * sizeof (CADET_ChannelNumber);
1087 //   esize += c_n * sizeof (struct GNUNET_CADET_Hash);
1088   if (msize != esize)
1089   {
1090     GNUNET_break_op (0);
1091     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "m:%u, e: %u\n", msize, esize);
1092     h->info_cb.peer_cb (h->info_cls, NULL, 0, 0, 0, NULL);
1093     goto clean_cls;
1094   }
1095
1096   /* Call Callback with tunnel info. */
1097   h->info_cb.peer_cb (h->info_cls, &msg->destination, 0, 0, 0, NULL);
1098
1099   clean_cls:
1100   h->info_cb.peer_cb = NULL;
1101   h->info_cls = NULL;
1102 }
1103
1104
1105 /**
1106  * Process a local reply about info on all tunnels, pass info to the user.
1107  *
1108  * @param h Cadet handle.
1109  * @param message Message itself.
1110  */
1111 static void
1112 process_get_tunnels (struct GNUNET_CADET_Handle *h,
1113                      const struct GNUNET_MessageHeader *message)
1114 {
1115   struct GNUNET_CADET_LocalInfoTunnel *msg;
1116   uint16_t size;
1117
1118   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Get Tunnels messasge received\n");
1119
1120   if (NULL == h->info_cb.tunnels_cb)
1121   {
1122     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  ignored\n");
1123     return;
1124   }
1125
1126   size = ntohs (message->size);
1127   if (sizeof (struct GNUNET_CADET_LocalInfoTunnel) > size)
1128   {
1129     h->info_cb.tunnels_cb (h->info_cls, NULL, 0, 0, 0, 0);
1130     h->info_cb.tunnels_cb = NULL;
1131     h->info_cls = NULL;
1132     return;
1133   }
1134
1135   msg = (struct GNUNET_CADET_LocalInfoTunnel *) message;
1136   h->info_cb.tunnels_cb (h->info_cls, &msg->destination,
1137                          ntohl (msg->channels), ntohl (msg->connections),
1138                          ntohs (msg->estate), ntohs (msg->cstate));
1139
1140 }
1141
1142
1143 /**
1144  * Process a local tunnel info reply, pass info to the user.
1145  *
1146  * @param h Cadet handle.
1147  * @param message Message itself.
1148  */
1149 static void
1150 process_get_tunnel (struct GNUNET_CADET_Handle *h,
1151                     const struct GNUNET_MessageHeader *message)
1152 {
1153   struct GNUNET_CADET_LocalInfoTunnel *msg;
1154   size_t esize;
1155   size_t msize;
1156   unsigned int ch_n;
1157   unsigned int c_n;
1158   struct GNUNET_CADET_Hash *conns;
1159   CADET_ChannelNumber *chns;
1160
1161   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Get Tunnel messasge received\n");
1162   if (NULL == h->info_cb.tunnel_cb)
1163   {
1164     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  ignored\n");
1165     return;
1166   }
1167
1168   /* Verify message sanity */
1169   msg = (struct GNUNET_CADET_LocalInfoTunnel *) message;
1170   msize = ntohs (message->size);
1171   esize = sizeof (struct GNUNET_CADET_LocalInfoTunnel);
1172   if (esize > msize)
1173   {
1174     GNUNET_break_op (0);
1175     h->info_cb.tunnel_cb (h->info_cls, NULL, 0, 0, NULL, NULL, 0, 0);
1176     goto clean_cls;
1177   }
1178   ch_n = ntohl (msg->channels);
1179   c_n = ntohl (msg->connections);
1180   esize += ch_n * sizeof (CADET_ChannelNumber);
1181   esize += c_n * sizeof (struct GNUNET_CADET_Hash);
1182   if (msize != esize)
1183   {
1184     GNUNET_break_op (0);
1185     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "m:%u, e: %u (%u ch, %u conn)\n",
1186                 msize, esize, ch_n, c_n);
1187     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%u (%u ch, %u conn)\n",
1188                 sizeof (struct GNUNET_CADET_LocalInfoTunnel),
1189                 sizeof (CADET_ChannelNumber), sizeof (struct GNUNET_HashCode));
1190     h->info_cb.tunnel_cb (h->info_cls, NULL, 0, 0, NULL, NULL, 0, 0);
1191     goto clean_cls;
1192   }
1193
1194   /* Call Callback with tunnel info. */
1195   conns = (struct GNUNET_CADET_Hash *) &msg[1];
1196   chns = (CADET_ChannelNumber *) &conns[c_n];
1197   h->info_cb.tunnel_cb (h->info_cls, &msg->destination,
1198                 ch_n, c_n, chns, conns,
1199                 ntohs (msg->estate), ntohs (msg->cstate));
1200
1201 clean_cls:
1202   h->info_cb.tunnel_cb = NULL;
1203   h->info_cls = NULL;
1204 }
1205
1206
1207 /**
1208  * Function to process all messages received from the service
1209  *
1210  * @param cls closure
1211  * @param msg message received, NULL on timeout or fatal error
1212  */
1213 static void
1214 msg_received (void *cls, const struct GNUNET_MessageHeader *msg)
1215 {
1216   struct GNUNET_CADET_Handle *h = cls;
1217   uint16_t type;
1218
1219   if (msg == NULL)
1220   {
1221     LOG (GNUNET_ERROR_TYPE_DEBUG,
1222          "Cadet service disconnected, reconnecting\n", h);
1223     reconnect (h);
1224     return;
1225   }
1226   type = ntohs (msg->type);
1227   LOG (GNUNET_ERROR_TYPE_DEBUG, "\n");
1228   LOG (GNUNET_ERROR_TYPE_DEBUG, "Received a message: %s\n",
1229        GC_m2s (type));
1230   switch (type)
1231   {
1232     /* Notify of a new incoming channel */
1233   case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE:
1234     process_channel_created (h, (struct GNUNET_CADET_ChannelMessage *) msg);
1235     break;
1236     /* Notify of a channel disconnection */
1237   case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY: /* TODO separate(gid problem)*/
1238   case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_NACK:
1239     process_channel_destroy (h, (struct GNUNET_CADET_ChannelMessage *) msg);
1240     break;
1241   case GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA:
1242     process_incoming_data (h, msg);
1243     break;
1244   case GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK:
1245     process_ack (h, msg);
1246     break;
1247 //   case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNELS:
1248 //     process_get_channels (h, msg);
1249 //     break;
1250 //   case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNEL:
1251 //     process_show_channel (h, msg);
1252 //     break;
1253   case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS:
1254     process_get_peers (h, msg);
1255     break;
1256   case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER:
1257     process_get_peer (h, msg);
1258     break;
1259   case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS:
1260     process_get_tunnels (h, msg);
1261     break;
1262   case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL:
1263     process_get_tunnel (h, msg);
1264     break;
1265 //   case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNEL:
1266 //     process_show_channel (h, msg);
1267 //     break;
1268   default:
1269     /* We shouldn't get any other packages, log and ignore */
1270     LOG (GNUNET_ERROR_TYPE_WARNING,
1271          "unsolicited message form service (type %s)\n",
1272          GC_m2s (ntohs (msg->type)));
1273   }
1274   LOG (GNUNET_ERROR_TYPE_DEBUG, "message processed\n");
1275   if (GNUNET_YES == h->in_receive)
1276   {
1277     GNUNET_CLIENT_receive (h->client, &msg_received, h,
1278                            GNUNET_TIME_UNIT_FOREVER_REL);
1279   }
1280   else
1281   {
1282     LOG (GNUNET_ERROR_TYPE_DEBUG,
1283          "in receive off, not calling CLIENT_receive\n");
1284   }
1285 }
1286
1287
1288 /******************************************************************************/
1289 /************************       SEND FUNCTIONS     ****************************/
1290 /******************************************************************************/
1291
1292 /**
1293  * Function called to send a message to the service.
1294  * "buf" will be NULL and "size" zero if the socket was closed for writing in
1295  * the meantime.
1296  *
1297  * @param cls closure, the cadet handle
1298  * @param size number of bytes available in buf
1299  * @param buf where the callee should write the connect message
1300  * @return number of bytes written to buf
1301  */
1302 static size_t
1303 send_callback (void *cls, size_t size, void *buf)
1304 {
1305   struct GNUNET_CADET_Handle *h = cls;
1306   struct GNUNET_CADET_TransmitHandle *th;
1307   struct GNUNET_CADET_TransmitHandle *next;
1308   struct GNUNET_CADET_Channel *ch;
1309   char *cbuf = buf;
1310   size_t tsize;
1311   size_t psize;
1312   size_t nsize;
1313
1314   LOG (GNUNET_ERROR_TYPE_DEBUG, "\n");
1315   LOG (GNUNET_ERROR_TYPE_DEBUG, "# Send callback, buffer %u\n", size);
1316   if ((0 == size) || (NULL == buf))
1317   {
1318     LOG (GNUNET_ERROR_TYPE_DEBUG, "# Received NULL send callback on %p\n", h);
1319     reconnect (h);
1320     h->th = NULL;
1321     return 0;
1322   }
1323   tsize = 0;
1324   next = h->th_head;
1325   nsize = message_ready_size (h);
1326   while ((NULL != (th = next)) && (0 < nsize) && (size >= nsize))
1327   {
1328     ch = th->channel;
1329     if (GNUNET_YES == th_is_payload (th))
1330     {
1331       struct GNUNET_CADET_LocalData *dmsg;
1332       struct GNUNET_MessageHeader *mh;
1333
1334       LOG (GNUNET_ERROR_TYPE_DEBUG, "#  payload\n");
1335       if (GNUNET_NO == ch->allow_send)
1336       {
1337         /* This channel is not ready to transmit yet, Try the next message */
1338         next = th->next;
1339         continue;
1340       }
1341       ch->packet_size = 0;
1342       GNUNET_assert (size >= th->size);
1343       dmsg = (struct GNUNET_CADET_LocalData *) cbuf;
1344       mh = (struct GNUNET_MessageHeader *) &dmsg[1];
1345       psize = th->notify (th->notify_cls, size - DATA_OVERHEAD, mh);
1346
1347       if (psize > 0)
1348       {
1349         GNUNET_assert (sizeof (struct GNUNET_MessageHeader) <= psize);
1350         psize += DATA_OVERHEAD;
1351         GNUNET_assert (size >= psize);
1352         dmsg->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA);
1353         dmsg->header.size = htons (psize);
1354         dmsg->id = htonl (ch->chid);
1355         LOG (GNUNET_ERROR_TYPE_DEBUG, "#  payload type %s\n",
1356              GC_m2s (ntohs (mh->type)));
1357         ch->allow_send = GNUNET_NO;
1358       }
1359       else
1360       {
1361         LOG (GNUNET_ERROR_TYPE_DEBUG,
1362              "#  callback returned size 0, "
1363              "application canceled transmission\n");
1364       }
1365     }
1366     else
1367     {
1368       const struct GNUNET_MessageHeader *mh;
1369
1370       mh = (const struct GNUNET_MessageHeader *) &th[1];
1371       LOG (GNUNET_ERROR_TYPE_DEBUG, "#  cadet internal traffic, type %s\n",
1372            GC_m2s (ntohs (mh->type)));
1373       memcpy (cbuf, &th[1], th->size);
1374       psize = th->size;
1375     }
1376     GNUNET_assert (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE >= psize);
1377     if (th->timeout_task != NULL)
1378       GNUNET_SCHEDULER_cancel (th->timeout_task);
1379     next = th->next;
1380     GNUNET_CONTAINER_DLL_remove (h->th_head, h->th_tail, th);
1381     GNUNET_free (th);
1382     nsize = message_ready_size (h);
1383     cbuf += psize;
1384     size -= psize;
1385     tsize += psize;
1386   }
1387   LOG (GNUNET_ERROR_TYPE_DEBUG, "#  total size: %u\n", tsize);
1388   h->th = NULL;
1389   size = message_ready_size (h);
1390   if (0 != size)
1391   {
1392     LOG (GNUNET_ERROR_TYPE_DEBUG, "#  next size: %u\n", size);
1393     h->th =
1394         GNUNET_CLIENT_notify_transmit_ready (h->client, size,
1395                                              GNUNET_TIME_UNIT_FOREVER_REL,
1396                                              GNUNET_YES, &send_callback, h);
1397   }
1398   else
1399   {
1400     if (NULL != h->th_head)
1401       LOG (GNUNET_ERROR_TYPE_DEBUG, "#  can't transmit any more\n");
1402     else
1403       LOG (GNUNET_ERROR_TYPE_DEBUG, "#  nothing left to transmit\n");
1404   }
1405   if (GNUNET_NO == h->in_receive)
1406   {
1407     LOG (GNUNET_ERROR_TYPE_DEBUG, "# start receiving from service\n");
1408     h->in_receive = GNUNET_YES;
1409     GNUNET_CLIENT_receive (h->client, &msg_received, h,
1410                            GNUNET_TIME_UNIT_FOREVER_REL);
1411   }
1412   LOG (GNUNET_ERROR_TYPE_DEBUG, "# Send packet() END\n");
1413   return tsize;
1414 }
1415
1416
1417 /**
1418  * Auxiliary function to send an already constructed packet to the service.
1419  * Takes care of creating a new queue element, copying the message and
1420  * calling the tmt_rdy function if necessary.
1421  *
1422  * @param h cadet handle
1423  * @param msg message to transmit
1424  * @param channel channel this send is related to (NULL if N/A)
1425  */
1426 static void
1427 send_packet (struct GNUNET_CADET_Handle *h,
1428              const struct GNUNET_MessageHeader *msg,
1429              struct GNUNET_CADET_Channel *channel)
1430 {
1431   struct GNUNET_CADET_TransmitHandle *th;
1432   size_t msize;
1433
1434   LOG (GNUNET_ERROR_TYPE_DEBUG, " Sending message to service: %s\n",
1435        GC_m2s(ntohs(msg->type)));
1436   msize = ntohs (msg->size);
1437   th = GNUNET_malloc (sizeof (struct GNUNET_CADET_TransmitHandle) + msize);
1438   th->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
1439   th->size = msize;
1440   th->channel = channel;
1441   memcpy (&th[1], msg, msize);
1442   add_to_queue (h, th);
1443   if (NULL != h->th)
1444     return;
1445   LOG (GNUNET_ERROR_TYPE_DEBUG, "  calling ntfy tmt rdy for %u bytes\n", msize);
1446   h->th =
1447       GNUNET_CLIENT_notify_transmit_ready (h->client, msize,
1448                                            GNUNET_TIME_UNIT_FOREVER_REL,
1449                                            GNUNET_YES, &send_callback, h);
1450 }
1451
1452
1453 /******************************************************************************/
1454 /**********************      API CALL DEFINITIONS     *************************/
1455 /******************************************************************************/
1456
1457 struct GNUNET_CADET_Handle *
1458 GNUNET_CADET_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls,
1459                      GNUNET_CADET_InboundChannelNotificationHandler new_channel,
1460                      GNUNET_CADET_ChannelEndHandler cleaner,
1461                      const struct GNUNET_CADET_MessageHandler *handlers,
1462                      const uint32_t *ports)
1463 {
1464   struct GNUNET_CADET_Handle *h;
1465
1466   LOG (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CADET_connect()\n");
1467   h = GNUNET_new (struct GNUNET_CADET_Handle);
1468   LOG (GNUNET_ERROR_TYPE_DEBUG, " addr %p\n", h);
1469   h->cfg = cfg;
1470   h->new_channel = new_channel;
1471   h->cleaner = cleaner;
1472   h->client = GNUNET_CLIENT_connect ("cadet", cfg);
1473   if (h->client == NULL)
1474   {
1475     GNUNET_break (0);
1476     GNUNET_free (h);
1477     return NULL;
1478   }
1479   h->cls = cls;
1480   h->message_handlers = handlers;
1481   h->ports = ports;
1482   h->next_chid = GNUNET_CADET_LOCAL_CHANNEL_ID_CLI;
1483   h->reconnect_time = GNUNET_TIME_UNIT_MILLISECONDS;
1484   h->reconnect_task = NULL;
1485
1486   if (NULL != ports && ports[0] != 0 && NULL == new_channel)
1487   {
1488     GNUNET_break (0);
1489     LOG (GNUNET_ERROR_TYPE_DEBUG,
1490          "no new channel handler given, ports parameter is useless!!\n");
1491   }
1492   if ((NULL == ports || ports[0] == 0) && NULL != new_channel)
1493   {
1494     GNUNET_break (0);
1495     LOG (GNUNET_ERROR_TYPE_DEBUG,
1496          "no ports given, new channel handler will never be called!!\n");
1497   }
1498   /* count handlers */
1499   for (h->n_handlers = 0;
1500        handlers && handlers[h->n_handlers].type;
1501        h->n_handlers++) ;
1502   for (h->n_ports = 0;
1503        ports && ports[h->n_ports];
1504        h->n_ports++) ;
1505   send_connect (h);
1506   LOG (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CADET_connect() END\n");
1507   return h;
1508 }
1509
1510
1511 void
1512 GNUNET_CADET_disconnect (struct GNUNET_CADET_Handle *handle)
1513 {
1514   struct GNUNET_CADET_Channel *ch;
1515   struct GNUNET_CADET_Channel *aux;
1516   struct GNUNET_CADET_TransmitHandle *th;
1517
1518   LOG (GNUNET_ERROR_TYPE_DEBUG, "CADET DISCONNECT\n");
1519
1520   ch = handle->channels_head;
1521   while (NULL != ch)
1522   {
1523     aux = ch->next;
1524     if (ch->chid < GNUNET_CADET_LOCAL_CHANNEL_ID_SERV)
1525     {
1526       GNUNET_break (0);
1527       LOG (GNUNET_ERROR_TYPE_DEBUG, "channel %X not destroyed\n", ch->chid);
1528     }
1529     destroy_channel (ch, GNUNET_YES);
1530     ch = aux;
1531   }
1532   while ( (th = handle->th_head) != NULL)
1533   {
1534     struct GNUNET_MessageHeader *msg;
1535
1536     /* Make sure it is an allowed packet (everything else should have been
1537      * already canceled).
1538      */
1539     GNUNET_break (GNUNET_NO == th_is_payload (th));
1540     msg = (struct GNUNET_MessageHeader *) &th[1];
1541     switch (ntohs(msg->type))
1542     {
1543       case GNUNET_MESSAGE_TYPE_CADET_LOCAL_CONNECT:
1544       case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE:
1545       case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY:
1546       case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNELS:
1547       case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNEL:
1548       case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER:
1549       case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS:
1550       case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL:
1551       case GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS:
1552         break;
1553       default:
1554         GNUNET_break (0);
1555         LOG (GNUNET_ERROR_TYPE_ERROR, "unexpected msg %u\n",
1556              ntohs(msg->type));
1557     }
1558
1559     GNUNET_CONTAINER_DLL_remove (handle->th_head, handle->th_tail, th);
1560     GNUNET_free (th);
1561   }
1562
1563   if (NULL != handle->th)
1564   {
1565     GNUNET_CLIENT_notify_transmit_ready_cancel (handle->th);
1566     handle->th = NULL;
1567   }
1568   if (NULL != handle->client)
1569   {
1570     GNUNET_CLIENT_disconnect (handle->client);
1571     handle->client = NULL;
1572   }
1573   if (NULL != handle->reconnect_task)
1574   {
1575     GNUNET_SCHEDULER_cancel(handle->reconnect_task);
1576     handle->reconnect_task = NULL;
1577   }
1578   GNUNET_free (handle);
1579 }
1580
1581
1582 /**
1583  * Create a new channel towards a remote peer.
1584  *
1585  * If the destination port is not open by any peer or the destination peer
1586  * does not accept the channel, #GNUNET_CADET_ChannelEndHandler will be called
1587  * for this channel.
1588  *
1589  * @param h cadet handle
1590  * @param channel_ctx client's channel context to associate with the channel
1591  * @param peer peer identity the channel should go to
1592  * @param port Port number.
1593  * @param options CadetOption flag field, with all desired option bits set to 1.
1594  *
1595  * @return handle to the channel
1596  */
1597 struct GNUNET_CADET_Channel *
1598 GNUNET_CADET_channel_create (struct GNUNET_CADET_Handle *h,
1599                             void *channel_ctx,
1600                             const struct GNUNET_PeerIdentity *peer,
1601                             uint32_t port,
1602                             enum GNUNET_CADET_ChannelOption options)
1603 {
1604   struct GNUNET_CADET_Channel *ch;
1605   struct GNUNET_CADET_ChannelMessage msg;
1606
1607   LOG (GNUNET_ERROR_TYPE_DEBUG,
1608        "Creating new channel to %s:%u\n",
1609        GNUNET_i2s (peer), port);
1610   ch = create_channel (h, 0);
1611   LOG (GNUNET_ERROR_TYPE_DEBUG, "  at %p\n", ch);
1612   LOG (GNUNET_ERROR_TYPE_DEBUG, "  number %X\n", ch->chid);
1613   ch->ctx = channel_ctx;
1614   ch->peer = GNUNET_PEER_intern (peer);
1615   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE);
1616   msg.header.size = htons (sizeof (struct GNUNET_CADET_ChannelMessage));
1617   msg.channel_id = htonl (ch->chid);
1618   msg.port = htonl (port);
1619   msg.peer = *peer;
1620   msg.opt = htonl (options);
1621   ch->allow_send = GNUNET_NO;
1622   send_packet (h, &msg.header, ch);
1623   return ch;
1624 }
1625
1626
1627 void
1628 GNUNET_CADET_channel_destroy (struct GNUNET_CADET_Channel *channel)
1629 {
1630   struct GNUNET_CADET_Handle *h;
1631   struct GNUNET_CADET_ChannelMessage msg;
1632   struct GNUNET_CADET_TransmitHandle *th;
1633
1634   LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroying channel\n");
1635   h = channel->cadet;
1636
1637   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY);
1638   msg.header.size = htons (sizeof (struct GNUNET_CADET_ChannelMessage));
1639   msg.channel_id = htonl (channel->chid);
1640   memset (&msg.peer, 0, sizeof (struct GNUNET_PeerIdentity));
1641   msg.port = 0;
1642   msg.opt = 0;
1643   th = h->th_head;
1644   while (th != NULL)
1645   {
1646     struct GNUNET_CADET_TransmitHandle *aux;
1647     if (th->channel == channel)
1648     {
1649       aux = th->next;
1650       if (GNUNET_YES == th_is_payload (th))
1651       {
1652         /* applications should cancel before destroying channel */
1653         GNUNET_break (0);
1654         th->notify (th->notify_cls, 0, NULL);
1655       }
1656       GNUNET_CADET_notify_transmit_ready_cancel (th);
1657       th = aux;
1658     }
1659     else
1660       th = th->next;
1661   }
1662
1663   destroy_channel (channel, GNUNET_YES);
1664   send_packet (h, &msg.header, NULL);
1665 }
1666
1667
1668 /**
1669  * Get information about a channel.
1670  *
1671  * @param channel Channel handle.
1672  * @param option Query (GNUNET_CADET_OPTION_*).
1673  * @param ... dependant on option, currently not used
1674  *
1675  * @return Union with an answer to the query.
1676  */
1677 const union GNUNET_CADET_ChannelInfo *
1678 GNUNET_CADET_channel_get_info (struct GNUNET_CADET_Channel *channel,
1679                               enum GNUNET_CADET_ChannelOption option, ...)
1680 {
1681   static int bool_flag;
1682   const union GNUNET_CADET_ChannelInfo *ret;
1683
1684   switch (option)
1685   {
1686     case GNUNET_CADET_OPTION_NOBUFFER:
1687     case GNUNET_CADET_OPTION_RELIABLE:
1688     case GNUNET_CADET_OPTION_OOORDER:
1689       if (0 != (option & channel->options))
1690         bool_flag = GNUNET_YES;
1691       else
1692         bool_flag = GNUNET_NO;
1693       ret = (const union GNUNET_CADET_ChannelInfo *) &bool_flag;
1694       break;
1695     case GNUNET_CADET_OPTION_PEER:
1696       ret = (const union GNUNET_CADET_ChannelInfo *) GNUNET_PEER_resolve2 (channel->peer);
1697       break;
1698     default:
1699       GNUNET_break (0);
1700       return NULL;
1701   }
1702
1703   return ret;
1704 }
1705
1706 struct GNUNET_CADET_TransmitHandle *
1707 GNUNET_CADET_notify_transmit_ready (struct GNUNET_CADET_Channel *channel, int cork,
1708                                     struct GNUNET_TIME_Relative maxdelay,
1709                                     size_t notify_size,
1710                                     GNUNET_CONNECTION_TransmitReadyNotify notify,
1711                                     void *notify_cls)
1712 {
1713   struct GNUNET_CADET_TransmitHandle *th;
1714
1715   GNUNET_assert (NULL != channel);
1716   GNUNET_assert (GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE >= notify_size);
1717   LOG (GNUNET_ERROR_TYPE_DEBUG, "CADET NOTIFY TRANSMIT READY\n");
1718   LOG (GNUNET_ERROR_TYPE_DEBUG, "    on channel %X\n", channel->chid);
1719   LOG (GNUNET_ERROR_TYPE_DEBUG, "    allow_send %d\n", channel->allow_send);
1720   if (channel->chid >= GNUNET_CADET_LOCAL_CHANNEL_ID_SERV)
1721     LOG (GNUNET_ERROR_TYPE_DEBUG, "    to origin\n");
1722   else
1723     LOG (GNUNET_ERROR_TYPE_DEBUG, "    to destination\n");
1724   LOG (GNUNET_ERROR_TYPE_DEBUG, "    payload size %u\n", notify_size);
1725   GNUNET_assert (NULL != notify);
1726   GNUNET_assert (0 == channel->packet_size); // Only one data packet allowed
1727   th = GNUNET_new (struct GNUNET_CADET_TransmitHandle);
1728   th->channel = channel;
1729   th->timeout = GNUNET_TIME_relative_to_absolute (maxdelay);
1730   th->size = notify_size + DATA_OVERHEAD;
1731   channel->packet_size = th->size;
1732   LOG (GNUNET_ERROR_TYPE_DEBUG, "    total size %u\n", th->size);
1733   th->notify = notify;
1734   th->notify_cls = notify_cls;
1735   add_to_queue (channel->cadet, th);
1736   if (NULL != channel->cadet->th)
1737     return th;
1738   if (GNUNET_NO == channel->allow_send)
1739     return th;
1740   LOG (GNUNET_ERROR_TYPE_DEBUG, "    call client notify tmt rdy\n");
1741   channel->cadet->th =
1742       GNUNET_CLIENT_notify_transmit_ready (channel->cadet->client, th->size,
1743                                            GNUNET_TIME_UNIT_FOREVER_REL,
1744                                            GNUNET_YES, &send_callback,
1745                                            channel->cadet);
1746   LOG (GNUNET_ERROR_TYPE_DEBUG, "CADET NOTIFY TRANSMIT READY END\n");
1747   return th;
1748 }
1749
1750
1751 void
1752 GNUNET_CADET_notify_transmit_ready_cancel (struct GNUNET_CADET_TransmitHandle *th)
1753 {
1754   struct GNUNET_CADET_Handle *cadet;
1755
1756   th->channel->packet_size = 0;
1757   cadet = th->channel->cadet;
1758   if (th->timeout_task != NULL)
1759     GNUNET_SCHEDULER_cancel (th->timeout_task);
1760   GNUNET_CONTAINER_DLL_remove (cadet->th_head, cadet->th_tail, th);
1761   GNUNET_free (th);
1762   if ((0 == message_ready_size (cadet)) && (NULL != cadet->th))
1763   {
1764     /* queue empty, no point in asking for transmission */
1765     GNUNET_CLIENT_notify_transmit_ready_cancel (cadet->th);
1766     cadet->th = NULL;
1767   }
1768 }
1769
1770
1771 void
1772 GNUNET_CADET_receive_done (struct GNUNET_CADET_Channel *channel)
1773 {
1774   send_ack (channel);
1775 }
1776
1777
1778 static void
1779 send_info_request (struct GNUNET_CADET_Handle *h, uint16_t type)
1780 {
1781   struct GNUNET_MessageHeader msg;
1782
1783   msg.size = htons (sizeof (msg));
1784   msg.type = htons (type);
1785   send_packet (h, &msg, NULL);
1786 }
1787
1788
1789 /**
1790  * Request a debug dump on the service's STDERR.
1791  *
1792  * WARNING: unstable API, likely to change in the future!
1793  *
1794  * @param h cadet handle
1795  */
1796 void
1797 GNUNET_CADET_request_dump (struct GNUNET_CADET_Handle *h)
1798 {
1799   LOG (GNUNET_ERROR_TYPE_DEBUG, "requesting dump\n");
1800   send_info_request (h, GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_DUMP);
1801 }
1802
1803
1804 /**
1805  * Request information about peers known to the running cadet service.
1806  * The callback will be called for every peer known to the service.
1807  * Only one info request (of any kind) can be active at once.
1808  *
1809  *
1810  * WARNING: unstable API, likely to change in the future!
1811  *
1812  * @param h Handle to the cadet peer.
1813  * @param callback Function to call with the requested data.
1814  * @param callback_cls Closure for @c callback.
1815  *
1816  * @return #GNUNET_OK / #GNUNET_SYSERR
1817  */
1818 int
1819 GNUNET_CADET_get_peers (struct GNUNET_CADET_Handle *h,
1820                        GNUNET_CADET_PeersCB callback,
1821                        void *callback_cls)
1822 {
1823   if (NULL != h->info_cb.peers_cb)
1824   {
1825     GNUNET_break (0);
1826     return GNUNET_SYSERR;
1827   }
1828   send_info_request (h, GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEERS);
1829   h->info_cb.peers_cb = callback;
1830   h->info_cls = callback_cls;
1831   return GNUNET_OK;
1832 }
1833
1834
1835 /**
1836  * Cancel a peer info request. The callback will not be called (anymore).
1837  *
1838  * WARNING: unstable API, likely to change in the future!
1839  *
1840  * @param h Cadet handle.
1841  *
1842  * @return Closure given to GNUNET_CADET_get_peers.
1843  */
1844 void *
1845 GNUNET_CADET_get_peers_cancel (struct GNUNET_CADET_Handle *h)
1846 {
1847   void *cls;
1848
1849   cls = h->info_cls;
1850   h->info_cb.peers_cb = NULL;
1851   h->info_cls = NULL;
1852   return cls;
1853 }
1854
1855
1856 /**
1857  * Request information about a peer known to the running cadet peer.
1858  * The callback will be called for the tunnel once.
1859  * Only one info request (of any kind) can be active at once.
1860  *
1861  * WARNING: unstable API, likely to change in the future!
1862  *
1863  * @param h Handle to the cadet peer.
1864  * @param id Peer whose tunnel to examine.
1865  * @param callback Function to call with the requested data.
1866  * @param callback_cls Closure for @c callback.
1867  *
1868  * @return #GNUNET_OK / #GNUNET_SYSERR
1869  */
1870 int
1871 GNUNET_CADET_get_peer (struct GNUNET_CADET_Handle *h,
1872                       const struct GNUNET_PeerIdentity *id,
1873                       GNUNET_CADET_PeerCB callback,
1874                       void *callback_cls)
1875 {
1876   struct GNUNET_CADET_LocalInfo msg;
1877
1878   if (NULL != h->info_cb.peer_cb)
1879   {
1880     GNUNET_break (0);
1881     return GNUNET_SYSERR;
1882   }
1883
1884   memset (&msg, 0, sizeof (msg));
1885   msg.header.size = htons (sizeof (msg));
1886   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_PEER);
1887   msg.peer = *id;
1888   send_packet (h, &msg.header, NULL);
1889   h->info_cb.peer_cb = callback;
1890   h->info_cls = callback_cls;
1891   return GNUNET_OK;
1892 }
1893
1894
1895 /**
1896  * Request information about tunnels of the running cadet peer.
1897  * The callback will be called for every tunnel of the service.
1898  * Only one info request (of any kind) can be active at once.
1899  *
1900  * WARNING: unstable API, likely to change in the future!
1901  *
1902  * @param h Handle to the cadet peer.
1903  * @param callback Function to call with the requested data.
1904  * @param callback_cls Closure for @c callback.
1905  *
1906  * @return #GNUNET_OK / #GNUNET_SYSERR
1907  */
1908 int
1909 GNUNET_CADET_get_tunnels (struct GNUNET_CADET_Handle *h,
1910                          GNUNET_CADET_TunnelsCB callback,
1911                          void *callback_cls)
1912 {
1913   if (NULL != h->info_cb.tunnels_cb)
1914   {
1915     GNUNET_break (0);
1916     return GNUNET_SYSERR;
1917   }
1918   send_info_request (h, GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNELS);
1919   h->info_cb.tunnels_cb = callback;
1920   h->info_cls = callback_cls;
1921   return GNUNET_OK;
1922 }
1923
1924
1925 /**
1926  * Cancel a monitor request. The monitor callback will not be called.
1927  *
1928  * @param h Cadet handle.
1929  *
1930  * @return Closure given to GNUNET_CADET_get_tunnels.
1931  */
1932 void *
1933 GNUNET_CADET_get_tunnels_cancel (struct GNUNET_CADET_Handle *h)
1934 {
1935   void *cls;
1936
1937   h->info_cb.tunnels_cb = NULL;
1938   cls = h->info_cls;
1939   h->info_cls = NULL;
1940
1941   return cls;
1942 }
1943
1944
1945
1946 /**
1947  * Request information about a tunnel of the running cadet peer.
1948  * The callback will be called for the tunnel once.
1949  * Only one info request (of any kind) can be active at once.
1950  *
1951  * WARNING: unstable API, likely to change in the future!
1952  *
1953  * @param h Handle to the cadet peer.
1954  * @param id Peer whose tunnel to examine.
1955  * @param callback Function to call with the requested data.
1956  * @param callback_cls Closure for @c callback.
1957  *
1958  * @return #GNUNET_OK / #GNUNET_SYSERR
1959  */
1960 int
1961 GNUNET_CADET_get_tunnel (struct GNUNET_CADET_Handle *h,
1962                         const struct GNUNET_PeerIdentity *id,
1963                         GNUNET_CADET_TunnelCB callback,
1964                         void *callback_cls)
1965 {
1966   struct GNUNET_CADET_LocalInfo msg;
1967
1968   if (NULL != h->info_cb.tunnel_cb)
1969   {
1970     GNUNET_break (0);
1971     return GNUNET_SYSERR;
1972   }
1973
1974   memset (&msg, 0, sizeof (msg));
1975   msg.header.size = htons (sizeof (msg));
1976   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_TUNNEL);
1977   msg.peer = *id;
1978   send_packet (h, &msg.header, NULL);
1979   h->info_cb.tunnel_cb = callback;
1980   h->info_cls = callback_cls;
1981   return GNUNET_OK;
1982 }
1983
1984
1985 /**
1986  * Request information about a specific channel of the running cadet peer.
1987  *
1988  * WARNING: unstable API, likely to change in the future!
1989  * FIXME Add destination option.
1990  *
1991  * @param h Handle to the cadet peer.
1992  * @param initiator ID of the owner of the channel.
1993  * @param channel_number Channel number.
1994  * @param callback Function to call with the requested data.
1995  * @param callback_cls Closure for @c callback.
1996  *
1997  * @return #GNUNET_OK / #GNUNET_SYSERR
1998  */
1999 int
2000 GNUNET_CADET_show_channel (struct GNUNET_CADET_Handle *h,
2001                          struct GNUNET_PeerIdentity *initiator,
2002                          unsigned int channel_number,
2003                          GNUNET_CADET_ChannelCB callback,
2004                          void *callback_cls)
2005 {
2006   struct GNUNET_CADET_LocalInfo msg;
2007
2008   if (NULL != h->info_cb.channel_cb)
2009   {
2010     GNUNET_break (0);
2011     return GNUNET_SYSERR;
2012   }
2013
2014   msg.header.size = htons (sizeof (msg));
2015   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_LOCAL_INFO_CHANNEL);
2016   msg.peer = *initiator;
2017   msg.channel_id = htonl (channel_number);
2018 //   msg.reserved = 0;
2019   send_packet (h, &msg.header, NULL);
2020   h->info_cb.channel_cb = callback;
2021   h->info_cls = callback_cls;
2022   return GNUNET_OK;
2023 }
2024
2025
2026 /**
2027  * Function called to notify a client about the connection
2028  * begin ready to queue more data.  "buf" will be
2029  * NULL and "size" zero if the connection was closed for
2030  * writing in the meantime.
2031  *
2032  * @param cls closure
2033  * @param size number of bytes available in buf
2034  * @param buf where the callee should write the message
2035  * @return number of bytes written to buf
2036  */
2037 static size_t
2038 cadet_mq_ntr (void *cls, size_t size,
2039              void *buf)
2040 {
2041   struct GNUNET_MQ_Handle *mq = cls;
2042   struct CadetMQState *state = GNUNET_MQ_impl_state (mq);
2043   const struct GNUNET_MessageHeader *msg = GNUNET_MQ_impl_current (mq);
2044   uint16_t msize;
2045
2046   state->th = NULL;
2047   if (NULL == buf)
2048   {
2049     GNUNET_MQ_inject_error (mq, GNUNET_MQ_ERROR_WRITE);
2050     return 0;
2051   }
2052   msize = ntohs (msg->size);
2053   GNUNET_assert (msize <= size);
2054   memcpy (buf, msg, msize);
2055   GNUNET_MQ_impl_send_continue (mq);
2056   return msize;
2057 }
2058
2059
2060 /**
2061  * Signature of functions implementing the
2062  * sending functionality of a message queue.
2063  *
2064  * @param mq the message queue
2065  * @param msg the message to send
2066  * @param impl_state state of the implementation
2067  */
2068 static void
2069 cadet_mq_send_impl (struct GNUNET_MQ_Handle *mq,
2070                     const struct GNUNET_MessageHeader *msg,
2071                     void *impl_state)
2072 {
2073   struct CadetMQState *state = impl_state;
2074
2075   GNUNET_assert (NULL == state->th);
2076   state->th =
2077       GNUNET_CADET_notify_transmit_ready (state->channel,
2078                                          /* FIXME: add option for corking */
2079                                          GNUNET_NO,
2080                                          GNUNET_TIME_UNIT_FOREVER_REL,
2081                                          ntohs (msg->size),
2082                                          &cadet_mq_ntr, mq);
2083
2084 }
2085
2086
2087 /**
2088  * Signature of functions implementing the
2089  * destruction of a message queue.
2090  * Implementations must not free 'mq', but should
2091  * take care of 'impl_state'.
2092  *
2093  * @param mq the message queue to destroy
2094  * @param impl_state state of the implementation
2095  */
2096 static void
2097 cadet_mq_destroy_impl (struct GNUNET_MQ_Handle *mq,
2098                        void *impl_state)
2099 {
2100   struct CadetMQState *state = impl_state;
2101
2102   if (NULL != state->th)
2103     GNUNET_CADET_notify_transmit_ready_cancel (state->th);
2104
2105   GNUNET_free (state);
2106 }
2107
2108
2109 /**
2110  * Create a message queue for a cadet channel.
2111  * The message queue can only be used to transmit messages,
2112  * not to receive them.
2113  *
2114  * @param channel the channel to create the message qeue for
2115  * @return a message queue to messages over the channel
2116  */
2117 struct GNUNET_MQ_Handle *
2118 GNUNET_CADET_mq_create (struct GNUNET_CADET_Channel *channel)
2119 {
2120   struct GNUNET_MQ_Handle *mq;
2121   struct CadetMQState *state;
2122
2123   state = GNUNET_new (struct CadetMQState);
2124   state->channel = channel;
2125
2126   mq = GNUNET_MQ_queue_for_callbacks (&cadet_mq_send_impl,
2127                                       &cadet_mq_destroy_impl,
2128                                       NULL, /* FIXME: cancel impl. */
2129                                       state,
2130                                       NULL, /* no msg handlers */
2131                                       NULL, /* no err handlers */
2132                                       NULL); /* no handler cls */
2133   return mq;
2134 }
2135