src/mesh/mesh_api.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010 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.c
  23  * @brief mesh service; API for the Mesh. This is used to talk to arbitrary peers
  24  *        as of 2011-01Jan-06 this is a mockup.
  25  * @author Philipp Tölke
  26  */
  27 #include <platform.h>
  28 #include <gnunet_constants.h>
  29 #include <gnunet_mesh_service.h>
  30 #include <gnunet_core_service.h>
  31 #include <gnunet_container_lib.h>
  32 #include <gnunet_applications.h>
  33
  34 struct tunnel_id
  35 {
  36   uint32_t id GNUNET_PACKED;
  37   struct GNUNET_PeerIdentity initiator;
  38   struct GNUNET_PeerIdentity target;
  39 };
  40
  41 static uint32_t current_id = 0;
  42
  43 struct tunnel_message
  44 {
  45   struct GNUNET_MessageHeader hdr;
  46   struct tunnel_id id;
  47   /* followed by another GNUNET_MessageHeader */
  48 };
  49
  50 struct notify_cls
  51 {
  52   void* notify_cls;
  53   GNUNET_CONNECTION_TransmitReadyNotify notify;
  54   struct GNUNET_MESH_Tunnel *tunnel;
  55 };
  56
  57 struct GNUNET_MESH_Tunnel
  58 {
  59   /* The other peer this tunnel leads to; just unicast for the moment! */
  60   struct GNUNET_PeerIdentity peer;
  61
  62   struct tunnel_id id;
  63
  64   /* The handlers and cls for outbound tunnels. Are NULL for inbound tunnels. */
  65   GNUNET_MESH_TunnelDisconnectHandler disconnect_handler;
  66   GNUNET_MESH_TunnelConnectHandler connect_handler;
  67   void *handler_cls;
  68
  69   struct GNUNET_MESH_Handle* handle;
  70
  71   /* The application-type requested for this tunnel. Is only needed for pending
  72    * by_tupe-tunnels
  73    */
  74   uint16_t application_type;
  75
  76   /* The context of the receive-function. */
  77   void *ctx;
  78 };
  79
  80 struct tunnel_list_element
  81 {
  82   struct GNUNET_MESH_Tunnel tunnel;
  83   struct tunnel_list_element *next, *prev;
  84 };
  85
  86 struct tunnel_list
  87 {
  88   struct tunnel_list_element *head, *tail;
  89 };
  90
  91 struct peer_list_element
  92 {
  93   struct GNUNET_PeerIdentity peer;
  94
  95   /* how many Message-Types can this peer receive */
  96   unsigned int num_types;
  97
  98   /* array of message-types */
  99   GNUNET_MESH_ApplicationType *types;
 100
 101   struct GNUNET_TRANSPORT_ATS_Information atsi;
 102   struct peer_list_element *next, *prev;
 103 };
 104
 105 struct peer_list
 106 {
 107   struct peer_list_element *head, *tail;
 108 };
 109
 110 struct GNUNET_MESH_Handle
 111 {
 112   struct GNUNET_CORE_Handle *core;
 113   struct GNUNET_MESH_MessageHandler *handlers;
 114   struct GNUNET_PeerIdentity myself;
 115   unsigned int connected_to_core;
 116   struct peer_list connected_peers;
 117   struct tunnel_list established_tunnels;
 118   struct tunnel_list pending_tunnels;
 119   struct tunnel_list pending_by_type_tunnels;
 120   void *cls;
 121   GNUNET_MESH_TunnelEndHandler *cleaner;
 122   size_t hello_message_size;
 123   uint16_t *hello_message;
 124 };
 125
 126 static void
 127 send_end_connect(void* cls,
 128                      const struct GNUNET_SCHEDULER_TaskContext* tc)
 129 {
 130   struct GNUNET_MESH_Tunnel* tunnel = cls;
 131
 132   tunnel->connect_handler(tunnel->handler_cls, NULL, NULL);
 133 }
 134
 135 static void
 136 send_self_connect(void* cls,
 137                         const struct GNUNET_SCHEDULER_TaskContext* tc)
 138 {
 139   struct GNUNET_MESH_Tunnel* tunnel = cls;
 140
 141   tunnel->connect_handler(tunnel->handler_cls, &tunnel->handle->myself, NULL);
 142   GNUNET_SCHEDULER_add_now(send_end_connect, tunnel);
 143 }
 144
 145 static void
 146 call_connect_handler (void *cls,
 147                       const struct GNUNET_SCHEDULER_TaskContext *tc)
 148 {
 149   struct GNUNET_MESH_Tunnel *tunnel = cls;
 150
 151   tunnel->connect_handler (tunnel->handler_cls, &tunnel->peer,
 152                            NULL);
 153   GNUNET_SCHEDULER_add_now (send_end_connect, tunnel);
 154 }
 155
 156 static void
 157 core_startup (void *cls,
 158               struct GNUNET_CORE_Handle *core,
 159               const struct GNUNET_PeerIdentity *my_identity,
 160               const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)
 161 {
 162   struct GNUNET_MESH_Handle *handle = cls;
 163   memcpy (&handle->myself, my_identity, sizeof (struct GNUNET_PeerIdentity));
 164   handle->connected_to_core = GNUNET_YES;
 165 }
 166
 167 static size_t
 168 send_hello_message (void *cls, size_t size, void *buf)
 169 {
 170   if (cls == NULL) return 0;
 171   struct GNUNET_MESH_Handle *handle = cls;
 172   struct GNUNET_MessageHeader *hdr = buf;
 173
 174   size_t sent = sizeof(struct GNUNET_MessageHeader) + handle->hello_message_size;
 175
 176   hdr->type = htons(GNUNET_MESSAGE_TYPE_MESH_HELLO);
 177   hdr->size = htons(size);
 178
 179   memcpy(hdr+1, handle->hello_message, handle->hello_message_size);
 180   return sent;
 181 }
 182
 183
 184 /**
 185  * Core calls this if we are connected to a new peer.
 186  *
 187  * The peer is added to the connected_peers-list.
 188  *
 189  */
 190 static void
 191 core_connect (void *cls,
 192               const struct GNUNET_PeerIdentity *peer,
 193               const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 194 {
 195   struct GNUNET_MESH_Handle *handle = cls;
 196
 197   /* Send a hello to this peer */
 198   GNUNET_CORE_notify_transmit_ready(handle->core,
 199                                     GNUNET_NO,
 200                                     42,
 201                                     GNUNET_TIME_UNIT_SECONDS,
 202                                     peer,
 203                                     sizeof(struct GNUNET_MessageHeader) + handle->hello_message_size,
 204                                     &send_hello_message,
 205                                     cls);
 206
 207   /* put the new peer into the list of connected peers */
 208   struct peer_list_element *element =
 209     GNUNET_malloc (sizeof (struct peer_list_element));
 210   memcpy (&element->peer, peer, sizeof (struct GNUNET_PeerIdentity));
 211
 212   if (NULL != atsi)
 213     memcpy (&element->atsi, atsi,
 214             sizeof (struct GNUNET_TRANSPORT_ATS_Information));
 215
 216   GNUNET_CONTAINER_DLL_insert_after (handle->connected_peers.head,
 217                                      handle->connected_peers.tail,
 218                                      handle->connected_peers.tail, element);
 219
 220   struct tunnel_list_element *tunnel = handle->pending_tunnels.head;
 221   while (tunnel != NULL)
 222     {
 223       if (0 ==
 224           memcmp (&tunnel->tunnel.peer, peer,
 225                   sizeof (struct GNUNET_PeerIdentity)))
 226         {
 227           struct tunnel_list_element *next = tunnel->next;
 228           GNUNET_CONTAINER_DLL_remove (handle->pending_tunnels.head,
 229                                        handle->pending_tunnels.tail, tunnel);
 230           GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
 231                                              handle->established_tunnels.tail,
 232                                              handle->established_tunnels.tail,
 233                                              tunnel);
 234           tunnel->tunnel.connect_handler (tunnel->tunnel.handler_cls,
 235                                           peer, atsi);
 236           GNUNET_SCHEDULER_add_now(send_end_connect, tunnel);
 237           tunnel = next;
 238         }
 239       else
 240         tunnel = tunnel->next;
 241     }
 242 }
 243
 244 /**
 245  * Core calls this if we disconnect a peer
 246  *
 247  * Remove this peer from the list of connected peers
 248  * Close all tunnels this peer belongs to
 249  */
 250 static void
 251 core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 252 {
 253   struct GNUNET_MESH_Handle *handle = cls;
 254
 255   struct peer_list_element *element = handle->connected_peers.head;
 256   while (element != NULL)
 257     {
 258       if (0 ==
 259           memcmp (&element->peer, peer, sizeof (struct GNUNET_PeerIdentity)))
 260         break;
 261       element = element->next;
 262     }
 263   if (element != NULL)
 264     {
 265       GNUNET_CONTAINER_DLL_remove (handle->connected_peers.head,
 266                                    handle->connected_peers.tail, element);
 267       GNUNET_free_non_null(element->types);
 268       GNUNET_free (element);
 269     }
 270
 271   struct tunnel_list_element *telement = handle->established_tunnels.head;
 272   while (telement != NULL)
 273     {
 274       if (0 ==
 275           memcmp (&telement->tunnel.peer, peer,
 276                   sizeof (struct GNUNET_PeerIdentity)))
 277         {
 278           /* disconnect tunnels */
 279           /* outbound tunnels */
 280           if (telement->tunnel.connect_handler != NULL && NULL != telement->tunnel.disconnect_handler)
 281             telement->tunnel.disconnect_handler (telement->tunnel.handler_cls,
 282                                                  peer);
 283           /* inbound tunnels */
 284           else if (NULL != handle->cleaner)
 285             handle->cleaner (handle->cls, &telement->tunnel,
 286                              &telement->tunnel.ctx);
 287
 288           struct tunnel_list_element *next = telement->next;
 289           GNUNET_CONTAINER_DLL_remove (handle->established_tunnels.head,
 290                                        handle->established_tunnels.tail,
 291                                        telement);
 292           GNUNET_free (telement);
 293           telement = next;
 294         }
 295       else
 296         {
 297           telement = telement->next;
 298         }
 299     }
 300 }
 301
 302 /**
 303  * Receive a message from core.
 304  * This is a hello-message, containing the application-types the other peer can receive
 305  */
 306 static int
 307 receive_hello (void *cls,
 308                const struct GNUNET_PeerIdentity *other,
 309                const struct GNUNET_MessageHeader *message,
 310                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 311 {
 312   struct GNUNET_MESH_Handle *handle = cls;
 313   uint16_t *num = (uint16_t *) (message + 1);
 314   uint16_t *ports = num + 1;
 315   unsigned int i;
 316
 317   struct peer_list_element *element = handle->connected_peers.head;
 318   while (element != NULL)
 319     {
 320       if (0 ==
 321           memcmp (&element->peer, other, sizeof (struct GNUNET_PeerIdentity)))
 322         break;
 323       element = element->next;
 324     }
 325
 326   /* TODO: add, not replace! */
 327   element->num_types = *num;
 328   element->types = GNUNET_malloc (*num * sizeof (GNUNET_MESH_ApplicationType));
 329
 330   for (i = 0; i < *num; i++)
 331     element->types[i] = (GNUNET_MESH_ApplicationType)ntohs (ports[i]);
 332
 333   struct tunnel_list_element *tunnel = handle->pending_by_type_tunnels.head;
 334   while (tunnel != NULL)
 335     {
 336       struct tunnel_list_element *next = tunnel->next;
 337       for (i = 0; i < *num; i++)
 338         {
 339           if (ntohs (ports[i]) == tunnel->tunnel.application_type)
 340             {
 341               GNUNET_CONTAINER_DLL_remove (handle->pending_tunnels.head,
 342                                            handle->pending_tunnels.tail,
 343                                            tunnel);
 344               GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.
 345                                                  head,
 346                                                  handle->established_tunnels.
 347                                                  tail,
 348                                                  handle->established_tunnels.
 349                                                  tail, tunnel);
 350               tunnel->tunnel.connect_handler (tunnel->tunnel.handler_cls,
 351                                               &tunnel->tunnel.peer, atsi);
 352               GNUNET_SCHEDULER_add_now (send_end_connect, tunnel);
 353               break;
 354             }
 355         }
 356       if (ntohs (ports[i]) == tunnel->tunnel.application_type)
 357         tunnel = next;
 358       else
 359         tunnel = tunnel->next;
 360     }
 361   return GNUNET_OK;
 362 }
 363
 364 /**
 365  * Receive a message from core.
 366  */
 367 static int
 368 core_receive (void *cls,
 369               const struct GNUNET_PeerIdentity *other,
 370               const struct GNUNET_MessageHeader *message,
 371               const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 372 {
 373   struct GNUNET_MESH_Handle *handle = cls;
 374   struct tunnel_message *tmessage = (struct tunnel_message *) message;
 375   struct GNUNET_MessageHeader *rmessage =
 376     (struct GNUNET_MessageHeader *) (tmessage + 1);
 377
 378   struct GNUNET_MESH_MessageHandler *handler;
 379
 380   for (handler = handle->handlers; handler->callback != NULL; handler++)
 381     {
 382       if ( (ntohs (rmessage->type) == handler->type)
 383            && ( (handler->expected_size == 0)
 384                 || (handler->expected_size == ntohs (rmessage->size))) )
 385         {
 386           break;
 387         }
 388     }
 389
 390   /* handler->callback handles this message */
 391
 392   /* If no handler was found, drop the message but keep the channel open */
 393   if (handler->callback == NULL)
 394     return GNUNET_OK;
 395
 396   struct tunnel_list_element *tunnel = handle->established_tunnels.head;
 397
 398   while (tunnel != NULL)
 399     {
 400       if (tunnel->tunnel.id.id == tmessage->id.id &&
 401           (0 ==
 402            memcmp (&tmessage->id.initiator, &tunnel->tunnel.id.initiator,
 403                    sizeof (struct GNUNET_PeerIdentity)))
 404           && (0 ==
 405               memcmp (&tmessage->id.target, &tunnel->tunnel.id.target,
 406                       sizeof (struct GNUNET_PeerIdentity))))
 407         break;
 408       tunnel = tunnel->next;
 409     }
 410
 411   /* if no tunnel was found: create a new inbound tunnel */
 412   if (tunnel == NULL)
 413     {
 414       tunnel = GNUNET_malloc (sizeof (struct tunnel_list_element));
 415       tunnel->tunnel.connect_handler = NULL;
 416       tunnel->tunnel.disconnect_handler = NULL;
 417       tunnel->tunnel.handler_cls = NULL;
 418       tunnel->tunnel.ctx = NULL;
 419       tunnel->tunnel.handle = handle;
 420       memcpy (&tunnel->tunnel.peer, other,
 421               sizeof (struct GNUNET_PeerIdentity));
 422       memcpy (&tunnel->tunnel.id, &tmessage->id, sizeof (struct tunnel_id));
 423
 424       GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
 425                                          handle->established_tunnels.tail,
 426                                          handle->established_tunnels.tail,
 427                                          tunnel);
 428     }
 429
 430   return handler->callback (handle->cls, &tunnel->tunnel,
 431                             &tunnel->tunnel.ctx, other, rmessage, atsi);
 432 }
 433
 434 struct GNUNET_MESH_Tunnel *
 435 GNUNET_MESH_peer_request_connect_by_type (struct GNUNET_MESH_Handle *handle,
 436                                           struct GNUNET_TIME_Relative timeout,
 437                                           GNUNET_MESH_ApplicationType application_type,
 438                                           GNUNET_MESH_TunnelConnectHandler
 439                                           connect_handler,
 440                                           GNUNET_MESH_TunnelDisconnectHandler
 441                                           disconnect_handler,
 442                                           void *handler_cls)
 443 {
 444   /* Look in the list of connected peers */
 445   struct peer_list_element *element = handle->connected_peers.head;
 446   while (element != NULL)
 447     {
 448       unsigned int i;
 449       for (i = 0; i < element->num_types; i++)
 450         if (application_type == element->types[i])
 451           return GNUNET_MESH_peer_request_connect_all (handle, timeout, 1,
 452                                                        &handle->myself,
 453                                                        connect_handler,
 454                                                        disconnect_handler,
 455                                                        handler_cls);
 456       element = element->next;
 457     }
 458
 459   /* Put into pending list */
 460   struct tunnel_list_element *tunnel =
 461     GNUNET_malloc (sizeof (struct tunnel_list_element));
 462
 463   tunnel->tunnel.connect_handler = connect_handler;
 464   tunnel->tunnel.disconnect_handler = disconnect_handler;
 465   tunnel->tunnel.handler_cls = handler_cls;
 466   tunnel->tunnel.ctx = NULL;
 467   tunnel->tunnel.handle = handle;
 468   memcpy (&tunnel->tunnel.id.initiator, &handle->myself,
 469           sizeof (struct GNUNET_PeerIdentity));
 470   tunnel->tunnel.id.id = current_id++;
 471   tunnel->tunnel.application_type = application_type;
 472
 473   GNUNET_CONTAINER_DLL_insert_after (handle->pending_by_type_tunnels.head,
 474                                      handle->pending_by_type_tunnels.tail,
 475                                      handle->pending_by_type_tunnels.tail,
 476                                      tunnel);
 477   return &tunnel->tunnel;
 478 }
 479
 480
 481
 482 struct GNUNET_MESH_Tunnel *
 483 GNUNET_MESH_peer_request_connect_all (struct GNUNET_MESH_Handle *handle,
 484                                       struct GNUNET_TIME_Relative timeout,
 485                                       unsigned int num_peers,
 486                                       const struct GNUNET_PeerIdentity *peers,
 487                                       GNUNET_MESH_TunnelConnectHandler
 488                                       connect_handler,
 489                                       GNUNET_MESH_TunnelDisconnectHandler
 490                                       disconnect_handler, void *handler_cls)
 491 {
 492   if (num_peers != 1)
 493     return NULL;
 494
 495   struct tunnel_list_element *tunnel =
 496     GNUNET_malloc (sizeof (struct tunnel_list_element));
 497
 498   tunnel->tunnel.connect_handler = connect_handler;
 499   tunnel->tunnel.disconnect_handler = disconnect_handler;
 500   tunnel->tunnel.handler_cls = handler_cls;
 501   tunnel->tunnel.ctx = NULL;
 502   tunnel->tunnel.handle = handle;
 503   memcpy (&tunnel->tunnel.id.initiator, &handle->myself,
 504           sizeof (struct GNUNET_PeerIdentity));
 505   memcpy (&tunnel->tunnel.id.target, peers,
 506           sizeof (struct GNUNET_PeerIdentity));
 507   tunnel->tunnel.id.id = current_id++;
 508   memcpy (&tunnel->tunnel.peer, peers, sizeof(struct GNUNET_PeerIdentity));
 509
 510   struct peer_list_element *element = handle->connected_peers.head;
 511   while (element != NULL)
 512     {
 513       if (0 ==
 514           memcmp (&element->peer, peers, sizeof (struct GNUNET_PeerIdentity)))
 515         break;
 516       element = element->next;
 517     }
 518
 519   if (element != NULL)
 520     {
 521       /* we are connected to this peer */
 522       GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
 523                                          handle->established_tunnels.tail,
 524                                          handle->established_tunnels.tail,
 525                                          tunnel);
 526       GNUNET_SCHEDULER_add_now(call_connect_handler, tunnel);
 527     }
 528   else if (0 ==
 529            memcmp (peers, &handle->myself,
 530                    sizeof (struct GNUNET_PeerIdentity)))
 531     {
 532       /* we are the peer */
 533       GNUNET_CONTAINER_DLL_insert_after (handle->established_tunnels.head,
 534                                          handle->established_tunnels.tail,
 535                                          handle->established_tunnels.tail,
 536                                          tunnel);
 537       GNUNET_SCHEDULER_add_now(send_self_connect, tunnel);
 538     }
 539   else
 540     {
 541       /* we are not connected to this peer */
 542       GNUNET_CONTAINER_DLL_insert_after (handle->pending_tunnels.head,
 543                                          handle->pending_tunnels.tail,
 544                                          handle->pending_tunnels.tail,
 545                                          tunnel);
 546       (void) GNUNET_CORE_peer_request_connect (handle->core,
 547                                                peers,
 548                                                NULL, NULL);
 549     }
 550
 551   return &tunnel->tunnel;
 552 }
 553
 554 const struct GNUNET_PeerIdentity*
 555 GNUNET_MESH_get_peer(const struct GNUNET_MESH_Tunnel* tunnel)
 556 {
 557   return &tunnel->peer;
 558 }
 559
 560 static size_t
 561 core_notify(void* cls, size_t size, void* buf)
 562 {
 563   struct notify_cls *ncls = cls;
 564   struct GNUNET_MESH_Tunnel *tunnel = ncls->tunnel;
 565   struct tunnel_message* message = buf;
 566   void* cbuf = (void*) &message[1];
 567   GNUNET_assert(NULL != ncls->notify);
 568
 569   size_t sent = ncls->notify(ncls->notify_cls, size - sizeof(struct tunnel_message), cbuf);
 570
 571   GNUNET_free(ncls);
 572
 573   if (0 == sent) return 0;
 574
 575   sent += sizeof(struct tunnel_message);
 576
 577   message->hdr.type = htons(GNUNET_MESSAGE_TYPE_MESH);
 578   message->hdr.size = htons(sent);
 579   memcpy(&message->id, &tunnel->id, sizeof(struct tunnel_id));
 580   return sent;
 581 }
 582
 583
 584 /**
 585  * Ask the mesh to call "notify" once it is ready to transmit the
 586  * given number of bytes to the specified "target".  If we are not yet
 587  * connected to the specified peer, a call to this function will cause
 588  * us to try to establish a connection.
 589  *
 590  * @param tunnel tunnel to use for transmission
 591  * @param cork is corking allowed for this transmission?
 592  * @param priority how important is the message?
 593  * @param maxdelay how long can the message wait?
 594  * @param target destination for the message, NULL for multicast to all tunnel targets
 595  * @param notify_size how many bytes of buffer space does notify want?
 596  * @param notify function to call when buffer space is available;
 597  *        will be called with NULL on timeout or if the overall queue
 598  *        for this peer is larger than queue_size and this is currently
 599  *        the message with the lowest priority
 600  * @param notify_cls closure for notify
 601  * @return non-NULL if the notify callback was queued,
 602  *         NULL if we can not even queue the request (insufficient
 603  *         memory); if NULL is returned, "notify" will NOT be called.
 604  */
 605 struct GNUNET_MESH_TransmitHandle *
 606 GNUNET_MESH_notify_transmit_ready (struct
 607                                    GNUNET_MESH_Tunnel
 608                                    *tunnel,
 609                                    int cork,
 610                                    uint32_t priority,
 611                                    struct
 612                                    GNUNET_TIME_Relative
 613                                    maxdelay,
 614                                    const struct GNUNET_PeerIdentity *target,
 615                                    size_t
 616                                    notify_size,
 617                                    GNUNET_CONNECTION_TransmitReadyNotify
 618                                    notify, void *notify_cls)
 619 {
 620   struct notify_cls *cls = GNUNET_malloc(sizeof(struct notify_cls));
 621   cls->notify_cls = notify_cls;
 622   GNUNET_assert(NULL != notify);
 623   cls->notify = notify;
 624   cls->tunnel = tunnel;
 625   GNUNET_CORE_notify_transmit_ready(tunnel->handle->core,
 626                                     cork,
 627                                     priority,
 628                                     maxdelay,
 629                                     &tunnel->peer,
 630                                     notify_size + sizeof(struct tunnel_message),
 631                                     &core_notify,
 632                                     (void*)cls);
 633
 634   /* aborting is not implemented yet */
 635   return (struct GNUNET_MESH_TransmitHandle*) 1;
 636 }
 637
 638 void build_hello_message(struct GNUNET_MESH_Handle* handle,
 639                          const GNUNET_MESH_ApplicationType *stypes)
 640 {
 641   int num = 0;
 642   const GNUNET_MESH_ApplicationType *t;
 643
 644   for (t = stypes; *t != GNUNET_APPLICATION_TYPE_END; t++, num++);
 645
 646   handle->hello_message_size = sizeof(uint16_t) + /* For the number of types */
 647     num * sizeof(GNUNET_MESH_ApplicationType); /* For the types */
 648
 649   uint16_t *nums = GNUNET_malloc(handle->hello_message_size);
 650   GNUNET_MESH_ApplicationType *types = (GNUNET_MESH_ApplicationType*)(nums + 1);
 651
 652   *nums = num;
 653   memcpy(types, stypes, num*sizeof(GNUNET_MESH_ApplicationType));
 654
 655   handle->hello_message = nums;
 656 }
 657
 658
 659 struct GNUNET_MESH_Handle *
 660 GNUNET_MESH_connect (const struct
 661                      GNUNET_CONFIGURATION_Handle
 662                      *cfg, void *cls,
 663                      GNUNET_MESH_TunnelEndHandler
 664                      cleaner,
 665                      const struct GNUNET_MESH_MessageHandler *handlers,
 666                      const GNUNET_MESH_ApplicationType *stypes)
 667 {
 668   struct GNUNET_MESH_Handle *ret =
 669     GNUNET_malloc (sizeof (struct GNUNET_MESH_Handle));
 670
 671   ret->connected_to_core = GNUNET_NO;
 672   ret->connected_peers.head = NULL;
 673   ret->connected_peers.tail = NULL;
 674   ret->cleaner = cleaner;
 675   ret->cls = cls;
 676
 677   const struct GNUNET_MESH_MessageHandler *it;
 678   unsigned int len = 1;
 679   for (it = handlers; it->callback != NULL; it++)
 680     {
 681       len++;
 682     }
 683
 684   ret->handlers =
 685     GNUNET_malloc (len * sizeof (struct GNUNET_MESH_MessageHandler));
 686   memset(ret->handlers, 0, len * sizeof(struct GNUNET_MESH_MessageHandler));
 687   memcpy (ret->handlers, handlers,
 688           len * sizeof (struct GNUNET_MESH_MessageHandler));
 689
 690   build_hello_message(ret, stypes);
 691
 692   const static struct GNUNET_CORE_MessageHandler core_handlers[] = {
 693     {&core_receive, GNUNET_MESSAGE_TYPE_MESH, 0},
 694     {&receive_hello, GNUNET_MESSAGE_TYPE_MESH_HELLO, 0},
 695     {NULL, 0, 0}
 696   };
 697
 698   ret->core = GNUNET_CORE_connect (cfg,
 699                                    42,
 700                                    ret,
 701                                    &core_startup,
 702                                    &core_connect,
 703                                    &core_disconnect,
 704                                    NULL,
 705                                    NULL,
 706                                    GNUNET_NO, NULL, GNUNET_NO, core_handlers);
 707   return ret;
 708 }
 709
 710 void
 711 GNUNET_MESH_disconnect (struct GNUNET_MESH_Handle *handle)
 712 {
 713   GNUNET_free (handle->handlers);
 714   GNUNET_free (handle->hello_message);
 715   GNUNET_CORE_disconnect (handle->core);
 716
 717   struct peer_list_element *element = handle->connected_peers.head;
 718   while (element != NULL)
 719     {
 720       struct peer_list_element *next = element->next;
 721       GNUNET_free_non_null(element->types);
 722       GNUNET_free (element);
 723       element = next;
 724     }
 725
 726   struct tunnel_list_element *tunnel = handle->pending_tunnels.head;
 727   while (tunnel != NULL)
 728     {
 729       struct tunnel_list_element *next = tunnel->next;
 730       GNUNET_free (tunnel);
 731       tunnel = next;
 732     }
 733   tunnel = handle->established_tunnels.head;;
 734   while (tunnel != NULL)
 735     {
 736       struct tunnel_list_element *next = tunnel->next;
 737       GNUNET_free (tunnel);
 738       tunnel = next;
 739     }
 740
 741   GNUNET_free (handle);
 742 }
 743
 744 /* end of mesh_api.c */