src/fs/gnunet-service-fs_mesh_client.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2012, 2013 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 fs/gnunet-service-fs_mesh_client.c
  23  * @brief non-anonymous file-transfer
  24  * @author Christian Grothoff
  25  *
  26  * TODO:
  27  * - PORT is set to old application type, unsure if we should keep
  28  *   it that way (fine for now)
  29  */
  30 #include "platform.h"
  31 #include "gnunet_constants.h"
  32 #include "gnunet_util_lib.h"
  33 #include "gnunet_mesh_service.h"
  34 #include "gnunet_protocols.h"
  35 #include "gnunet_applications.h"
  36 #include "gnunet-service-fs.h"
  37 #include "gnunet-service-fs_indexing.h"
  38 #include "gnunet-service-fs_mesh.h"
  39
  40
  41 /**
  42  * After how long do we reset connections without replies?
  43  */
  44 #define CLIENT_RETRY_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
  45
  46
  47 /**
  48  * Handle for a mesh to another peer.
  49  */
  50 struct MeshHandle;
  51
  52
  53 /**
  54  * Handle for a request that is going out via mesh API.
  55  */
  56 struct GSF_MeshRequest
  57 {
  58
  59   /**
  60    * DLL.
  61    */
  62   struct GSF_MeshRequest *next;
  63
  64   /**
  65    * DLL.
  66    */
  67   struct GSF_MeshRequest *prev;
  68
  69   /**
  70    * Which mesh is this request associated with?
  71    */
  72   struct MeshHandle *mh;
  73
  74   /**
  75    * Function to call with the result.
  76    */
  77   GSF_MeshReplyProcessor proc;
  78
  79   /**
  80    * Closure for 'proc'
  81    */
  82   void *proc_cls;
  83
  84   /**
  85    * Query to transmit to the other peer.
  86    */
  87   struct GNUNET_HashCode query;
  88
  89   /**
  90    * Desired type for the reply.
  91    */
  92   enum GNUNET_BLOCK_Type type;
  93
  94   /**
  95    * Did we transmit this request already? YES if we are
  96    * in the 'waiting_map', NO if we are in the 'pending' DLL.
  97    */
  98   int was_transmitted;
  99 };
 100
 101
 102 /**
 103  * Handle for a mesh to another peer.
 104  */
 105 struct MeshHandle
 106 {
 107   /**
 108    * Head of DLL of pending requests on this mesh.
 109    */
 110   struct GSF_MeshRequest *pending_head;
 111
 112   /**
 113    * Tail of DLL of pending requests on this mesh.
 114    */
 115   struct GSF_MeshRequest *pending_tail;
 116
 117   /**
 118    * Map from query to 'struct GSF_MeshRequest's waiting for
 119    * a reply.
 120    */
 121   struct GNUNET_CONTAINER_MultiHashMap *waiting_map;
 122
 123   /**
 124    * Tunnel to the other peer.
 125    */
 126   struct GNUNET_MESH_Tunnel *tunnel;
 127
 128   /**
 129    * Handle for active write operation, or NULL.
 130    */
 131   struct GNUNET_MESH_TransmitHandle *wh;
 132
 133   /**
 134    * Which peer does this mesh go to?
 135    */
 136   struct GNUNET_PeerIdentity target;
 137
 138   /**
 139    * Task to kill inactive meshs (we keep them around for
 140    * a few seconds to give the application a chance to give
 141    * us another query).
 142    */
 143   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
 144
 145   /**
 146    * Task to reset meshs that had errors (asynchronously,
 147    * as we may not be able to do it immediately during a
 148    * callback from the mesh API).
 149    */
 150   GNUNET_SCHEDULER_TaskIdentifier reset_task;
 151
 152 };
 153
 154
 155 /**
 156  * Mesh tunnel for creating outbound tunnels.
 157  */
 158 static struct GNUNET_MESH_Handle *mesh_handle;
 159
 160 /**
 161  * Map from peer identities to 'struct MeshHandles' with mesh
 162  * tunnels to those peers.
 163  */
 164 static struct GNUNET_CONTAINER_MultiHashMap *mesh_map;
 165
 166
 167 /* ********************* client-side code ************************* */
 168
 169
 170 /**
 171  * Transmit pending requests via the mesh.
 172  *
 173  * @param mh mesh to process
 174  */
 175 static void
 176 transmit_pending (struct MeshHandle *mh);
 177
 178
 179 /**
 180  * Iterator called on each entry in a waiting map to
 181  * move it back to the pending list.
 182  *
 183  * @param cls the 'struct MeshHandle'
 184  * @param key the key of the entry in the map (the query)
 185  * @param value the 'struct GSF_MeshRequest' to move to pending
 186  * @return GNUNET_YES (continue to iterate)
 187  */
 188 static int
 189 move_to_pending (void *cls,
 190                  const struct GNUNET_HashCode *key,
 191                  void *value)
 192 {
 193   struct MeshHandle *mh = cls;
 194   struct GSF_MeshRequest *sr = value;
 195
 196   GNUNET_assert (GNUNET_YES ==
 197                  GNUNET_CONTAINER_multihashmap_remove (mh->waiting_map,
 198                                                        key,
 199                                                        value));
 200   GNUNET_CONTAINER_DLL_insert (mh->pending_head,
 201                                mh->pending_tail,
 202                                sr);
 203   sr->was_transmitted = GNUNET_NO;
 204   return GNUNET_YES;
 205 }
 206
 207
 208 /**
 209  * We had a serious error, tear down and re-create mesh from scratch.
 210  *
 211  * @param mh mesh to reset
 212  */
 213 static void
 214 reset_mesh (struct MeshHandle *mh)
 215 {
 216   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 217               "Resetting mesh tunnel to %s\n",
 218               GNUNET_i2s (&mh->target));
 219   GNUNET_MESH_tunnel_destroy (mh->tunnel);
 220   GNUNET_CONTAINER_multihashmap_iterate (mh->waiting_map,
 221                                          &move_to_pending,
 222                                          mh);
 223   mh->tunnel = GNUNET_MESH_tunnel_create (mesh_handle,
 224                                           mh,
 225                                           &mh->target,
 226                                           GNUNET_APPLICATION_TYPE_FS_BLOCK_TRANSFER,
 227                                           GNUNET_YES,
 228                                           GNUNET_YES);
 229   transmit_pending (mh);
 230 }
 231
 232
 233 /**
 234  * Task called when it is time to destroy an inactive mesh tunnel.
 235  *
 236  * @param cls the 'struct MeshHandle' to tear down
 237  * @param tc scheduler context, unused
 238  */
 239 static void
 240 mesh_timeout (void *cls,
 241               const struct GNUNET_SCHEDULER_TaskContext *tc)
 242 {
 243   struct MeshHandle *mh = cls;
 244   struct GNUNET_MESH_Tunnel *tun;
 245
 246   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 247               "Timeout on mesh tunnel to %s\n",
 248               GNUNET_i2s (&mh->target));
 249   mh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 250   tun = mh->tunnel;
 251   mh->tunnel = NULL;
 252   GNUNET_MESH_tunnel_destroy (tun);
 253 }
 254
 255
 256 /**
 257  * Task called when it is time to reset an mesh.
 258  *
 259  * @param cls the 'struct MeshHandle' to tear down
 260  * @param tc scheduler context, unused
 261  */
 262 static void
 263 reset_mesh_task (void *cls,
 264                  const struct GNUNET_SCHEDULER_TaskContext *tc)
 265 {
 266   struct MeshHandle *mh = cls;
 267
 268   mh->reset_task = GNUNET_SCHEDULER_NO_TASK;
 269   reset_mesh (mh);
 270 }
 271
 272
 273 /**
 274  * We had a serious error, tear down and re-create mesh from scratch,
 275  * but do so asynchronously.
 276  *
 277  * @param mh mesh to reset
 278  */
 279 static void
 280 reset_mesh_async (struct MeshHandle *mh)
 281 {
 282   if (GNUNET_SCHEDULER_NO_TASK != mh->reset_task)
 283     GNUNET_SCHEDULER_cancel (mh->reset_task);
 284   mh->reset_task = GNUNET_SCHEDULER_add_now (&reset_mesh_task,
 285                                              mh);
 286 }
 287
 288
 289 /**
 290  * Functions of this signature are called whenever we are ready to transmit
 291  * query via a mesh.
 292  *
 293  * @param cls the struct MeshHandle for which we did the write call
 294  * @param size the number of bytes that can be written to 'buf'
 295  * @param buf where to write the message
 296  * @return number of bytes written to 'buf'
 297  */
 298 static size_t
 299 transmit_sqm (void *cls,
 300               size_t size,
 301               void *buf)
 302 {
 303   struct MeshHandle *mh = cls;
 304   struct MeshQueryMessage sqm;
 305   struct GSF_MeshRequest *sr;
 306
 307   mh->wh = NULL;
 308   if (NULL == buf)
 309   {
 310     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 311                 "Mesh tunnel to %s failed during transmission attempt, rebuilding\n",
 312                 GNUNET_i2s (&mh->target));
 313     reset_mesh_async (mh);
 314     return 0;
 315   }
 316   sr = mh->pending_head;
 317   if (NULL == sr)
 318     return 0;
 319   GNUNET_assert (size >= sizeof (struct MeshQueryMessage));
 320   GNUNET_CONTAINER_DLL_remove (mh->pending_head,
 321                                mh->pending_tail,
 322                                sr);
 323   GNUNET_assert (GNUNET_OK ==
 324                  GNUNET_CONTAINER_multihashmap_put (mh->waiting_map,
 325                                                     &sr->query,
 326                                                     sr,
 327                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
 328   sr->was_transmitted = GNUNET_YES;
 329   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 330               "Sending query for %s via mesh to %s\n",
 331               GNUNET_h2s (&sr->query),
 332               GNUNET_i2s (&mh->target));
 333   sqm.header.size = htons (sizeof (sqm));
 334   sqm.header.type = htons (GNUNET_MESSAGE_TYPE_FS_MESH_QUERY);
 335   sqm.type = htonl (sr->type);
 336   sqm.query = sr->query;
 337   memcpy (buf, &sqm, sizeof (sqm));
 338   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 339               "Successfully transmitted %u bytes via mesh to %s\n",
 340               (unsigned int) size,
 341               GNUNET_i2s (&mh->target));
 342   transmit_pending (mh);
 343   return sizeof (sqm);
 344 }
 345
 346
 347 /**
 348  * Transmit pending requests via the mesh.
 349  *
 350  * @param mh mesh to process
 351  */
 352 static void
 353 transmit_pending (struct MeshHandle *mh)
 354 {
 355   if (NULL != mh->wh)
 356     return;
 357   mh->wh = GNUNET_MESH_notify_transmit_ready (mh->tunnel, GNUNET_YES /* allow cork */,
 358                                               GNUNET_TIME_UNIT_FOREVER_REL,
 359                                               sizeof (struct MeshQueryMessage),
 360                                               &transmit_sqm, mh);
 361 }
 362
 363
 364 /**
 365  * Closure for 'handle_reply'.
 366  */
 367 struct HandleReplyClosure
 368 {
 369
 370   /**
 371    * Reply payload.
 372    */
 373   const void *data;
 374
 375   /**
 376    * Expiration time for the block.
 377    */
 378   struct GNUNET_TIME_Absolute expiration;
 379
 380   /**
 381    * Number of bytes in 'data'.
 382    */
 383   size_t data_size;
 384
 385   /**
 386    * Type of the block.
 387    */
 388   enum GNUNET_BLOCK_Type type;
 389
 390   /**
 391    * Did we have a matching query?
 392    */
 393   int found;
 394 };
 395
 396
 397 /**
 398  * Iterator called on each entry in a waiting map to
 399  * process a result.
 400  *
 401  * @param cls the 'struct HandleReplyClosure'
 402  * @param key the key of the entry in the map (the query)
 403  * @param value the 'struct GSF_MeshRequest' to handle result for
 404  * @return GNUNET_YES (continue to iterate)
 405  */
 406 static int
 407 handle_reply (void *cls,
 408               const struct GNUNET_HashCode *key,
 409               void *value)
 410 {
 411   struct HandleReplyClosure *hrc = cls;
 412   struct GSF_MeshRequest *sr = value;
 413
 414   sr->proc (sr->proc_cls,
 415             hrc->type,
 416             hrc->expiration,
 417             hrc->data_size,
 418             hrc->data);
 419   GSF_mesh_query_cancel (sr);
 420   hrc->found = GNUNET_YES;
 421   return GNUNET_YES;
 422 }
 423
 424
 425 /**
 426  * Functions with this signature are called whenever a complete reply
 427  * is received.
 428  *
 429  * @param cls closure with the 'struct MeshHandle'
 430  * @param tunnel tunnel handle
 431  * @param tunnel_ctx tunnel context
 432  * @param message the actual message
 433  * @return GNUNET_OK on success, GNUNET_SYSERR to stop further processing
 434  */
 435 static int
 436 reply_cb (void *cls,
 437           struct GNUNET_MESH_Tunnel *tunnel,
 438           void **tunnel_ctx,
 439           const struct GNUNET_MessageHeader *message)
 440 {
 441   struct MeshHandle *mh = *tunnel_ctx;
 442   const struct MeshReplyMessage *srm;
 443   struct HandleReplyClosure hrc;
 444   uint16_t msize;
 445   enum GNUNET_BLOCK_Type type;
 446   struct GNUNET_HashCode query;
 447
 448   msize = ntohs (message->size);
 449   if (sizeof (struct MeshReplyMessage) > msize)
 450   {
 451     GNUNET_break_op (0);
 452     reset_mesh_async (mh);
 453     return GNUNET_SYSERR;
 454   }
 455   srm = (const struct MeshReplyMessage *) message;
 456   msize -= sizeof (struct MeshReplyMessage);
 457   type = (enum GNUNET_BLOCK_Type) ntohl (srm->type);
 458   if (GNUNET_YES !=
 459       GNUNET_BLOCK_get_key (GSF_block_ctx,
 460                             type,
 461                             &srm[1], msize, &query))
 462   {
 463     GNUNET_break_op (0);
 464     reset_mesh_async (mh);
 465     return GNUNET_SYSERR;
 466   }
 467   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 468               "Received reply `%s' via mesh from peer %s\n",
 469               GNUNET_h2s (&query),
 470               GNUNET_i2s (&mh->target));
 471   GNUNET_MESH_receive_done (tunnel);
 472   GNUNET_STATISTICS_update (GSF_stats,
 473                             gettext_noop ("# replies received via mesh"), 1,
 474                             GNUNET_NO);
 475   hrc.data = &srm[1];
 476   hrc.data_size = msize;
 477   hrc.expiration = GNUNET_TIME_absolute_ntoh (srm->expiration);
 478   hrc.type = type;
 479   hrc.found = GNUNET_NO;
 480   GNUNET_CONTAINER_multihashmap_get_multiple (mh->waiting_map,
 481                                               &query,
 482                                               &handle_reply,
 483                                               &hrc);
 484   if (GNUNET_NO == hrc.found)
 485   {
 486     GNUNET_STATISTICS_update (GSF_stats,
 487                               gettext_noop ("# replies received via mesh dropped"), 1,
 488                               GNUNET_NO);
 489     return GNUNET_OK;
 490   }
 491   return GNUNET_OK;
 492 }
 493
 494
 495 /**
 496  * Get (or create) a mesh to talk to the given peer.
 497  *
 498  * @param target peer we want to communicate with
 499  */
 500 static struct MeshHandle *
 501 get_mesh (const struct GNUNET_PeerIdentity *target)
 502 {
 503   struct MeshHandle *mh;
 504
 505   mh = GNUNET_CONTAINER_multihashmap_get (mesh_map,
 506                                           &target->hashPubKey);
 507   if (NULL != mh)
 508   {
 509     if (GNUNET_SCHEDULER_NO_TASK != mh->timeout_task)
 510     {
 511       GNUNET_SCHEDULER_cancel (mh->timeout_task);
 512       mh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 513     }
 514     return mh;
 515   }
 516   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 517               "Creating mesh tunnel to %s\n",
 518               GNUNET_i2s (target));
 519   mh = GNUNET_new (struct MeshHandle);
 520   mh->reset_task = GNUNET_SCHEDULER_add_delayed (CLIENT_RETRY_TIMEOUT,
 521                                                  &reset_mesh_task,
 522                                                  mh);
 523   mh->waiting_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_YES);
 524   mh->target = *target;
 525   mh->tunnel = GNUNET_MESH_tunnel_create (mesh_handle,
 526                                           mh,
 527                                           &mh->target,
 528                                           GNUNET_APPLICATION_TYPE_FS_BLOCK_TRANSFER,
 529                                           GNUNET_NO,
 530                                           GNUNET_YES);
 531   GNUNET_assert (GNUNET_OK ==
 532                  GNUNET_CONTAINER_multihashmap_put (mesh_map,
 533                                                     &mh->target.hashPubKey,
 534                                                     mh,
 535                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 536   return mh;
 537 }
 538
 539
 540 /**
 541  * Look for a block by directly contacting a particular peer.
 542  *
 543  * @param target peer that should have the block
 544  * @param query hash to query for the block
 545  * @param type desired type for the block
 546  * @param proc function to call with result
 547  * @param proc_cls closure for 'proc'
 548  * @return handle to cancel the operation
 549  */
 550 struct GSF_MeshRequest *
 551 GSF_mesh_query (const struct GNUNET_PeerIdentity *target,
 552                 const struct GNUNET_HashCode *query,
 553                 enum GNUNET_BLOCK_Type type,
 554                 GSF_MeshReplyProcessor proc, void *proc_cls)
 555 {
 556   struct MeshHandle *mh;
 557   struct GSF_MeshRequest *sr;
 558
 559   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 560               "Preparing to send query for %s via mesh to %s\n",
 561               GNUNET_h2s (query),
 562               GNUNET_i2s (target));
 563   mh = get_mesh (target);
 564   sr = GNUNET_new (struct GSF_MeshRequest);
 565   sr->mh = mh;
 566   sr->proc = proc;
 567   sr->proc_cls = proc_cls;
 568   sr->type = type;
 569   sr->query = *query;
 570   GNUNET_CONTAINER_DLL_insert (mh->pending_head,
 571                                mh->pending_tail,
 572                                sr);
 573   transmit_pending (mh);
 574   return sr;
 575 }
 576
 577
 578 /**
 579  * Cancel an active request; must not be called after 'proc'
 580  * was calld.
 581  *
 582  * @param sr request to cancel
 583  */
 584 void
 585 GSF_mesh_query_cancel (struct GSF_MeshRequest *sr)
 586 {
 587   struct MeshHandle *mh = sr->mh;
 588
 589   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 590               "Cancelled query for %s via mesh to %s\n",
 591               GNUNET_h2s (&sr->query),
 592               GNUNET_i2s (&sr->mh->target));
 593   if (GNUNET_YES == sr->was_transmitted)
 594     GNUNET_assert (GNUNET_OK ==
 595                    GNUNET_CONTAINER_multihashmap_remove (mh->waiting_map,
 596                                                          &sr->query,
 597                                                          sr));
 598   else
 599     GNUNET_CONTAINER_DLL_remove (mh->pending_head,
 600                                  mh->pending_tail,
 601                                  sr);
 602   GNUNET_free (sr);
 603   if ( (0 == GNUNET_CONTAINER_multihashmap_size (mh->waiting_map)) &&
 604        (NULL == mh->pending_head) )
 605     mh->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
 606                                                      &mesh_timeout,
 607                                                      mh);
 608 }
 609
 610
 611 /**
 612  * Iterator called on each entry in a waiting map to
 613  * call the 'proc' continuation and release associated
 614  * resources.
 615  *
 616  * @param cls the 'struct MeshHandle'
 617  * @param key the key of the entry in the map (the query)
 618  * @param value the 'struct GSF_MeshRequest' to clean up
 619  * @return GNUNET_YES (continue to iterate)
 620  */
 621 static int
 622 free_waiting_entry (void *cls,
 623                     const struct GNUNET_HashCode *key,
 624                     void *value)
 625 {
 626   struct GSF_MeshRequest *sr = value;
 627
 628   sr->proc (sr->proc_cls, GNUNET_BLOCK_TYPE_ANY,
 629             GNUNET_TIME_UNIT_FOREVER_ABS,
 630             0, NULL);
 631   GSF_mesh_query_cancel (sr);
 632   return GNUNET_YES;
 633 }
 634
 635
 636 /**
 637  * Function called by mesh when a client disconnects.
 638  * Cleans up our 'struct MeshClient' of that tunnel.
 639  *
 640  * @param cls NULL
 641  * @param tunnel tunnel of the disconnecting client
 642  * @param tunnel_ctx our 'struct MeshClient'
 643  */
 644 static void
 645 cleaner_cb (void *cls,
 646             const struct GNUNET_MESH_Tunnel *tunnel,
 647             void *tunnel_ctx)
 648 {
 649   struct MeshHandle *mh = tunnel_ctx;
 650   struct GSF_MeshRequest *sr;
 651
 652   mh->tunnel = NULL;
 653   while (NULL != (sr = mh->pending_head))
 654   {
 655     sr->proc (sr->proc_cls, GNUNET_BLOCK_TYPE_ANY,
 656               GNUNET_TIME_UNIT_FOREVER_ABS,
 657               0, NULL);
 658     GSF_mesh_query_cancel (sr);
 659   }
 660   GNUNET_CONTAINER_multihashmap_iterate (mh->waiting_map,
 661                                          &free_waiting_entry,
 662                                          mh);
 663   if (NULL != mh->wh)
 664     GNUNET_MESH_notify_transmit_ready_cancel (mh->wh);
 665   if (GNUNET_SCHEDULER_NO_TASK != mh->timeout_task)
 666     GNUNET_SCHEDULER_cancel (mh->timeout_task);
 667   if (GNUNET_SCHEDULER_NO_TASK != mh->reset_task)
 668     GNUNET_SCHEDULER_cancel (mh->reset_task);
 669   GNUNET_assert (GNUNET_OK ==
 670                  GNUNET_CONTAINER_multihashmap_remove (mesh_map,
 671                                                        &mh->target.hashPubKey,
 672                                                        mh));
 673   GNUNET_CONTAINER_multihashmap_destroy (mh->waiting_map);
 674   GNUNET_free (mh);
 675 }
 676
 677
 678 /**
 679  * Initialize subsystem for non-anonymous file-sharing.
 680  */
 681 void
 682 GSF_mesh_start_client ()
 683 {
 684   static const struct GNUNET_MESH_MessageHandler handlers[] = {
 685     { &reply_cb, GNUNET_MESSAGE_TYPE_FS_MESH_REPLY, 0 },
 686     { NULL, 0, 0 }
 687   };
 688
 689   mesh_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_YES);
 690   mesh_handle = GNUNET_MESH_connect (GSF_cfg,
 691                                      NULL,
 692                                      NULL,
 693                                      &cleaner_cb,
 694                                      handlers,
 695                                      NULL);
 696 }
 697
 698
 699 /**
 700  * Function called on each active meshs to shut them down.
 701  *
 702  * @param cls NULL
 703  * @param key target peer, unused
 704  * @param value the 'struct MeshHandle' to destroy
 705  * @return GNUNET_YES (continue to iterate)
 706  */
 707 static int
 708 release_meshs (void *cls,
 709                const struct GNUNET_HashCode *key,
 710                void *value)
 711 {
 712   struct MeshHandle *mh = value;
 713   struct GNUNET_MESH_Tunnel *tun;
 714
 715   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 716               "Timeout on mesh tunnel to %s\n",
 717               GNUNET_i2s (&mh->target));
 718   tun = mh->tunnel;
 719   mh->tunnel = NULL;
 720   if (NULL != tun)
 721     GNUNET_MESH_tunnel_destroy (tun);
 722   return GNUNET_YES;
 723 }
 724
 725
 726 /**
 727  * Shutdown subsystem for non-anonymous file-sharing.
 728  */
 729 void
 730 GSF_mesh_stop_client ()
 731 {
 732   GNUNET_CONTAINER_multihashmap_iterate (mesh_map,
 733                                          &release_meshs,
 734                                          NULL);
 735   GNUNET_CONTAINER_multihashmap_destroy (mesh_map);
 736   mesh_map = NULL;
 737   if (NULL != mesh_handle)
 738   {
 739     GNUNET_MESH_disconnect (mesh_handle);
 740     mesh_handle = NULL;
 741   }
 742 }
 743
 744
 745 /* end of gnunet-service-fs_mesh_client.c */