src/mesh/gnunet-service-mesh.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2001 - 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/gnunet-service-mesh.c
  23  * @brief GNUnet MESH service
  24  * @author Bartlomiej Polot
  25  *
  26  * STRUCTURE:
  27  * - DATA STRUCTURES
  28  * - GLOBAL VARIABLES
  29  * - GENERAL HELPERS
  30  * - PERIODIC FUNCTIONS
  31  * - MESH NETWORK HANDLER HELPERS
  32  * - MESH NETWORK HANDLES
  33  * - MESH LOCAL HANDLER HELPERS
  34  * - MESH LOCAL HANDLES
  35  * - MAIN FUNCTIONS (main & run)
  36  *
  37  * TODO:
  38  * - error reporting (CREATE/CHANGE/ADD/DEL?) -- new message!
  39  * - partial disconnect reporting -- same as error reporting?
  40  * - add vs create? change vs. keep-alive? same msg or different ones? -- thinking...
  41  * - speed requirement specification (change?) in mesh API -- API call
  42  * - add ping message
  43  * - relay corking down to core
  44  * - set ttl relative to tree depth
  45  */
  46
  47 #include "platform.h"
  48 #include "mesh.h"
  49 #include "mesh_protocol.h"
  50 #include "gnunet_dht_service.h"
  51 #include "mesh_tunnel_tree.h"
  52
  53 /* TODO: move into configuration file */
  54 #define REFRESH_PATH_TIME       GNUNET_TIME_relative_multiply(\
  55                                     GNUNET_TIME_UNIT_SECONDS,\
  56                                     300)
  57 #define APP_ANNOUNCE_TIME       GNUNET_TIME_relative_multiply(\
  58                                     GNUNET_TIME_UNIT_SECONDS,\
  59                                     5)
  60
  61 #define ID_ANNOUNCE_TIME        GNUNET_TIME_relative_multiply(\
  62                                     GNUNET_TIME_UNIT_SECONDS,\
  63                                     10)
  64
  65 #define GET_RESTART_TIME        GNUNET_TIME_relative_multiply(\
  66                                     GNUNET_TIME_UNIT_SECONDS,\
  67                                     5)
  68
  69 #define UNACKNOWLEDGED_WAIT     GNUNET_TIME_relative_multiply(\
  70                                     GNUNET_TIME_UNIT_SECONDS,\
  71                                     2)
  72 #define DEFAULT_TTL     64
  73
  74 #define MESH_DEBUG_DHT GNUNET_NO
  75
  76
  77
  78 /******************************************************************************/
  79 /************************      DATA STRUCTURES     ****************************/
  80 /******************************************************************************/
  81
  82 /** FWD declaration */
  83 struct MeshPeerInfo;
  84
  85 /**
  86  * Struct containing all info possibly needed to build a package when called
  87  * back by core.
  88  */
  89 struct MeshDataDescriptor
  90 {
  91     /** ID of the tunnel this packet travels in */
  92   struct MESH_TunnelID *origin;
  93
  94     /** Data itself */
  95   void *data;
  96
  97     /** Client that asked for the transmission, if any */
  98   struct GNUNET_SERVER_Client *client;
  99
 100     /** Who was this message being sent to */
 101   struct MeshPeerInfo *peer;
 102
 103     /** Ultimate destination of the packet */
 104   GNUNET_PEER_Id destination;
 105
 106     /** Number of identical messages sent to different hops (multicast) */
 107   unsigned int *copies;
 108
 109     /** Which handler was used to request the transmission */
 110   unsigned int handler_n;
 111
 112     /** Size of the data */
 113   size_t size;
 114
 115     /** Used to allow a client send more traffic to the service after a
 116      * previous packet was tried to be sent to a neighbor and couldn't */
 117   GNUNET_SCHEDULER_TaskIdentifier *timeout_task;
 118 };
 119
 120
 121 /**
 122  * Struct containing all information regarding a given peer
 123  */
 124 struct MeshPeerInfo
 125 {
 126     /**
 127      * ID of the peer
 128      */
 129   GNUNET_PEER_Id id;
 130
 131     /**
 132      * Last time we heard from this peer
 133      */
 134   struct GNUNET_TIME_Absolute last_contact;
 135
 136     /**
 137      * Number of attempts to reconnect so far
 138      */
 139   int n_reconnect_attempts;
 140
 141     /**
 142      * Paths to reach the peer, ordered by ascending hop count
 143      */
 144   struct MeshPeerPath *path_head;
 145
 146     /**
 147      * Paths to reach the peer, ordered by ascending hop count
 148      */
 149   struct MeshPeerPath *path_tail;
 150
 151     /**
 152      * Handle to stop the DHT search for a path to this peer
 153      */
 154   struct GNUNET_DHT_GetHandle *dhtget;
 155
 156     /**
 157      * Closure given to the DHT GET
 158      */
 159   struct MeshPathInfo *dhtgetcls;
 160
 161     /**
 162      * Handles to stop queued transmissions for this peer
 163      */
 164   struct GNUNET_CORE_TransmitHandle *core_transmit[CORE_QUEUE_SIZE];
 165
 166     /**
 167      * Pointer to info stuctures used as cls for queued transmissions
 168      */
 169   void *infos[CORE_QUEUE_SIZE];
 170
 171     /**
 172      * Type of message being in each transmission
 173      */
 174   uint16_t types[CORE_QUEUE_SIZE];
 175
 176     /**
 177      * Array of tunnels this peer participates in
 178      * (most probably a small amount, therefore not a hashmap)
 179      * When the path to the peer changes, notify these tunnels to let them
 180      * re-adjust their path trees.
 181      */
 182   struct MeshTunnel **tunnels;
 183
 184     /**
 185      * Number of tunnels this peers participates in
 186      */
 187   unsigned int ntunnels;
 188 };
 189
 190
 191 /**
 192  * Data scheduled to transmit (to local client or remote peer)
 193  */
 194 struct MeshQueue
 195 {
 196     /**
 197      * Double linked list
 198      */
 199   struct MeshQueue *next;
 200   struct MeshQueue *prev;
 201
 202     /**
 203      * Target of the data (NULL if target is client)
 204      */
 205   struct MeshPeerInfo *peer;
 206
 207     /**
 208      * Client to send the data to (NULL if target is peer)
 209      */
 210   struct MeshClient *client;
 211
 212     /**
 213      * Size of the message to transmit
 214      */
 215   unsigned int size;
 216
 217     /**
 218      * How old is the data?
 219      */
 220   struct GNUNET_TIME_Absolute timestamp;
 221
 222     /**
 223      * Data itself
 224      */
 225   struct GNUNET_MessageHeader *data;
 226 };
 227
 228 /**
 229  * Globally unique tunnel identification (owner + number)
 230  * DO NOT USE OVER THE NETWORK
 231  */
 232 struct MESH_TunnelID
 233 {
 234     /**
 235      * Node that owns the tunnel
 236      */
 237   GNUNET_PEER_Id oid;
 238
 239     /**
 240      * Tunnel number to differentiate all the tunnels owned by the node oid
 241      * ( tid < GNUNET_MESH_LOCAL_TUNNEL_ID_CLI )
 242      */
 243   MESH_TunnelNumber tid;
 244 };
 245
 246
 247 struct MeshClient;              /* FWD declaration */
 248
 249 /**
 250  * Struct containing all information regarding a tunnel
 251  * For an intermediate node the improtant info used will be:
 252  * - id        Tunnel unique identification
 253  * - paths[0]  To know where to send it next
 254  * - metainfo: ready, speeds, accounting
 255  */
 256 struct MeshTunnel
 257 {
 258     /**
 259      * Tunnel ID
 260      */
 261   struct MESH_TunnelID id;
 262
 263     /**
 264      * Local tunnel number ( >= GNUNET_MESH_LOCAL_TUNNEL_ID_CLI or 0 )
 265      */
 266   MESH_TunnelNumber local_tid;
 267
 268     /**
 269      * ID of the last multicast packet seen/sent.
 270      */
 271   uint32_t mid;
 272
 273     /**
 274      * Last time the tunnel was used
 275      */
 276   struct GNUNET_TIME_Absolute timestamp;
 277
 278     /**
 279      * Peers in the tunnel, indexed by PeerIdentity -> (MeshPeerInfo)
 280      * containing peers added by id or by type, not intermediate peers.
 281      */
 282   struct GNUNET_CONTAINER_MultiHashMap *peers;
 283
 284     /**
 285      * Number of peers that are connected and potentially ready to receive data
 286      */
 287   unsigned int peers_ready;
 288
 289     /**
 290      * Number of peers that have been added to the tunnel
 291      */
 292   unsigned int peers_total;
 293
 294     /**
 295      * Client owner of the tunnel, if any
 296      */
 297   struct MeshClient *client;
 298
 299     /**
 300      * Messages ready to transmit
 301      */
 302   struct MeshQueue *queue_head;
 303   struct MeshQueue *queue_tail;
 304
 305   /**
 306    * Tunnel paths
 307    */
 308   struct MeshTunnelTree *tree;
 309
 310   /**
 311    * Application type we are looking for in this tunnel
 312    */
 313   GNUNET_MESH_ApplicationType type;
 314
 315     /**
 316      * Used to search peers offering a service
 317      */
 318   struct GNUNET_DHT_GetHandle *dht_get_type;
 319
 320   /**
 321    * Task to keep the used paths alive
 322    */
 323   GNUNET_SCHEDULER_TaskIdentifier path_refresh_task;
 324
 325   /**
 326    * Task to destroy the tunnel after timeout
 327    *
 328    * FIXME: merge the two? a tunnel will have either
 329    * a path refresh OR a timeout, never both!
 330    */
 331   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
 332 };
 333
 334
 335 /**
 336  * Info needed to work with tunnel paths and peers
 337  */
 338 struct MeshPathInfo
 339 {
 340   /**
 341    * Tunnel
 342    */
 343   struct MeshTunnel *t;
 344
 345   /**
 346    * Neighbouring peer to whom we send the packet to
 347    */
 348   struct MeshPeerInfo *peer;
 349
 350   /**
 351    * Path itself
 352    */
 353   struct MeshPeerPath *path;
 354
 355   /**
 356    * Position in peer's transmit queue
 357    */
 358   unsigned int pos;
 359 };
 360
 361
 362 /**
 363  * Struct containing information about a client of the service
 364  */
 365 struct MeshClient
 366 {
 367     /**
 368      * Linked list
 369      */
 370   struct MeshClient *next;
 371   struct MeshClient *prev;
 372
 373     /**
 374      * Tunnels that belong to this client, indexed by local id
 375      */
 376   struct GNUNET_CONTAINER_MultiHashMap *tunnels;
 377
 378     /**
 379      * Handle to communicate with the client
 380      */
 381   struct GNUNET_SERVER_Client *handle;
 382
 383     /**
 384      * Applications that this client has claimed to provide
 385      */
 386   struct GNUNET_CONTAINER_MultiHashMap *apps;
 387
 388     /**
 389      * Messages that this client has declared interest in
 390      */
 391   struct GNUNET_CONTAINER_MultiHashMap *types;
 392
 393 #if MESH_DEBUG
 394     /**
 395      * ID of the client, for debug messages
 396      */
 397   unsigned int id;
 398 #endif
 399
 400 };
 401
 402
 403
 404 /******************************************************************************/
 405 /************************      DEBUG FUNCTIONS     ****************************/
 406 /******************************************************************************/
 407
 408 #if MESH_DEBUG
 409 /**
 410  * GNUNET_SCHEDULER_Task for printing a message after some operation is done
 411  * @param cls string to print
 412  * @param tc task context
 413  */
 414 static void
 415 mesh_debug (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 416 {
 417   char *s = cls;
 418
 419   if (GNUNET_SCHEDULER_REASON_SHUTDOWN == tc->reason)
 420   {
 421     return;
 422   }
 423   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: %s\n", s);
 424 }
 425 #endif
 426
 427 /******************************************************************************/
 428 /***********************      GLOBAL VARIABLES     ****************************/
 429 /******************************************************************************/
 430
 431 /**
 432  * All the clients
 433  */
 434 static struct MeshClient *clients;
 435 static struct MeshClient *clients_tail;
 436
 437 /**
 438  * Tunnels known, indexed by MESH_TunnelID (MeshTunnel)
 439  */
 440 static struct GNUNET_CONTAINER_MultiHashMap *tunnels;
 441
 442 /**
 443  * Tunnels incoming, indexed by MESH_TunnelNumber
 444  * (which is greater than GNUNET_MESH_LOCAL_TUNNEL_ID_SERV)
 445  */
 446 static struct GNUNET_CONTAINER_MultiHashMap *incoming_tunnels;
 447
 448 /**
 449  * Peers known, indexed by PeerIdentity (MeshPeerInfo)
 450  */
 451 static struct GNUNET_CONTAINER_MultiHashMap *peers;
 452
 453 /**
 454  * Handle to communicate with core
 455  */
 456 static struct GNUNET_CORE_Handle *core_handle;
 457
 458 /**
 459  * Handle to communicate with transport
 460  */
 461 // static struct GNUNET_TRANSPORT_Handle *transport_handle;
 462
 463 /**
 464  * Handle to use DHT
 465  */
 466 static struct GNUNET_DHT_Handle *dht_handle;
 467
 468 /**
 469  * Handle to server
 470  */
 471 static struct GNUNET_SERVER_Handle *server_handle;
 472
 473 /**
 474  * Notification context, to send messages to local clients
 475  */
 476 static struct GNUNET_SERVER_NotificationContext *nc;
 477
 478 /**
 479  * Local peer own ID (memory efficient handle)
 480  */
 481 static GNUNET_PEER_Id myid;
 482
 483 /**
 484  * Local peer own ID (full value)
 485  */
 486 static struct GNUNET_PeerIdentity my_full_id;
 487
 488 /**
 489  * Own private key
 490  */
 491 static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
 492
 493 /**
 494  * Own public key.
 495  */
 496 static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key;
 497
 498 /**
 499  * Tunnel ID for the next created tunnel (global tunnel number)
 500  */
 501 static MESH_TunnelNumber next_tid;
 502
 503 /**
 504  * Tunnel ID for the next incoming tunnel (local tunnel number)
 505  */
 506 static MESH_TunnelNumber next_local_tid;
 507
 508 /**
 509  * All application types provided by this peer
 510  */
 511 static struct GNUNET_CONTAINER_MultiHashMap *applications;
 512
 513 /**
 514  * All message types clients of this peer are interested in
 515  */
 516 static struct GNUNET_CONTAINER_MultiHashMap *types;
 517
 518 /**
 519  * Task to periodically announce provided applications
 520  */
 521 GNUNET_SCHEDULER_TaskIdentifier announce_applications_task;
 522
 523 /**
 524  * Task to periodically announce itself in the network
 525  */
 526 GNUNET_SCHEDULER_TaskIdentifier announce_id_task;
 527
 528 #if MESH_DEBUG
 529 unsigned int next_client_id;
 530 #endif
 531
 532
 533 /******************************************************************************/
 534 /************************         ITERATORS        ****************************/
 535 /******************************************************************************/
 536
 537 /* FIXME move iterators here */
 538
 539
 540 /******************************************************************************/
 541 /************************    PERIODIC FUNCTIONS    ****************************/
 542 /******************************************************************************/
 543
 544 /**
 545  * Announce iterator over for each application provided by the peer
 546  *
 547  * @param cls closure
 548  * @param key current key code
 549  * @param value value in the hash map
 550  * @return GNUNET_YES if we should continue to
 551  *         iterate,
 552  *         GNUNET_NO if not.
 553  */
 554 static int
 555 announce_application (void *cls, const GNUNET_HashCode * key, void *value)
 556 {
 557   /* FIXME are hashes in multihash map equal on all aquitectures? */
 558   GNUNET_DHT_put (dht_handle, key, 10U,
 559                   GNUNET_DHT_RO_RECORD_ROUTE |
 560                   GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_BLOCK_TYPE_TEST,
 561                   sizeof (struct GNUNET_PeerIdentity),
 562                   (const char *) &my_full_id,
 563 #if MESH_DEBUG
 564                   GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_FOREVER_REL,
 565                   &mesh_debug, "DHT_put for app completed");
 566 #else
 567                   GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
 568                                             APP_ANNOUNCE_TIME),
 569                   APP_ANNOUNCE_TIME, NULL, NULL);
 570 #endif
 571   return GNUNET_OK;
 572 }
 573
 574
 575 /**
 576  * Periodically announce what applications are provided by local clients
 577  *
 578  * @param cls closure
 579  * @param tc task context
 580  */
 581 static void
 582 announce_applications (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 583 {
 584   if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
 585   {
 586     announce_applications_task = GNUNET_SCHEDULER_NO_TASK;
 587     return;
 588   }
 589 #if MESH_DEBUG_DHT
 590   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Starting PUT for apps\n");
 591 #endif
 592   GNUNET_CONTAINER_multihashmap_iterate (applications, &announce_application,
 593                                          NULL);
 594   announce_applications_task =
 595       GNUNET_SCHEDULER_add_delayed (APP_ANNOUNCE_TIME, &announce_applications,
 596                                     cls);
 597 #if MESH_DEBUG_DHT
 598   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Finished PUT for apps\n");
 599 #endif
 600   return;
 601 }
 602
 603
 604 /**
 605  * Periodically announce self id in the DHT
 606  *
 607  * @param cls closure
 608  * @param tc task context
 609  */
 610 static void
 611 announce_id (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 612 {
 613   if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
 614   {
 615     announce_id_task = GNUNET_SCHEDULER_NO_TASK;
 616     return;
 617   }
 618   /* TODO
 619    * - Set data expiration in function of X
 620    * - Adapt X to churn
 621    */
 622 #if MESH_DEBUG_DHT
 623   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: DHT_put for ID %s started.\n",
 624               GNUNET_i2s (&my_full_id));
 625 #endif
 626   GNUNET_DHT_put (dht_handle,   /* DHT handle */
 627                   &my_full_id.hashPubKey,       /* Key to use */
 628                   10U,          /* Replication level */
 629                   GNUNET_DHT_RO_RECORD_ROUTE | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,    /* DHT options */
 630                   GNUNET_BLOCK_TYPE_TEST,       /* Block type */
 631                   sizeof (my_full_id),  /* Size of the data */
 632                   (char *) &my_full_id, /* Data itself */
 633                   GNUNET_TIME_absolute_get_forever (),  /* Data expiration */
 634                   GNUNET_TIME_UNIT_FOREVER_REL, /* Retry time */
 635 #if MESH_DEBUG_DHT
 636                   &mesh_debug, "DHT_put for id completed");
 637 #else
 638                   NULL,         /* Continuation */
 639                   NULL);        /* Continuation closure */
 640 #endif
 641   announce_id_task =
 642       GNUNET_SCHEDULER_add_delayed (ID_ANNOUNCE_TIME, &announce_id, cls);
 643 }
 644
 645
 646 /**
 647  * Function to process paths received for a new peer addition. The recorded
 648  * paths form the initial tunnel, which can be optimized later.
 649  * Called on each result obtained for the DHT search.
 650  *
 651  * @param cls closure
 652  * @param exp when will this value expire
 653  * @param key key of the result
 654  * @param type type of the result
 655  * @param size number of bytes in data
 656  * @param data pointer to the result data
 657  */
 658 static void
 659 dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp,
 660                     const GNUNET_HashCode * key,
 661                     const struct GNUNET_PeerIdentity *get_path,
 662                     unsigned int get_path_length,
 663                     const struct GNUNET_PeerIdentity *put_path,
 664                     unsigned int put_path_length, enum GNUNET_BLOCK_Type type,
 665                     size_t size, const void *data);
 666
 667
 668 /******************************************************************************/
 669 /******************      GENERAL HELPER FUNCTIONS      ************************/
 670 /******************************************************************************/
 671
 672 /**
 673  * Check if client has registered with the service and has not disconnected
 674  *
 675  * @param client the client to check
 676  *
 677  * @return non-NULL if client exists in the global DLL
 678  */
 679 static struct MeshClient *
 680 client_get (struct GNUNET_SERVER_Client *client)
 681 {
 682   struct MeshClient *c;
 683
 684   c = clients;
 685   while (NULL != c)
 686   {
 687     if (c->handle == client)
 688       return c;
 689     c = c->next;
 690   }
 691   return NULL;
 692 }
 693
 694
 695 /**
 696  * Checks if a given client has subscribed to certain message type
 697  *
 698  * @param message_type Type of message to check
 699  * @param c Client to check
 700  *
 701  * @return GNUNET_YES or GNUNET_NO, depending on subscription status
 702  *
 703  * TODO inline?
 704  */
 705 static int
 706 client_is_subscribed (uint16_t message_type, struct MeshClient *c)
 707 {
 708   GNUNET_HashCode hc;
 709
 710   GNUNET_CRYPTO_hash (&message_type, sizeof (uint16_t), &hc);
 711   return GNUNET_CONTAINER_multihashmap_contains (c->types, &hc);
 712 }
 713
 714
 715 /**
 716  * Allow a client to send more data after transmitting a multicast message
 717  * which some neighbor has not yet accepted altough a reasonable time has
 718  * passed.
 719  *
 720  * @param cls Closure (DataDescriptor containing the task identifier)
 721  * @param tc Task Context
 722  */
 723 static void
 724 client_allow_send (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 725 {
 726   struct MeshDataDescriptor *info = cls;
 727
 728   if (GNUNET_SCHEDULER_REASON_SHUTDOWN == tc->reason)
 729     return;
 730 #if MESH_DEBUG
 731   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 732               "MESH: CLIENT ALLOW SEND DESPITE %u COPIES PENDING\n",
 733               *(info->copies));
 734 #endif
 735   *(info->timeout_task) = GNUNET_SCHEDULER_NO_TASK;
 736   GNUNET_SERVER_receive_done (info->client, GNUNET_OK);
 737 }
 738
 739
 740 /**
 741  * Search for a tunnel by global ID using full PeerIdentities
 742  *
 743  * @param oid owner of the tunnel
 744  * @param tid global tunnel number
 745  *
 746  * @return tunnel handler, NULL if doesn't exist
 747  */
 748 static struct MeshTunnel *
 749 tunnel_get (struct GNUNET_PeerIdentity *oid, MESH_TunnelNumber tid);
 750
 751
 752 /**
 753  * Notify a tunnel that a connection has broken that affects at least
 754  * some of its peers.
 755  *
 756  * @param t Tunnel affected.
 757  * @param p1 Peer that got disconnected from p2.
 758  * @param p2 Peer that got disconnected from p1.
 759  *
 760  * @return Short ID of the peer disconnected (either p1 or p2).
 761  *         0 if the tunnel remained unaffected.
 762  */
 763 static GNUNET_PEER_Id
 764 tunnel_notify_connection_broken (struct MeshTunnel *t, GNUNET_PEER_Id p1,
 765                                  GNUNET_PEER_Id p2);
 766
 767
 768 /**
 769  * Send the message to all clients that have subscribed to its type
 770  *
 771  * @param msg Pointer to the message itself
 772  * @return number of clients this message was sent to
 773  */
 774 static unsigned int
 775 send_subscribed_clients (const struct GNUNET_MessageHeader *msg,
 776                          const struct GNUNET_MessageHeader *payload)
 777 {
 778   struct GNUNET_PeerIdentity *oid;
 779   struct MeshClient *c;
 780   struct MeshTunnel *t;
 781   MESH_TunnelNumber *tid;
 782   unsigned int count;
 783   uint16_t type;
 784   char cbuf[htons (msg->size)];
 785
 786   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Sending to clients...\n");
 787   type = ntohs (payload->type);
 788   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: message of type %u\n", type);
 789
 790   memcpy (cbuf, msg, sizeof (cbuf));
 791   switch (htons (msg->type))
 792   {
 793     struct GNUNET_MESH_Unicast *uc;
 794     struct GNUNET_MESH_Multicast *mc;
 795     struct GNUNET_MESH_ToOrigin *to;
 796
 797   case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
 798     uc = (struct GNUNET_MESH_Unicast *) cbuf;
 799     tid = &uc->tid;
 800     oid = &uc->oid;
 801     break;
 802   case GNUNET_MESSAGE_TYPE_MESH_MULTICAST:
 803     mc = (struct GNUNET_MESH_Multicast *) cbuf;
 804     tid = &mc->tid;
 805     oid = &mc->oid;
 806     break;
 807   case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
 808     to = (struct GNUNET_MESH_ToOrigin *) cbuf;
 809     tid = &to->tid;
 810     oid = &to->oid;
 811     break;
 812   default:
 813     GNUNET_break (0);
 814     return 0;
 815   }
 816   t = tunnel_get (oid, ntohl (*tid));
 817   if (NULL == t)
 818   {
 819     GNUNET_break (0);
 820     return 0;
 821   }
 822   *tid = htonl (t->local_tid);
 823   for (count = 0, c = clients; c != NULL; c = c->next)
 824   {
 825 #if MESH_DEBUG
 826     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    client %u\n", c->id);
 827 #endif
 828     if (client_is_subscribed (type, c))
 829     {
 830       count++;
 831       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:      sending\n");
 832       GNUNET_SERVER_notification_context_unicast (nc, c->handle,
 833                                                   (struct GNUNET_MessageHeader
 834                                                    *) cbuf, GNUNET_YES);
 835     }
 836   }
 837   return count;
 838 }
 839
 840
 841 /**
 842  * Notify the client that owns the tunnel that a peer has connected to it
 843  * (the requested path to it has been confirmed).
 844  *
 845  * @param t Tunnel whose owner to notify
 846  * @param id Short id of the peer that has connected
 847  */
 848 static void
 849 send_client_peer_connected (const struct MeshTunnel *t, const GNUNET_PEER_Id id)
 850 {
 851   struct GNUNET_MESH_PeerControl pc;
 852
 853   pc.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_ADD);
 854   pc.header.size = htons (sizeof (struct GNUNET_MESH_PeerControl));
 855   pc.tunnel_id = htonl (t->local_tid);
 856   GNUNET_PEER_resolve (id, &pc.peer);
 857   GNUNET_SERVER_notification_context_unicast (nc, t->client->handle, &pc.header,
 858                                               GNUNET_NO);
 859 }
 860
 861
 862 /**
 863  * Notify all clients (not depending on registration status) that the incoming
 864  * tunnel is no longer valid.
 865  *
 866  * @param t Tunnel that was destroyed.
 867  */
 868 static void
 869 send_clients_tunnel_destroy (struct MeshTunnel *t)
 870 {
 871   struct GNUNET_MESH_TunnelMessage msg;
 872
 873   msg.header.size = htons (sizeof (msg));
 874   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_DESTROY);
 875   msg.tunnel_id = htonl (t->local_tid);
 876   GNUNET_SERVER_notification_context_broadcast (nc, &msg.header, GNUNET_NO);
 877 }
 878
 879
 880 /**
 881  * Function called to notify a client about the socket
 882  * being ready to queue more data.  "buf" will be
 883  * NULL and "size" zero if the socket was closed for
 884  * writing in the meantime.
 885  *
 886  * @param cls closure
 887  * @param size number of bytes available in buf
 888  * @param buf where the callee should write the message
 889  * @return number of bytes written to buf
 890  */
 891 static size_t
 892 send_core_create_path (void *cls, size_t size, void *buf);
 893
 894
 895 /**
 896  * Function called to notify a client about the socket
 897  * being ready to queue more data.  "buf" will be
 898  * NULL and "size" zero if the socket was closed for
 899  * writing in the meantime.
 900  *
 901  * @param cls closure (data itself)
 902  * @param size number of bytes available in buf
 903  * @param buf where the callee should write the message
 904  *
 905  * @return number of bytes written to buf
 906  */
 907 static size_t
 908 send_core_data_multicast (void *cls, size_t size, void *buf);
 909
 910
 911 /**
 912  * Decrements the reference counter and frees all resources if needed
 913  *
 914  * @param dd Data Descriptor used in a multicast message
 915  */
 916 static void
 917 data_descriptor_decrement_multicast (struct MeshDataDescriptor *dd)
 918 {
 919   if (0 == --(*(dd->copies)))
 920   {
 921     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Last copy!\n");
 922     if (NULL != dd->client)
 923     {
 924       if (GNUNET_SCHEDULER_NO_TASK != *(dd->timeout_task))
 925       {
 926         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 927                     "MESH:  cancelling client timeout (%u)...\n",
 928                     *(dd->timeout_task));
 929         GNUNET_SCHEDULER_cancel (*(dd->timeout_task));
 930         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:  notifying client...\n");
 931         GNUNET_SERVER_receive_done (dd->client, GNUNET_OK);
 932       }
 933       GNUNET_free (dd->timeout_task);
 934     }
 935     GNUNET_free (dd->copies);
 936     GNUNET_free (dd->data);
 937   }
 938 }
 939
 940
 941 /**
 942  * Cancel a core transmission that was already requested and free all resources
 943  * associated to the request.
 944  *
 945  * @param peer PeeInfo of the peer whose transmission is cancelled.
 946  * @param i Position of the transmission to be cancelled.
 947  */
 948 static void
 949 peer_info_cancel_transmission (struct MeshPeerInfo *peer, unsigned int i)
 950 {
 951   if (NULL != peer->core_transmit[i])
 952   {
 953     struct MeshDataDescriptor *dd;
 954     struct MeshPathInfo *path_info;
 955
 956 #if MESH_DEBUG
 957     {
 958       struct GNUNET_PeerIdentity id;
 959
 960       GNUNET_PEER_resolve (peer->id, &id);
 961       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 962                   "MESH:   Cancelling data transmission at %s [%u]\n",
 963                   GNUNET_i2s (&id), i);
 964       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    message type %u\n",
 965                   peer->types[i]);
 966     }
 967 #endif
 968     /* TODO: notify that tranmission has failed */
 969     switch (peer->types[i])
 970     {
 971     case GNUNET_MESSAGE_TYPE_MESH_MULTICAST:
 972     case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
 973     case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
 974       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    type payload\n");
 975       dd = peer->infos[i];
 976       data_descriptor_decrement_multicast (dd);
 977       break;
 978     case GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE:
 979       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    type create path\n");
 980       path_info = peer->infos[i];
 981       path_destroy (path_info->path);
 982       break;
 983     default:
 984       GNUNET_break (0);
 985       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    type unknown!\n");
 986     }
 987     GNUNET_CORE_notify_transmit_ready_cancel (peer->core_transmit[i]);
 988     peer->core_transmit[i] = NULL;
 989     GNUNET_free (peer->infos[i]);
 990   }
 991 }
 992
 993
 994 /**
 995  * Get a unused CORE slot to transmit a message to a peer. If all the slots
 996  * are used, cancel one and return it's position.
 997  *
 998  * @param peer PeerInfo of the neighbor we want to transmit to.
 999  *
1000  * @return The index of an available slot to transmit to the neighbor.
1001  */
1002 static unsigned int
1003 peer_info_transmit_slot (struct MeshPeerInfo *peer)
1004 {
1005   unsigned int i;
1006
1007   for (i = 0; peer->core_transmit[i]; i++)
1008   {
1009     if (i == (CORE_QUEUE_SIZE - 1))
1010     {
1011       /* All positions are taken! Overwriting! */
1012       GNUNET_break (0);
1013       peer_info_cancel_transmission (peer, 0);
1014       return 0;
1015     }
1016   }
1017   return i;
1018 }
1019
1020
1021 /**
1022  * Retrieve the MeshPeerInfo stucture associated with the peer, create one
1023  * and insert it in the appropiate structures if the peer is not known yet.
1024  *
1025  * @param peer Full identity of the peer.
1026  *
1027  * @return Existing or newly created peer info.
1028  */
1029 static struct MeshPeerInfo *
1030 peer_info_get (const struct GNUNET_PeerIdentity *peer)
1031 {
1032   struct MeshPeerInfo *peer_info;
1033
1034   peer_info = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
1035   if (NULL == peer_info)
1036   {
1037     peer_info =
1038         (struct MeshPeerInfo *) GNUNET_malloc (sizeof (struct MeshPeerInfo));
1039     GNUNET_CONTAINER_multihashmap_put (peers, &peer->hashPubKey, peer_info,
1040                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
1041     peer_info->id = GNUNET_PEER_intern (peer);
1042   }
1043
1044   return peer_info;
1045 }
1046
1047
1048 /**
1049  * Retrieve the MeshPeerInfo stucture associated with the peer, create one
1050  * and insert it in the appropiate structures if the peer is not known yet.
1051  *
1052  * @param peer Short identity of the peer.
1053  *
1054  * @return Existing or newly created peer info.
1055  */
1056 static struct MeshPeerInfo *
1057 peer_info_get_short (const GNUNET_PEER_Id peer)
1058 {
1059   struct GNUNET_PeerIdentity id;
1060
1061   GNUNET_PEER_resolve (peer, &id);
1062   return peer_info_get (&id);
1063 }
1064
1065
1066 /**
1067  * Iterator to remove the tunnel from the list of tunnels a peer participates
1068  * in.
1069  *
1070  * @param cls Closure (tunnel info)
1071  * @param key GNUNET_PeerIdentity of the peer (unused)
1072  * @param value PeerInfo of the peer
1073  *
1074  * @return always GNUNET_YES, to keep iterating
1075  */
1076 static int
1077 peer_info_delete_tunnel (void *cls, const GNUNET_HashCode * key, void *value)
1078 {
1079   struct MeshTunnel *t = cls;
1080   struct MeshPeerInfo *peer = value;
1081   unsigned int i;
1082
1083   for (i = 0; i < peer->ntunnels; i++)
1084   {
1085     if (0 ==
1086         memcmp (&peer->tunnels[i]->id, &t->id, sizeof (struct MESH_TunnelID)))
1087     {
1088       peer->ntunnels--;
1089       peer->tunnels[i] = peer->tunnels[peer->ntunnels];
1090       peer->tunnels = GNUNET_realloc (peer->tunnels, peer->ntunnels);
1091       return GNUNET_YES;
1092     }
1093   }
1094   return GNUNET_YES;
1095 }
1096
1097
1098 /**
1099   * Core callback to write a
1100   *
1101   * @param cls Closure (MeshDataDescriptor with data in "data" member).
1102   * @param size Number of bytes available in buf.
1103   * @param buf Where the to write the message.
1104   *
1105   * @return number of bytes written to buf
1106   */
1107 static size_t
1108 send_core_data_raw (void *cls, size_t size, void *buf)
1109 {
1110   struct MeshDataDescriptor *info = cls;
1111   struct GNUNET_MessageHeader *msg;
1112   size_t total_size;
1113
1114   GNUNET_assert (NULL != info);
1115   GNUNET_assert (NULL != info->data);
1116   msg = (struct GNUNET_MessageHeader *) info->data;
1117   total_size = ntohs (msg->size);
1118
1119   if (total_size > size)
1120   {
1121     struct GNUNET_PeerIdentity id;
1122
1123     GNUNET_PEER_resolve (info->peer->id, &id);
1124     info->peer->core_transmit[info->handler_n] =
1125         GNUNET_CORE_notify_transmit_ready (core_handle, 0, 100,
1126                                            GNUNET_TIME_UNIT_FOREVER_REL, &id,
1127                                            size, &send_core_data_raw, info);
1128     return 0;
1129   }
1130   info->peer->core_transmit[info->handler_n] = NULL;
1131   memcpy (buf, msg, total_size);
1132   GNUNET_free (info->data);
1133   GNUNET_free (info);
1134   return total_size;
1135 }
1136
1137
1138 /**
1139  * Sends an already built message to a peer, properly registrating
1140  * all used resources.
1141  *
1142  * @param message Message to send. Fucntion makes a copy of it.
1143  * @param peer Short ID of the neighbor whom to send the message.
1144  */
1145 static void
1146 send_message (const struct GNUNET_MessageHeader *message,
1147               const struct GNUNET_PeerIdentity *peer)
1148 {
1149   struct MeshDataDescriptor *info;
1150   struct MeshPeerInfo *neighbor;
1151   struct MeshPeerPath *p;
1152   unsigned int i;
1153   size_t size;
1154
1155 //   GNUNET_TRANSPORT_try_connect();
1156
1157   size = ntohs (message->size);
1158   info = GNUNET_malloc (sizeof (struct MeshDataDescriptor));
1159   info->data = GNUNET_malloc (size);
1160   memcpy (info->data, message, size);
1161   neighbor = peer_info_get (peer);
1162   for (p = neighbor->path_head; NULL != p; p = p->next)
1163   {
1164     if (2 == p->length)
1165     {
1166       break;
1167     }
1168   }
1169   if (NULL == p)
1170   {
1171     GNUNET_break (0);
1172     GNUNET_free (info);
1173     return;
1174   }
1175   i = peer_info_transmit_slot (neighbor);
1176   info->handler_n = i;
1177   info->peer = neighbor;
1178   neighbor->types[i] = GNUNET_MESSAGE_TYPE_MESH_UNICAST;
1179   neighbor->infos[i] = info;
1180   neighbor->core_transmit[i] =
1181       GNUNET_CORE_notify_transmit_ready (core_handle, 0, 100,
1182                                          GNUNET_TIME_UNIT_FOREVER_REL, peer,
1183                                          size, &send_core_data_raw, info);
1184
1185 }
1186
1187
1188 /**
1189  * Sends a CREATE PATH message for a path to a peer, properly registrating
1190  * all used resources.
1191  *
1192  * @param peer PeerInfo of the final peer for whom this path is being created.
1193  * @param p Path itself.
1194  * @param t Tunnel for which the path is created.
1195  */
1196 static void
1197 send_create_path (struct MeshPeerInfo *peer, struct MeshPeerPath *p,
1198                   struct MeshTunnel *t)
1199 {
1200   struct GNUNET_PeerIdentity id;
1201   struct MeshPathInfo *path_info;
1202   struct MeshPeerInfo *neighbor;
1203   unsigned int i;
1204
1205   if (NULL == p)
1206   {
1207     p = tree_get_path_to_peer (t->tree, peer->id);
1208     if (NULL == p)
1209     {
1210       GNUNET_break (0);
1211       return;
1212     }
1213   }
1214   for (i = 0; i < p->length; i++)
1215   {
1216     if (p->peers[i] == myid)
1217       break;
1218   }
1219   if (i >= p->length - 1)
1220   {
1221     path_destroy (p);
1222     GNUNET_break (0);
1223     return;
1224   }
1225   GNUNET_PEER_resolve (p->peers[i + 1], &id);
1226
1227   path_info = GNUNET_malloc (sizeof (struct MeshPathInfo));
1228   path_info->path = p;
1229   path_info->t = t;
1230   neighbor = peer_info_get (&id);
1231   path_info->peer = neighbor;
1232   path_info->pos = peer_info_transmit_slot (neighbor);
1233   neighbor->types[path_info->pos] = GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE;
1234   neighbor->infos[path_info->pos] = path_info;
1235   neighbor->core_transmit[path_info->pos] = GNUNET_CORE_notify_transmit_ready (core_handle,     /* handle */
1236                                                                                0,       /* cork */
1237                                                                                0,       /* priority */
1238                                                                                GNUNET_TIME_UNIT_FOREVER_REL,    /* timeout */
1239                                                                                &id,     /* target */
1240                                                                                sizeof (struct GNUNET_MESH_ManipulatePath) + (p->length * sizeof (struct GNUNET_PeerIdentity)),  /*size */
1241                                                                                &send_core_create_path,  /* callback */
1242                                                                                path_info);      /* cls */
1243 }
1244
1245
1246 /**
1247  * Sends a DESTROY PATH message to free resources for a path in a tunnel
1248  *
1249  * @param t Tunnel whose path to destroy.
1250  * @param destination Short ID of the peer to whom the path to destroy.
1251  */
1252 static void
1253 send_destroy_path (struct MeshTunnel *t, GNUNET_PEER_Id destination)
1254 {
1255   struct MeshPeerPath *p;
1256   size_t size;
1257
1258   p = tree_get_path_to_peer (t->tree, destination);
1259   if (NULL == p)
1260   {
1261     GNUNET_break (0);
1262     return;
1263   }
1264   size = sizeof (struct GNUNET_MESH_ManipulatePath);
1265   size += p->length * sizeof (struct GNUNET_PeerIdentity);
1266   {
1267     struct GNUNET_MESH_ManipulatePath *msg;
1268     struct GNUNET_PeerIdentity *pi;
1269     char cbuf[size];
1270     unsigned int i;
1271
1272     msg = (struct GNUNET_MESH_ManipulatePath *) cbuf;
1273     msg->header.size = htons (size);
1274     msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_DESTROY);
1275     msg->tid = htonl (t->id.tid);
1276     pi = (struct GNUNET_PeerIdentity *) &msg[1];
1277     for (i = 0; i < p->length; i++)
1278     {
1279       GNUNET_PEER_resolve (p->peers[i], &pi[i]);
1280     }
1281     send_message (&msg->header, tree_get_first_hop (t->tree, destination));
1282   }
1283   path_destroy (p);
1284 }
1285
1286
1287 /**
1288  * Try to establish a new connection to this peer.
1289  * Use the best path for the given tunnel.
1290  * If the peer doesn't have any path to it yet, try to get one.
1291  * If the peer already has some path, send a CREATE PATH towards it.
1292  *
1293  * @param peer PeerInfo of the peer.
1294  * @param t Tunnel for which to create the path, if possible.
1295  */
1296 static void
1297 peer_info_connect (struct MeshPeerInfo *peer, struct MeshTunnel *t)
1298 {
1299   struct MeshPeerPath *p;
1300   struct MeshPathInfo *path_info;
1301
1302   if (NULL != peer->path_head)
1303   {
1304     p = tree_get_path_to_peer (t->tree, peer->id);
1305     if (NULL == p)
1306     {
1307       GNUNET_break (0);
1308       return;
1309     }
1310
1311     if (p->length > 1)
1312     {
1313       send_create_path (peer, p, t);
1314     }
1315     else
1316     {
1317       path_destroy (p);
1318       send_client_peer_connected (t, myid);
1319     }
1320   }
1321   else if (NULL == peer->dhtget)
1322   {
1323     struct GNUNET_PeerIdentity id;
1324
1325     GNUNET_PEER_resolve (peer->id, &id);
1326     path_info = GNUNET_malloc (sizeof (struct MeshPathInfo));
1327     path_info->peer = peer;
1328     path_info->t = t;
1329     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1330                 "MESH:   Starting DHT GET for peer %s\n", GNUNET_i2s (&id));
1331     peer->dhtgetcls = path_info;
1332     peer->dhtget = GNUNET_DHT_get_start (dht_handle,    /* handle */
1333                                          GNUNET_TIME_UNIT_FOREVER_REL,  /* timeout */
1334                                          GNUNET_BLOCK_TYPE_TEST,        /* type */
1335                                          &id.hashPubKey,        /* key to search */
1336                                          4,     /* replication level */
1337                                          GNUNET_DHT_RO_RECORD_ROUTE | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, NULL,       /* xquery */
1338                                          0,     /* xquery bits */
1339                                          &dht_get_id_handler, path_info);
1340   }
1341   /* Otherwise, there is no path but the DHT get is already started. */
1342 }
1343
1344
1345 /**
1346  * Task to delay the connection of a peer
1347  *
1348  * @param cls Closure (path info with tunnel and peer to connect).
1349  *            Will be free'd on exection.
1350  * @param tc TaskContext
1351  */
1352 static void
1353 peer_info_connect_task (void *cls,
1354                         const struct GNUNET_SCHEDULER_TaskContext *tc)
1355 {
1356   struct MeshPathInfo *path_info = cls;
1357
1358   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
1359   {
1360     GNUNET_free (cls);
1361     return;
1362   }
1363   peer_info_connect (path_info->peer, path_info->t);
1364   GNUNET_free (cls);
1365 }
1366
1367
1368 /**
1369  * Destroy the peer_info and free any allocated resources linked to it
1370  *
1371  * @param pi The peer_info to destroy.
1372  *
1373  * @return GNUNET_OK on success
1374  */
1375 static int
1376 peer_info_destroy (struct MeshPeerInfo *pi)
1377 {
1378   struct GNUNET_PeerIdentity id;
1379   struct MeshPeerPath *p;
1380   struct MeshPeerPath *nextp;
1381   unsigned int i;
1382
1383   GNUNET_PEER_resolve (pi->id, &id);
1384   GNUNET_PEER_change_rc (pi->id, -1);
1385
1386   if (GNUNET_YES !=
1387       GNUNET_CONTAINER_multihashmap_remove (peers, &id.hashPubKey, pi))
1388   {
1389     GNUNET_break (0);
1390     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1391                 "MESH: removing peer %s, not in hashmap\n", GNUNET_i2s (&id));
1392   }
1393   if (NULL != pi->dhtget)
1394   {
1395     GNUNET_DHT_get_stop (pi->dhtget);
1396     GNUNET_free (pi->dhtgetcls);
1397   }
1398   for (i = 0; i < CORE_QUEUE_SIZE; i++)
1399   {
1400     peer_info_cancel_transmission (pi, i);
1401   }
1402   p = pi->path_head;
1403   while (NULL != p)
1404   {
1405     nextp = p->next;
1406     GNUNET_CONTAINER_DLL_remove (pi->path_head, pi->path_tail, p);
1407     path_destroy (p);
1408     p = nextp;
1409   }
1410   GNUNET_free (pi);
1411   return GNUNET_OK;
1412 }
1413
1414
1415 /**
1416  * Remove all paths that rely on a direct connection between p1 and p2
1417  * from the peer itself and notify all tunnels about it.
1418  *
1419  * @param peer PeerInfo of affected peer.
1420  * @param p1 GNUNET_PEER_Id of one peer.
1421  * @param p2 GNUNET_PEER_Id of another peer that was connected to the first and
1422  *           no longer is.
1423  *
1424  * TODO: optimize (see below)
1425  */
1426 static void
1427 peer_info_remove_path (struct MeshPeerInfo *peer, GNUNET_PEER_Id p1,
1428                        GNUNET_PEER_Id p2)
1429 {
1430   struct MeshPeerPath *p;
1431   struct MeshPeerPath *aux;
1432   struct MeshPeerInfo *peer_d;
1433   GNUNET_PEER_Id d;
1434   unsigned int destroyed;
1435   unsigned int best;
1436   unsigned int cost;
1437   unsigned int i;
1438
1439   destroyed = 0;
1440   p = peer->path_head;
1441   while (NULL != p)
1442   {
1443     aux = p->next;
1444     for (i = 0; i < (p->length - 1); i++)
1445     {
1446       if ((p->peers[i] == p1 && p->peers[i + 1] == p2) ||
1447           (p->peers[i] == p2 && p->peers[i + 1] == p1))
1448       {
1449         GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, p);
1450         path_destroy (p);
1451         destroyed++;
1452         break;
1453       }
1454     }
1455     p = aux;
1456   }
1457   if (0 == destroyed)
1458     return;
1459
1460   for (i = 0; i < peer->ntunnels; i++)
1461   {
1462     d = tunnel_notify_connection_broken (peer->tunnels[i], p1, p2);
1463     if (0 == d) continue;
1464     /* TODO
1465      * Problem: one or more peers have been deleted from the tunnel tree.
1466      * We don't know who they are to try to add them again.
1467      * We need to try to find a new path for each of the disconnected peers.
1468      * Some of them might already have a path to reach them that does not
1469      * involve p1 and p2. Adding all anew might render in a better tree than
1470      * the trivial immediate fix.
1471      *
1472      * Trivial immiediate fix: try to reconnect to the disconnected node. All
1473      * its children will be reachable trough him.
1474      */
1475     peer_d = peer_info_get_short (d);
1476     best = UINT_MAX;
1477     aux = NULL;
1478     for (p = peer_d->path_head; NULL != p; p = p->next)
1479     {
1480       if ((cost = tree_get_path_cost (peer->tunnels[i]->tree, p)) < best)
1481       {
1482         best = cost;
1483         aux = p;
1484       }
1485     }
1486     if (NULL != aux)
1487     {
1488       /* No callback, as peer will be already disconnected and a connection
1489        * scheduled by tunnel_notify_connection_broken.
1490        */
1491       tree_add_path (peer->tunnels[i]->tree, aux, NULL, NULL);
1492     }
1493     else
1494     {
1495       peer_info_connect (peer_d, peer->tunnels[i]);
1496     }
1497   }
1498 }
1499
1500
1501 /**
1502  * Add the path to the peer and update the path used to reach it in case this
1503  * is the shortest.
1504  *
1505  * @param peer_info Destination peer to add the path to.
1506  * @param path New path to add. Last peer must be the peer in arg 1.
1507  *             Path will be either used of freed if already known.
1508  * @param trusted Do we trust that this path is real?
1509  */
1510 void
1511 peer_info_add_path (struct MeshPeerInfo *peer_info, struct MeshPeerPath *path,
1512                     int trusted)
1513 {
1514   struct MeshPeerPath *aux;
1515   unsigned int l;
1516   unsigned int l2;
1517
1518   if ((NULL == peer_info) || (NULL == path))
1519   {
1520     GNUNET_break (0);
1521     path_destroy (path);
1522     return;
1523   }
1524   if (path->peers[path->length - 1] != peer_info->id)
1525   {
1526     GNUNET_break (0);
1527     path_destroy (path);
1528     return;
1529   }
1530   if (path->length <= 2 && GNUNET_NO == trusted)
1531   {
1532     /* Only allow CORE to tell us about direct paths */
1533     path_destroy (path);
1534     return;
1535   }
1536   GNUNET_assert (peer_info->id == path->peers[path->length - 1]);
1537   for (l = 1; l < path->length; l++)
1538   {
1539     if (path->peers[l] == myid)
1540     {
1541       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: shortening path by %u\n", l);
1542       for (l2 = 0; l2 < path->length - l; l2++)
1543       {
1544         path->peers[l2] = path->peers[l + l2];
1545       }
1546       path->length -= l;
1547       l = 1;
1548       path->peers =
1549           GNUNET_realloc (path->peers, path->length * sizeof (GNUNET_PEER_Id));
1550     }
1551   }
1552 #if MESH_DEBUG
1553   {
1554     struct GNUNET_PeerIdentity id;
1555
1556     GNUNET_PEER_resolve (peer_info->id, &id);
1557     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: adding path [%u] to peer %s\n",
1558                 path->length, GNUNET_i2s (&id));
1559   }
1560 #endif
1561   l = path_get_length (path);
1562   if (0 == l)
1563   {
1564     GNUNET_free (path);
1565     return;
1566   }
1567
1568   GNUNET_assert (peer_info->id == path->peers[path->length - 1]);
1569   for (aux = peer_info->path_head; aux != NULL; aux = aux->next)
1570   {
1571     l2 = path_get_length (aux);
1572     if (l2 > l)
1573     {
1574       GNUNET_CONTAINER_DLL_insert_before (peer_info->path_head,
1575                                           peer_info->path_tail, aux, path);
1576       return;
1577     }
1578     else
1579     {
1580       if (l2 == l && memcmp (path->peers, aux->peers, l) == 0)
1581       {
1582         path_destroy (path);
1583         return;
1584       }
1585     }
1586   }
1587   GNUNET_CONTAINER_DLL_insert_tail (peer_info->path_head, peer_info->path_tail,
1588                                     path);
1589   return;
1590 }
1591
1592
1593 /**
1594  * Add the path to the origin peer and update the path used to reach it in case
1595  * this is the shortest.
1596  * The path is given in peer_info -> destination, therefore we turn the path
1597  * upside down first.
1598  *
1599  * @param peer_info Peer to add the path to, being the origin of the path.
1600  * @param path New path to add after being inversed.
1601  * @param trusted Do we trust that this path is real?
1602  */
1603 static void
1604 peer_info_add_path_to_origin (struct MeshPeerInfo *peer_info,
1605                               struct MeshPeerPath *path, int trusted)
1606 {
1607   path_invert (path);
1608   peer_info_add_path (peer_info, path, trusted);
1609 }
1610
1611
1612 /**
1613  * Build a PeerPath from the paths returned from the DHT, reversing the paths
1614  * to obtain a local peer -> destination path and interning the peer ids.
1615  *
1616  * @return Newly allocated and created path
1617  */
1618 static struct MeshPeerPath *
1619 path_build_from_dht (const struct GNUNET_PeerIdentity *get_path,
1620                      unsigned int get_path_length,
1621                      const struct GNUNET_PeerIdentity *put_path,
1622                      unsigned int put_path_length)
1623 {
1624   struct MeshPeerPath *p;
1625   GNUNET_PEER_Id id;
1626   int i;
1627
1628   p = path_new (1);
1629   p->peers[0] = myid;
1630   GNUNET_PEER_change_rc (myid, 1);
1631   i = get_path_length;
1632   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    GET has %d hops.\n", i);
1633   for (i--; i >= 0; i--)
1634   {
1635     id = GNUNET_PEER_intern (&get_path[i]);
1636     if (p->length > 0 && id == p->peers[p->length - 1])
1637     {
1638       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    Optimizing 1 hop out.\n");
1639       GNUNET_PEER_change_rc (id, -1);
1640     }
1641     else
1642     {
1643       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    Adding from GET: %s.\n",
1644                   GNUNET_i2s (&get_path[i]));
1645       p->length++;
1646       p->peers = GNUNET_realloc (p->peers, sizeof (GNUNET_PEER_Id) * p->length);
1647       p->peers[p->length - 1] = id;
1648     }
1649   }
1650   i = put_path_length;
1651   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    PUT has %d hops.\n", i);
1652   for (i--; i >= 0; i--)
1653   {
1654     id = GNUNET_PEER_intern (&put_path[i]);
1655     if (id == myid)
1656     {
1657       /* PUT path went through us, so discard the path up until now and start
1658        * from here to get a much shorter (and loop-free) path.
1659        */
1660       path_destroy (p);
1661       p = path_new (0);
1662     }
1663     if (p->length > 0 && id == p->peers[p->length - 1])
1664     {
1665       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    Optimizing 1 hop out.\n");
1666       GNUNET_PEER_change_rc (id, -1);
1667     }
1668     else
1669     {
1670       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    Adding from PUT: %s.\n",
1671                   GNUNET_i2s (&put_path[i]));
1672       p->length++;
1673       p->peers = GNUNET_realloc (p->peers, sizeof (GNUNET_PEER_Id) * p->length);
1674       p->peers[p->length - 1] = id;
1675     }
1676   }
1677 #if MESH_DEBUG
1678   if (get_path_length > 0)
1679     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    (first of GET: %s)\n",
1680                 GNUNET_i2s (&get_path[0]));
1681   if (put_path_length > 0)
1682     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    (first of PUT: %s)\n",
1683                 GNUNET_i2s (&put_path[0]));
1684   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    In total: %d hops\n",
1685               p->length);
1686   for (i = 0; i < p->length; i++)
1687   {
1688     struct GNUNET_PeerIdentity peer_id;
1689
1690     GNUNET_PEER_resolve (p->peers[i], &peer_id);
1691     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:        %u: %s\n", p->peers[i],
1692                 GNUNET_i2s (&peer_id));
1693   }
1694 #endif
1695   return p;
1696 }
1697
1698
1699 /**
1700  * Send keepalive packets for a peer
1701  *
1702  * @param cls Closure (tunnel for which to send the keepalive).
1703  * @param tc Notification context.
1704  *
1705  * TODO: implement explicit multicast keepalive?
1706  */
1707 static void
1708 path_refresh (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
1709
1710
1711 /**
1712  * Search for a tunnel among the incoming tunnels
1713  *
1714  * @param tid the local id of the tunnel
1715  *
1716  * @return tunnel handler, NULL if doesn't exist
1717  */
1718 static struct MeshTunnel *
1719 tunnel_get_incoming (MESH_TunnelNumber tid)
1720 {
1721   GNUNET_HashCode hash;
1722
1723   GNUNET_assert (tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV);
1724   GNUNET_CRYPTO_hash (&tid, sizeof (MESH_TunnelNumber), &hash);
1725   return GNUNET_CONTAINER_multihashmap_get (incoming_tunnels, &hash);
1726 }
1727
1728
1729 /**
1730  * Search for a tunnel among the tunnels for a client
1731  *
1732  * @param c the client whose tunnels to search in
1733  * @param tid the local id of the tunnel
1734  *
1735  * @return tunnel handler, NULL if doesn't exist
1736  */
1737 static struct MeshTunnel *
1738 tunnel_get_by_local_id (struct MeshClient *c, MESH_TunnelNumber tid)
1739 {
1740   if (tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV)
1741   {
1742     return tunnel_get_incoming (tid);
1743   }
1744   else
1745   {
1746     GNUNET_HashCode hash;
1747
1748     GNUNET_CRYPTO_hash (&tid, sizeof (MESH_TunnelNumber), &hash);
1749     return GNUNET_CONTAINER_multihashmap_get (c->tunnels, &hash);
1750   }
1751 }
1752
1753
1754 /**
1755  * Search for a tunnel by global ID using PEER_ID
1756  *
1757  * @param pi owner of the tunnel
1758  * @param tid global tunnel number
1759  *
1760  * @return tunnel handler, NULL if doesn't exist
1761  */
1762 static struct MeshTunnel *
1763 tunnel_get_by_pi (GNUNET_PEER_Id pi, MESH_TunnelNumber tid)
1764 {
1765   struct MESH_TunnelID id;
1766   GNUNET_HashCode hash;
1767
1768   id.oid = pi;
1769   id.tid = tid;
1770
1771   GNUNET_CRYPTO_hash (&id, sizeof (struct MESH_TunnelID), &hash);
1772   return GNUNET_CONTAINER_multihashmap_get (tunnels, &hash);
1773 }
1774
1775
1776 /**
1777  * Search for a tunnel by global ID using full PeerIdentities
1778  *
1779  * @param oid owner of the tunnel
1780  * @param tid global tunnel number
1781  *
1782  * @return tunnel handler, NULL if doesn't exist
1783  */
1784 static struct MeshTunnel *
1785 tunnel_get (struct GNUNET_PeerIdentity *oid, MESH_TunnelNumber tid)
1786 {
1787   return tunnel_get_by_pi (GNUNET_PEER_search (oid), tid);
1788 }
1789
1790
1791 /**
1792  * Callback used to notify a client owner of a tunnel that a peer has
1793  * disconnected, most likely because of a path change.
1794  *
1795  * @param cls Closure (tunnel this notification is about).
1796  * @param peer_id Short ID of disconnected peer.
1797  */
1798 void
1799 notify_peer_disconnected (void *cls, GNUNET_PEER_Id peer_id)
1800 {
1801   struct MeshTunnel *t = cls;
1802   struct MeshPeerInfo *peer;
1803   struct MeshPathInfo *path_info;
1804
1805   if (NULL != t->client && NULL != nc)
1806   {
1807     struct GNUNET_MESH_PeerControl msg;
1808
1809     msg.header.size = htons (sizeof (msg));
1810     msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_DEL);
1811     msg.tunnel_id = htonl (t->local_tid);
1812     GNUNET_PEER_resolve (peer_id, &msg.peer);
1813     GNUNET_SERVER_notification_context_unicast (nc, t->client->handle,
1814                                                 &msg.header, GNUNET_NO);
1815   }
1816   peer = peer_info_get_short (peer_id);
1817   path_info = GNUNET_malloc (sizeof (struct MeshPathInfo));
1818   path_info->peer = peer;
1819   path_info->t = t;
1820   GNUNET_SCHEDULER_add_now (&peer_info_connect_task, path_info);
1821 }
1822
1823
1824 /**
1825  * Add a peer to a tunnel, accomodating paths accordingly and initializing all
1826  * needed rescources.
1827  * If peer already exists, reevaluate shortest path and change if different.
1828  *
1829  * @param t Tunnel we want to add a new peer to
1830  * @param peer PeerInfo of the peer being added
1831  *
1832  */
1833 static void
1834 tunnel_add_peer (struct MeshTunnel *t, struct MeshPeerInfo *peer)
1835 {
1836   struct GNUNET_PeerIdentity id;
1837   struct MeshPeerPath *best_p;
1838   struct MeshPeerPath *p;
1839   unsigned int best_cost;
1840   unsigned int cost;
1841
1842   GNUNET_PEER_resolve (peer->id, &id);
1843   if (GNUNET_NO ==
1844       GNUNET_CONTAINER_multihashmap_contains (t->peers, &id.hashPubKey))
1845   {
1846     t->peers_total++;
1847     GNUNET_array_append (peer->tunnels, peer->ntunnels, t);
1848     GNUNET_assert (GNUNET_OK ==
1849                    GNUNET_CONTAINER_multihashmap_put (t->peers, &id.hashPubKey,
1850                                                       peer,
1851                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
1852   }
1853
1854   if (NULL != (p = peer->path_head))
1855   {
1856     best_p = p;
1857     best_cost = tree_get_path_cost (t->tree, p);
1858     while (NULL != p)
1859     {
1860       if ((cost = tree_get_path_cost (t->tree, p)) < best_cost)
1861       {
1862         best_cost = cost;
1863         best_p = p;
1864       }
1865       p = p->next;
1866     }
1867     tree_add_path (t->tree, best_p, &notify_peer_disconnected, t);
1868     if (GNUNET_SCHEDULER_NO_TASK == t->path_refresh_task)
1869       t->path_refresh_task =
1870           GNUNET_SCHEDULER_add_delayed (REFRESH_PATH_TIME, &path_refresh, t);
1871   }
1872   else
1873   {
1874     /* Start a DHT get */
1875     peer_info_connect (peer, t);
1876   }
1877 }
1878
1879 /**
1880  * Add a path to a tunnel which we don't own, just to remember the next hop.
1881  * If destination node was already in the tunnel, the first hop information
1882  * will be replaced with the new path.
1883  *
1884  * @param t Tunnel we want to add a new peer to
1885  * @param p Path to add
1886  * @param own_pos Position of local node in path.
1887  *
1888  */
1889 static void
1890 tunnel_add_path (struct MeshTunnel *t, struct MeshPeerPath *p,
1891                  unsigned int own_pos)
1892 {
1893   struct GNUNET_PeerIdentity id;
1894
1895   GNUNET_assert (0 != own_pos);
1896   tree_add_path (t->tree, p, NULL, NULL);
1897   if (own_pos < p->length - 1)
1898   {
1899     GNUNET_PEER_resolve (p->peers[own_pos + 1], &id);
1900     tree_update_first_hops (t->tree, myid, &id);
1901   }
1902 }
1903
1904
1905 /**
1906  * Notifies a tunnel that a connection has broken that affects at least
1907  * some of its peers. Sends a notification towards the root of the tree.
1908  * In case the peer is the owner of the tree, notifies the client that owns
1909  * the tunnel and tries to reconnect.
1910  *
1911  * @param t Tunnel affected.
1912  * @param p1 Peer that got disconnected from p2.
1913  * @param p2 Peer that got disconnected from p1.
1914  *
1915  * @return Short ID of the peer disconnected (either p1 or p2).
1916  *         0 if the tunnel remained unaffected.
1917  */
1918 static GNUNET_PEER_Id
1919 tunnel_notify_connection_broken (struct MeshTunnel *t, GNUNET_PEER_Id p1,
1920                                  GNUNET_PEER_Id p2)
1921 {
1922   GNUNET_PEER_Id pid;
1923
1924   pid =
1925       tree_notify_connection_broken (t->tree, p1, p2, &notify_peer_disconnected,
1926                                      t);
1927   if (myid != p1 && myid != p2)
1928   {
1929     return pid;
1930   }
1931   if (pid != myid)
1932   {
1933     if (tree_get_predecessor (t->tree) != 0)
1934     {
1935       /* We are the peer still connected, notify owner of the disconnection. */
1936       struct GNUNET_MESH_PathBroken msg;
1937       struct GNUNET_PeerIdentity neighbor;
1938
1939       msg.header.size = htons (sizeof (msg));
1940       msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_BROKEN);
1941       GNUNET_PEER_resolve (t->id.oid, &msg.oid);
1942       msg.tid = htonl (t->id.tid);
1943       msg.peer1 = my_full_id;
1944       GNUNET_PEER_resolve (pid, &msg.peer2);
1945       GNUNET_PEER_resolve (tree_get_predecessor (t->tree), &neighbor);
1946       send_message (&msg.header, &neighbor);
1947     }
1948   }
1949   return pid;
1950 }
1951
1952
1953 struct MeshMulticastData
1954 {
1955   struct MeshTunnel *t;
1956
1957   GNUNET_SCHEDULER_TaskIdentifier *task;
1958
1959   unsigned int *reference_counter;
1960
1961   size_t data_len;
1962
1963   void *data;
1964 };
1965
1966
1967 /**
1968  * Send a multicast packet to a neighbor.
1969  */
1970 static void
1971 tunnel_send_multicast_iterator (void *cls, GNUNET_PEER_Id neighbor_id)
1972 {
1973   struct MeshMulticastData *mdata = cls;
1974   struct MeshDataDescriptor *info;
1975   struct GNUNET_PeerIdentity neighbor;
1976   unsigned int i;
1977
1978   info = GNUNET_malloc (sizeof (struct MeshDataDescriptor));
1979
1980   info->data = mdata->data;
1981   info->size = mdata->data_len;
1982   info->copies = mdata->reference_counter;
1983   (*(mdata->reference_counter))++;
1984
1985   if (NULL != mdata->t->client)
1986   {
1987     info->client = mdata->t->client->handle;
1988     info->timeout_task = mdata->task;
1989   }
1990   info->destination = neighbor_id;
1991   GNUNET_PEER_resolve (neighbor_id, &neighbor);
1992 #if MESH_DEBUG
1993   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    sending to %s...\n",
1994               GNUNET_i2s (&neighbor));
1995 #endif
1996   info->peer = peer_info_get (&neighbor);
1997   GNUNET_assert (NULL != info->peer);
1998   i = peer_info_transmit_slot (info->peer);
1999   info->handler_n = i;
2000   info->peer->infos[i] = info;
2001   info->peer->types[i] = GNUNET_MESSAGE_TYPE_MESH_MULTICAST;
2002   info->peer->core_transmit[i] =
2003       GNUNET_CORE_notify_transmit_ready (core_handle, 0, 0,
2004                                          GNUNET_TIME_UNIT_FOREVER_REL,
2005                                          &neighbor, info->size,
2006                                          &send_core_data_multicast, info);
2007 }
2008
2009 /**
2010  * Send a message in a tunnel in multicast, sending a copy to each child node
2011  * down the local one in the tunnel tree.
2012  *
2013  * @param t Tunnel in which to send the data.
2014  * @param msg Message to be sent
2015  */
2016 static void
2017 tunnel_send_multicast (struct MeshTunnel *t,
2018                        const struct GNUNET_MessageHeader *msg)
2019 {
2020   struct MeshMulticastData *mdata;
2021
2022 #if MESH_DEBUG
2023   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2024               "MESH:  sending a multicast packet...\n");
2025 #endif
2026   mdata = GNUNET_malloc (sizeof (struct MeshMulticastData));
2027   mdata->data_len = ntohs (msg->size);
2028   mdata->reference_counter = GNUNET_malloc (sizeof (unsigned int));
2029   mdata->t = t;
2030   mdata->data = GNUNET_malloc (mdata->data_len);
2031   memcpy (mdata->data, msg, mdata->data_len);
2032   if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_MESH_MULTICAST)
2033   {
2034     struct GNUNET_MESH_Multicast *mcast;
2035
2036     mcast = (struct GNUNET_MESH_Multicast *) mdata->data;
2037     mcast->ttl = htonl (ntohl (mcast->ttl) - 1);
2038 #if MESH_DEBUG
2039     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2040                 "MESH:   data packet, ttl: %u\n",
2041                 ntohl (mcast->ttl));
2042   }
2043   else
2044   {
2045     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2046                 "MESH:   not a data packet, no ttl\n");
2047 #endif
2048   }
2049   if (NULL != t->client)
2050   {
2051     mdata->task = GNUNET_malloc (sizeof (GNUNET_SCHEDULER_TaskIdentifier));
2052     *(mdata->task) =
2053         GNUNET_SCHEDULER_add_delayed (UNACKNOWLEDGED_WAIT, &client_allow_send,
2054                                       t->client->handle);
2055   }
2056
2057   tree_iterate_children (t->tree, &tunnel_send_multicast_iterator, mdata);
2058   if (*(mdata->reference_counter) == 0)
2059   {
2060     GNUNET_free (mdata->data);
2061     GNUNET_free (mdata->reference_counter);
2062     if (NULL != mdata->task)
2063     {
2064       GNUNET_free (mdata->task);
2065     }
2066   }
2067   GNUNET_free (mdata);
2068 #if MESH_DEBUG
2069   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2070               "MESH:  sending a multicast packet done\n");
2071 #endif
2072   return;
2073 }
2074
2075
2076 /**
2077  * Send a message to all peers in this tunnel that the tunnel is no longer
2078  * valid.
2079  *
2080  * @param t The tunnel whose peers to notify.
2081  */
2082 static void
2083 tunnel_send_destroy (struct MeshTunnel *t)
2084 {
2085   struct GNUNET_MESH_TunnelDestroy msg;
2086
2087   msg.header.size = htons (sizeof (msg));
2088   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY);
2089   GNUNET_PEER_resolve (t->id.oid, &msg.oid);
2090   msg.tid = htonl (t->id.tid);
2091   tunnel_send_multicast (t, &msg.header);
2092 }
2093
2094
2095
2096 /**
2097  * Destroy the tunnel and free any allocated resources linked to it
2098  *
2099  * @param t the tunnel to destroy
2100  *
2101  * @return GNUNET_OK on success
2102  */
2103 static int
2104 tunnel_destroy (struct MeshTunnel *t)
2105 {
2106   struct MeshClient *c;
2107   struct MeshQueue *q;
2108   struct MeshQueue *qn;
2109   GNUNET_HashCode hash;
2110   int r;
2111
2112   if (NULL == t)
2113     return GNUNET_OK;
2114
2115   c = t->client;
2116 #if MESH_DEBUG
2117   {
2118     struct GNUNET_PeerIdentity id;
2119
2120     GNUNET_PEER_resolve (t->id.oid, &id);
2121     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: destroying tunnel %s [%x]\n",
2122                 GNUNET_i2s (&id), t->id.tid);
2123     if (NULL != c)
2124       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   by client %u\n", c->id);
2125   }
2126 #endif
2127
2128   GNUNET_CRYPTO_hash (&t->id, sizeof (struct MESH_TunnelID), &hash);
2129   if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (tunnels, &hash, t))
2130   {
2131     r = GNUNET_SYSERR;
2132   }
2133
2134   GNUNET_CRYPTO_hash (&t->local_tid, sizeof (MESH_TunnelNumber), &hash);
2135   if (NULL != c &&
2136       GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (c->tunnels, &hash, t))
2137   {
2138     r = GNUNET_SYSERR;
2139   }
2140   if (t->local_tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV)
2141   {
2142     GNUNET_CRYPTO_hash (&t->local_tid, sizeof (MESH_TunnelNumber), &hash);
2143     GNUNET_break (GNUNET_YES ==
2144                   GNUNET_CONTAINER_multihashmap_remove (incoming_tunnels, &hash,
2145                                                         t));
2146   }
2147   if (NULL != t->peers)
2148   {
2149     GNUNET_CONTAINER_multihashmap_iterate (t->peers, &peer_info_delete_tunnel,
2150                                            t);
2151     GNUNET_CONTAINER_multihashmap_destroy (t->peers);
2152   }
2153   q = t->queue_head;
2154   while (NULL != q)
2155   {
2156     if (NULL != q->data)
2157       GNUNET_free (q->data);
2158     qn = q->next;
2159     GNUNET_free (q);
2160     q = qn;
2161     /* TODO cancel core transmit ready in case it was active */
2162   }
2163   tree_destroy (t->tree);
2164   if (NULL != t->dht_get_type)
2165     GNUNET_DHT_get_stop (t->dht_get_type);
2166   if (GNUNET_SCHEDULER_NO_TASK != t->timeout_task)
2167     GNUNET_SCHEDULER_cancel (t->timeout_task);
2168   if (GNUNET_SCHEDULER_NO_TASK != t->path_refresh_task)
2169     GNUNET_SCHEDULER_cancel (t->path_refresh_task);
2170   GNUNET_free (t);
2171   return r;
2172 }
2173
2174
2175 /**
2176  * Removes an explicit path from a tunnel, freeing all intermediate nodes
2177  * that are no longer needed, as well as nodes of no longer reachable peers.
2178  * The tunnel itself is also destoyed if results in a remote empty tunnel.
2179  *
2180  * @param t Tunnel from which to remove the path.
2181  * @param p Peer which should be removed.
2182  */
2183 static void
2184 tunnel_delete_peer (struct MeshTunnel *t, GNUNET_PEER_Id peer)
2185 {
2186   if (GNUNET_NO == tree_del_peer (t->tree, peer, NULL, NULL))
2187     tunnel_destroy (t);
2188 }
2189
2190
2191 /**
2192  * tunnel_destroy_iterator: iterator for deleting each tunnel that belongs to a
2193  * client when the client disconnects.
2194  *
2195  * @param cls closure (client that is disconnecting)
2196  * @param key the hash of the local tunnel id (used to access the hashmap)
2197  * @param value the value stored at the key (tunnel to destroy)
2198  *
2199  * @return GNUNET_OK on success
2200  */
2201 static int
2202 tunnel_destroy_iterator (void *cls, const GNUNET_HashCode * key, void *value)
2203 {
2204   struct MeshTunnel *t = value;
2205   int r;
2206
2207   r = tunnel_destroy (t);
2208   return r;
2209 }
2210
2211
2212 /**
2213  * Timeout function, destroys tunnel if called
2214  *
2215  * @param cls Closure (tunnel to destroy).
2216  * @param tc TaskContext
2217  */
2218 static void
2219 tunnel_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
2220 {
2221   struct MeshTunnel *t = cls;
2222
2223   if (GNUNET_SCHEDULER_REASON_SHUTDOWN == tc->reason)
2224     return;
2225   t->timeout_task = GNUNET_SCHEDULER_NO_TASK;
2226   tunnel_destroy (t);
2227 }
2228
2229 /**
2230  * Resets the tunnel timeout. Starts it if no timeout was running.
2231  *
2232  * @param t Tunnel whose timeout to reset.
2233  */
2234 static void
2235 tunnel_reset_timeout (struct MeshTunnel *t)
2236 {
2237   if (GNUNET_SCHEDULER_NO_TASK != t->timeout_task)
2238     GNUNET_SCHEDULER_cancel (t->timeout_task);
2239   t->timeout_task =
2240       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
2241                                     (REFRESH_PATH_TIME, 4), &tunnel_timeout, t);
2242 }
2243
2244
2245 /******************************************************************************/
2246 /****************      MESH NETWORK HANDLER HELPERS     ***********************/
2247 /******************************************************************************/
2248
2249 /**
2250  * Function called to notify a client about the socket
2251  * being ready to queue more data.  "buf" will be
2252  * NULL and "size" zero if the socket was closed for
2253  * writing in the meantime.
2254  *
2255  * @param cls closure
2256  * @param size number of bytes available in buf
2257  * @param buf where the callee should write the message
2258  * @return number of bytes written to buf
2259  */
2260 static size_t
2261 send_core_create_path (void *cls, size_t size, void *buf)
2262 {
2263   struct MeshPathInfo *info = cls;
2264   struct GNUNET_MESH_ManipulatePath *msg;
2265   struct GNUNET_PeerIdentity *peer_ptr;
2266   struct MeshPeerInfo *peer = info->peer;
2267   struct MeshTunnel *t = info->t;
2268   struct MeshPeerPath *p = info->path;
2269   size_t size_needed;
2270   int i;
2271
2272   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: CREATE PATH sending...\n");
2273   size_needed =
2274       sizeof (struct GNUNET_MESH_ManipulatePath) +
2275       p->length * sizeof (struct GNUNET_PeerIdentity);
2276
2277   if (size < size_needed || NULL == buf)
2278   {
2279     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: create path retransmit!\n");
2280     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   buf:  %p\n", buf);
2281     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   size: (%u/%u)\n", size,
2282                 size_needed);
2283     info->peer->core_transmit[info->pos] =
2284         GNUNET_CORE_notify_transmit_ready (core_handle, 0, 0,
2285                                            GNUNET_TIME_UNIT_FOREVER_REL,
2286                                            tree_get_first_hop (t->tree,
2287                                                                peer->id),
2288                                            size_needed, &send_core_create_path,
2289                                            info);
2290     return 0;
2291   }
2292   info->peer->core_transmit[info->pos] = NULL;
2293 #if MESH_DEBUG
2294   {
2295     struct GNUNET_PeerIdentity id;
2296
2297     GNUNET_PEER_resolve (peer->id, &id);
2298     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2299                 "MESH:   setting core_transmit %s [%u] to NULL\n",
2300                 GNUNET_i2s (&id), info->pos);
2301   }
2302 #endif
2303   msg = (struct GNUNET_MESH_ManipulatePath *) buf;
2304   msg->header.size = htons (size_needed);
2305   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE);
2306   msg->tid = ntohl (t->id.tid);
2307
2308   peer_ptr = (struct GNUNET_PeerIdentity *) &msg[1];
2309   for (i = 0; i < p->length; i++)
2310   {
2311     GNUNET_PEER_resolve (p->peers[i], peer_ptr++);
2312   }
2313
2314   path_destroy (p);
2315   GNUNET_free (info);
2316
2317   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2318               "MESH: CREATE PATH (%u bytes long) sent!\n", size_needed);
2319   return size_needed;
2320 }
2321
2322
2323 /**
2324  * Function called to notify a client about the socket
2325  * being ready to queue more data.  "buf" will be
2326  * NULL and "size" zero if the socket was closed for
2327  * writing in the meantime.
2328  *
2329  * @param cls closure (data itself)
2330  * @param size number of bytes available in buf
2331  * @param buf where the callee should write the message
2332  *
2333  * @return number of bytes written to buf
2334  */
2335 static size_t
2336 send_core_data_multicast (void *cls, size_t size, void *buf)
2337 {
2338   struct MeshDataDescriptor *info = cls;
2339   size_t total_size;
2340
2341   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Multicast callback.\n");
2342   GNUNET_assert (NULL != info);
2343   GNUNET_assert (NULL != info->peer);
2344   total_size = info->size;
2345   GNUNET_assert (total_size < GNUNET_SERVER_MAX_MESSAGE_SIZE);
2346
2347   if (total_size > size)
2348   {
2349     /* Retry */
2350     struct GNUNET_PeerIdentity id;
2351
2352     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2353                 "MESH: Multicast: retransmitting... (%u/%u)\n", size,
2354                 total_size);
2355     GNUNET_PEER_resolve (info->peer->id, &id);
2356     info->peer->core_transmit[info->handler_n] =
2357         GNUNET_CORE_notify_transmit_ready (core_handle, 0, 0,
2358                                            GNUNET_TIME_UNIT_FOREVER_REL, &id,
2359                                            total_size,
2360                                            &send_core_data_multicast, info);
2361     return 0;
2362   }
2363   info->peer->core_transmit[info->handler_n] = NULL;
2364   info->peer->infos[info->handler_n] = NULL;
2365   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:  copying data...\n");
2366   memcpy (buf, info->data, total_size);
2367 #if MESH_DEBUG
2368   {
2369     struct GNUNET_MESH_Multicast *mc;
2370     struct GNUNET_MessageHeader *mh;
2371
2372     mh = buf;
2373     if (ntohs (mh->type) == GNUNET_MESSAGE_TYPE_MESH_MULTICAST)
2374     {
2375       mc = (struct GNUNET_MESH_Multicast *) mh;
2376       mh = (struct GNUNET_MessageHeader *) &mc[1];
2377       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2378                   "MESH:  multicast, payload type %u\n", ntohs (mh->type));
2379       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2380                   "MESH:  multicast, payload size %u\n", ntohs (mh->size));
2381     }
2382     else
2383     {
2384       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:  type %u\n",
2385                   ntohs (mh->type));
2386     }
2387   }
2388 #endif
2389   data_descriptor_decrement_multicast (info);
2390   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: freeing info...\n");
2391   GNUNET_free (info);
2392   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: return %u\n", total_size);
2393   return total_size;
2394 }
2395
2396
2397 /**
2398  * Function called to notify a client about the socket
2399  * being ready to queue more data.  "buf" will be
2400  * NULL and "size" zero if the socket was closed for
2401  * writing in the meantime.
2402  *
2403  * @param cls closure (MeshDataDescriptor)
2404  * @param size number of bytes available in buf
2405  * @param buf where the callee should write the message
2406  * @return number of bytes written to buf
2407  */
2408 static size_t
2409 send_core_path_ack (void *cls, size_t size, void *buf)
2410 {
2411   struct MeshDataDescriptor *info = cls;
2412   struct GNUNET_MESH_PathACK *msg = buf;
2413
2414   GNUNET_assert (NULL != info);
2415   if (info->peer)
2416   {
2417     info->peer->core_transmit[info->handler_n] = NULL;
2418   }
2419   if (sizeof (struct GNUNET_MESH_PathACK) > size)
2420   {
2421     GNUNET_break (0);
2422     return 0;
2423   }
2424   msg->header.size = htons (sizeof (struct GNUNET_MESH_PathACK));
2425   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_ACK);
2426   GNUNET_PEER_resolve (info->origin->oid, &msg->oid);
2427   msg->tid = htonl (info->origin->tid);
2428   msg->peer_id = my_full_id;
2429   GNUNET_free (info);
2430   /* TODO add signature */
2431
2432   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: PATH ACK sent!\n");
2433   return sizeof (struct GNUNET_MESH_PathACK);
2434 }
2435
2436
2437 /******************************************************************************/
2438 /********************      MESH NETWORK HANDLERS     **************************/
2439 /******************************************************************************/
2440
2441
2442 /**
2443  * Core handler for path creation
2444  *
2445  * @param cls closure
2446  * @param message message
2447  * @param peer peer identity this notification is about
2448  * @param atsi performance data
2449  * @param atsi_count number of records in 'atsi'
2450  *
2451  * @return GNUNET_OK to keep the connection open,
2452  *         GNUNET_SYSERR to close it (signal serious error)
2453  */
2454 static int
2455 handle_mesh_path_create (void *cls, const struct GNUNET_PeerIdentity *peer,
2456                          const struct GNUNET_MessageHeader *message,
2457                          const struct GNUNET_ATS_Information *atsi,
2458                          unsigned int atsi_count)
2459 {
2460   unsigned int own_pos;
2461   uint16_t size;
2462   uint16_t i;
2463   MESH_TunnelNumber tid;
2464   struct GNUNET_MESH_ManipulatePath *msg;
2465   struct GNUNET_PeerIdentity *pi;
2466   GNUNET_HashCode hash;
2467   struct MeshPeerPath *path;
2468   struct MeshPeerInfo *dest_peer_info;
2469   struct MeshPeerInfo *orig_peer_info;
2470   struct MeshTunnel *t;
2471
2472   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2473               "MESH: Received a path create msg [%s]\n",
2474               GNUNET_i2s (&my_full_id));
2475   size = ntohs (message->size);
2476   if (size < sizeof (struct GNUNET_MESH_ManipulatePath))
2477   {
2478     GNUNET_break_op (0);
2479     return GNUNET_OK;
2480   }
2481
2482   size -= sizeof (struct GNUNET_MESH_ManipulatePath);
2483   if (size % sizeof (struct GNUNET_PeerIdentity))
2484   {
2485     GNUNET_break_op (0);
2486     return GNUNET_OK;
2487   }
2488   size /= sizeof (struct GNUNET_PeerIdentity);
2489   if (size < 2)
2490   {
2491     GNUNET_break_op (0);
2492     return GNUNET_OK;
2493   }
2494   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:     path has %u hops.\n", size);
2495   msg = (struct GNUNET_MESH_ManipulatePath *) message;
2496
2497   tid = ntohl (msg->tid);
2498   pi = (struct GNUNET_PeerIdentity *) &msg[1];
2499   t = tunnel_get (pi, tid);
2500   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2501               "MESH:     path is for tunnel %s [%X].\n", GNUNET_i2s (pi), tid);
2502   if (NULL == t)
2503   {
2504     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   Creating tunnel\n");
2505     t = GNUNET_malloc (sizeof (struct MeshTunnel));
2506     t->id.oid = GNUNET_PEER_intern (pi);
2507     t->id.tid = tid;
2508     while (NULL != tunnel_get_incoming (next_local_tid))
2509       next_local_tid = (next_local_tid + 1) | GNUNET_MESH_LOCAL_TUNNEL_ID_SERV;
2510     t->local_tid = next_local_tid++;
2511     next_local_tid = next_local_tid | GNUNET_MESH_LOCAL_TUNNEL_ID_SERV;
2512     t->tree = tree_new (t->id.oid);
2513
2514     GNUNET_CRYPTO_hash (&t->id, sizeof (struct MESH_TunnelID), &hash);
2515     if (GNUNET_OK !=
2516         GNUNET_CONTAINER_multihashmap_put (tunnels, &hash, t,
2517                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
2518     {
2519       tunnel_destroy (t);
2520       GNUNET_break (0);
2521       return GNUNET_OK;
2522     }
2523     tunnel_reset_timeout (t);
2524     GNUNET_CRYPTO_hash (&t->local_tid, sizeof (MESH_TunnelNumber), &hash);
2525     if (GNUNET_OK !=
2526         GNUNET_CONTAINER_multihashmap_put (incoming_tunnels, &hash, t,
2527                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
2528     {
2529       tunnel_destroy (t);
2530       GNUNET_break (0);
2531       return GNUNET_OK;
2532     }
2533   }
2534   dest_peer_info =
2535       GNUNET_CONTAINER_multihashmap_get (peers, &pi[size - 1].hashPubKey);
2536   if (NULL == dest_peer_info)
2537   {
2538     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2539                 "MESH:   Creating PeerInfo for destination.\n");
2540     dest_peer_info = GNUNET_malloc (sizeof (struct MeshPeerInfo));
2541     dest_peer_info->id = GNUNET_PEER_intern (&pi[size - 1]);
2542     GNUNET_CONTAINER_multihashmap_put (peers, &pi[size - 1].hashPubKey,
2543                                        dest_peer_info,
2544                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
2545   }
2546   orig_peer_info = GNUNET_CONTAINER_multihashmap_get (peers, &pi->hashPubKey);
2547   if (NULL == orig_peer_info)
2548   {
2549     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2550                 "MESH:   Creating PeerInfo for origin.\n");
2551     orig_peer_info = GNUNET_malloc (sizeof (struct MeshPeerInfo));
2552     orig_peer_info->id = GNUNET_PEER_intern (pi);
2553     GNUNET_CONTAINER_multihashmap_put (peers, &pi->hashPubKey, orig_peer_info,
2554                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
2555   }
2556   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   Creating path...\n");
2557   path = path_new (size);
2558   own_pos = 0;
2559   for (i = 0; i < size; i++)
2560   {
2561     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   ... adding %s\n",
2562                 GNUNET_i2s (&pi[i]));
2563     path->peers[i] = GNUNET_PEER_intern (&pi[i]);
2564     if (path->peers[i] == myid)
2565       own_pos = i;
2566   }
2567   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   Own position: %u\n", own_pos);
2568   if (own_pos == 0)
2569   {
2570     /* cannot be self, must be 'not found' */
2571     /* create path: self not found in path through self */
2572     GNUNET_break_op (0);
2573     path_destroy (path);
2574     /* FIXME error. destroy tunnel? leave for timeout? */
2575     return 0;
2576   }
2577   tunnel_add_path (t, path, own_pos);
2578   if (own_pos == size - 1)
2579   {
2580     /* It is for us! Send ack. */
2581     struct MeshDataDescriptor *info;
2582     unsigned int j;
2583
2584     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   It's for us!\n");
2585     peer_info_add_path_to_origin (orig_peer_info, path, GNUNET_NO);
2586     if (NULL == t->peers)
2587     {
2588       /* New tunnel! Notify clients! */
2589       struct GNUNET_MESH_TunnelNotification cmsg;
2590
2591       cmsg.header.size = htons (sizeof (cmsg));
2592       cmsg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_CREATE);
2593       GNUNET_PEER_resolve (t->id.oid, &cmsg.peer);
2594       cmsg.tunnel_id = htonl (t->local_tid);
2595       GNUNET_SERVER_notification_context_broadcast (nc, &cmsg.header,
2596                                                     GNUNET_NO);
2597
2598       t->peers = GNUNET_CONTAINER_multihashmap_create (4);
2599     }
2600     GNUNET_break (GNUNET_OK ==
2601                   GNUNET_CONTAINER_multihashmap_put (t->peers,
2602                                                      &my_full_id.hashPubKey,
2603                                                      peer_info_get
2604                                                      (&my_full_id),
2605                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
2606     /* FIXME use send_message */
2607     info = GNUNET_malloc (sizeof (struct MeshDataDescriptor));
2608     info->origin = &t->id;
2609     info->peer = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
2610     GNUNET_assert (NULL != info->peer);
2611     j = peer_info_transmit_slot (info->peer);
2612     info->handler_n = j;
2613     info->peer->types[j] = GNUNET_MESSAGE_TYPE_MESH_PATH_ACK;
2614     info->peer->infos[j] = info;
2615     info->peer->core_transmit[j] =
2616         GNUNET_CORE_notify_transmit_ready (core_handle, 0, 100,
2617                                            GNUNET_TIME_UNIT_FOREVER_REL, peer,
2618                                            sizeof (struct GNUNET_MESH_PathACK),
2619                                            &send_core_path_ack, info);
2620   }
2621   else
2622   {
2623     struct MeshPeerPath *path2;
2624
2625     /* It's for somebody else! Retransmit. */
2626     path2 = path_duplicate (path);
2627     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   Retransmitting.\n");
2628     peer_info_add_path (dest_peer_info, path2, GNUNET_NO);
2629     path2 = path_duplicate (path);
2630     peer_info_add_path_to_origin (orig_peer_info, path2, GNUNET_NO);
2631     send_create_path (dest_peer_info, path, t);
2632   }
2633   return GNUNET_OK;
2634 }
2635
2636
2637 /**
2638  * Core handler for path destruction
2639  *
2640  * @param cls closure
2641  * @param message message
2642  * @param peer peer identity this notification is about
2643  * @param atsi performance data
2644  * @param atsi_count number of records in 'atsi'
2645  *
2646  * @return GNUNET_OK to keep the connection open,
2647  *         GNUNET_SYSERR to close it (signal serious error)
2648  */
2649 static int
2650 handle_mesh_path_destroy (void *cls, const struct GNUNET_PeerIdentity *peer,
2651                           const struct GNUNET_MessageHeader *message,
2652                           const struct GNUNET_ATS_Information *atsi,
2653                           unsigned int atsi_count)
2654 {
2655   struct GNUNET_MESH_ManipulatePath *msg;
2656   struct GNUNET_PeerIdentity *pi;
2657   struct MeshPeerPath *path;
2658   struct MeshTunnel *t;
2659   unsigned int own_pos;
2660   unsigned int i;
2661   size_t size;
2662
2663   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2664               "MESH: Received a PATH DESTROY msg from %s\n", GNUNET_i2s (peer));
2665   size = ntohs (message->size);
2666   if (size < sizeof (struct GNUNET_MESH_ManipulatePath))
2667   {
2668     GNUNET_break_op (0);
2669     return GNUNET_OK;
2670   }
2671
2672   size -= sizeof (struct GNUNET_MESH_ManipulatePath);
2673   if (size % sizeof (struct GNUNET_PeerIdentity))
2674   {
2675     GNUNET_break_op (0);
2676     return GNUNET_OK;
2677   }
2678   size /= sizeof (struct GNUNET_PeerIdentity);
2679   if (size < 2)
2680   {
2681     GNUNET_break_op (0);
2682     return GNUNET_OK;
2683   }
2684   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:     path has %u hops.\n", size);
2685
2686   msg = (struct GNUNET_MESH_ManipulatePath *) message;
2687   pi = (struct GNUNET_PeerIdentity *) &msg[1];
2688   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2689               "MESH:     path is for tunnel %s [%X].\n", GNUNET_i2s (pi),
2690               msg->tid);
2691   t = tunnel_get (pi, ntohl (msg->tid));
2692   if (NULL == t)
2693   {
2694     /* TODO notify back: we don't know this tunnel */
2695     GNUNET_break_op (0);
2696     return GNUNET_OK;
2697   }
2698   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   Creating path...\n");
2699   path = path_new (size);
2700   own_pos = 0;
2701   for (i = 0; i < size; i++)
2702   {
2703     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   ... adding %s\n",
2704                 GNUNET_i2s (&pi[i]));
2705     path->peers[i] = GNUNET_PEER_intern (&pi[i]);
2706     if (path->peers[i] == myid)
2707       own_pos = i;
2708   }
2709   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   Own position: %u\n", own_pos);
2710   if (own_pos < path->length - 1)
2711     send_message (message, &pi[own_pos + 1]);
2712   tunnel_delete_peer (t, path->peers[path->length - 1]);
2713   path_destroy (path);
2714   return GNUNET_OK;
2715 }
2716
2717
2718 /**
2719  * Core handler for notifications of broken paths
2720  *
2721  * @param cls closure
2722  * @param message message
2723  * @param peer peer identity this notification is about
2724  * @param atsi performance data
2725  * @param atsi_count number of records in 'atsi'
2726  *
2727  * @return GNUNET_OK to keep the connection open,
2728  *         GNUNET_SYSERR to close it (signal serious error)
2729  */
2730 static int
2731 handle_mesh_path_broken (void *cls, const struct GNUNET_PeerIdentity *peer,
2732                          const struct GNUNET_MessageHeader *message,
2733                          const struct GNUNET_ATS_Information *atsi,
2734                          unsigned int atsi_count)
2735 {
2736   struct GNUNET_MESH_PathBroken *msg;
2737   struct MeshTunnel *t;
2738
2739   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2740               "MESH: Received a PATH BROKEN msg from %s\n", GNUNET_i2s (peer));
2741   msg = (struct GNUNET_MESH_PathBroken *) message;
2742   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   regarding %s\n",
2743               GNUNET_i2s (&msg->peer1));
2744   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   regarding %s\n",
2745               GNUNET_i2s (&msg->peer2));
2746   t = tunnel_get (&msg->oid, ntohl (msg->tid));
2747   if (NULL == t)
2748   {
2749     GNUNET_break_op (0);
2750     return GNUNET_OK;
2751   }
2752   tunnel_notify_connection_broken (t, GNUNET_PEER_search (&msg->peer1),
2753                                    GNUNET_PEER_search (&msg->peer2));
2754   return GNUNET_OK;
2755
2756 }
2757
2758
2759 /**
2760  * Core handler for tunnel destruction
2761  *
2762  * @param cls closure
2763  * @param message message
2764  * @param peer peer identity this notification is about
2765  * @param atsi performance data
2766  * @param atsi_count number of records in 'atsi'
2767  *
2768  * @return GNUNET_OK to keep the connection open,
2769  *         GNUNET_SYSERR to close it (signal serious error)
2770  */
2771 static int
2772 handle_mesh_tunnel_destroy (void *cls, const struct GNUNET_PeerIdentity *peer,
2773                             const struct GNUNET_MessageHeader *message,
2774                             const struct GNUNET_ATS_Information *atsi,
2775                             unsigned int atsi_count)
2776 {
2777   struct GNUNET_MESH_TunnelDestroy *msg;
2778   struct MeshTunnel *t;
2779
2780   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2781               "MESH: Got a TUNNEL DESTROY packet from %s\n", GNUNET_i2s (peer));
2782   msg = (struct GNUNET_MESH_TunnelDestroy *) message;
2783   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   for tunnel %s [%u]\n",
2784               GNUNET_i2s (&msg->oid), ntohl (msg->tid));
2785   t = tunnel_get (&msg->oid, ntohl (msg->tid));
2786   if (NULL == t)
2787   {
2788     /* Probably already got the message from another path,
2789      * destroyed the tunnel and retransmitted to children.
2790      * Safe to ignore.
2791      */
2792     return GNUNET_OK;
2793   }
2794   if (t->id.oid == myid)
2795   {
2796     GNUNET_break_op (0);
2797     return GNUNET_OK;
2798   }
2799   if (t->local_tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV)
2800   {
2801     /* Tunnel was incoming, notify clients */
2802     send_clients_tunnel_destroy (t);
2803   }
2804   tunnel_send_destroy (t);
2805   tunnel_destroy (t);
2806   return GNUNET_OK;
2807 }
2808
2809
2810 /**
2811  * Core handler for mesh network traffic going from the origin to a peer
2812  *
2813  * @param cls closure
2814  * @param peer peer identity this notification is about
2815  * @param message message
2816  * @param atsi performance data
2817  * @param atsi_count number of records in 'atsi'
2818  * @return GNUNET_OK to keep the connection open,
2819  *         GNUNET_SYSERR to close it (signal serious error)
2820  */
2821 static int
2822 handle_mesh_data_unicast (void *cls, const struct GNUNET_PeerIdentity *peer,
2823                           const struct GNUNET_MessageHeader *message,
2824                           const struct GNUNET_ATS_Information *atsi,
2825                           unsigned int atsi_count)
2826 {
2827   struct GNUNET_MESH_Unicast *msg;
2828   struct MeshTunnel *t;
2829   GNUNET_PEER_Id pid;
2830   size_t size;
2831
2832   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: got a unicast packet from %s\n",
2833               GNUNET_i2s (peer));
2834   size = ntohs (message->size);
2835   if (size <
2836       sizeof (struct GNUNET_MESH_Unicast) +
2837       sizeof (struct GNUNET_MessageHeader))
2838   {
2839     GNUNET_break (0);
2840     return GNUNET_OK;
2841   }
2842   msg = (struct GNUNET_MESH_Unicast *) message;
2843   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:  of type %u\n",
2844               ntohs (msg[1].header.type));
2845   t = tunnel_get (&msg->oid, ntohl (msg->tid));
2846   if (NULL == t)
2847   {
2848     /* TODO notify back: we don't know this tunnel */
2849     GNUNET_break_op (0);
2850     return GNUNET_OK;
2851   }
2852   tunnel_reset_timeout (t);
2853   pid = GNUNET_PEER_search (&msg->destination);
2854   if (pid == myid)
2855   {
2856     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2857                 "MESH:   it's for us! sending to clients...\n");
2858     send_subscribed_clients (message, (struct GNUNET_MessageHeader *) &msg[1]);
2859     return GNUNET_OK;
2860   }
2861   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2862               "MESH:   not for us, retransmitting...\n");
2863   send_message (message, tree_get_first_hop (t->tree, pid));
2864   return GNUNET_OK;
2865 }
2866
2867
2868 /**
2869  * Core handler for mesh network traffic going from the origin to all peers
2870  *
2871  * @param cls closure
2872  * @param message message
2873  * @param peer peer identity this notification is about
2874  * @param atsi performance data
2875  * @param atsi_count number of records in 'atsi'
2876  * @return GNUNET_OK to keep the connection open,
2877  *         GNUNET_SYSERR to close it (signal serious error)
2878  *
2879  * TODO: Check who we got this from, to validate route.
2880  */
2881 static int
2882 handle_mesh_data_multicast (void *cls, const struct GNUNET_PeerIdentity *peer,
2883                             const struct GNUNET_MessageHeader *message,
2884                             const struct GNUNET_ATS_Information *atsi,
2885                             unsigned int atsi_count)
2886 {
2887   struct GNUNET_MESH_Multicast *msg;
2888   struct MeshTunnel *t;
2889   size_t size;
2890
2891   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: got a multicast packet from %s\n",
2892               GNUNET_i2s (peer));
2893   size = ntohs (message->size);
2894   if (sizeof (struct GNUNET_MESH_Multicast) +
2895       sizeof (struct GNUNET_MessageHeader) > size)
2896   {
2897     GNUNET_break_op (0);
2898     return GNUNET_OK;
2899   }
2900   msg = (struct GNUNET_MESH_Multicast *) message;
2901   t = tunnel_get (&msg->oid, ntohl (msg->tid));
2902
2903   if (NULL == t)
2904   {
2905     /* TODO notify that we dont know that tunnel */
2906     GNUNET_break_op (0);
2907     return GNUNET_OK;
2908   }
2909   if (t->mid == ntohl (msg->mid))
2910   {
2911     /* FIXME: already seen this packet, log dropping */
2912     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2913                 "MESH:  Already seen mid %u, DROPPING!\n",
2914                 t->mid);
2915     return GNUNET_OK;
2916   }
2917 #if MESH_DEBUG
2918   else
2919   {
2920     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2921                 "MESH:  mid %u not seen yet, forwarding\n",
2922                 ntohl (msg->mid));
2923   }
2924 #endif
2925   t->mid = ntohl (msg->mid);
2926   tunnel_reset_timeout (t);
2927
2928   /* Transmit to locally interested clients */
2929   if (NULL != t->peers &&
2930       GNUNET_CONTAINER_multihashmap_contains (t->peers, &my_full_id.hashPubKey))
2931   {
2932     send_subscribed_clients (message, &msg[1].header);
2933   }
2934 #if MESH_DEBUG
2935   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2936               "MESH:    ttl: %u\n",
2937               ntohl (msg->ttl));
2938 #endif
2939   if (ntohl (msg->ttl) == 0)
2940   {
2941     /* FIXME: ttl is 0, log dropping */
2942     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2943                 "MESH:  TTL is 0, DROPPING!\n");
2944     return GNUNET_OK;
2945   }
2946   tunnel_send_multicast (t, message);
2947   return GNUNET_OK;
2948 }
2949
2950
2951 /**
2952  * Core handler for mesh network traffic toward the owner of a tunnel
2953  *
2954  * @param cls closure
2955  * @param message message
2956  * @param peer peer identity this notification is about
2957  * @param atsi performance data
2958  * @param atsi_count number of records in 'atsi'
2959  *
2960  * @return GNUNET_OK to keep the connection open,
2961  *         GNUNET_SYSERR to close it (signal serious error)
2962  */
2963 static int
2964 handle_mesh_data_to_orig (void *cls, const struct GNUNET_PeerIdentity *peer,
2965                           const struct GNUNET_MessageHeader *message,
2966                           const struct GNUNET_ATS_Information *atsi,
2967                           unsigned int atsi_count)
2968 {
2969   struct GNUNET_MESH_ToOrigin *msg;
2970   struct GNUNET_PeerIdentity id;
2971   struct MeshPeerInfo *peer_info;
2972   struct MeshTunnel *t;
2973   size_t size;
2974
2975   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: got a ToOrigin packet from %s\n",
2976               GNUNET_i2s (peer));
2977   size = ntohs (message->size);
2978   if (size < sizeof (struct GNUNET_MESH_ToOrigin) +     /* Payload must be */
2979       sizeof (struct GNUNET_MessageHeader))     /* at least a header */
2980   {
2981     GNUNET_break_op (0);
2982     return GNUNET_OK;
2983   }
2984   msg = (struct GNUNET_MESH_ToOrigin *) message;
2985   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:  of type %u\n",
2986               ntohs (msg[1].header.type));
2987   t = tunnel_get (&msg->oid, ntohl (msg->tid));
2988
2989   if (NULL == t)
2990   {
2991     /* TODO notify that we dont know this tunnel (whom)? */
2992     GNUNET_break_op (0);
2993     return GNUNET_OK;
2994   }
2995
2996   if (t->id.oid == myid)
2997   {
2998     char cbuf[size];
2999     struct GNUNET_MESH_ToOrigin *copy;
3000
3001     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3002                 "MESH:   it's for us! sending to clients...\n");
3003     if (NULL == t->client)
3004     {
3005       /* got data packet for ownerless tunnel */
3006       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   no clients!\n");
3007       GNUNET_break_op (0);
3008       return GNUNET_OK;
3009     }
3010     /* TODO signature verification */
3011     memcpy (cbuf, message, size);
3012     copy = (struct GNUNET_MESH_ToOrigin *) cbuf;
3013     copy->tid = htonl (t->local_tid);
3014     GNUNET_SERVER_notification_context_unicast (nc, t->client->handle,
3015                                                 &copy->header, GNUNET_YES);
3016     return GNUNET_OK;
3017   }
3018   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3019               "MESH:   not for us, retransmitting...\n");
3020
3021   peer_info = peer_info_get (&msg->oid);
3022   if (NULL == peer_info)
3023   {
3024     /* unknown origin of tunnel */
3025     GNUNET_break (0);
3026     return GNUNET_OK;
3027   }
3028   GNUNET_PEER_resolve (tree_get_predecessor (t->tree), &id);
3029   send_message (message, &id);
3030
3031   return GNUNET_OK;
3032 }
3033
3034
3035 /**
3036  * Core handler for path ACKs
3037  *
3038  * @param cls closure
3039  * @param message message
3040  * @param peer peer identity this notification is about
3041  * @param atsi performance data
3042  * @param atsi_count number of records in 'atsi'
3043  *
3044  * @return GNUNET_OK to keep the connection open,
3045  *         GNUNET_SYSERR to close it (signal serious error)
3046  */
3047 static int
3048 handle_mesh_path_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
3049                       const struct GNUNET_MessageHeader *message,
3050                       const struct GNUNET_ATS_Information *atsi,
3051                       unsigned int atsi_count)
3052 {
3053   struct GNUNET_MESH_PathACK *msg;
3054   struct GNUNET_PeerIdentity id;
3055   struct MeshPeerInfo *peer_info;
3056   struct MeshPeerPath *p;
3057   struct MeshTunnel *t;
3058   unsigned int i;
3059
3060   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Received a path ACK msg [%s]\n",
3061               GNUNET_i2s (&my_full_id));
3062   msg = (struct GNUNET_MESH_PathACK *) message;
3063   t = tunnel_get (&msg->oid, msg->tid);
3064   if (NULL == t)
3065   {
3066     /* TODO notify that we don't know the tunnel */
3067     return GNUNET_OK;
3068   }
3069
3070   /* Add paths to peers */
3071   peer_info = peer_info_get (&msg->peer_id);
3072   p = tree_get_path_to_peer(t->tree, peer_info->id);
3073   if (NULL != p)
3074   {
3075     for (i = 1; i < p->length && p->peers[i] != myid; i++) /* skip'em */;
3076     for (i++; i < p->length; i++)
3077     {
3078       struct MeshPeerInfo *aux;
3079       struct MeshPeerPath *copy;
3080
3081       aux = peer_info_get_short(p->peers[i]);
3082       copy = path_duplicate(p);
3083       copy->length = i;
3084       peer_info_add_path(aux, copy, 0);
3085     }
3086     path_destroy(p);
3087   }
3088   else
3089   {
3090     GNUNET_break (0);
3091   }
3092
3093   /* Message for us? */
3094   if (0 == memcmp (&msg->oid, &my_full_id, sizeof (struct GNUNET_PeerIdentity)))
3095   {
3096     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   It's for us!\n");
3097     if (NULL == t->client)
3098     {
3099       GNUNET_break_op (0);
3100       return GNUNET_OK;
3101     }
3102     if (NULL != t->dht_get_type)
3103     {
3104       GNUNET_DHT_get_stop (t->dht_get_type);
3105       t->dht_get_type = NULL;
3106     }
3107     if (tree_get_status(t->tree, peer_info->id) != MESH_PEER_READY)
3108     {
3109       tree_set_status (t->tree, peer_info->id, MESH_PEER_READY);
3110       send_client_peer_connected (t, peer_info->id);
3111     }
3112     return GNUNET_OK;
3113   }
3114
3115   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3116               "MESH:   not for us, retransmitting...\n");
3117   GNUNET_PEER_resolve (tree_get_predecessor (t->tree), &id);
3118   peer_info = peer_info_get (&msg->oid);
3119   if (NULL == peer_info)
3120   {
3121     /* If we know the tunnel, we should DEFINITELY know the peer */
3122     GNUNET_break (0);
3123     return GNUNET_OK;
3124   }
3125   send_message (message, &id);
3126   return GNUNET_OK;
3127 }
3128
3129
3130 /**
3131  * Functions to handle messages from core
3132  */
3133 static struct GNUNET_CORE_MessageHandler core_handlers[] = {
3134   {&handle_mesh_path_create, GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE, 0},
3135   {&handle_mesh_path_destroy, GNUNET_MESSAGE_TYPE_MESH_PATH_DESTROY, 0},
3136   {&handle_mesh_path_broken, GNUNET_MESSAGE_TYPE_MESH_PATH_BROKEN,
3137    sizeof (struct GNUNET_MESH_PathBroken)},
3138   {&handle_mesh_tunnel_destroy, GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY, 0},
3139   {&handle_mesh_data_unicast, GNUNET_MESSAGE_TYPE_MESH_UNICAST, 0},
3140   {&handle_mesh_data_multicast, GNUNET_MESSAGE_TYPE_MESH_MULTICAST, 0},
3141   {&handle_mesh_data_to_orig, GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN, 0},
3142   {&handle_mesh_path_ack, GNUNET_MESSAGE_TYPE_MESH_PATH_ACK,
3143    sizeof (struct GNUNET_MESH_PathACK)},
3144   {NULL, 0, 0}
3145 };
3146
3147
3148
3149 /******************************************************************************/
3150 /****************       MESH LOCAL HANDLER HELPERS      ***********************/
3151 /******************************************************************************/
3152
3153 /**
3154  * deregister_app: iterator for removing each application registered by a client
3155  *
3156  * @param cls closure
3157  * @param key the hash of the application id (used to access the hashmap)
3158  * @param value the value stored at the key (client)
3159  *
3160  * @return GNUNET_OK on success
3161  */
3162 static int
3163 deregister_app (void *cls, const GNUNET_HashCode * key, void *value)
3164 {
3165   GNUNET_break (GNUNET_YES ==
3166                 GNUNET_CONTAINER_multihashmap_remove (applications, key,
3167                                                       value));
3168   return GNUNET_OK;
3169 }
3170
3171 #if LATER
3172 /**
3173  * notify_client_connection_failure: notify a client that the connection to the
3174  * requested remote peer is not possible (for instance, no route found)
3175  * Function called when the socket is ready to queue more data. "buf" will be
3176  * NULL and "size" zero if the socket was closed for writing in the meantime.
3177  *
3178  * @param cls closure
3179  * @param size number of bytes available in buf
3180  * @param buf where the callee should write the message
3181  * @return number of bytes written to buf
3182  */
3183 static size_t
3184 notify_client_connection_failure (void *cls, size_t size, void *buf)
3185 {
3186   int size_needed;
3187   struct MeshPeerInfo *peer_info;
3188   struct GNUNET_MESH_PeerControl *msg;
3189   struct GNUNET_PeerIdentity id;
3190
3191   if (0 == size && NULL == buf)
3192   {
3193     // TODO retry? cancel?
3194     return 0;
3195   }
3196
3197   size_needed = sizeof (struct GNUNET_MESH_PeerControl);
3198   peer_info = (struct MeshPeerInfo *) cls;
3199   msg = (struct GNUNET_MESH_PeerControl *) buf;
3200   msg->header.size = htons (sizeof (struct GNUNET_MESH_PeerControl));
3201   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_DISCONNECTED);
3202 //     msg->tunnel_id = htonl(peer_info->t->tid);
3203   GNUNET_PEER_resolve (peer_info->id, &id);
3204   memcpy (&msg->peer, &id, sizeof (struct GNUNET_PeerIdentity));
3205
3206   return size_needed;
3207 }
3208 #endif
3209
3210
3211 /**
3212  * Send keepalive packets for a peer
3213  *
3214  * @param cls Closure (tunnel for which to send the keepalive).
3215  * @param tc Notification context.
3216  *
3217  * TODO: implement explicit multicast keepalive?
3218  */
3219 static void
3220 path_refresh (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
3221 {
3222   struct MeshTunnel *t = cls;
3223   struct GNUNET_MessageHeader *payload;
3224   struct GNUNET_MESH_Multicast *msg;
3225   size_t size =
3226       sizeof (struct GNUNET_MESH_Multicast) +
3227       sizeof (struct GNUNET_MessageHeader);
3228   char cbuf[size];
3229
3230   if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
3231   {
3232     return;
3233   }
3234   t->path_refresh_task = GNUNET_SCHEDULER_NO_TASK;
3235
3236   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3237               "MESH: sending keepalive for tunnel %d\n", t->id.tid);
3238
3239   msg = (struct GNUNET_MESH_Multicast *) cbuf;
3240   msg->header.size = htons (size);
3241   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_MULTICAST);
3242   msg->oid = my_full_id;
3243   msg->tid = htonl (t->id.tid);
3244   payload = (struct GNUNET_MessageHeader *) &msg[1];
3245   payload->size = htons (sizeof (struct GNUNET_MessageHeader));
3246   payload->type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_KEEPALIVE);
3247   tunnel_send_multicast (t, &msg->header);
3248
3249   t->path_refresh_task =
3250       GNUNET_SCHEDULER_add_delayed (REFRESH_PATH_TIME, &path_refresh, t);
3251   return;
3252 }
3253
3254
3255 /**
3256  * Function to process paths received for a new peer addition. The recorded
3257  * paths form the initial tunnel, which can be optimized later.
3258  * Called on each result obtained for the DHT search.
3259  *
3260  * @param cls closure
3261  * @param exp when will this value expire
3262  * @param key key of the result
3263  * @param type type of the result
3264  * @param size number of bytes in data
3265  * @param data pointer to the result data
3266  *
3267  * TODO: re-issue the request after certain time? cancel after X results?
3268  */
3269 static void
3270 dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp,
3271                     const GNUNET_HashCode * key,
3272                     const struct GNUNET_PeerIdentity *get_path,
3273                     unsigned int get_path_length,
3274                     const struct GNUNET_PeerIdentity *put_path,
3275                     unsigned int put_path_length, enum GNUNET_BLOCK_Type type,
3276                     size_t size, const void *data)
3277 {
3278   struct MeshPathInfo *path_info = cls;
3279   struct MeshPeerPath *p;
3280   struct GNUNET_PeerIdentity pi;
3281   int i;
3282
3283   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Got results from DHT!\n");
3284   GNUNET_PEER_resolve (path_info->peer->id, &pi);
3285   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   for %s\n", GNUNET_i2s (&pi));
3286
3287   p = path_build_from_dht (get_path, get_path_length, put_path,
3288                            put_path_length);
3289   peer_info_add_path (path_info->peer, p, GNUNET_NO);
3290   for (i = 0; i < path_info->peer->ntunnels; i++)
3291   {
3292     tunnel_add_peer (path_info->peer->tunnels[i], path_info->peer);
3293     peer_info_connect (path_info->peer, path_info->t);
3294   }
3295
3296   return;
3297 }
3298
3299
3300 /**
3301  * Function to process paths received for a new peer addition. The recorded
3302  * paths form the initial tunnel, which can be optimized later.
3303  * Called on each result obtained for the DHT search.
3304  *
3305  * @param cls closure
3306  * @param exp when will this value expire
3307  * @param key key of the result
3308  * @param type type of the result
3309  * @param size number of bytes in data
3310  * @param data pointer to the result data
3311  */
3312 static void
3313 dht_get_type_handler (void *cls, struct GNUNET_TIME_Absolute exp,
3314                       const GNUNET_HashCode * key,
3315                       const struct GNUNET_PeerIdentity *get_path,
3316                       unsigned int get_path_length,
3317                       const struct GNUNET_PeerIdentity *put_path,
3318                       unsigned int put_path_length, enum GNUNET_BLOCK_Type type,
3319                       size_t size, const void *data)
3320 {
3321   const struct GNUNET_PeerIdentity *pi = data;
3322   struct MeshTunnel *t = cls;
3323   struct MeshPeerInfo *peer_info;
3324   struct MeshPeerPath *p;
3325
3326   if (size != sizeof (struct GNUNET_PeerIdentity))
3327   {
3328     GNUNET_break_op (0);
3329     return;
3330   }
3331   GNUNET_assert (NULL != t->client);
3332   peer_info = peer_info_get (pi);
3333   (void) GNUNET_CONTAINER_multihashmap_put (t->peers, &pi->hashPubKey,
3334                                             peer_info,
3335                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
3336
3337   p = path_build_from_dht (get_path, get_path_length, put_path,
3338                            put_path_length);
3339   peer_info_add_path (peer_info, p, GNUNET_NO);
3340   tunnel_add_peer (t, peer_info);
3341   peer_info_connect (peer_info, t);
3342 }
3343
3344
3345 /******************************************************************************/
3346 /*********************       MESH LOCAL HANDLES      **************************/
3347 /******************************************************************************/
3348
3349
3350 /**
3351  * Handler for client disconnection
3352  *
3353  * @param cls closure
3354  * @param client identification of the client; NULL
3355  *        for the last call when the server is destroyed
3356  */
3357 static void
3358 handle_local_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
3359 {
3360   struct MeshClient *c;
3361   struct MeshClient *next;
3362
3363   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: client disconnected\n");
3364   if (client == NULL)
3365   {
3366     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    (SERVER DOWN)\n");
3367     return;
3368   }
3369   c = clients;
3370   while (NULL != c)
3371   {
3372     if (c->handle != client && NULL != client)
3373     {
3374       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    ... searching\n");
3375       c = c->next;
3376       continue;
3377     }
3378     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: matching client found\n");
3379     GNUNET_SERVER_client_drop (c->handle);
3380     if (NULL != c->tunnels)
3381     {
3382       GNUNET_CONTAINER_multihashmap_iterate (c->tunnels,
3383                                              &tunnel_destroy_iterator, c);
3384       GNUNET_CONTAINER_multihashmap_destroy (c->tunnels);
3385     }
3386
3387     /* deregister clients applications */
3388     if (NULL != c->apps)
3389     {
3390       GNUNET_CONTAINER_multihashmap_iterate (c->apps, &deregister_app, NULL);
3391       GNUNET_CONTAINER_multihashmap_destroy (c->apps);
3392     }
3393     if (0 == GNUNET_CONTAINER_multihashmap_size (applications) &&
3394         GNUNET_SCHEDULER_NO_TASK != announce_applications_task)
3395     {
3396       GNUNET_SCHEDULER_cancel (announce_applications_task);
3397       announce_applications_task = GNUNET_SCHEDULER_NO_TASK;
3398     }
3399     if (NULL != c->types)
3400       GNUNET_CONTAINER_multihashmap_destroy (c->types);
3401     next = c->next;
3402     GNUNET_CONTAINER_DLL_remove (clients, clients_tail, c);
3403     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   CLIENT FREE at %p\n", c);
3404     GNUNET_free (c);
3405     c = next;
3406   }
3407
3408   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:    done!\n");
3409   return;
3410 }
3411
3412
3413 /**
3414  * Handler for new clients
3415  *
3416  * @param cls closure
3417  * @param client identification of the client
3418  * @param message the actual message, which includes messages the client wants
3419  */
3420 static void
3421 handle_local_new_client (void *cls, struct GNUNET_SERVER_Client *client,
3422                          const struct GNUNET_MessageHeader *message)
3423 {
3424   struct GNUNET_MESH_ClientConnect *cc_msg;
3425   struct MeshClient *c;
3426   GNUNET_MESH_ApplicationType *a;
3427   unsigned int size;
3428   uint16_t ntypes;
3429   uint16_t *t;
3430   uint16_t napps;
3431   uint16_t i;
3432
3433   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: new client connected\n");
3434   /* Check data sanity */
3435   size = ntohs (message->size) - sizeof (struct GNUNET_MESH_ClientConnect);
3436   cc_msg = (struct GNUNET_MESH_ClientConnect *) message;
3437   ntypes = ntohs (cc_msg->types);
3438   napps = ntohs (cc_msg->applications);
3439   if (size !=
3440       ntypes * sizeof (uint16_t) + napps * sizeof (GNUNET_MESH_ApplicationType))
3441   {
3442     GNUNET_break (0);
3443     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3444     return;
3445   }
3446
3447   /* Create new client structure */
3448   c = GNUNET_malloc (sizeof (struct MeshClient));
3449 #if MESH_DEBUG
3450   c->id = next_client_id++;
3451   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   CLIENT NEW %u at %p\n", c->id,
3452               c);
3453 #endif
3454   c->handle = client;
3455   GNUNET_SERVER_client_keep (client);
3456   a = (GNUNET_MESH_ApplicationType *) &cc_msg[1];
3457   if (napps > 0)
3458   {
3459     GNUNET_MESH_ApplicationType at;
3460     GNUNET_HashCode hc;
3461
3462     c->apps = GNUNET_CONTAINER_multihashmap_create (napps);
3463     for (i = 0; i < napps; i++)
3464     {
3465       at = ntohl (a[i]);
3466       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   app type: %u\n", at);
3467       GNUNET_CRYPTO_hash (&at, sizeof (at), &hc);
3468       /* store in clients hashmap */
3469       GNUNET_CONTAINER_multihashmap_put (c->apps, &hc, c,
3470                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
3471       /* store in global hashmap, for announcements */
3472       GNUNET_CONTAINER_multihashmap_put (applications, &hc, c,
3473                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
3474     }
3475     if (GNUNET_SCHEDULER_NO_TASK == announce_applications_task)
3476       announce_applications_task =
3477           GNUNET_SCHEDULER_add_now (&announce_applications, NULL);
3478
3479   }
3480   if (ntypes > 0)
3481   {
3482     uint16_t u16;
3483     GNUNET_HashCode hc;
3484
3485     t = (uint16_t *) & a[napps];
3486     c->types = GNUNET_CONTAINER_multihashmap_create (ntypes);
3487     for (i = 0; i < ntypes; i++)
3488     {
3489       u16 = ntohs (t[i]);
3490       GNUNET_CRYPTO_hash (&u16, sizeof (u16), &hc);
3491
3492       /* store in clients hashmap */
3493       GNUNET_CONTAINER_multihashmap_put (c->types, &hc, c,
3494                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
3495       /* store in global hashmap */
3496       GNUNET_CONTAINER_multihashmap_put (types, &hc, c,
3497                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
3498     }
3499   }
3500   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3501               "MESH:  client has %u+%u subscriptions\n", napps, ntypes);
3502
3503   GNUNET_CONTAINER_DLL_insert (clients, clients_tail, c);
3504   c->tunnels = GNUNET_CONTAINER_multihashmap_create (32);
3505   GNUNET_SERVER_notification_context_add (nc, client);
3506
3507   GNUNET_SERVER_receive_done (client, GNUNET_OK);
3508 #if MESH_DEBUG
3509   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: new client processed\n");
3510 #endif
3511 }
3512
3513
3514 /**
3515  * Handler for requests of new tunnels
3516  *
3517  * @param cls closure
3518  * @param client identification of the client
3519  * @param message the actual message
3520  */
3521 static void
3522 handle_local_tunnel_create (void *cls, struct GNUNET_SERVER_Client *client,
3523                             const struct GNUNET_MessageHeader *message)
3524 {
3525   struct GNUNET_MESH_TunnelMessage *t_msg;
3526   struct MeshTunnel *t;
3527   struct MeshClient *c;
3528   GNUNET_HashCode hash;
3529
3530   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: new tunnel requested\n");
3531
3532   /* Sanity check for client registration */
3533   if (NULL == (c = client_get (client)))
3534   {
3535     GNUNET_break (0);
3536     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3537     return;
3538   }
3539 #if MESH_DEBUG
3540   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   by client %u\n", c->id);
3541 #endif
3542
3543   /* Message sanity check */
3544   if (sizeof (struct GNUNET_MESH_TunnelMessage) != ntohs (message->size))
3545   {
3546     GNUNET_break (0);
3547     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3548     return;
3549   }
3550
3551   t_msg = (struct GNUNET_MESH_TunnelMessage *) message;
3552   /* Sanity check for tunnel numbering */
3553   if (0 == (ntohl (t_msg->tunnel_id) & GNUNET_MESH_LOCAL_TUNNEL_ID_CLI))
3554   {
3555     GNUNET_break (0);
3556     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3557     return;
3558   }
3559   /* Sanity check for duplicate tunnel IDs */
3560   if (NULL != tunnel_get_by_local_id (c, ntohl (t_msg->tunnel_id)))
3561   {
3562     GNUNET_break (0);
3563     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3564     return;
3565   }
3566
3567   t = GNUNET_malloc (sizeof (struct MeshTunnel));
3568   while (NULL != tunnel_get_by_pi (myid, next_tid))
3569     next_tid = (next_tid + 1) & ~GNUNET_MESH_LOCAL_TUNNEL_ID_CLI;
3570   t->id.tid = next_tid++;
3571   next_tid = next_tid & ~GNUNET_MESH_LOCAL_TUNNEL_ID_CLI;
3572   t->id.oid = myid;
3573   t->local_tid = ntohl (t_msg->tunnel_id);
3574 #if MESH_DEBUG
3575   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: CREATED TUNNEL %s [%x] (%x)\n",
3576               GNUNET_i2s (&my_full_id), t->id.tid, t->local_tid);
3577 #endif
3578   t->client = c;
3579   t->peers = GNUNET_CONTAINER_multihashmap_create (32);
3580
3581   GNUNET_CRYPTO_hash (&t->local_tid, sizeof (MESH_TunnelNumber), &hash);
3582   if (GNUNET_OK !=
3583       GNUNET_CONTAINER_multihashmap_put (c->tunnels, &hash, t,
3584                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
3585   {
3586     GNUNET_break (0);
3587     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3588     return;
3589   }
3590
3591   GNUNET_CRYPTO_hash (&t->id, sizeof (struct MESH_TunnelID), &hash);
3592   if (GNUNET_OK !=
3593       GNUNET_CONTAINER_multihashmap_put (tunnels, &hash, t,
3594                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
3595   {
3596     GNUNET_break (0);
3597     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3598     return;
3599   }
3600   t->tree = tree_new (myid);
3601
3602   GNUNET_SERVER_receive_done (client, GNUNET_OK);
3603   return;
3604 }
3605
3606
3607 /**
3608  * Handler for requests of deleting tunnels
3609  *
3610  * @param cls closure
3611  * @param client identification of the client
3612  * @param message the actual message
3613  */
3614 static void
3615 handle_local_tunnel_destroy (void *cls, struct GNUNET_SERVER_Client *client,
3616                              const struct GNUNET_MessageHeader *message)
3617 {
3618   struct GNUNET_MESH_TunnelMessage *tunnel_msg;
3619   struct MeshClient *c;
3620   struct MeshTunnel *t;
3621   MESH_TunnelNumber tid;
3622   GNUNET_HashCode hash;
3623
3624   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3625               "MESH: Got a DESTROY TUNNEL from client!\n");
3626
3627   /* Sanity check for client registration */
3628   if (NULL == (c = client_get (client)))
3629   {
3630     GNUNET_break (0);
3631     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3632     return;
3633   }
3634   /* Message sanity check */
3635   if (sizeof (struct GNUNET_MESH_TunnelMessage) != ntohs (message->size))
3636   {
3637     GNUNET_break (0);
3638     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3639     return;
3640   }
3641 #if MESH_DEBUG
3642   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   by client %u\n", c->id);
3643 #endif
3644   tunnel_msg = (struct GNUNET_MESH_TunnelMessage *) message;
3645
3646   /* Retrieve tunnel */
3647   tid = ntohl (tunnel_msg->tunnel_id);
3648
3649   /* Remove from local id hashmap */
3650   GNUNET_CRYPTO_hash (&tid, sizeof (MESH_TunnelNumber), &hash);
3651   t = GNUNET_CONTAINER_multihashmap_get (c->tunnels, &hash);
3652   GNUNET_assert (GNUNET_YES ==
3653                  GNUNET_CONTAINER_multihashmap_remove (c->tunnels, &hash, t));
3654
3655   t->client = NULL;
3656   tunnel_send_destroy (t);
3657   tunnel_destroy (t);
3658   GNUNET_SERVER_receive_done (client, GNUNET_OK);
3659   return;
3660 }
3661
3662
3663 /**
3664  * Handler for connection requests to new peers
3665  *
3666  * @param cls closure
3667  * @param client identification of the client
3668  * @param message the actual message (PeerControl)
3669  */
3670 static void
3671 handle_local_connect_add (void *cls, struct GNUNET_SERVER_Client *client,
3672                           const struct GNUNET_MessageHeader *message)
3673 {
3674   struct GNUNET_MESH_PeerControl *peer_msg;
3675   struct MeshPeerInfo *peer_info;
3676   struct MeshClient *c;
3677   struct MeshTunnel *t;
3678   MESH_TunnelNumber tid;
3679
3680   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Got connection request\n");
3681   /* Sanity check for client registration */
3682   if (NULL == (c = client_get (client)))
3683   {
3684     GNUNET_break (0);
3685     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3686     return;
3687   }
3688
3689   peer_msg = (struct GNUNET_MESH_PeerControl *) message;
3690   /* Sanity check for message size */
3691   if (sizeof (struct GNUNET_MESH_PeerControl) != ntohs (peer_msg->header.size))
3692   {
3693     GNUNET_break (0);
3694     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3695     return;
3696   }
3697
3698   /* Tunnel exists? */
3699   tid = ntohl (peer_msg->tunnel_id);
3700   t = tunnel_get_by_local_id (c, tid);
3701   if (NULL == t)
3702   {
3703     GNUNET_break (0);
3704     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3705     return;
3706   }
3707
3708   /* Does client own tunnel? */
3709   if (t->client->handle != client)
3710   {
3711     GNUNET_break (0);
3712     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3713     return;
3714   }
3715   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:      for %s\n",
3716               GNUNET_i2s (&peer_msg->peer));
3717   peer_info = peer_info_get (&peer_msg->peer);
3718
3719   tunnel_add_peer (t, peer_info);
3720   peer_info_connect (peer_info, t);
3721
3722   GNUNET_SERVER_receive_done (client, GNUNET_OK);
3723   return;
3724 }
3725
3726
3727 /**
3728  * Handler for disconnection requests of peers in a tunnel
3729  *
3730  * @param cls closure
3731  * @param client identification of the client
3732  * @param message the actual message (PeerControl)
3733  */
3734 static void
3735 handle_local_connect_del (void *cls, struct GNUNET_SERVER_Client *client,
3736                           const struct GNUNET_MessageHeader *message)
3737 {
3738   struct GNUNET_MESH_PeerControl *peer_msg;
3739   struct MeshPeerInfo *peer_info;
3740   struct MeshClient *c;
3741   struct MeshTunnel *t;
3742   MESH_TunnelNumber tid;
3743
3744   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Got a PEER DEL request\n");
3745   /* Sanity check for client registration */
3746   if (NULL == (c = client_get (client)))
3747   {
3748     GNUNET_break (0);
3749     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3750     return;
3751   }
3752   peer_msg = (struct GNUNET_MESH_PeerControl *) message;
3753   /* Sanity check for message size */
3754   if (sizeof (struct GNUNET_MESH_PeerControl) != ntohs (peer_msg->header.size))
3755   {
3756     GNUNET_break (0);
3757     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3758     return;
3759   }
3760
3761   /* Tunnel exists? */
3762   tid = ntohl (peer_msg->tunnel_id);
3763   t = tunnel_get_by_local_id (c, tid);
3764   if (NULL == t)
3765   {
3766     GNUNET_break (0);
3767     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3768     return;
3769   }
3770   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   on tunnel %X\n", t->id.tid);
3771
3772   /* Does client own tunnel? */
3773   if (t->client->handle != client)
3774   {
3775     GNUNET_break (0);
3776     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3777     return;
3778   }
3779
3780   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:   for peer %s\n",
3781               GNUNET_i2s (&peer_msg->peer));
3782   /* Is the peer in the tunnel? */
3783   peer_info =
3784       GNUNET_CONTAINER_multihashmap_get (t->peers, &peer_msg->peer.hashPubKey);
3785   if (NULL == peer_info)
3786   {
3787     GNUNET_break (0);
3788     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3789     return;
3790   }
3791
3792   /* Ok, delete peer from tunnel */
3793   GNUNET_CONTAINER_multihashmap_remove_all (t->peers,
3794                                             &peer_msg->peer.hashPubKey);
3795
3796   send_destroy_path (t, peer_info->id);
3797   tunnel_delete_peer (t, peer_info->id);
3798   GNUNET_SERVER_receive_done (client, GNUNET_OK);
3799   return;
3800 }
3801
3802
3803 /**
3804  * Handler for connection requests to new peers by type
3805  *
3806  * @param cls closure
3807  * @param client identification of the client
3808  * @param message the actual message (ConnectPeerByType)
3809  */
3810 static void
3811 handle_local_connect_by_type (void *cls, struct GNUNET_SERVER_Client *client,
3812                               const struct GNUNET_MessageHeader *message)
3813 {
3814   struct GNUNET_MESH_ConnectPeerByType *connect_msg;
3815   struct MeshClient *c;
3816   struct MeshTunnel *t;
3817   GNUNET_HashCode hash;
3818   MESH_TunnelNumber tid;
3819
3820   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: got connect by type request\n");
3821   /* Sanity check for client registration */
3822   if (NULL == (c = client_get (client)))
3823   {
3824     GNUNET_break (0);
3825     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3826     return;
3827   }
3828
3829   connect_msg = (struct GNUNET_MESH_ConnectPeerByType *) message;
3830   /* Sanity check for message size */
3831   if (sizeof (struct GNUNET_MESH_ConnectPeerByType) !=
3832       ntohs (connect_msg->header.size))
3833   {
3834     GNUNET_break (0);
3835     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3836     return;
3837   }
3838
3839   /* Tunnel exists? */
3840   tid = ntohl (connect_msg->tunnel_id);
3841   t = tunnel_get_by_local_id (c, tid);
3842   if (NULL == t)
3843   {
3844     GNUNET_break (0);
3845     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3846     return;
3847   }
3848
3849   /* Does client own tunnel? */
3850   if (t->client->handle != client)
3851   {
3852     GNUNET_break (0);
3853     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3854     return;
3855   }
3856
3857   /* Do WE have the service? */
3858   t->type = ntohl (connect_msg->type);
3859   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:  type requested: %u\n", t->type);
3860   GNUNET_CRYPTO_hash (&t->type, sizeof (GNUNET_MESH_ApplicationType), &hash);
3861   if (GNUNET_CONTAINER_multihashmap_contains (applications, &hash) ==
3862       GNUNET_YES)
3863   {
3864     /* Yes! Fast forward, add ourselves to the tunnel and send the
3865      * good news to the client
3866      */
3867     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:  available locally\n");
3868     GNUNET_CONTAINER_multihashmap_put (t->peers, &my_full_id.hashPubKey,
3869                                        peer_info_get (&my_full_id),
3870                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
3871
3872     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:  notifying client\n");
3873     send_client_peer_connected (t, myid);
3874     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:  Done\n");
3875     GNUNET_SERVER_receive_done (client, GNUNET_OK);
3876     return;
3877   }
3878   /* Ok, lets find a peer offering the service */
3879   if (NULL != t->dht_get_type)
3880   {
3881     GNUNET_DHT_get_stop (t->dht_get_type);
3882   }
3883   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:  looking in DHT for %s\n",
3884               GNUNET_h2s (&hash));
3885   t->dht_get_type =
3886       GNUNET_DHT_get_start (dht_handle, GNUNET_TIME_UNIT_FOREVER_REL,
3887                             GNUNET_BLOCK_TYPE_TEST, &hash, 10U,
3888                             GNUNET_DHT_RO_RECORD_ROUTE |
3889                             GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, NULL, 0,
3890                             &dht_get_type_handler, t);
3891
3892   GNUNET_SERVER_receive_done (client, GNUNET_OK);
3893   return;
3894 }
3895
3896
3897 /**
3898  * Handler for client traffic directed to one peer
3899  *
3900  * @param cls closure
3901  * @param client identification of the client
3902  * @param message the actual message
3903  */
3904 static void
3905 handle_local_unicast (void *cls, struct GNUNET_SERVER_Client *client,
3906                       const struct GNUNET_MessageHeader *message)
3907 {
3908   struct MeshClient *c;
3909   struct MeshTunnel *t;
3910   struct MeshPeerInfo *pi;
3911   struct GNUNET_MESH_Unicast *data_msg;
3912   MESH_TunnelNumber tid;
3913   size_t size;
3914
3915   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3916               "MESH: Got a unicast request from a client!\n");
3917
3918   /* Sanity check for client registration */
3919   if (NULL == (c = client_get (client)))
3920   {
3921     GNUNET_break (0);
3922     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3923     return;
3924   }
3925   data_msg = (struct GNUNET_MESH_Unicast *) message;
3926   /* Sanity check for message size */
3927   size = ntohs (message->size);
3928   if (sizeof (struct GNUNET_MESH_Unicast) +
3929       sizeof (struct GNUNET_MessageHeader) > size)
3930   {
3931     GNUNET_break (0);
3932     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3933     return;
3934   }
3935
3936   /* Tunnel exists? */
3937   tid = ntohl (data_msg->tid);
3938   t = tunnel_get_by_local_id (c, tid);
3939   if (NULL == t)
3940   {
3941     GNUNET_break (0);
3942     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3943     return;
3944   }
3945
3946   /*  Is it a local tunnel? Then, does client own the tunnel? */
3947   if (NULL != t->client && NULL != t->client->handle &&
3948       t->client->handle != client)
3949   {
3950     GNUNET_break (0);
3951     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3952     return;
3953   }
3954
3955   pi = GNUNET_CONTAINER_multihashmap_get (t->peers,
3956                                           &data_msg->destination.hashPubKey);
3957   /* Is the selected peer in the tunnel? */
3958   if (NULL == pi)
3959   {
3960     GNUNET_break (0);
3961     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3962     return;
3963   }
3964
3965   /* Ok, everything is correct, send the message
3966    * (pretend we got it from a mesh peer)
3967    */
3968   {
3969     char buf[ntohs (message->size)];
3970     struct GNUNET_MESH_Unicast *copy;
3971
3972     /* Work around const limitation */
3973     copy = (struct GNUNET_MESH_Unicast *) buf;
3974     memcpy (buf, data_msg, size);
3975     copy->oid = my_full_id;
3976     copy->tid = htonl (t->id.tid);
3977     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3978                 "MESH:   calling generic handler...\n");
3979     handle_mesh_data_unicast (NULL, &my_full_id, &copy->header, NULL, 0);
3980   }
3981   GNUNET_SERVER_receive_done (client, GNUNET_OK);
3982   return;
3983 }
3984
3985
3986 /**
3987  * Handler for client traffic directed to the origin
3988  *
3989  * @param cls closure
3990  * @param client identification of the client
3991  * @param message the actual message
3992  */
3993 static void
3994 handle_local_to_origin (void *cls, struct GNUNET_SERVER_Client *client,
3995                         const struct GNUNET_MessageHeader *message)
3996 {
3997   struct GNUNET_MESH_ToOrigin *data_msg;
3998   struct GNUNET_PeerIdentity id;
3999   struct MeshClient *c;
4000   struct MeshTunnel *t;
4001   MESH_TunnelNumber tid;
4002   size_t size;
4003
4004   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4005               "MESH: Got a ToOrigin request from a client!\n");
4006
4007   /* Sanity check for client registration */
4008   if (NULL == (c = client_get (client)))
4009   {
4010     GNUNET_break (0);
4011     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4012     return;
4013   }
4014   data_msg = (struct GNUNET_MESH_ToOrigin *) message;
4015   /* Sanity check for message size */
4016   size = ntohs (message->size);
4017   if (sizeof (struct GNUNET_MESH_ToOrigin) +
4018       sizeof (struct GNUNET_MessageHeader) > size)
4019   {
4020     GNUNET_break (0);
4021     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4022     return;
4023   }
4024
4025   /* Tunnel exists? */
4026   tid = ntohl (data_msg->tid);
4027   if (tid < GNUNET_MESH_LOCAL_TUNNEL_ID_SERV)
4028   {
4029     GNUNET_break (0);
4030     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4031     return;
4032   }
4033   t = tunnel_get_by_local_id (c, tid);
4034   if (NULL == t)
4035   {
4036     GNUNET_break (0);
4037     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4038     return;
4039   }
4040
4041   /*  It shouldn't be a local tunnel.  */
4042   if (NULL != t->client)
4043   {
4044     GNUNET_break (0);
4045     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4046     return;
4047   }
4048   GNUNET_PEER_resolve (t->id.oid, &id);
4049
4050   /* Ok, everything is correct, send the message
4051    * (pretend we got it from a mesh peer)
4052    */
4053   {
4054     char buf[ntohs (message->size)];
4055     struct GNUNET_MESH_ToOrigin *copy;
4056
4057     /* Work around const limitation */
4058     copy = (struct GNUNET_MESH_ToOrigin *) buf;
4059     memcpy (buf, data_msg, size);
4060     copy->oid = id;
4061     copy->tid = htonl (t->id.tid);
4062     copy->sender = my_full_id;
4063     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4064                 "MESH:   calling generic handler...\n");
4065     handle_mesh_data_to_orig (NULL, &my_full_id, &copy->header, NULL, 0);
4066   }
4067   GNUNET_SERVER_receive_done (client, GNUNET_OK);
4068   return;
4069 }
4070
4071
4072 /**
4073  * Handler for client traffic directed to all peers in a tunnel
4074  *
4075  * @param cls closure
4076  * @param client identification of the client
4077  * @param message the actual message
4078  */
4079 static void
4080 handle_local_multicast (void *cls, struct GNUNET_SERVER_Client *client,
4081                         const struct GNUNET_MessageHeader *message)
4082 {
4083   struct MeshClient *c;
4084   struct MeshTunnel *t;
4085   struct GNUNET_MESH_Multicast *data_msg;
4086   MESH_TunnelNumber tid;
4087
4088   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4089               "MESH: Got a multicast request from a client!\n");
4090
4091   /* Sanity check for client registration */
4092   if (NULL == (c = client_get (client)))
4093   {
4094     GNUNET_break (0);
4095     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4096     return;
4097   }
4098   data_msg = (struct GNUNET_MESH_Multicast *) message;
4099   /* Sanity check for message size */
4100   if (sizeof (struct GNUNET_MESH_Multicast) +
4101       sizeof (struct GNUNET_MessageHeader) > ntohs (data_msg->header.size))
4102   {
4103     GNUNET_break (0);
4104     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4105     return;
4106   }
4107
4108   /* Tunnel exists? */
4109   tid = ntohl (data_msg->tid);
4110   t = tunnel_get_by_local_id (c, tid);
4111   if (NULL == t)
4112   {
4113     GNUNET_break (0);
4114     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4115     return;
4116   }
4117
4118   /* Does client own tunnel? */
4119   if (t->client->handle != client)
4120   {
4121     GNUNET_break (0);
4122     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4123     return;
4124   }
4125
4126   {
4127     char buf[ntohs (message->size)];
4128     struct GNUNET_MESH_Multicast *copy;
4129
4130     copy = (struct GNUNET_MESH_Multicast *) buf;
4131     memcpy (buf, message, ntohs (message->size));
4132     copy->oid = my_full_id;
4133     copy->tid = htonl (t->id.tid);
4134     copy->ttl = htonl (DEFAULT_TTL);
4135     copy->mid = htonl (t->mid + 1);
4136     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4137                 "MESH:   calling generic handler...\n");
4138     handle_mesh_data_multicast (client, &my_full_id, &copy->header, NULL, 0);
4139   }
4140
4141   /* receive done gets called when last copy is sent to a neighbor */
4142   return;
4143 }
4144
4145 /**
4146  * Functions to handle messages from clients
4147  */
4148 static struct GNUNET_SERVER_MessageHandler client_handlers[] = {
4149   {&handle_local_new_client, NULL,
4150    GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT, 0},
4151   {&handle_local_tunnel_create, NULL,
4152    GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_CREATE,
4153    sizeof (struct GNUNET_MESH_TunnelMessage)},
4154   {&handle_local_tunnel_destroy, NULL,
4155    GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_DESTROY,
4156    sizeof (struct GNUNET_MESH_TunnelMessage)},
4157   {&handle_local_connect_add, NULL,
4158    GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_ADD,
4159    sizeof (struct GNUNET_MESH_PeerControl)},
4160   {&handle_local_connect_del, NULL,
4161    GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_DEL,
4162    sizeof (struct GNUNET_MESH_PeerControl)},
4163   {&handle_local_connect_by_type, NULL,
4164    GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_ADD_BY_TYPE,
4165    sizeof (struct GNUNET_MESH_ConnectPeerByType)},
4166   {&handle_local_unicast, NULL,
4167    GNUNET_MESSAGE_TYPE_MESH_UNICAST, 0},
4168   {&handle_local_to_origin, NULL,
4169    GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN, 0},
4170   {&handle_local_multicast, NULL,
4171    GNUNET_MESSAGE_TYPE_MESH_MULTICAST, 0},
4172   {NULL, NULL, 0, 0}
4173 };
4174
4175
4176 /**
4177  * To be called on core init/fail.
4178  *
4179  * @param cls service closure
4180  * @param server handle to the server for this service
4181  * @param identity the public identity of this peer
4182  */
4183 static void
4184 core_init (void *cls, struct GNUNET_CORE_Handle *server,
4185            const struct GNUNET_PeerIdentity *identity)
4186 {
4187   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Core init\n");
4188   core_handle = server;
4189   if (0 != memcmp (identity, &my_full_id, sizeof (my_full_id)) ||
4190       NULL == server)
4191   {
4192     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("MESH: Wrong CORE service\n"));
4193     GNUNET_SCHEDULER_shutdown ();
4194   }
4195   return;
4196 }
4197
4198 /**
4199  * Method called whenever a given peer connects.
4200  *
4201  * @param cls closure
4202  * @param peer peer identity this notification is about
4203  * @param atsi performance data for the connection
4204  * @param atsi_count number of records in 'atsi'
4205  */
4206 static void
4207 core_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
4208               const struct GNUNET_ATS_Information *atsi,
4209               unsigned int atsi_count)
4210 {
4211   struct MeshPeerInfo *peer_info;
4212   struct MeshPeerPath *path;
4213
4214 #if MESH_DEBUG_CONNECTION
4215   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Peer connected\n");
4216   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:      %s\n",
4217               GNUNET_i2s (&my_full_id));
4218 #endif
4219   peer_info = peer_info_get (peer);
4220   if (myid == peer_info->id)
4221   {
4222 #if MESH_DEBUG_CONNECTION
4223     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:      (self)\n");
4224 #endif
4225     return;
4226   }
4227 #if MESH_DEBUG_CONNECTION
4228   else
4229   {
4230     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:      %s\n", GNUNET_i2s (peer));
4231   }
4232 #endif
4233   path = path_new (2);
4234   path->peers[0] = myid;
4235   path->peers[1] = peer_info->id;
4236   GNUNET_PEER_change_rc (myid, 1);
4237   GNUNET_PEER_change_rc (peer_info->id, 1);
4238   peer_info_add_path (peer_info, path, GNUNET_YES);
4239   return;
4240 }
4241
4242 /**
4243  * Method called whenever a peer disconnects.
4244  *
4245  * @param cls closure
4246  * @param peer peer identity this notification is about
4247  */
4248 static void
4249 core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
4250 {
4251   struct MeshPeerInfo *pi;
4252   unsigned int i;
4253
4254 #if MESH_DEBUG_CONNECTION
4255   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Peer disconnected\n");
4256 #endif
4257   pi = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
4258   if (NULL == pi)
4259   {
4260     GNUNET_break (0);
4261     return;
4262   }
4263   for (i = 0; i < CORE_QUEUE_SIZE; i++)
4264   {
4265     /* TODO: notify that the transmission failed */
4266     peer_info_cancel_transmission (pi, i);
4267   }
4268   peer_info_remove_path (pi, pi->id, myid);
4269 #if MESH_DEBUG_CONNECTION
4270   if (myid == pi->id)
4271   {
4272     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:      (self)\n");
4273   }
4274 #endif
4275   return;
4276 }
4277
4278
4279 /******************************************************************************/
4280 /************************      MAIN FUNCTIONS      ****************************/
4281 /******************************************************************************/
4282
4283 /**
4284  * Iterator over tunnel hash map entries to destroy the tunnel during shutdown.
4285  *
4286  * @param cls closure
4287  * @param key current key code
4288  * @param value value in the hash map
4289  * @return GNUNET_YES if we should continue to iterate,
4290  *         GNUNET_NO if not.
4291  */
4292 static int
4293 shutdown_tunnel (void *cls, const GNUNET_HashCode * key, void *value)
4294 {
4295   struct MeshTunnel *t = value;
4296
4297   tunnel_destroy (t);
4298   return GNUNET_YES;
4299 }
4300
4301 /**
4302  * Iterator over peer hash map entries to destroy the tunnel during shutdown.
4303  *
4304  * @param cls closure
4305  * @param key current key code
4306  * @param value value in the hash map
4307  * @return GNUNET_YES if we should continue to iterate,
4308  *         GNUNET_NO if not.
4309  */
4310 static int
4311 shutdown_peer (void *cls, const GNUNET_HashCode * key, void *value)
4312 {
4313   struct MeshPeerInfo *p = value;
4314
4315   peer_info_destroy (p);
4316   return GNUNET_YES;
4317 }
4318
4319 /**
4320  * Task run during shutdown.
4321  *
4322  * @param cls unused
4323  * @param tc unused
4324  */
4325 static void
4326 shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
4327 {
4328   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: shutting down\n");
4329   /* TODO: destroy tunnels? */
4330   if (core_handle != NULL)
4331   {
4332     GNUNET_CORE_disconnect (core_handle);
4333     core_handle = NULL;
4334   }
4335   GNUNET_CONTAINER_multihashmap_iterate (tunnels, &shutdown_tunnel, NULL);
4336   GNUNET_CONTAINER_multihashmap_iterate (peers, &shutdown_peer, NULL);
4337   if (dht_handle != NULL)
4338   {
4339     GNUNET_DHT_disconnect (dht_handle);
4340     dht_handle = NULL;
4341   }
4342   if (nc != NULL)
4343   {
4344     GNUNET_SERVER_notification_context_destroy (nc);
4345     nc = NULL;
4346   }
4347   if (GNUNET_SCHEDULER_NO_TASK != announce_id_task)
4348   {
4349     GNUNET_SCHEDULER_cancel (announce_id_task);
4350     announce_id_task = GNUNET_SCHEDULER_NO_TASK;
4351   }
4352   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: shut down\n");
4353 }
4354
4355 /**
4356  * Process mesh requests.
4357  *
4358  * @param cls closure
4359  * @param server the initialized server
4360  * @param c configuration to use
4361  */
4362 static void
4363 run (void *cls, struct GNUNET_SERVER_Handle *server,
4364      const struct GNUNET_CONFIGURATION_Handle *c)
4365 {
4366   struct MeshPeerInfo *peer;
4367   struct MeshPeerPath *p;
4368   char *keyfile;
4369
4370   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: starting to run\n");
4371   server_handle = server;
4372   core_handle = GNUNET_CORE_connect (c, /* Main configuration */
4373                                      CORE_QUEUE_SIZE,   /* queue size */
4374                                      NULL,      /* Closure passed to MESH functions */
4375                                      &core_init,        /* Call core_init once connected */
4376                                      &core_connect,     /* Handle connects */
4377                                      &core_disconnect,  /* remove peers on disconnects */
4378                                      NULL,      /* Don't notify about all incoming messages */
4379                                      GNUNET_NO, /* For header only in notification */
4380                                      NULL,      /* Don't notify about all outbound messages */
4381                                      GNUNET_NO, /* For header-only out notification */
4382                                      core_handlers);    /* Register these handlers */
4383
4384   if (core_handle == NULL)
4385   {
4386     GNUNET_break (0);
4387     GNUNET_SCHEDULER_shutdown ();
4388     return;
4389   }
4390
4391   if (GNUNET_OK !=
4392       GNUNET_CONFIGURATION_get_value_filename (c, "GNUNETD", "HOSTKEY",
4393                                                &keyfile))
4394   {
4395     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
4396                 _
4397                 ("Mesh service is lacking key configuration settings.  Exiting.\n"));
4398     GNUNET_SCHEDULER_shutdown ();
4399     return;
4400   }
4401   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
4402   GNUNET_free (keyfile);
4403   if (my_private_key == NULL)
4404   {
4405     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
4406                 _("Mesh service could not access hostkey.  Exiting.\n"));
4407     GNUNET_SCHEDULER_shutdown ();
4408     return;
4409   }
4410   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
4411   GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
4412                       &my_full_id.hashPubKey);
4413   myid = GNUNET_PEER_intern (&my_full_id);
4414
4415 // //   transport_handle = GNUNET_TRANSPORT_connect(c,
4416 // //                                               &my_full_id,
4417 // //                                               NULL,
4418 // //                                               NULL,
4419 // //                                               NULL,
4420 // //                                               NULL);
4421
4422   dht_handle = GNUNET_DHT_connect (c, 64);
4423   if (dht_handle == NULL)
4424   {
4425     GNUNET_break (0);
4426   }
4427
4428   next_tid = 0;
4429   next_local_tid = GNUNET_MESH_LOCAL_TUNNEL_ID_SERV;
4430
4431   tunnels = GNUNET_CONTAINER_multihashmap_create (32);
4432   incoming_tunnels = GNUNET_CONTAINER_multihashmap_create (32);
4433   peers = GNUNET_CONTAINER_multihashmap_create (32);
4434   applications = GNUNET_CONTAINER_multihashmap_create (32);
4435   types = GNUNET_CONTAINER_multihashmap_create (32);
4436
4437   GNUNET_SERVER_add_handlers (server_handle, client_handlers);
4438   nc = GNUNET_SERVER_notification_context_create (server_handle,
4439                                                   LOCAL_QUEUE_SIZE);
4440   GNUNET_SERVER_disconnect_notify (server_handle,
4441                                    &handle_local_client_disconnect, NULL);
4442
4443
4444   clients = NULL;
4445   clients_tail = NULL;
4446 #if MESH_DEBUG
4447   next_client_id = 0;
4448 #endif
4449
4450   announce_applications_task = GNUNET_SCHEDULER_NO_TASK;
4451   announce_id_task = GNUNET_SCHEDULER_add_now (&announce_id, cls);
4452
4453   /* Create a peer_info for the local peer */
4454   peer = peer_info_get (&my_full_id);
4455   p = path_new (1);
4456   p->peers[0] = myid;
4457   GNUNET_PEER_change_rc (myid, 1);
4458   peer_info_add_path (peer, p, GNUNET_YES);
4459
4460   /* Scheduled the task to clean up when shutdown is called */
4461   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
4462                                 NULL);
4463
4464   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: end of run()\n");
4465 }
4466
4467 /**
4468  * The main function for the mesh service.
4469  *
4470  * @param argc number of arguments from the command line
4471  * @param argv command line arguments
4472  * @return 0 ok, 1 on error
4473  */
4474 int
4475 main (int argc, char *const *argv)
4476 {
4477   int ret;
4478
4479   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: main()\n");
4480   ret =
4481       (GNUNET_OK ==
4482        GNUNET_SERVICE_run (argc, argv, "mesh", GNUNET_SERVICE_OPTION_NONE, &run,
4483                            NULL)) ? 0 : 1;
4484   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: main() END\n");
4485
4486   return ret;
4487 }