src/mesh/mesh_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 mesh/mesh_api.c
  20  * @brief mesh api: client implementation of new mesh service
  21  * @author Bartlomiej Polot
  22  */
  23
  24 #include "platform.h"
  25 #include "gnunet_util_lib.h"
  26 #include "gnunet_mesh_service.h"
  27 #include "mesh.h"
  28 #include "mesh_protocol.h"
  29
  30 #define LOG(kind,...) GNUNET_log_from (kind, "mesh-api",__VA_ARGS__)
  31
  32 /******************************************************************************/
  33 /************************      DATA STRUCTURES     ****************************/
  34 /******************************************************************************/
  35
  36 /**
  37  * Transmission queue to the service
  38  */
  39 struct GNUNET_MESH_TransmitHandle
  40 {
  41
  42     /**
  43      * Double Linked list
  44      */
  45   struct GNUNET_MESH_TransmitHandle *next;
  46
  47     /**
  48      * Double Linked list
  49      */
  50   struct GNUNET_MESH_TransmitHandle *prev;
  51
  52     /**
  53      * Channel this message is sent on / for (may be NULL for control messages).
  54      */
  55   struct GNUNET_MESH_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 MeshInfoCB {
  90
  91   /**
  92    * Channel callback.
  93    */
  94   GNUNET_MESH_ChannelCB channel_cb;
  95
  96   /**
  97    * Monitor callback
  98    */
  99   GNUNET_MESH_PeersCB peers_cb;
 100
 101   /**
 102    * Monitor callback
 103    */
 104   GNUNET_MESH_PeerCB peer_cb;
 105
 106   /**
 107    * Monitor callback
 108    */
 109   GNUNET_MESH_TunnelsCB tunnels_cb;
 110
 111   /**
 112    * Tunnel callback.
 113    */
 114   GNUNET_MESH_TunnelCB tunnel_cb;
 115 };
 116
 117
 118 /**
 119  * Opaque handle to the service.
 120  */
 121 struct GNUNET_MESH_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_MESH_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_MESH_Channel *channels_head;
 153
 154     /**
 155      * Double linked list of the channels this client is connected to, tail.
 156      */
 157   struct GNUNET_MESH_Channel *channels_tail;
 158
 159     /**
 160      * Callback for inbound channel creation
 161      */
 162   GNUNET_MESH_InboundChannelNotificationHandler *new_channel;
 163
 164     /**
 165      * Callback for inbound channel disconnection
 166      */
 167   GNUNET_MESH_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_MESH_TransmitHandle *th_head;
 183
 184     /**
 185      * Messages to send to the service, tail.
 186      */
 187   struct GNUNET_MESH_TransmitHandle *th_tail;
 188
 189     /**
 190      * chid of the next channel to create (to avoid reusing IDs often)
 191      */
 192   MESH_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 'MESH_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 MeshInfoCB 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_MESH_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_MESH_Channel *t;
 241 };
 242
 243
 244 /**
 245  * Opaque handle to a channel.
 246  */
 247 struct GNUNET_MESH_Channel
 248 {
 249
 250     /**
 251      * DLL next
 252      */
 253   struct GNUNET_MESH_Channel *next;
 254
 255     /**
 256      * DLL prev
 257      */
 258   struct GNUNET_MESH_Channel *prev;
 259
 260     /**
 261      * Handle to the mesh this channel belongs to
 262      */
 263   struct GNUNET_MESH_Handle *mesh;
 264
 265     /**
 266      * Local ID of the channel
 267      */
 268   MESH_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_MESH_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 mesh's message queue.
 305  */
 306 struct MeshMQState
 307 {
 308   /**
 309    * The current transmit handle, or NULL
 310    * if no transmit is active.
 311    */
 312   struct GNUNET_MESH_TransmitHandle *th;
 313
 314   /**
 315    * Channel to send the data over.
 316    */
 317   struct GNUNET_MESH_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 mesh 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 mesh management packet.
 350  */
 351 static int
 352 th_is_payload (struct GNUNET_MESH_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 Mesh 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_MESH_Handle *h)
 368 {
 369   struct GNUNET_MESH_TransmitHandle *th;
 370   struct GNUNET_MESH_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 Mesh 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_MESH_Channel *
 397 retrieve_channel (struct GNUNET_MESH_Handle *h, MESH_ChannelNumber chid)
 398 {
 399   struct GNUNET_MESH_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 mesh handle
 414  *
 415  * @param h Mesh 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_MESH_Channel *
 421 create_channel (struct GNUNET_MESH_Handle *h, MESH_ChannelNumber chid)
 422 {
 423   struct GNUNET_MESH_Channel *ch;
 424
 425   ch = GNUNET_new (struct GNUNET_MESH_Channel);
 426   GNUNET_CONTAINER_DLL_insert (h->channels_head, h->channels_tail, ch);
 427   ch->mesh = 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_MESH_LOCAL_CHANNEL_ID_SERV;
 435       h->next_chid |= GNUNET_MESH_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_MESH_Channel *ch, int call_cleaner)
 461 {
 462   struct GNUNET_MESH_Handle *h;
 463   struct GNUNET_MESH_TransmitHandle *th;
 464   struct GNUNET_MESH_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->mesh;
 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 mesh 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_MESH_TransmitHandle *th = cls;
 529   struct GNUNET_MESH_Handle *mesh;
 530
 531   mesh = th->channel->mesh;
 532   GNUNET_CONTAINER_DLL_remove (mesh->th_head, mesh->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 (mesh)) && (NULL != mesh->th))
 538   {
 539     /* nothing ready to transmit, no point in asking for transmission */
 540     GNUNET_CLIENT_notify_transmit_ready_cancel (mesh->th);
 541     mesh->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 mesh 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_MESH_Handle *h,
 555               struct GNUNET_MESH_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 mesh 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_MESH_Handle *h,
 577              const struct GNUNET_MessageHeader *msg,
 578              struct GNUNET_MESH_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_MESH_Channel *ch)
 588 {
 589   struct GNUNET_MESH_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_MESH_LOCAL_ACK);
 593   msg.header.size = htons (sizeof (msg));
 594   msg.channel_id = htonl (ch->chid);
 595
 596   send_packet (ch->mesh, &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 (mesh 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 mesh handle.
 617  *
 618  */
 619 static void
 620 send_connect (struct GNUNET_MESH_Handle *h)
 621 {
 622   size_t size;
 623
 624   size = sizeof (struct GNUNET_MESH_ClientConnect);
 625   size += h->n_ports * sizeof (uint32_t);
 626   {
 627     char buf[size] GNUNET_ALIGN;
 628     struct GNUNET_MESH_ClientConnect *msg;
 629     uint32_t *ports;
 630     uint16_t i;
 631
 632     /* build connection packet */
 633     msg = (struct GNUNET_MESH_ClientConnect *) buf;
 634     msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_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 mesh
 656  *
 657  * @return GNUNET_YES in case of sucess, GNUNET_NO otherwise (service down...)
 658  */
 659 static int
 660 do_reconnect (struct GNUNET_MESH_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 ("mesh", 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 (mesh 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_MESH_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 mesh
 726  *
 727  * @return GNUNET_YES in case of sucess, GNUNET_NO otherwise (service down...)
 728  */
 729 static void
 730 reconnect (struct GNUNET_MESH_Handle *h)
 731 {
 732   struct GNUNET_MESH_Channel *ch;
 733   struct GNUNET_MESH_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 mesh handle
 757  * @param msg   A message with the details of the new incoming channel
 758  */
 759 static void
 760 process_channel_created (struct GNUNET_MESH_Handle *h,
 761                         const struct GNUNET_MESH_ChannelMessage *msg)
 762 {
 763   struct GNUNET_MESH_Channel *ch;
 764   MESH_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_MESH_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->mesh = 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_MESH_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_MESH_CHANNEL_DESTROY);
 800     d_msg.header.size = htons (sizeof (struct GNUNET_MESH_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 mesh handle
 816  * @param msg   A message with the details of the channel being destroyed
 817  */
 818 static void
 819 process_channel_destroy (struct GNUNET_MESH_Handle *h,
 820                          const struct GNUNET_MESH_ChannelMessage *msg)
 821 {
 822   struct GNUNET_MESH_Channel *ch;
 823   MESH_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 mesh handle
 843  * @param message   A message encapsulating the data
 844  */
 845 static void
 846 process_incoming_data (struct GNUNET_MESH_Handle *h,
 847                        const struct GNUNET_MessageHeader *message)
 848 {
 849   const struct GNUNET_MessageHeader *payload;
 850   const struct GNUNET_MESH_MessageHandler *handler;
 851   struct GNUNET_MESH_LocalData *dmsg;
 852   struct GNUNET_MESH_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_MESH_LocalData *) message;
 859   ch = retrieve_channel (h, ntohl (dmsg->id));
 860   payload = (struct GNUNET_MessageHeader *) &dmsg[1];
 861   LOG (GNUNET_ERROR_TYPE_DEBUG, "  %s data on channel %s [%X]\n",
 862        GM_f2s (ch->chid >= GNUNET_MESH_LOCAL_CHANNEL_ID_SERV),
 863        GNUNET_i2s (GNUNET_PEER_resolve2 (ch->peer)), ntohl (dmsg->id));
 864
 865   size = ntohs (message->size);
 866   LOG (GNUNET_ERROR_TYPE_DEBUG, "  %u bytes\n", size);
 867
 868   if (NULL == ch)
 869   {
 870     /* Channel was ignored/destroyed, probably service didn't get it yet */
 871     LOG (GNUNET_ERROR_TYPE_DEBUG, "  ignored!\n");
 872     return;
 873   }
 874   type = ntohs (payload->type);
 875   size = ntohs (payload->size);
 876   LOG (GNUNET_ERROR_TYPE_DEBUG, "  payload type %s\n", GM_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_MESH_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 Mesh handle.
 907  * @param message Message itself.
 908  */
 909 static void
 910 process_ack (struct GNUNET_MESH_Handle *h,
 911              const struct GNUNET_MessageHeader *message)
 912 {
 913   struct GNUNET_MESH_LocalAck *msg;
 914   struct GNUNET_MESH_Channel *ch;
 915   MESH_ChannelNumber chid;
 916
 917   LOG (GNUNET_ERROR_TYPE_DEBUG, "Got an ACK!\n");
 918   msg = (struct GNUNET_MESH_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 Mesh handle.
 942  * @param message Message itself.
 943  */
 944 // static void
 945 // process_get_channels (struct GNUNET_MESH_Handle *h,
 946 //                      const struct GNUNET_MessageHeader *message)
 947 // {
 948 //   struct GNUNET_MESH_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_MESH_LocalInfo *) message;
 959 //   if (ntohs (message->size) !=
 960 //       (sizeof (struct GNUNET_MESH_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_MESH_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 Mesh handle.
 982  * @param message Message itself.
 983  */
 984 // static void
 985 // process_show_channel (struct GNUNET_MESH_Handle *h,
 986 //                      const struct GNUNET_MessageHeader *message)
 987 // {
 988 //   struct GNUNET_MESH_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_MESH_LocalInfo *) message;
1001 //   esize = sizeof (struct GNUNET_MESH_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 Mesh handle.
1028  * @param message Message itself.
1029  */
1030 static void
1031 process_get_peers (struct GNUNET_MESH_Handle *h,
1032                      const struct GNUNET_MessageHeader *message)
1033 {
1034   struct GNUNET_MESH_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_MESH_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_MESH_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 reply about info on all tunnels, pass info to the user.
1064  *
1065  * @param h Mesh handle.
1066  * @param message Message itself.
1067  */
1068 static void
1069 process_get_tunnels (struct GNUNET_MESH_Handle *h,
1070                      const struct GNUNET_MessageHeader *message)
1071 {
1072   struct GNUNET_MESH_LocalInfoTunnel *msg;
1073   uint16_t size;
1074
1075   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Get Tunnels messasge received\n");
1076
1077   if (NULL == h->info_cb.tunnels_cb)
1078   {
1079     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  ignored\n");
1080     return;
1081   }
1082
1083   size = ntohs (message->size);
1084   if (sizeof (struct GNUNET_MESH_LocalInfoTunnel) > size)
1085   {
1086     h->info_cb.tunnels_cb (h->info_cls, NULL, 0, 0, 0, 0);
1087     h->info_cb.tunnels_cb = NULL;
1088     h->info_cls = NULL;
1089     return;
1090   }
1091
1092   msg = (struct GNUNET_MESH_LocalInfoTunnel *) message;
1093   h->info_cb.tunnels_cb (h->info_cls, &msg->destination,
1094                          ntohl (msg->channels), ntohl (msg->connections),
1095                          ntohs (msg->estate), ntohs (msg->cstate));
1096
1097 }
1098
1099
1100
1101 /**
1102  * Process a local tunnel info reply, pass info to the user.
1103  *
1104  * @param h Mesh handle.
1105  * @param message Message itself.
1106  */
1107 static void
1108 process_get_tunnel (struct GNUNET_MESH_Handle *h,
1109                     const struct GNUNET_MessageHeader *message)
1110 {
1111   struct GNUNET_MESH_LocalInfoTunnel *msg;
1112   size_t esize;
1113   size_t msize;
1114   unsigned int ch_n;
1115   unsigned int c_n;
1116   struct GNUNET_MeshHash *conns;
1117   MESH_ChannelNumber *chns;
1118
1119   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Get Tunnel messasge received\n");
1120   if (NULL == h->info_cb.tunnel_cb)
1121   {
1122     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  ignored\n");
1123     return;
1124   }
1125
1126   /* Verify message sanity */
1127   msg = (struct GNUNET_MESH_LocalInfoTunnel *) message;
1128   msize = ntohs (message->size);
1129   esize = sizeof (struct GNUNET_MESH_LocalInfoTunnel);
1130   if (esize > msize)
1131   {
1132     GNUNET_break_op (0);
1133     h->info_cb.tunnel_cb (h->info_cls, NULL, 0, 0, NULL, NULL, 0, 0);
1134     goto clean_cls;
1135   }
1136   ch_n = ntohl (msg->channels);
1137   c_n = ntohl (msg->connections);
1138   esize += ch_n * sizeof (MESH_ChannelNumber);
1139   esize += c_n * sizeof (struct GNUNET_MeshHash);
1140   if (msize != esize)
1141   {
1142     GNUNET_break_op (0);
1143     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "m:%u, e: %u (%u ch, %u conn)\n",
1144                 msize, esize, ch_n, c_n);
1145     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%u (%u ch, %u conn)\n",
1146                 sizeof (struct GNUNET_MESH_LocalInfoTunnel),
1147                 sizeof (MESH_ChannelNumber), sizeof (struct GNUNET_HashCode));
1148     h->info_cb.tunnel_cb (h->info_cls, NULL, 0, 0, NULL, NULL, 0, 0);
1149     goto clean_cls;
1150   }
1151
1152   /* Call Callback with tunnel info. */
1153   conns = (struct GNUNET_MeshHash *) &msg[1];
1154   chns = (MESH_ChannelNumber *) &conns[c_n];
1155   h->info_cb.tunnel_cb (h->info_cls, &msg->destination,
1156                 ch_n, c_n, chns, conns,
1157                 ntohs (msg->estate), ntohs (msg->cstate));
1158
1159 clean_cls:
1160   h->info_cb.tunnel_cb = NULL;
1161   h->info_cls = NULL;
1162 }
1163
1164 /**
1165  * Function to process all messages received from the service
1166  *
1167  * @param cls closure
1168  * @param msg message received, NULL on timeout or fatal error
1169  */
1170 static void
1171 msg_received (void *cls, const struct GNUNET_MessageHeader *msg)
1172 {
1173   struct GNUNET_MESH_Handle *h = cls;
1174   uint16_t type;
1175
1176   if (msg == NULL)
1177   {
1178     LOG (GNUNET_ERROR_TYPE_DEBUG,
1179          "Mesh service disconnected, reconnecting\n", h);
1180     reconnect (h);
1181     return;
1182   }
1183   type = ntohs (msg->type);
1184   LOG (GNUNET_ERROR_TYPE_DEBUG, "\n");
1185   LOG (GNUNET_ERROR_TYPE_DEBUG, "Received a message: %s\n",
1186        GM_m2s (type));
1187   switch (type)
1188   {
1189     /* Notify of a new incoming channel */
1190   case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE:
1191     process_channel_created (h, (struct GNUNET_MESH_ChannelMessage *) msg);
1192     break;
1193     /* Notify of a channel disconnection */
1194   case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY: /* TODO separate(gid problem)*/
1195   case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_NACK:
1196     process_channel_destroy (h, (struct GNUNET_MESH_ChannelMessage *) msg);
1197     break;
1198   case GNUNET_MESSAGE_TYPE_MESH_LOCAL_DATA:
1199     process_incoming_data (h, msg);
1200     break;
1201   case GNUNET_MESSAGE_TYPE_MESH_LOCAL_ACK:
1202     process_ack (h, msg);
1203     break;
1204 //   case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_CHANNELS:
1205 //     process_get_channels (h, msg);
1206 //     break;
1207 //   case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_CHANNEL:
1208 //     process_show_channel (h, msg);
1209 //     break;
1210   case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_PEERS:
1211     process_get_peers (h, msg);
1212     break;
1213   case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNELS:
1214     process_get_tunnels (h, msg);
1215     break;
1216   case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNEL:
1217     process_get_tunnel (h, msg);
1218     break;
1219 //   case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_CHANNEL:
1220 //     process_show_channel (h, msg);
1221 //     break;
1222   default:
1223     /* We shouldn't get any other packages, log and ignore */
1224     LOG (GNUNET_ERROR_TYPE_WARNING,
1225          "unsolicited message form service (type %s)\n",
1226          GM_m2s (ntohs (msg->type)));
1227   }
1228   LOG (GNUNET_ERROR_TYPE_DEBUG, "message processed\n");
1229   if (GNUNET_YES == h->in_receive)
1230   {
1231     GNUNET_CLIENT_receive (h->client, &msg_received, h,
1232                            GNUNET_TIME_UNIT_FOREVER_REL);
1233   }
1234   else
1235   {
1236     LOG (GNUNET_ERROR_TYPE_DEBUG,
1237          "in receive off, not calling CLIENT_receive\n");
1238   }
1239 }
1240
1241
1242 /******************************************************************************/
1243 /************************       SEND FUNCTIONS     ****************************/
1244 /******************************************************************************/
1245
1246 /**
1247  * Function called to send a message to the service.
1248  * "buf" will be NULL and "size" zero if the socket was closed for writing in
1249  * the meantime.
1250  *
1251  * @param cls closure, the mesh handle
1252  * @param size number of bytes available in buf
1253  * @param buf where the callee should write the connect message
1254  * @return number of bytes written to buf
1255  */
1256 static size_t
1257 send_callback (void *cls, size_t size, void *buf)
1258 {
1259   struct GNUNET_MESH_Handle *h = cls;
1260   struct GNUNET_MESH_TransmitHandle *th;
1261   struct GNUNET_MESH_TransmitHandle *next;
1262   struct GNUNET_MESH_Channel *ch;
1263   char *cbuf = buf;
1264   size_t tsize;
1265   size_t psize;
1266   size_t nsize;
1267
1268   LOG (GNUNET_ERROR_TYPE_DEBUG, "\n");
1269   LOG (GNUNET_ERROR_TYPE_DEBUG, "# Send packet() Buffer %u\n", size);
1270   if ((0 == size) || (NULL == buf))
1271   {
1272     LOG (GNUNET_ERROR_TYPE_DEBUG, "# Received NULL send callback on %p\n", h);
1273     reconnect (h);
1274     h->th = NULL;
1275     return 0;
1276   }
1277   tsize = 0;
1278   next = h->th_head;
1279   nsize = message_ready_size (h);
1280   while ((NULL != (th = next)) && (0 < nsize) && (size >= nsize))
1281   {
1282     ch = th->channel;
1283     if (GNUNET_YES == th_is_payload (th))
1284     {
1285       struct GNUNET_MESH_LocalData *dmsg;
1286       struct GNUNET_MessageHeader *mh;
1287
1288       LOG (GNUNET_ERROR_TYPE_DEBUG, "#  payload\n");
1289       if (GNUNET_NO == ch->allow_send)
1290       {
1291         /* This channel is not ready to transmit yet, try next message */
1292         next = th->next;
1293         continue;
1294       }
1295       ch->packet_size = 0;
1296       GNUNET_assert (size >= th->size);
1297       dmsg = (struct GNUNET_MESH_LocalData *) cbuf;
1298       mh = (struct GNUNET_MessageHeader *) &dmsg[1];
1299       psize = th->notify (th->notify_cls,
1300                           size - sizeof (struct GNUNET_MESH_LocalData),
1301                           mh);
1302       if (psize > 0)
1303       {
1304         psize += sizeof (struct GNUNET_MESH_LocalData);
1305         GNUNET_assert (size >= psize);
1306         dmsg->header.size = htons (psize);
1307         dmsg->id = htonl (ch->chid);
1308         dmsg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_DATA);
1309         LOG (GNUNET_ERROR_TYPE_DEBUG, "#  payload type %s\n",
1310              GM_m2s (ntohs (mh->type)));
1311                 ch->allow_send = GNUNET_NO;
1312       }
1313       else
1314       {
1315         LOG (GNUNET_ERROR_TYPE_DEBUG,
1316              "#  callback returned size 0, "
1317              "application canceled transmission\n");
1318       }
1319     }
1320     else
1321     {
1322       struct GNUNET_MessageHeader *mh = (struct GNUNET_MessageHeader *) &th[1];
1323
1324       LOG (GNUNET_ERROR_TYPE_DEBUG, "#  mesh internal traffic, type %s\n",
1325            GM_m2s (ntohs (mh->type)));
1326       memcpy (cbuf, &th[1], th->size);
1327       psize = th->size;
1328     }
1329     if (th->timeout_task != GNUNET_SCHEDULER_NO_TASK)
1330       GNUNET_SCHEDULER_cancel (th->timeout_task);
1331     GNUNET_CONTAINER_DLL_remove (h->th_head, h->th_tail, th);
1332     GNUNET_free (th);
1333     next = h->th_head;
1334     nsize = message_ready_size (h);
1335     cbuf += psize;
1336     size -= psize;
1337     tsize += psize;
1338   }
1339   LOG (GNUNET_ERROR_TYPE_DEBUG, "#  total size: %u\n", tsize);
1340   h->th = NULL;
1341   size = message_ready_size (h);
1342   if (0 != size)
1343   {
1344     LOG (GNUNET_ERROR_TYPE_DEBUG, "#  next size: %u\n", size);
1345     h->th =
1346         GNUNET_CLIENT_notify_transmit_ready (h->client, size,
1347                                              GNUNET_TIME_UNIT_FOREVER_REL,
1348                                              GNUNET_YES, &send_callback, h);
1349   }
1350   else
1351   {
1352     if (NULL != h->th_head)
1353       LOG (GNUNET_ERROR_TYPE_DEBUG, "#  can't transmit any more\n");
1354     else
1355       LOG (GNUNET_ERROR_TYPE_DEBUG, "#  nothing left to transmit\n");
1356   }
1357   if (GNUNET_NO == h->in_receive)
1358   {
1359     LOG (GNUNET_ERROR_TYPE_DEBUG, "# start receiving from service\n");
1360     h->in_receive = GNUNET_YES;
1361     GNUNET_CLIENT_receive (h->client, &msg_received, h,
1362                            GNUNET_TIME_UNIT_FOREVER_REL);
1363   }
1364   LOG (GNUNET_ERROR_TYPE_DEBUG, "# Send packet() END\n");
1365   return tsize;
1366 }
1367
1368
1369 /**
1370  * Auxiliary function to send an already constructed packet to the service.
1371  * Takes care of creating a new queue element, copying the message and
1372  * calling the tmt_rdy function if necessary.
1373  *
1374  * @param h mesh handle
1375  * @param msg message to transmit
1376  * @param channel channel this send is related to (NULL if N/A)
1377  */
1378 static void
1379 send_packet (struct GNUNET_MESH_Handle *h,
1380              const struct GNUNET_MessageHeader *msg,
1381              struct GNUNET_MESH_Channel *channel)
1382 {
1383   struct GNUNET_MESH_TransmitHandle *th;
1384   size_t msize;
1385
1386   LOG (GNUNET_ERROR_TYPE_DEBUG, " Sending message to service: %s\n",
1387        GM_m2s(ntohs(msg->type)));
1388   msize = ntohs (msg->size);
1389   th = GNUNET_malloc (sizeof (struct GNUNET_MESH_TransmitHandle) + msize);
1390   th->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
1391   th->size = msize;
1392   th->channel = channel;
1393   memcpy (&th[1], msg, msize);
1394   add_to_queue (h, th);
1395   LOG (GNUNET_ERROR_TYPE_DEBUG, "  queued\n");
1396   if (NULL != h->th)
1397     return;
1398   LOG (GNUNET_ERROR_TYPE_DEBUG, "  calling ntfy tmt rdy for %u bytes\n", msize);
1399   h->th =
1400       GNUNET_CLIENT_notify_transmit_ready (h->client, msize,
1401                                            GNUNET_TIME_UNIT_FOREVER_REL,
1402                                            GNUNET_YES, &send_callback, h);
1403 }
1404
1405
1406 /******************************************************************************/
1407 /**********************      API CALL DEFINITIONS     *************************/
1408 /******************************************************************************/
1409
1410 struct GNUNET_MESH_Handle *
1411 GNUNET_MESH_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls,
1412                      GNUNET_MESH_InboundChannelNotificationHandler new_channel,
1413                      GNUNET_MESH_ChannelEndHandler cleaner,
1414                      const struct GNUNET_MESH_MessageHandler *handlers,
1415                      const uint32_t *ports)
1416 {
1417   struct GNUNET_MESH_Handle *h;
1418
1419   LOG (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_MESH_connect()\n");
1420   h = GNUNET_new (struct GNUNET_MESH_Handle);
1421   LOG (GNUNET_ERROR_TYPE_DEBUG, " addr %p\n", h);
1422   h->cfg = cfg;
1423   h->new_channel = new_channel;
1424   h->cleaner = cleaner;
1425   h->client = GNUNET_CLIENT_connect ("mesh", cfg);
1426   if (h->client == NULL)
1427   {
1428     GNUNET_break (0);
1429     GNUNET_free (h);
1430     return NULL;
1431   }
1432   h->cls = cls;
1433   h->message_handlers = handlers;
1434   h->ports = ports;
1435   h->next_chid = GNUNET_MESH_LOCAL_CHANNEL_ID_CLI;
1436   h->reconnect_time = GNUNET_TIME_UNIT_MILLISECONDS;
1437   h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
1438
1439   if (NULL != ports && ports[0] != 0 && NULL == new_channel)
1440   {
1441     GNUNET_break (0);
1442     LOG (GNUNET_ERROR_TYPE_DEBUG,
1443          "no new channel handler given, ports parameter is useless!!\n");
1444   }
1445   if ((NULL == ports || ports[0] == 0) && NULL != new_channel)
1446   {
1447     GNUNET_break (0);
1448     LOG (GNUNET_ERROR_TYPE_DEBUG,
1449          "no ports given, new channel handler will never be called!!\n");
1450   }
1451   /* count handlers */
1452   for (h->n_handlers = 0;
1453        handlers && handlers[h->n_handlers].type;
1454        h->n_handlers++) ;
1455   for (h->n_ports = 0;
1456        ports && ports[h->n_ports];
1457        h->n_ports++) ;
1458   send_connect (h);
1459   LOG (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_MESH_connect() END\n");
1460   return h;
1461 }
1462
1463
1464 void
1465 GNUNET_MESH_disconnect (struct GNUNET_MESH_Handle *handle)
1466 {
1467   struct GNUNET_MESH_Channel *ch;
1468   struct GNUNET_MESH_Channel *aux;
1469   struct GNUNET_MESH_TransmitHandle *th;
1470
1471   LOG (GNUNET_ERROR_TYPE_DEBUG, "MESH DISCONNECT\n");
1472
1473   ch = handle->channels_head;
1474   while (NULL != ch)
1475   {
1476     aux = ch->next;
1477     if (ch->chid < GNUNET_MESH_LOCAL_CHANNEL_ID_SERV)
1478     {
1479       GNUNET_break (0);
1480       LOG (GNUNET_ERROR_TYPE_DEBUG, "channel %X not destroyed\n", ch->chid);
1481     }
1482     destroy_channel (ch, GNUNET_YES);
1483     ch = aux;
1484   }
1485   while ( (th = handle->th_head) != NULL)
1486   {
1487     struct GNUNET_MessageHeader *msg;
1488
1489     /* Make sure it is an allowed packet (everything else should have been
1490      * already canceled).
1491      */
1492     GNUNET_break (GNUNET_NO == th_is_payload (th));
1493     msg = (struct GNUNET_MessageHeader *) &th[1];
1494     switch (ntohs(msg->type))
1495     {
1496       case GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT:
1497       case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE:
1498       case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY:
1499       case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_CHANNELS:
1500       case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_CHANNEL:
1501       case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_PEER:
1502       case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_PEERS:
1503       case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNEL:
1504       case GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNELS:
1505         break;
1506       default:
1507         GNUNET_break (0);
1508         LOG (GNUNET_ERROR_TYPE_ERROR, "unexpected msg %u\n",
1509              ntohs(msg->type));
1510     }
1511
1512     GNUNET_CONTAINER_DLL_remove (handle->th_head, handle->th_tail, th);
1513     GNUNET_free (th);
1514   }
1515
1516   if (NULL != handle->th)
1517   {
1518     GNUNET_CLIENT_notify_transmit_ready_cancel (handle->th);
1519     handle->th = NULL;
1520   }
1521   if (NULL != handle->client)
1522   {
1523     GNUNET_CLIENT_disconnect (handle->client);
1524     handle->client = NULL;
1525   }
1526   if (GNUNET_SCHEDULER_NO_TASK != handle->reconnect_task)
1527   {
1528     GNUNET_SCHEDULER_cancel(handle->reconnect_task);
1529     handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
1530   }
1531   GNUNET_free (handle);
1532 }
1533
1534
1535 /**
1536  * Create a new channel towards a remote peer.
1537  *
1538  * If the destination port is not open by any peer or the destination peer
1539  * does not accept the channel, #GNUNET_MESH_ChannelEndHandler will be called
1540  * for this channel.
1541  *
1542  * @param h mesh handle
1543  * @param channel_ctx client's channel context to associate with the channel
1544  * @param peer peer identity the channel should go to
1545  * @param port Port number.
1546  * @param options MeshOption flag field, with all desired option bits set to 1.
1547  *
1548  * @return handle to the channel
1549  */
1550 struct GNUNET_MESH_Channel *
1551 GNUNET_MESH_channel_create (struct GNUNET_MESH_Handle *h,
1552                             void *channel_ctx,
1553                             const struct GNUNET_PeerIdentity *peer,
1554                             uint32_t port,
1555                             enum GNUNET_MESH_ChannelOption options)
1556 {
1557   struct GNUNET_MESH_Channel *ch;
1558   struct GNUNET_MESH_ChannelMessage msg;
1559
1560   LOG (GNUNET_ERROR_TYPE_DEBUG,
1561        "Creating new channel to %s:%u\n",
1562        GNUNET_i2s (peer), port);
1563   ch = create_channel (h, 0);
1564   LOG (GNUNET_ERROR_TYPE_DEBUG, "  at %p\n", ch);
1565   LOG (GNUNET_ERROR_TYPE_DEBUG, "  number %X\n", ch->chid);
1566   ch->ctx = channel_ctx;
1567   ch->peer = GNUNET_PEER_intern (peer);
1568   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE);
1569   msg.header.size = htons (sizeof (struct GNUNET_MESH_ChannelMessage));
1570   msg.channel_id = htonl (ch->chid);
1571   msg.port = htonl (port);
1572   msg.peer = *peer;
1573   msg.opt = htonl (options);
1574   ch->allow_send = 0;
1575   send_packet (h, &msg.header, ch);
1576   return ch;
1577 }
1578
1579
1580 void
1581 GNUNET_MESH_channel_destroy (struct GNUNET_MESH_Channel *channel)
1582 {
1583   struct GNUNET_MESH_Handle *h;
1584   struct GNUNET_MESH_ChannelMessage msg;
1585   struct GNUNET_MESH_TransmitHandle *th;
1586
1587   LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroying channel\n");
1588   h = channel->mesh;
1589
1590   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY);
1591   msg.header.size = htons (sizeof (struct GNUNET_MESH_ChannelMessage));
1592   msg.channel_id = htonl (channel->chid);
1593   memset (&msg.peer, 0, sizeof (struct GNUNET_PeerIdentity));
1594   msg.port = 0;
1595   msg.opt = 0;
1596   th = h->th_head;
1597   while (th != NULL)
1598   {
1599     struct GNUNET_MESH_TransmitHandle *aux;
1600     if (th->channel == channel)
1601     {
1602       aux = th->next;
1603       /* FIXME call the handler? */
1604       if (GNUNET_YES == th_is_payload (th))
1605         th->notify (th->notify_cls, 0, NULL);
1606       GNUNET_CONTAINER_DLL_remove (h->th_head, h->th_tail, th);
1607       GNUNET_free (th);
1608       th = aux;
1609     }
1610     else
1611       th = th->next;
1612   }
1613
1614   destroy_channel (channel, GNUNET_YES);
1615   send_packet (h, &msg.header, NULL);
1616 }
1617
1618
1619 /**
1620  * Get information about a channel.
1621  *
1622  * @param channel Channel handle.
1623  * @param option Query (GNUNET_MESH_OPTION_*).
1624  * @param ... dependant on option, currently not used
1625  *
1626  * @return Union with an answer to the query.
1627  */
1628 const union GNUNET_MESH_ChannelInfo *
1629 GNUNET_MESH_channel_get_info (struct GNUNET_MESH_Channel *channel,
1630                               enum GNUNET_MESH_ChannelOption option, ...)
1631 {
1632   static int bool_flag;
1633   const union GNUNET_MESH_ChannelInfo *ret;
1634
1635   switch (option)
1636   {
1637     case GNUNET_MESH_OPTION_NOBUFFER:
1638     case GNUNET_MESH_OPTION_RELIABLE:
1639     case GNUNET_MESH_OPTION_OOORDER:
1640       if (0 != (option & channel->options))
1641         bool_flag = GNUNET_YES;
1642       else
1643         bool_flag = GNUNET_NO;
1644       ret = (const union GNUNET_MESH_ChannelInfo *) &bool_flag;
1645       break;
1646     case GNUNET_MESH_OPTION_PEER:
1647       ret = (const union GNUNET_MESH_ChannelInfo *) GNUNET_PEER_resolve2 (channel->peer);
1648       break;
1649     default:
1650       GNUNET_break (0);
1651       return NULL;
1652   }
1653
1654   return ret;
1655 }
1656
1657 struct GNUNET_MESH_TransmitHandle *
1658 GNUNET_MESH_notify_transmit_ready (struct GNUNET_MESH_Channel *channel, int cork,
1659                                    struct GNUNET_TIME_Relative maxdelay,
1660                                    size_t notify_size,
1661                                    GNUNET_CONNECTION_TransmitReadyNotify notify,
1662                                    void *notify_cls)
1663 {
1664   struct GNUNET_MESH_TransmitHandle *th;
1665
1666   GNUNET_assert (NULL != channel);
1667   LOG (GNUNET_ERROR_TYPE_DEBUG, "MESH NOTIFY TRANSMIT READY\n");
1668   LOG (GNUNET_ERROR_TYPE_DEBUG, "    on channel %X\n", channel->chid);
1669   LOG (GNUNET_ERROR_TYPE_DEBUG, "    allow_send %d\n", channel->allow_send);
1670   if (channel->chid >= GNUNET_MESH_LOCAL_CHANNEL_ID_SERV)
1671     LOG (GNUNET_ERROR_TYPE_DEBUG, "    to origin\n");
1672   else
1673     LOG (GNUNET_ERROR_TYPE_DEBUG, "    to destination\n");
1674   LOG (GNUNET_ERROR_TYPE_DEBUG, "    payload size %u\n", notify_size);
1675   GNUNET_assert (NULL != notify);
1676   GNUNET_assert (0 == channel->packet_size); // Only one data packet allowed
1677   th = GNUNET_new (struct GNUNET_MESH_TransmitHandle);
1678   th->channel = channel;
1679   th->timeout = GNUNET_TIME_relative_to_absolute (maxdelay);
1680   th->size = notify_size + sizeof (struct GNUNET_MESH_LocalData);
1681   channel->packet_size = th->size;
1682   LOG (GNUNET_ERROR_TYPE_DEBUG, "    total size %u\n", th->size);
1683   th->notify = notify;
1684   th->notify_cls = notify_cls;
1685   add_to_queue (channel->mesh, th);
1686   if (NULL != channel->mesh->th)
1687     return th;
1688   if (GNUNET_NO == channel->allow_send)
1689     return th;
1690   LOG (GNUNET_ERROR_TYPE_DEBUG, "    call client notify tmt rdy\n");
1691   channel->mesh->th =
1692       GNUNET_CLIENT_notify_transmit_ready (channel->mesh->client, th->size,
1693                                            GNUNET_TIME_UNIT_FOREVER_REL,
1694                                            GNUNET_YES, &send_callback,
1695                                            channel->mesh);
1696   LOG (GNUNET_ERROR_TYPE_DEBUG, "MESH NOTIFY TRANSMIT READY END\n");
1697   return th;
1698 }
1699
1700
1701 void
1702 GNUNET_MESH_notify_transmit_ready_cancel (struct GNUNET_MESH_TransmitHandle *th)
1703 {
1704   struct GNUNET_MESH_Handle *mesh;
1705
1706   th->channel->packet_size = 0;
1707   mesh = th->channel->mesh;
1708   if (th->timeout_task != GNUNET_SCHEDULER_NO_TASK)
1709     GNUNET_SCHEDULER_cancel (th->timeout_task);
1710   GNUNET_CONTAINER_DLL_remove (mesh->th_head, mesh->th_tail, th);
1711   GNUNET_free (th);
1712   if ((0 == message_ready_size (mesh)) && (NULL != mesh->th))
1713   {
1714     /* queue empty, no point in asking for transmission */
1715     GNUNET_CLIENT_notify_transmit_ready_cancel (mesh->th);
1716     mesh->th = NULL;
1717   }
1718 }
1719
1720
1721 void
1722 GNUNET_MESH_receive_done (struct GNUNET_MESH_Channel *channel)
1723 {
1724   send_ack (channel);
1725 }
1726
1727
1728 static void
1729 send_info_request (struct GNUNET_MESH_Handle *h, uint16_t type)
1730 {
1731   struct GNUNET_MessageHeader msg;
1732
1733   msg.size = htons (sizeof (msg));
1734   msg.type = htons (type);
1735   send_packet (h, &msg, NULL);
1736 }
1737
1738
1739 /**
1740  * Request information about peers known to the running mesh service.
1741  * The callback will be called for every peer known to the service.
1742  * Only one info request (of any kind) can be active at once.
1743  *
1744  *
1745  * WARNING: unstable API, likely to change in the future!
1746  *
1747  * @param h Handle to the mesh peer.
1748  * @param callback Function to call with the requested data.
1749  * @param callback_cls Closure for @c callback.
1750  *
1751  * @return #GNUNET_OK / #GNUNET_SYSERR
1752  */
1753 int
1754 GNUNET_MESH_get_peers (struct GNUNET_MESH_Handle *h,
1755                        GNUNET_MESH_PeersCB callback,
1756                        void *callback_cls)
1757 {
1758   if (NULL != h->info_cb.peers_cb)
1759   {
1760     GNUNET_break (0);
1761     return GNUNET_SYSERR;
1762   }
1763   send_info_request (h, GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_PEERS);
1764   h->info_cb.peers_cb = callback;
1765   h->info_cls = callback_cls;
1766   return GNUNET_OK;
1767 }
1768
1769
1770 /**
1771  * Cancel a peer info request. The callback will not be called (anymore).
1772  *
1773  * WARNING: unstable API, likely to change in the future!
1774  *
1775  * @param h Mesh handle.
1776  *
1777  * @return Closure given to GNUNET_MESH_get_peers.
1778  */
1779 void *
1780 GNUNET_MESH_get_peers_cancel (struct GNUNET_MESH_Handle *h)
1781 {
1782   void *cls;
1783
1784   cls = h->info_cls;
1785   h->info_cb.peers_cb = NULL;
1786   h->info_cls = NULL;
1787   return cls;
1788 }
1789
1790
1791 /**
1792  * Request information about a peer known to the running mesh peer.
1793  * The callback will be called for the tunnel once.
1794  * Only one info request (of any kind) can be active at once.
1795  *
1796  * WARNING: unstable API, likely to change in the future!
1797  *
1798  * @param h Handle to the mesh peer.
1799  * @param id Peer whose tunnel to examine.
1800  * @param callback Function to call with the requested data.
1801  * @param callback_cls Closure for @c callback.
1802  *
1803  * @return #GNUNET_OK / #GNUNET_SYSERR
1804  */
1805 int
1806 GNUNET_MESH_get_peer (struct GNUNET_MESH_Handle *h,
1807                       const struct GNUNET_PeerIdentity *id,
1808                       GNUNET_MESH_PeerCB callback,
1809                       void *callback_cls)
1810 {
1811   struct GNUNET_MESH_LocalInfo msg;
1812
1813   if (NULL != h->info_cb.peer_cb)
1814   {
1815     GNUNET_break (0);
1816     return GNUNET_SYSERR;
1817   }
1818
1819   memset (&msg, 0, sizeof (msg));
1820   msg.header.size = htons (sizeof (msg));
1821   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_PEER);
1822   msg.peer = *id;
1823   send_packet (h, &msg.header, NULL);
1824   h->info_cb.peer_cb = callback;
1825   h->info_cls = callback_cls;
1826   return GNUNET_OK;
1827 }
1828
1829
1830 /**
1831  * Request information about tunnels of the running mesh peer.
1832  * The callback will be called for every tunnel of the service.
1833  * Only one info request (of any kind) can be active at once.
1834  *
1835  * WARNING: unstable API, likely to change in the future!
1836  *
1837  * @param h Handle to the mesh peer.
1838  * @param callback Function to call with the requested data.
1839  * @param callback_cls Closure for @c callback.
1840  *
1841  * @return #GNUNET_OK / #GNUNET_SYSERR
1842  */
1843 int
1844 GNUNET_MESH_get_tunnels (struct GNUNET_MESH_Handle *h,
1845                          GNUNET_MESH_TunnelsCB callback,
1846                          void *callback_cls)
1847 {
1848   if (NULL != h->info_cb.tunnels_cb)
1849   {
1850     GNUNET_break (0);
1851     return GNUNET_SYSERR;
1852   }
1853   send_info_request (h, GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNELS);
1854   h->info_cb.tunnels_cb = callback;
1855   h->info_cls = callback_cls;
1856   return GNUNET_OK;
1857 }
1858
1859
1860 /**
1861  * Cancel a monitor request. The monitor callback will not be called.
1862  *
1863  * @param h Mesh handle.
1864  *
1865  * @return Closure given to GNUNET_MESH_get_tunnels.
1866  */
1867 void *
1868 GNUNET_MESH_get_tunnels_cancel (struct GNUNET_MESH_Handle *h)
1869 {
1870   void *cls;
1871
1872   h->info_cb.tunnels_cb = NULL;
1873   cls = h->info_cls;
1874   h->info_cls = NULL;
1875
1876   return cls;
1877 }
1878
1879
1880
1881 /**
1882  * Request information about a tunnel of the running mesh peer.
1883  * The callback will be called for the tunnel once.
1884  * Only one info request (of any kind) can be active at once.
1885  *
1886  * WARNING: unstable API, likely to change in the future!
1887  *
1888  * @param h Handle to the mesh peer.
1889  * @param id Peer whose tunnel to examine.
1890  * @param callback Function to call with the requested data.
1891  * @param callback_cls Closure for @c callback.
1892  *
1893  * @return #GNUNET_OK / #GNUNET_SYSERR
1894  */
1895 int
1896 GNUNET_MESH_get_tunnel (struct GNUNET_MESH_Handle *h,
1897                         const struct GNUNET_PeerIdentity *id,
1898                         GNUNET_MESH_TunnelCB callback,
1899                         void *callback_cls)
1900 {
1901   struct GNUNET_MESH_LocalInfo msg;
1902
1903   if (NULL != h->info_cb.tunnel_cb)
1904   {
1905     GNUNET_break (0);
1906     return GNUNET_SYSERR;
1907   }
1908
1909   memset (&msg, 0, sizeof (msg));
1910   msg.header.size = htons (sizeof (msg));
1911   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNEL);
1912   msg.peer = *id;
1913   send_packet (h, &msg.header, NULL);
1914   h->info_cb.tunnel_cb = callback;
1915   h->info_cls = callback_cls;
1916   return GNUNET_OK;
1917 }
1918
1919
1920 /**
1921  * Request information about a specific channel of the running mesh peer.
1922  *
1923  * WARNING: unstable API, likely to change in the future!
1924  * FIXME Add destination option.
1925  *
1926  * @param h Handle to the mesh peer.
1927  * @param initiator ID of the owner of the channel.
1928  * @param channel_number Channel number.
1929  * @param callback Function to call with the requested data.
1930  * @param callback_cls Closure for @c callback.
1931  *
1932  * @return #GNUNET_OK / #GNUNET_SYSERR
1933  */
1934 int
1935 GNUNET_MESH_show_channel (struct GNUNET_MESH_Handle *h,
1936                          struct GNUNET_PeerIdentity *initiator,
1937                          unsigned int channel_number,
1938                          GNUNET_MESH_ChannelCB callback,
1939                          void *callback_cls)
1940 {
1941   struct GNUNET_MESH_LocalInfo msg;
1942
1943   if (NULL != h->info_cb.channel_cb)
1944   {
1945     GNUNET_break (0);
1946     return GNUNET_SYSERR;
1947   }
1948
1949   msg.header.size = htons (sizeof (msg));
1950   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_CHANNEL);
1951   msg.peer = *initiator;
1952   msg.channel_id = htonl (channel_number);
1953 //   msg.reserved = 0;
1954   send_packet (h, &msg.header, NULL);
1955   h->info_cb.channel_cb = callback;
1956   h->info_cls = callback_cls;
1957   return GNUNET_OK;
1958 }
1959
1960
1961 /**
1962  * Function called to notify a client about the connection
1963  * begin ready to queue more data.  "buf" will be
1964  * NULL and "size" zero if the connection was closed for
1965  * writing in the meantime.
1966  *
1967  * @param cls closure
1968  * @param size number of bytes available in buf
1969  * @param buf where the callee should write the message
1970  * @return number of bytes written to buf
1971  */
1972 static size_t
1973 mesh_mq_ntr (void *cls, size_t size,
1974              void *buf)
1975 {
1976   struct GNUNET_MQ_Handle *mq = cls;
1977   struct MeshMQState *state = GNUNET_MQ_impl_state (mq);
1978   const struct GNUNET_MessageHeader *msg = GNUNET_MQ_impl_current (mq);
1979   uint16_t msize;
1980
1981   state->th = NULL;
1982   if (NULL == buf)
1983   {
1984     GNUNET_MQ_inject_error (mq, GNUNET_MQ_ERROR_WRITE);
1985     return 0;
1986   }
1987   msize = ntohs (msg->size);
1988   GNUNET_assert (msize <= size);
1989   memcpy (buf, msg, msize);
1990   GNUNET_MQ_impl_send_continue (mq);
1991   return msize;
1992 }
1993
1994
1995 /**
1996  * Signature of functions implementing the
1997  * sending functionality of a message queue.
1998  *
1999  * @param mq the message queue
2000  * @param msg the message to send
2001  * @param impl_state state of the implementation
2002  */
2003 static void
2004 mesh_mq_send_impl (struct GNUNET_MQ_Handle *mq,
2005                    const struct GNUNET_MessageHeader *msg, void *impl_state)
2006 {
2007   struct MeshMQState *state = impl_state;
2008
2009   GNUNET_assert (NULL == state->th);
2010   state->th =
2011       GNUNET_MESH_notify_transmit_ready (state->channel,
2012                                          /* FIXME: add option for corking */
2013                                          GNUNET_NO,
2014                                          GNUNET_TIME_UNIT_FOREVER_REL,
2015                                          ntohs (msg->size),
2016                                          mesh_mq_ntr, mq);
2017
2018 }
2019
2020
2021 /**
2022  * Signature of functions implementing the
2023  * destruction of a message queue.
2024  * Implementations must not free 'mq', but should
2025  * take care of 'impl_state'.
2026  *
2027  * @param mq the message queue to destroy
2028  * @param impl_state state of the implementation
2029  */
2030 static void
2031 mesh_mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
2032 {
2033   struct MeshMQState *state = impl_state;
2034
2035   if (NULL != state->th)
2036     GNUNET_MESH_notify_transmit_ready_cancel (state->th);
2037
2038   GNUNET_free (state);
2039 }
2040
2041
2042 /**
2043  * Create a message queue for a mesh channel.
2044  * The message queue can only be used to transmit messages,
2045  * not to receive them.
2046  *
2047  * @param channel the channel to create the message qeue for
2048  * @return a message queue to messages over the channel
2049  */
2050 struct GNUNET_MQ_Handle *
2051 GNUNET_MESH_mq_create (struct GNUNET_MESH_Channel *channel)
2052 {
2053   struct GNUNET_MQ_Handle *mq;
2054   struct MeshMQState *state;
2055
2056   state = GNUNET_new (struct MeshMQState);
2057   state->channel = channel;
2058
2059   mq = GNUNET_MQ_queue_for_callbacks (mesh_mq_send_impl,
2060                                       mesh_mq_destroy_impl,
2061                                       NULL, /* FIXME: cancel impl. */
2062                                       state,
2063                                       NULL, /* no msg handlers */
2064                                       NULL, /* no err handlers */
2065                                       NULL); /* no handler cls */
2066   return mq;
2067 }
2068