src/cadet/cadet_api.c

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