src/mesh/mesh_api_new.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2011 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file mesh/mesh_api_new.c
  23  * @brief mesh api: client implementation of mesh service
  24  * @author Bartlomiej Polot
  25  *
  26  * STRUCTURE:
  27  * - CONSTANTS
  28  * - DATA STRUCTURES
  29  * - AUXILIARY FUNCTIONS
  30  * - RECEIVE HANDLERS
  31  * - SEND FUNCTIONS
  32  * - API CALL DEFINITIONS
  33  */
  34
  35 #ifdef __cplusplus
  36
  37 extern "C"
  38 {
  39 #if 0                           /* keep Emacsens' auto-indent happy */
  40 }
  41 #endif
  42 #endif
  43
  44
  45 #include "platform.h"
  46 #include "gnunet_common.h"
  47 #include "gnunet_client_lib.h"
  48 #include "gnunet_util_lib.h"
  49 #include "gnunet_peer_lib.h"
  50 #include "gnunet_mesh_service_new.h"
  51 #include "mesh.h"
  52 #include "mesh_protocol.h"
  53
  54 #define MESH_API_MAX_QUEUE 10
  55
  56 /******************************************************************************/
  57 /************************      DATA STRUCTURES     ****************************/
  58 /******************************************************************************/
  59
  60 /**
  61  * Transmission queue to the service
  62  */
  63 struct GNUNET_MESH_queue
  64 {
  65     /**
  66      * Double Linked list
  67      */
  68     struct GNUNET_MESH_queue    *next;
  69     struct GNUNET_MESH_queue    *prev;
  70
  71     /**
  72      * Size of the data to follow
  73      */
  74     uint16_t                    size;
  75
  76     /**
  77      * Data itself
  78      */
  79     void                        *data;
  80 };
  81
  82
  83 /**
  84  * Opaque handle to the service.
  85  */
  86 struct GNUNET_MESH_Handle
  87 {
  88     /**
  89      * Handle to the server connection, to send messages later
  90      */
  91   struct GNUNET_CLIENT_Connection *client;
  92
  93     /**
  94      * Set of handlers used for processing incoming messages in the tunnels
  95      */
  96   const struct GNUNET_MESH_MessageHandler *message_handlers;
  97   int n_handlers;
  98
  99     /**
 100      * Set of applications that should be claimed to be offered at this node.
 101      * Note that this is just informative, the appropiate handlers must be
 102      * registered independently and the mapping is up to the developer of the
 103      * client application.
 104      */
 105   const GNUNET_MESH_ApplicationType *applications;
 106   int n_applications;
 107
 108     /**
 109      * Double linked list of the tunnels this client is connected to.
 110      */
 111   struct GNUNET_MESH_Tunnel *tunnels_head;
 112   struct GNUNET_MESH_Tunnel *tunnels_tail;
 113
 114     /**
 115      * tid of the next tunnel to create (to avoid reusing IDs often)
 116      */
 117   MESH_TunnelNumber next_tid;
 118
 119     /**
 120      * Callback for tunnel disconnection
 121      */
 122   GNUNET_MESH_TunnelEndHandler *cleaner;
 123
 124     /**
 125      * Handle to cancel pending transmissions in case of disconnection
 126      */
 127   struct GNUNET_CLIENT_TransmitHandle *th;
 128
 129     /**
 130      * Closure for all the handlers given by the client
 131      */
 132   void *cls;
 133
 134     /**
 135      * Messages to send to the service
 136      */
 137   struct GNUNET_MESH_queue      *queue_head;
 138   struct GNUNET_MESH_queue      *queue_tail;
 139 };
 140
 141 /**
 142  * Opaque handle to a tunnel.
 143  */
 144 struct GNUNET_MESH_Tunnel
 145 {
 146
 147     /**
 148      * DLL
 149      */
 150   struct GNUNET_MESH_Tunnel *next;
 151   struct GNUNET_MESH_Tunnel *prev;
 152
 153     /**
 154      * Local ID of the tunnel
 155      */
 156   MESH_TunnelNumber tid;
 157
 158     /**
 159      * Owner of the tunnel
 160      */
 161   GNUNET_PEER_Id owner;
 162
 163     /**
 164      * Callback to execute when peers connect to the tunnel
 165      */
 166   GNUNET_MESH_TunnelConnectHandler connect_handler;
 167
 168     /**
 169      * Callback to execute when peers disconnect to the tunnel
 170      */
 171   GNUNET_MESH_TunnelDisconnectHandler disconnect_handler;
 172
 173     /**
 174      * All peers added to the tunnel
 175      */
 176   GNUNET_PEER_Id *peers;
 177
 178     /**
 179      * Number of peer added to the tunnel
 180      */
 181   uint32_t npeers;
 182
 183     /**
 184      * Closure for the connect/disconnect handlers
 185      */
 186   void *cls;
 187
 188     /**
 189      * Handle to the mesh this tunnel belongs to
 190      */
 191   struct GNUNET_MESH_Handle *mesh;
 192 };
 193
 194 struct GNUNET_MESH_TransmitHandle
 195 {
 196   struct GNUNET_MESH_Tunnel *t;
 197   struct GNUNET_MESH_queue *q;
 198 };
 199
 200 /******************************************************************************/
 201 /***********************     AUXILIARY FUNCTIONS      *************************/
 202 /******************************************************************************/
 203
 204 /**
 205  * Get the tunnel handler for the tunnel specified by id from the given handle
 206  * @param h Mesh handle
 207  * @param tid ID of the wanted tunnel
 208  * @return handle to the required tunnel or NULL if not found
 209  */
 210 static struct GNUNET_MESH_Tunnel *
 211 retrieve_tunnel (struct GNUNET_MESH_Handle *h, MESH_TunnelNumber tid)
 212 {
 213   struct GNUNET_MESH_Tunnel *t;
 214
 215   t = h->tunnels_head;
 216   while (t != NULL)
 217   {
 218     if (t->tid == tid)
 219       return t;
 220     t = t->next;
 221   }
 222   return NULL;
 223 }
 224
 225 /**
 226  * Get the length of the transmission queue
 227  * @param h mesh handle whose queue is to be measured
 228  */
 229 static uint32_t
 230 get_queue_length (struct GNUNET_MESH_Handle *h)
 231 {
 232   struct GNUNET_MESH_queue *q;
 233   uint32_t i;
 234
 235   /* count */
 236   for (q = h->queue_head, i = 0; NULL != q; q = q->next, i++);
 237
 238   return i;
 239 }
 240
 241
 242 /******************************************************************************/
 243 /***********************      RECEIVE HANDLERS     ****************************/
 244 /******************************************************************************/
 245
 246 /**
 247  * Process the new tunnel notification and add it to the tunnels in the handle
 248  *
 249  * @param h     The mesh handle
 250  * @param msg   A message with the details of the new incoming tunnel
 251  */
 252 static void
 253 process_tunnel_create (struct GNUNET_MESH_Handle *h,
 254                        const struct GNUNET_MESH_TunnelMessage *msg)
 255 {
 256   struct GNUNET_MESH_Tunnel *t;
 257   MESH_TunnelNumber tid;
 258
 259   tid = ntohl (msg->tunnel_id);
 260   if (tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_MARK)
 261   {
 262     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 263                 "MESH: received an incoming tunnel with tid in local range (%X)\n",
 264                 tid);
 265     GNUNET_break_op (0);
 266     return;                     //FIXME abort? reconnect?
 267   }
 268   t = GNUNET_malloc (sizeof (struct GNUNET_MESH_Tunnel));
 269   t->cls = h->cls;
 270   t->mesh = h;
 271   t->tid = tid;
 272
 273   return;
 274 }
 275
 276
 277 /**
 278  * Process the new peer event and notify the upper level of it
 279  *
 280  * @param h     The mesh handle
 281  * @param msg   A message with the details of the peer event
 282  */
 283 static void
 284 process_peer_event (struct GNUNET_MESH_Handle *h,
 285                     const struct GNUNET_MESH_PeerControl *msg)
 286 {
 287   struct GNUNET_MESH_Tunnel *t;
 288   uint16_t size;
 289
 290   size = ntohs (msg->header.size);
 291   if (size != sizeof (struct GNUNET_MESH_PeerControl))
 292   {
 293     GNUNET_break_op (0);
 294     return;
 295   }
 296   t = retrieve_tunnel (h, ntohl (msg->tunnel_id));
 297   if (NULL == t)
 298   {
 299     GNUNET_break_op (0);
 300     return;
 301   }
 302   if (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_CONNECTED == msg->header.type)
 303   {
 304     if (NULL != t->connect_handler)
 305     {
 306       t->connect_handler (t->cls, &msg->peer, NULL);    /* FIXME atsi */
 307     }
 308   }
 309   else
 310   {
 311     if (NULL != t->disconnect_handler)
 312     {
 313       t->disconnect_handler (t->cls, &msg->peer);
 314     }
 315   }
 316 }
 317
 318
 319 /**
 320  * Process the incoming data packets
 321  *
 322  * @param h     The mesh handle
 323  * @param msh   A message encapsulating the data
 324  */
 325 static void
 326 process_incoming_data (struct GNUNET_MESH_Handle *h,
 327                        const struct GNUNET_MessageHeader *message)
 328 {
 329   const struct GNUNET_MessageHeader *payload;
 330   const struct GNUNET_MESH_MessageHandler *handler;
 331   const struct GNUNET_PeerIdentity *peer;
 332   struct GNUNET_MESH_Unicast *ucast;
 333   struct GNUNET_MESH_Multicast *mcast;
 334   struct GNUNET_MESH_ToOrigin *to_orig;
 335   struct GNUNET_MESH_Tunnel *t;
 336   uint16_t type;
 337   int i;
 338
 339   type = ntohs (message->type);
 340   switch (type)
 341   {
 342   case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
 343     ucast = (struct GNUNET_MESH_Unicast *) message;
 344     t = retrieve_tunnel (h, ntohl (ucast->tid));
 345     payload = (struct GNUNET_MessageHeader *) &ucast[1];
 346     peer = &ucast->oid;
 347     break;
 348   case GNUNET_MESSAGE_TYPE_MESH_MULTICAST:
 349     mcast = (struct GNUNET_MESH_Multicast *) message;
 350     t = retrieve_tunnel (h, ntohl (mcast->tid));
 351     payload = (struct GNUNET_MessageHeader *) &mcast[1];
 352     peer = &mcast->oid;
 353     break;
 354   case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
 355     to_orig = (struct GNUNET_MESH_ToOrigin *) message;
 356     t = retrieve_tunnel (h, ntohl (to_orig->tid));
 357     payload = (struct GNUNET_MessageHeader *) &to_orig[1];
 358     peer = &to_orig->sender;
 359     break;
 360   default:
 361     GNUNET_break_op (0);
 362     return;
 363   }
 364   if (NULL == t)
 365   {
 366     GNUNET_break_op (0);
 367     return;
 368   }
 369   for (i = 0; i < h->n_handlers; i++)
 370   {
 371     handler = &h->message_handlers[i];
 372     if (handler->type == type)
 373     {
 374       if (GNUNET_OK == handler->callback (h->cls, t, NULL,      /* FIXME ctx */
 375                                           peer, payload, NULL)) /* FIXME atsi */
 376       {
 377         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 378                     "MESH: callback completed successfully\n");
 379       }
 380       else
 381       {
 382         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 383                     "MESH: callback caused disconnection\n");
 384         GNUNET_MESH_disconnect (h);
 385       }
 386     }
 387   }
 388   return;
 389 }
 390
 391
 392 /**
 393  * Function to process all messages received from the service
 394  *
 395  * @param cls closure
 396  * @param msg message received, NULL on timeout or fatal error
 397  */
 398 static void
 399 msg_received (void *cls, const struct GNUNET_MessageHeader *msg)
 400 {
 401   struct GNUNET_MESH_Handle *h = cls;
 402
 403   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: received a message from MESH\n");
 404   if (msg == NULL)
 405   {
 406     GNUNET_break_op (0);
 407     return;
 408   }
 409
 410   switch (ntohs (msg->type))
 411   {
 412     /* Notify of a new incoming tunnel */
 413   case GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_CREATE:
 414     process_tunnel_create (h, (struct GNUNET_MESH_TunnelMessage *) msg);
 415     break;
 416     /* Notify of a new peer or a peer disconnect in the tunnel */
 417   case GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_CONNECTED:
 418   case GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_DISCONNECTED:
 419     process_peer_event (h, (struct GNUNET_MESH_PeerControl *) msg);
 420     break;
 421     /* Notify of a new data packet in the tunnel */
 422   case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
 423   case GNUNET_MESSAGE_TYPE_MESH_MULTICAST:
 424   case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
 425     process_incoming_data (h, msg);
 426     break;
 427     /* We shouldn't get any other packages, log and ignore */
 428   default:
 429     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 430                 "MESH: unsolicited message form service (type %d)\n",
 431                 ntohs (msg->type));
 432   }
 433
 434   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: message processed\n");
 435   GNUNET_CLIENT_receive (h->client, &msg_received, h,
 436                          GNUNET_TIME_UNIT_FOREVER_REL);
 437   return;
 438 }
 439
 440
 441 /******************************************************************************/
 442 /************************       SEND FUNCTIONS     ****************************/
 443 /******************************************************************************/
 444
 445 /**
 446  * Function called to send a message to the service.
 447  * "buf" will be NULL and "size" zero if the socket was closed for writing in
 448  * the meantime.
 449  *
 450  * @param cls closure, the mesh handle
 451  * @param size number of bytes available in buf
 452  * @param buf where the callee should write the connect message
 453  * @return number of bytes written to buf
 454  */
 455 static size_t
 456 send_raw (void *cls, size_t size, void *buf)
 457 {
 458   struct GNUNET_MESH_Handle *h = cls;
 459   struct GNUNET_MESH_queue *q;
 460
 461   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: Send packet() Buffer %u\n", size);
 462   h->th = NULL;
 463   if (0 == size || NULL == buf)
 464   {
 465     // FIXME: disconnect, reconnect, retry?
 466     return 0;
 467   }
 468   q = h->queue_head;
 469   if (sizeof (struct GNUNET_MessageHeader) > size)
 470   {
 471     GNUNET_break (0);
 472     GNUNET_assert (sizeof (struct GNUNET_MessageHeader) > q->size);
 473     h->th = GNUNET_CLIENT_notify_transmit_ready (h->client, q->size,
 474                                                  GNUNET_TIME_UNIT_FOREVER_REL,
 475                                                  GNUNET_YES, &send_raw, h);
 476     return 0;
 477   }
 478   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh:   type: %i\n",
 479               ntohs(((struct GNUNET_MessageHeader *)q->data)->type));
 480   memcpy(buf, q->data, q->size);
 481   GNUNET_free (q->data);
 482   size = q->size;
 483   GNUNET_CONTAINER_DLL_remove(h->queue_head, h->queue_tail, q);
 484   GNUNET_free(q);
 485   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh:   size: %u\n", size);
 486
 487   if (NULL != h->queue_head)
 488   {
 489     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh:   next size: %u\n",
 490                 h->queue_head->size);
 491     h->th = GNUNET_CLIENT_notify_transmit_ready (h->client, h->queue_head->size,
 492                                                  GNUNET_TIME_UNIT_FOREVER_REL,
 493                                                  GNUNET_YES, &send_raw, h);
 494   }
 495   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: Send packet() END\n");
 496
 497   return size;
 498 }
 499
 500 /**
 501  * Auxiliary function to send a packet to the service
 502  * Takes care of creating a new queue element and calling the tmt_rdy function
 503  * if necessary.
 504  * @param h mesh handle
 505  * @param size size of the packet to transmit
 506  * @param data packet itself
 507  */
 508 static void
 509 send_packet (struct GNUNET_MESH_Handle *h, size_t size, void *data)
 510 {
 511   struct GNUNET_MESH_queue *q;
 512
 513   q = GNUNET_malloc (sizeof (struct GNUNET_MESH_queue));
 514   q->size = size;
 515   q->data = data;
 516   GNUNET_CONTAINER_DLL_insert_tail (h->queue_head, h->queue_tail, q);
 517   if (NULL == h->th)
 518   {
 519     h->th = GNUNET_CLIENT_notify_transmit_ready (h->client, size,
 520                                                  GNUNET_TIME_UNIT_FOREVER_REL,
 521                                                  GNUNET_YES, &send_raw, h);
 522   }
 523 }
 524
 525 /******************************************************************************/
 526 /**********************      API CALL DEFINITIONS     *************************/
 527 /******************************************************************************/
 528
 529 /**
 530  * Connect to the mesh service.
 531  *
 532  * @param cfg configuration to use
 533  * @param cls closure for the various callbacks that follow
 534  *            (including handlers in the handlers array)
 535  * @param cleaner function called when an *inbound* tunnel is destroyed
 536  * @param handlers callbacks for messages we care about, NULL-terminated
 537  *                 note that the mesh is allowed to drop notifications about
 538  *                 inbound messages if the client does not process them fast
 539  *                 enough (for this notification type, a bounded queue is used)
 540  * @param stypes Application Types the client claims to offer
 541  * @return handle to the mesh service
 542  *         NULL on error (in this case, init is never called)
 543  */
 544 struct GNUNET_MESH_Handle *
 545 GNUNET_MESH_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls,
 546                      GNUNET_MESH_TunnelEndHandler cleaner,
 547                      const struct GNUNET_MESH_MessageHandler *handlers,
 548                      const GNUNET_MESH_ApplicationType *stypes)
 549 {
 550   struct GNUNET_MESH_Handle *h;
 551   struct GNUNET_MESH_ClientConnect *msg;
 552   GNUNET_MESH_ApplicationType *apps;
 553   uint16_t napps;
 554   uint16_t *types;
 555   uint16_t ntypes;
 556   size_t size;
 557
 558   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: GNUNET_MESH_connect()\n");
 559   h = GNUNET_malloc (sizeof (struct GNUNET_MESH_Handle));
 560
 561   h->cleaner = cleaner;
 562   h->client = GNUNET_CLIENT_connect ("mesh", cfg);
 563   if (h->client == NULL)
 564   {
 565     GNUNET_break (0);
 566     GNUNET_free (h);
 567     return NULL;
 568   }
 569
 570   h->cls = cls;
 571   h->message_handlers = handlers;
 572   h->applications = stypes;
 573   h->next_tid = 0x80000000;
 574
 575   /* count handlers and apps, calculate size */
 576   for (h->n_handlers = 0; handlers[h->n_handlers].type; h->n_handlers++) ;
 577   for (h->n_applications = 0; stypes[h->n_applications]; h->n_applications++) ;
 578   size = sizeof (struct GNUNET_MESH_ClientConnect);
 579   size += h->n_handlers * sizeof (uint16_t);
 580   size += h->n_applications * sizeof (GNUNET_MESH_ApplicationType);
 581
 582   /* build connection packet */
 583   msg = GNUNET_malloc(size);
 584   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT);
 585   msg->header.size = htons (size);
 586   types = (uint16_t *) &msg[1];
 587   for (ntypes = 0; ntypes < h->n_handlers; ntypes++)
 588   {
 589     types[ntypes] = h->message_handlers[ntypes].type;
 590   }
 591   apps = (GNUNET_MESH_ApplicationType *) &types[ntypes];
 592   for (napps = 0; napps < h->n_applications; napps++)
 593   {
 594     apps[napps] = h->applications[napps];
 595   }
 596   msg->applications = htons (napps);
 597   msg->types = htons (ntypes);
 598
 599   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 600               "mesh: Sending %lu bytes long message %d types and %d apps\n",
 601               ntohs (msg->header.size), ntypes, napps);
 602
 603   send_packet(h, size, msg);
 604
 605   GNUNET_CLIENT_receive (h->client, &msg_received, h,
 606                          GNUNET_TIME_UNIT_FOREVER_REL);
 607
 608   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: GNUNET_MESH_connect() END\n");
 609
 610   return h;
 611 }
 612
 613
 614 /**
 615  * Disconnect from the mesh service.
 616  *
 617  * @param handle connection to mesh to disconnect
 618  */
 619 void
 620 GNUNET_MESH_disconnect (struct GNUNET_MESH_Handle *handle)
 621 {
 622   if (NULL != handle->th)
 623   {
 624     GNUNET_CLIENT_notify_transmit_ready_cancel (handle->th);
 625   }
 626   if (NULL != handle->client)
 627   {
 628     GNUNET_CLIENT_disconnect (handle->client, GNUNET_NO);
 629   }
 630   GNUNET_free (handle);
 631 }
 632
 633
 634 /**
 635  * Create a new tunnel (we're initiator and will be allowed to add/remove peers
 636  * and to broadcast).
 637  *
 638  * @param h mesh handle
 639  * @param connect_handler function to call when peers are actually connected
 640  * @param disconnect_handler function to call when peers are disconnected
 641  * @param handler_cls closure for connect/disconnect handlers
 642  */
 643 struct GNUNET_MESH_Tunnel *
 644 GNUNET_MESH_tunnel_create (struct GNUNET_MESH_Handle *h,
 645                            GNUNET_MESH_TunnelConnectHandler connect_handler,
 646                            GNUNET_MESH_TunnelDisconnectHandler
 647                            disconnect_handler, void *handler_cls)
 648 {
 649   struct GNUNET_MESH_Tunnel *t;
 650   struct GNUNET_MESH_TunnelMessage *msg;
 651
 652   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: Creating new tunnel\n");
 653   t = GNUNET_malloc (sizeof (struct GNUNET_MESH_Tunnel));
 654
 655   t->connect_handler = connect_handler;
 656   t->disconnect_handler = disconnect_handler;
 657   t->cls = handler_cls;
 658   t->mesh = h;
 659   t->tid = h->next_tid++;
 660   h->next_tid |= GNUNET_MESH_LOCAL_TUNNEL_ID_MARK;      // keep in range
 661
 662   msg = GNUNET_malloc (sizeof (struct GNUNET_MESH_TunnelMessage));
 663   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_CREATE);
 664   msg->header.size = htons (sizeof (struct GNUNET_MESH_TunnelMessage));
 665   msg->tunnel_id = htonl (t->tid);
 666
 667   send_packet(h, sizeof (struct GNUNET_MESH_TunnelMessage), msg);
 668
 669   return t;
 670 }
 671
 672
 673 /**
 674  * Destroy an existing tunnel.
 675  *
 676  * @param tun tunnel handle
 677  */
 678 void
 679 GNUNET_MESH_tunnel_destroy (struct GNUNET_MESH_Tunnel *tun)
 680 {
 681   struct GNUNET_MESH_Handle *h;
 682   struct GNUNET_MESH_TunnelMessage *msg;
 683
 684   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: Destroying tunnel\n");
 685
 686   h = tun->mesh;
 687   msg = GNUNET_malloc (sizeof (struct GNUNET_MESH_TunnelMessage));
 688   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_DESTROY);
 689   msg->header.size = htons (sizeof (struct GNUNET_MESH_TunnelMessage));
 690   msg->tunnel_id = htonl (tun->tid);
 691
 692   GNUNET_free (tun);
 693
 694   send_packet(h, sizeof (struct GNUNET_MESH_TunnelMessage), msg);
 695 }
 696
 697
 698 /**
 699  * Request that a peer should be added to the tunnel.  The existing
 700  * connect handler will be called ONCE with either success or failure.
 701  *
 702  * @param tunnel handle to existing tunnel
 703  * @param timeout how long to try to establish a connection
 704  * @param peer peer to add
 705  */
 706 void
 707 GNUNET_MESH_peer_request_connect_add (struct GNUNET_MESH_Tunnel *tunnel,
 708                                       struct GNUNET_TIME_Relative timeout,
 709                                       const struct GNUNET_PeerIdentity *peer)
 710 {
 711   struct GNUNET_MESH_PeerControl *msg;
 712   GNUNET_PEER_Id peer_id;
 713   int i;
 714
 715   peer_id = GNUNET_PEER_intern (peer);
 716   for (i = 0; i < tunnel->npeers; i++)
 717   {
 718     if (tunnel->peers[i] == peer_id)
 719     {
 720       GNUNET_PEER_change_rc (peer_id, -1);
 721       return;
 722     }
 723   }
 724   tunnel->npeers++;
 725   tunnel->peers = GNUNET_realloc (tunnel->peers,
 726                                   tunnel->npeers * sizeof (GNUNET_PEER_Id));
 727   tunnel->peers[tunnel->npeers - 1] = peer_id;
 728
 729   msg = GNUNET_malloc (sizeof (struct GNUNET_MESH_PeerControl));
 730   msg->header.size = htons (sizeof (struct GNUNET_MESH_PeerControl));
 731   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_ADD);
 732   msg->tunnel_id = htonl(tunnel->tid);
 733   memcpy (&msg->peer, peer, sizeof (struct GNUNET_PeerIdentity));
 734
 735   send_packet(tunnel->mesh, sizeof (struct GNUNET_MESH_PeerControl), msg);
 736
 737 //   tunnel->connect_handler (tunnel->cls, peer, NULL); FIXME call this later
 738 //   TODO: remember timeout
 739   return;
 740 }
 741
 742
 743 /**
 744  * Request that a peer should be removed from the tunnel.  The existing
 745  * disconnect handler will be called ONCE if we were connected.
 746  *
 747  * @param tunnel handle to existing tunnel
 748  * @param peer peer to remove
 749  */
 750 void
 751 GNUNET_MESH_peer_request_connect_del (struct GNUNET_MESH_Tunnel *tunnel,
 752                                       const struct GNUNET_PeerIdentity *peer)
 753 {
 754   struct GNUNET_MESH_PeerControl *msg;
 755   GNUNET_PEER_Id peer_id;
 756   int i;
 757
 758   peer_id = GNUNET_PEER_search (peer);
 759   if (0 == peer_id) return;
 760   for (i = 0; i < tunnel->npeers; i++)
 761   {
 762     if (tunnel->peers[i] == peer_id)
 763     {
 764       GNUNET_PEER_change_rc (peer_id, -1);
 765       tunnel->npeers--;
 766       while (i < tunnel->npeers)
 767       {
 768         tunnel->peers[i] = tunnel->peers[i+1];
 769         i++;
 770       }
 771       tunnel->peers = GNUNET_realloc (tunnel->peers,
 772                                       tunnel->npeers * sizeof (GNUNET_PEER_Id));
 773       msg = GNUNET_malloc (sizeof (struct GNUNET_MESH_PeerControl));
 774       msg->header.size = htons(sizeof (struct GNUNET_MESH_PeerControl));
 775       msg->header.type = htons(GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_DEL);
 776       msg->tunnel_id = htonl(tunnel->tid);
 777       memcpy (&msg->peer, peer, sizeof (struct GNUNET_PeerIdentity));
 778
 779       send_packet(tunnel->mesh, sizeof (struct GNUNET_MESH_PeerControl), msg);
 780
 781       return;
 782     }
 783   }
 784   //   TODO: remember timeout
 785   return;
 786 }
 787
 788
 789 /**
 790  * Request that the mesh should try to connect to a peer supporting the given
 791  * message type.
 792  *
 793  * @param tunnel handle to existing tunnel
 794  * @param timeout how long to try to establish a connection
 795  * @param app_type application type that must be supported by the peer (MESH
 796  *                 should discover peer in proximity handling this type)
 797  */
 798 void
 799 GNUNET_MESH_peer_request_connect_by_type (struct GNUNET_MESH_Tunnel *tunnel,
 800                                           struct GNUNET_TIME_Relative timeout,
 801                                           GNUNET_MESH_ApplicationType app_type)
 802 {
 803   struct GNUNET_MESH_ConnectPeerByType *msg;
 804   msg = GNUNET_malloc (sizeof (struct GNUNET_MESH_ConnectPeerByType));
 805   msg->header.size = htons(sizeof (struct GNUNET_MESH_ConnectPeerByType));
 806   msg->header.type = htons(GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_BY_TYPE);
 807   msg->tunnel_id = htonl(tunnel->tid);
 808   msg->type = htonl(app_type);
 809
 810   send_packet(tunnel->mesh, sizeof (struct GNUNET_MESH_ConnectPeerByType), msg);
 811   //   TODO: remember timeout
 812   return;
 813 }
 814
 815
 816 /**
 817  * Ask the mesh to call "notify" once it is ready to transmit the
 818  * given number of bytes to the specified "target".  If we are not yet
 819  * connected to the specified peer, a call to this function will cause
 820  * us to try to establish a connection.
 821  *
 822  * @param tunnel tunnel to use for transmission
 823  * @param cork is corking allowed for this transmission?
 824  * @param priority how important is the message?
 825  * @param maxdelay how long can the message wait?
 826  * @param target destination for the message,
 827  *               NULL for multicast to all tunnel targets
 828  * @param notify_size how many bytes of buffer space does notify want?
 829  * @param notify function to call when buffer space is available;
 830  *        will be called with NULL on timeout or if the overall queue
 831  *        for this peer is larger than queue_size and this is currently
 832  *        the message with the lowest priority
 833  * @param notify_cls closure for notify
 834  * @return non-NULL if the notify callback was queued,
 835  *         NULL if we can not even queue the request (insufficient
 836  *         memory); if NULL is returned, "notify" will NOT be called.
 837  */
 838 struct GNUNET_MESH_TransmitHandle *
 839 GNUNET_MESH_notify_transmit_ready (struct GNUNET_MESH_Tunnel *tunnel, int cork,
 840                                    uint32_t priority,
 841                                    struct GNUNET_TIME_Relative maxdelay,
 842                                    const struct GNUNET_PeerIdentity *target,
 843                                    size_t notify_size,
 844                                    GNUNET_CONNECTION_TransmitReadyNotify notify,
 845                                    void *notify_cls)
 846 {
 847   struct GNUNET_MESH_TransmitHandle *handle;
 848
 849   handle = GNUNET_malloc (sizeof (struct GNUNET_MESH_TransmitHandle));
 850   handle->t = tunnel;
 851   handle->q = GNUNET_malloc (sizeof (struct GNUNET_MESH_queue));
 852   handle->q->size = notify_size;
 853   handle->q->data = GNUNET_malloc (notify_size);
 854
 855   if (get_queue_length(tunnel->mesh) < MESH_API_MAX_QUEUE)
 856   {
 857     notify (notify_cls, notify_size, handle->q->data);
 858     GNUNET_CONTAINER_DLL_insert_tail(tunnel->mesh->queue_head,
 859                                      tunnel->mesh->queue_tail,
 860                                      handle->q);
 861   } else {
 862     // TODO dataless - queue
 863   }
 864
 865   return handle;
 866 }
 867
 868
 869 /**
 870  * Cancel the specified transmission-ready notification.
 871  *
 872  * @param th handle that was returned by "notify_transmit_ready".
 873  */
 874 void
 875 GNUNET_MESH_notify_transmit_ready_cancel (struct GNUNET_MESH_TransmitHandle *th)
 876 {
 877     GNUNET_CONTAINER_DLL_remove(th->t->mesh->queue_head,
 878                                 th->t->mesh->queue_tail,
 879                                 th->q);
 880     // TODO remove from dataless queue
 881     GNUNET_free (th->q->data);
 882     GNUNET_free (th->q);
 883     GNUNET_free (th);
 884 }
 885
 886
 887 #if 0                           /* keep Emacsens' auto-indent happy */
 888 {
 889 #endif
 890 #ifdef __cplusplus
 891 }
 892 #endif