src/dht/gnunet-service-wdht_neighbours.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2009-2015 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  * @file dht/gnunet-service-wdht_neighbours.c
  22  * @brief GNUnet DHT service's finger and friend table management code
  23  * @author Supriti Singh
  24  */
  25 #include "platform.h"
  26 #include "gnunet_util_lib.h"
  27 #include "gnunet_block_lib.h"
  28 #include "gnunet_hello_lib.h"
  29 #include "gnunet_constants.h"
  30 #include "gnunet_protocols.h"
  31 #include "gnunet_ats_service.h"
  32 #include "gnunet_core_service.h"
  33 #include "gnunet_datacache_lib.h"
  34 #include "gnunet_transport_service.h"
  35 #include "gnunet_dht_service.h"
  36 #include "gnunet_statistics_service.h"
  37 #include "gnunet-service-wdht.h"
  38 #include "gnunet-service-wdht_clients.h"
  39 #include "gnunet-service-wdht_datacache.h"
  40 #include "gnunet-service-wdht_neighbours.h"
  41 #include "gnunet-service-wdht_nse.h"
  42 #include <fenv.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45 #include "dht.h"
  46
  47 #define DEBUG(...)                                           \
  48   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
  49
  50 /**
  51  * Trail timeout. After what time do trails always die?
  52  */
  53 #define TRAIL_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 42)
  54
  55 /**
  56  * Random walk delay. How often do we walk the overlay?
  57  */
  58 #define RANDOM_WALK_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 42)
  59
  60 /**
  61  * The number of layered ID to use.
  62  */
  63 #define NUMBER_LAYERED_ID 8
  64
  65 /**
  66  * The number of random walk to launch at the beginning of the initialization
  67  */
  68 /* FIXME: find a better value */
  69 #define NUMBER_RANDOM_WALK 20
  70
  71
  72 /******************* The db structure and related functions *******************/
  73
  74 /**
  75  * Entry in #friends_peermap.
  76  */
  77 struct FriendInfo;
  78
  79
  80 /**
  81  * Information we keep per trail.
  82  */
  83 struct Trail
  84 {
  85
  86   /**
  87    * MDLL entry in the list of all trails with the same predecessor.
  88    */
  89   struct Trail *prev_succ;
  90
  91   /**
  92    * MDLL entry in the list of all trails with the same predecessor.
  93    */
  94   struct Trail *next_succ;
  95
  96   /**
  97    * MDLL entry in the list of all trails with the same predecessor.
  98    */
  99   struct Trail *prev_pred;
 100
 101   /**
 102    * MDLL entry in the list of all trails with the same predecessor.
 103    */
 104   struct Trail *next_pred;
 105
 106   /**
 107    * Our predecessor in the trail, NULL if we are initiator (?).
 108    */
 109   struct FriendInfo *pred;
 110
 111   /**
 112    * Our successor in the trail, NULL if we are the last peer.
 113    */
 114   struct FriendInfo *succ;
 115
 116   /**
 117    * Identifier of the trail with the predecessor.
 118    */
 119   struct GNUNET_HashCode pred_id;
 120
 121   /**
 122    * Identifier of the trail with the successor.
 123    */
 124   struct GNUNET_HashCode succ_id;
 125
 126   /**
 127    * When does this trail expire.
 128    */
 129   struct GNUNET_TIME_Absolute expiration_time;
 130
 131   /**
 132    * Location of this trail in the heap.
 133    */
 134   struct GNUNET_CONTAINER_HeapNode *hn;
 135
 136   /**
 137    * If this peer started the to create a Finger (and thus @e pred is
 138    * NULL), this is the Finger we are trying to intialize.
 139    */
 140   struct Finger **finger;
 141
 142 };
 143
 144
 145 /**
 146  *  Entry in #friends_peermap.
 147  */
 148 struct FriendInfo
 149 {
 150   /**
 151    * Friend Identity
 152    */
 153   struct GNUNET_PeerIdentity id;
 154
 155   /**
 156    *
 157    */
 158   struct Trail *pred_head;
 159
 160   /**
 161    *
 162    */
 163   struct Trail *pred_tail;
 164
 165   /**
 166    *
 167    */
 168   struct Trail *succ_head;
 169
 170   /**
 171    *
 172    */
 173   struct Trail *succ_tail;
 174
 175   /**
 176    * Core handle for sending messages to this friend.
 177    */
 178   struct GNUNET_MQ_Handle *mq;
 179
 180 };
 181
 182
 183 /**
 184  *
 185  */
 186 struct FingerTable;
 187
 188
 189 /**
 190  *
 191  */
 192 struct Finger
 193 {
 194   /**
 195    *
 196    */
 197   struct Trail *trail;
 198
 199   /**
 200    *
 201    */
 202   struct FingerTable *ft;
 203
 204   /**
 205    *
 206    */
 207   struct GNUNET_HashCode destination;
 208
 209   /**
 210    * #GNUNET_YES if a response has been received. Otherwise #GNUNET_NO.
 211    */
 212   int valid;
 213 };
 214
 215
 216 struct FingerTable
 217 {
 218   /**
 219    * Array of our fingers, unsorted.
 220    */
 221   struct Finger **fingers;
 222
 223   /**
 224    * Array of sorted fingers (sorted by destination, valid fingers first).
 225    */
 226   struct Finger **sorted_fingers;
 227
 228   /**
 229    * Size of the finger array.
 230    */
 231   unsigned int finger_array_size;
 232
 233   /**
 234    * Number of valid entries in @e sorted_fingers (contiguous from offset 0)
 235    */
 236   unsigned int number_valid_fingers;
 237
 238   /**
 239    * Which offset in @e fingers will we redo next.
 240    */
 241   unsigned int walk_offset;
 242
 243   /**
 244    * Is the finger array sorted?
 245    */
 246   int is_sorted;
 247
 248 };
 249
 250
 251 /***********************  end of the db structure part  ***********************/
 252
 253
 254 GNUNET_NETWORK_STRUCT_BEGIN
 255
 256 /**
 257  * Setup a finger using the underlay topology ("social network").
 258  */
 259 struct RandomWalkMessage
 260 {
 261   /**
 262    * Type: #GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK
 263    */
 264   struct GNUNET_MessageHeader header;
 265
 266   /**
 267    * Number of hops this message has taken so far, we stop at
 268    * log(NSE), in NBO.
 269    */
 270   uint16_t hops_taken GNUNET_PACKED;
 271
 272   /**
 273    * Layer for the request, in NBO.
 274    */
 275   uint16_t layer GNUNET_PACKED;
 276
 277   /**
 278    * Unique (random) identifier this peer will use to
 279    * identify the trail (in future messages).
 280    */
 281   struct GNUNET_HashCode trail_id;
 282
 283 };
 284
 285 /**
 286  * Response to a `struct RandomWalkMessage`.
 287  */
 288 struct RandomWalkResponseMessage
 289 {
 290   /**
 291    * Type: #GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK_RESPONSE
 292    */
 293   struct GNUNET_MessageHeader header;
 294
 295   /**
 296    * Zero, for alignment.
 297    */
 298   uint32_t reserved GNUNET_PACKED;
 299
 300   /**
 301    * Unique (random) identifier from the
 302    * `struct RandomWalkMessage`.
 303    */
 304   struct GNUNET_HashCode trail_id;
 305
 306   /**
 307    * Random location in the respective layer where the
 308    * random path of the finger setup terminated.
 309    */
 310   struct GNUNET_HashCode location;
 311
 312 };
 313
 314 /**
 315  * Response to an event that causes a trail to die.
 316  */
 317 struct TrailDestroyMessage
 318 {
 319   /**
 320    * Type: #GNUNET_MESSAGE_TYPE_WDHT_TRAIL_DESTROY
 321    */
 322   struct GNUNET_MessageHeader header;
 323
 324   /**
 325    * Zero, for alignment.
 326    */
 327   uint32_t reserved GNUNET_PACKED;
 328
 329   /**
 330    * Unique (random) identifier this peer will use to
 331    * identify the finger (in future messages).
 332    */
 333   struct GNUNET_HashCode trail_id;
 334
 335 };
 336
 337
 338 /**
 339  * Send a message along a trail.
 340  */
 341 struct FindSuccessorMessage
 342 {
 343   /**
 344    * Type: #GNUNET_MESSAGE_TYPE_WDHT_FIND_SUCCESSOR
 345    */
 346   struct GNUNET_MessageHeader header;
 347
 348   /**
 349    * Zero, for alignment.
 350    */
 351   uint32_t reserved GNUNET_PACKED;
 352
 353   /**
 354    * Unique (random) identifier this peer will use to
 355    * identify the finger (in future messages).
 356    */
 357   struct GNUNET_HashCode trail_id;
 358
 359   /**
 360    * Key for which we would like close values returned.
 361    * identify the finger (in future messages).
 362    */
 363   struct GNUNET_HashCode key;
 364
 365 };
 366
 367
 368 /**
 369  * Send a message along a trail.
 370  */
 371 struct TrailRouteMessage
 372 {
 373   /**
 374    * Type: #GNUNET_MESSAGE_TYPE_WDHT_TRAIL_ROUTE
 375    */
 376   struct GNUNET_MessageHeader header;
 377
 378   /**
 379    * #GNUNET_YES if the path should be recorded, #GNUNET_NO if not; in NBO.
 380    */
 381   uint16_t record_path GNUNET_PACKED;
 382
 383   /**
 384    * Length of the recorded trail, 0 if @e record_path is #GNUNET_NO; in NBO.
 385    */
 386   uint16_t path_length GNUNET_PACKED;
 387
 388   /**
 389    * Unique (random) identifier this peer will use to
 390    * identify the finger (in future messages).
 391    */
 392   struct GNUNET_HashCode trail_id;
 393
 394   /**
 395    * Path the message has taken so far (excluding sender).
 396    */
 397   /* struct GNUNET_PeerIdentity path[path_length]; */
 398
 399   /* followed by payload (another `struct GNUNET_MessageHeader`) to
 400      send along the trail */
 401 };
 402
 403
 404 /**
 405  * P2P PUT message
 406  */
 407 struct PeerPutMessage
 408 {
 409   /**
 410    * Type: #GNUNET_MESSAGE_TYPE_WDHT_PUT
 411    */
 412   struct GNUNET_MessageHeader header;
 413
 414   /**
 415    * Processing options
 416    */
 417   uint32_t options GNUNET_PACKED;
 418
 419   /**
 420    * Content type.
 421    */
 422   uint32_t block_type GNUNET_PACKED;
 423
 424   /**
 425    * Hop count
 426    */
 427   uint32_t hop_count GNUNET_PACKED;
 428
 429   /**
 430    * Replication level for this message
 431    * In the current implementation, this value is not used.
 432    */
 433   uint32_t desired_replication_level GNUNET_PACKED;
 434
 435   /**
 436    * Length of the PUT path that follows (if tracked).
 437    */
 438   uint32_t put_path_length GNUNET_PACKED;
 439
 440   /**
 441    * When does the content expire?
 442    */
 443   struct GNUNET_TIME_AbsoluteNBO expiration_time;
 444
 445   /**
 446    * The key to store the value under.
 447    */
 448   struct GNUNET_HashCode key GNUNET_PACKED;
 449
 450   /* put path (if tracked) */
 451
 452   /* Payload */
 453
 454 };
 455
 456 /**
 457  * P2P GET message
 458  */
 459 struct PeerGetMessage
 460 {
 461   /**
 462    * Type: #GNUNET_MESSAGE_TYPE_WDHT_GET
 463    */
 464   struct GNUNET_MessageHeader header;
 465
 466   /**
 467    * Processing options
 468    */
 469   uint32_t options GNUNET_PACKED;
 470
 471   /**
 472    * Desired content type.
 473    */
 474   uint32_t block_type GNUNET_PACKED;
 475
 476   /**
 477    * Hop count
 478    */
 479   uint32_t hop_count GNUNET_PACKED;
 480
 481   /**
 482    * Desired replication level for this request.
 483    * In the current implementation, this value is not used.
 484    */
 485   uint32_t desired_replication_level GNUNET_PACKED;
 486
 487   /**
 488    * Total number of peers in get path.
 489    */
 490   unsigned int get_path_length;
 491
 492   /**
 493    * The key we are looking for.
 494    */
 495   struct GNUNET_HashCode key;
 496
 497   /* Get path. */
 498   /* struct GNUNET_PeerIdentity[]*/
 499 };
 500
 501
 502 /**
 503  * P2P Result message
 504  */
 505 struct PeerGetResultMessage
 506 {
 507   /**
 508    * Type: #GNUNET_MESSAGE_TYPE_WDHT_GET_RESULT
 509    */
 510   struct GNUNET_MessageHeader header;
 511
 512   /**
 513    * The type for the data.
 514    */
 515   uint32_t type GNUNET_PACKED;
 516
 517   /**
 518    * Number of peers recorded in the outgoing path from source to the
 519    * stored location of this message.
 520    */
 521   uint32_t put_path_length GNUNET_PACKED;
 522
 523   /**
 524    * Length of the GET path that follows (if tracked).
 525    */
 526   uint32_t get_path_length GNUNET_PACKED;
 527
 528   /**
 529    * Peer which queried for get and should get the result.
 530    */
 531   struct GNUNET_PeerIdentity querying_peer;
 532
 533   /**
 534    * When does the content expire?
 535    */
 536   struct GNUNET_TIME_Absolute expiration_time;
 537
 538   /**
 539    * The key of the corresponding GET request.
 540    */
 541   struct GNUNET_HashCode key;
 542
 543   /* put path (if tracked) */
 544
 545   /* get path (if tracked) */
 546
 547   /* Payload */
 548
 549 };
 550
 551 GNUNET_NETWORK_STRUCT_END
 552
 553
 554 /**
 555  * Contains all the layered IDs of this peer.
 556  */
 557 struct GNUNET_PeerIdentity layered_id[NUMBER_LAYERED_ID];
 558
 559 /**
 560  * Task to timeout trails that have expired.
 561  */
 562 static struct GNUNET_SCHEDULER_Task *trail_timeout_task;
 563
 564 /**
 565  * Task to perform random walks.
 566  */
 567 static struct GNUNET_SCHEDULER_Task *random_walk_task;
 568
 569 /**
 570  * Identity of this peer.
 571  */
 572 static struct GNUNET_PeerIdentity my_identity;
 573
 574 /**
 575  * Peer map of all the friends of a peer
 576  */
 577 static struct GNUNET_CONTAINER_MultiPeerMap *friends_peermap;
 578
 579 /**
 580  * Fingers per layer.
 581  */
 582 static struct FingerTable fingers[NUMBER_LAYERED_ID];
 583
 584 /**
 585  * Tail map, mapping tail identifiers to `struct Trail`s
 586  */
 587 static struct GNUNET_CONTAINER_MultiHashMap *trail_map;
 588
 589 /**
 590  * Tail heap, organizing trails by expiration time.
 591  */
 592 static struct GNUNET_CONTAINER_Heap *trail_heap;
 593
 594 /**
 595  * Handle to CORE.
 596  */
 597 static struct GNUNET_CORE_Handle *core_api;
 598
 599
 600 /**
 601  * Handle the put request from the client.
 602  *
 603  * @param key Key for the content
 604  * @param block_type Type of the block
 605  * @param options Routing options
 606  * @param desired_replication_level Desired replication count
 607  * @param expiration_time When does the content expire
 608  * @param data Content to store
 609  * @param data_size Size of content @a data in bytes
 610  */
 611 void
 612 GDS_NEIGHBOURS_handle_put (const struct GNUNET_HashCode *key,
 613                            enum GNUNET_BLOCK_Type block_type,
 614                            enum GNUNET_DHT_RouteOption options,
 615                            uint32_t desired_replication_level,
 616                            struct GNUNET_TIME_Absolute expiration_time,
 617                            const void *data,
 618                            size_t data_size)
 619 {
 620   GDS_DATACACHE_handle_put (expiration_time,
 621                             key,
 622                             0, NULL,
 623                             0, NULL,
 624                             block_type,
 625                             data_size,
 626                             data);
 627   GDS_CLIENTS_process_put (options,
 628                            block_type,
 629                            0, 0,
 630                            0, NULL,
 631                            expiration_time,
 632                            key,
 633                            data,
 634                            data_size);
 635 }
 636
 637
 638 /**
 639  * Handle the get request from the client file. If I am destination do
 640  * datacache put and return. Else find the target friend and forward message
 641  * to it.
 642  *
 643  * @param key Key for the content
 644  * @param block_type Type of the block
 645  * @param options Routing options
 646  * @param desired_replication_level Desired replication count
 647  */
 648 void
 649 GDS_NEIGHBOURS_handle_get (const struct GNUNET_HashCode *key,
 650                            enum GNUNET_BLOCK_Type block_type,
 651                            enum GNUNET_DHT_RouteOption options,
 652                            uint32_t desired_replication_level)
 653 {
 654   // find closest finger(s) on all layers
 655   // use TrailRoute with PeerGetMessage embedded to contact peer
 656 }
 657
 658
 659 /**
 660  * Delete a trail, it died (timeout, link failure, etc.).
 661  *
 662  * @param trail trail to delete from all data structures
 663  * @param inform_pred should we notify the predecessor?
 664  * @param inform_succ should we inform the successor?
 665  */
 666 static void
 667 delete_trail (struct Trail *trail,
 668               int inform_pred,
 669               int inform_succ)
 670 {
 671   struct FriendInfo *friend;
 672   struct GNUNET_MQ_Envelope *env;
 673   struct TrailDestroyMessage *tdm;
 674   struct Finger *finger;
 675
 676   friend = trail->pred;
 677   if (NULL != friend)
 678   {
 679     if (GNUNET_YES == inform_pred)
 680     {
 681       env = GNUNET_MQ_msg (tdm,
 682                            GNUNET_MESSAGE_TYPE_WDHT_TRAIL_DESTROY);
 683       tdm->trail_id = trail->pred_id;
 684       GNUNET_MQ_send (friend->mq,
 685                       env);
 686     }
 687     GNUNET_CONTAINER_MDLL_remove (pred,
 688                                   friend->pred_head,
 689                                   friend->pred_tail,
 690                                   trail);
 691   }
 692   friend = trail->succ;
 693   if (NULL != friend)
 694   {
 695     if (GNUNET_YES == inform_succ)
 696     {
 697       env = GNUNET_MQ_msg (tdm,
 698                            GNUNET_MESSAGE_TYPE_WDHT_TRAIL_DESTROY);
 699       tdm->trail_id = trail->pred_id;
 700       GNUNET_MQ_send (friend->mq,
 701                       env);
 702     }
 703     GNUNET_CONTAINER_MDLL_remove (succ,
 704                                   friend->pred_head,
 705                                   friend->pred_tail,
 706                                   trail);
 707   }
 708   GNUNET_break (trail ==
 709                 GNUNET_CONTAINER_heap_remove_node (trail->hn));
 710   finger = *trail->finger;
 711   if (NULL != finger)
 712   {
 713     *trail->finger = NULL;
 714     GNUNET_free (finger);
 715   }
 716   GNUNET_free (trail);
 717 }
 718
 719
 720 /**
 721  * Send the get result to requesting client.
 722  *
 723  * @param trail_id trail identifying where to send the result to, NULL for us
 724  * @param key Key of the requested data.
 725  * @param type Block type
 726  * @param put_path_length Number of peers in @a put_path
 727  * @param put_path Path taken to put the data at its stored location.
 728  * @param expiration When will this result expire?
 729  * @param data Payload to store
 730  * @param data_size Size of the @a data
 731  *
 732  * FIXME: also pass options, so we know to record paths or not...
 733  */
 734 void
 735 GDS_NEIGHBOURS_send_get_result (const struct GNUNET_HashCode *trail_id,
 736                                 const struct GNUNET_HashCode *key,
 737                                 enum GNUNET_BLOCK_Type type,
 738                                 unsigned int put_path_length,
 739                                 const struct GNUNET_PeerIdentity *put_path,
 740                                 struct GNUNET_TIME_Absolute expiration,
 741                                 const void *data,
 742                                 size_t data_size)
 743 {
 744   // TRICKY: need to introduce some context to remember trail from
 745   // the lookup...
 746 }
 747
 748
 749 /**
 750  * Method called whenever a peer disconnects.
 751  *
 752  * @param cls closure
 753  * @param peer peer identity this notification is about
 754  */
 755 static void
 756 handle_core_disconnect (void *cls,
 757                         const struct GNUNET_PeerIdentity *peer)
 758 {
 759   struct FriendInfo *remove_friend;
 760   struct Trail *t;
 761
 762   /* If disconnected to own identity, then return. */
 763   if (0 == memcmp (&my_identity,
 764                    peer,
 765                    sizeof (struct GNUNET_PeerIdentity)))
 766     return;
 767
 768   if (NULL == (remove_friend =
 769                GNUNET_CONTAINER_multipeermap_get (friends_peermap,
 770                                                   peer)))
 771   {
 772     GNUNET_break (0);
 773     return;
 774   }
 775
 776   GNUNET_assert (GNUNET_YES ==
 777                  GNUNET_CONTAINER_multipeermap_remove (friends_peermap,
 778                                                        peer,
 779                                                        remove_friend));
 780   while (NULL != (t = remove_friend->succ_head))
 781     delete_trail (t,
 782                   GNUNET_YES,
 783                   GNUNET_NO);
 784   while (NULL != (t = remove_friend->pred_head))
 785     delete_trail (t,
 786                   GNUNET_NO,
 787                   GNUNET_YES);
 788   GNUNET_MQ_destroy (remove_friend->mq);
 789   GNUNET_free (remove_friend);
 790   if (0 ==
 791       GNUNET_CONTAINER_multipeermap_size (friends_peermap))
 792   {
 793     GNUNET_SCHEDULER_cancel (random_walk_task);
 794     random_walk_task = NULL;
 795   }
 796 }
 797
 798
 799 /**
 800  * Pick random friend from friends for random walk.
 801  */
 802 static struct FriendInfo *
 803 pick_random_friend ()
 804 {
 805   // TODO: need to extend peermap API to return random entry...
 806   // (Note: same extension exists for hashmap API).
 807   return NULL; // FIXME...
 808 }
 809
 810
 811 /**
 812  * One of our trails might have timed out, check and
 813  * possibly initiate cleanup.
 814  *
 815  * @param cls NULL
 816  * @param tc unused
 817  */
 818 static void
 819 trail_timeout_callback (void *cls,
 820                         const struct GNUNET_SCHEDULER_TaskContext *tc)
 821 {
 822   struct Trail *trail;
 823   struct GNUNET_TIME_Relative left;
 824
 825   trail_timeout_task = NULL;
 826   while (NULL != (trail = GNUNET_CONTAINER_heap_peek (trail_heap)))
 827   {
 828     left = GNUNET_TIME_absolute_get_remaining (trail->expiration_time);
 829     if (0 != left.rel_value_us)
 830       break;
 831     delete_trail (trail,
 832                   GNUNET_YES,
 833                   GNUNET_YES);
 834   }
 835   if (NULL != trail)
 836     trail_timeout_task = GNUNET_SCHEDULER_add_delayed (left,
 837                                                        &trail_timeout_callback,
 838                                                        NULL);
 839 }
 840
 841
 842 /**
 843  * Initiate a random walk.
 844  *
 845  * @param cls NULL
 846  * @param tc unused
 847  */
 848 static void
 849 do_random_walk (void *cls,
 850                 const struct GNUNET_SCHEDULER_TaskContext *tc)
 851 {
 852   static unsigned int walk_layer;
 853   struct FriendInfo *friend;
 854   struct GNUNET_MQ_Envelope *env;
 855   struct RandomWalkMessage *rwm;
 856   struct FingerTable *ft;
 857   struct Finger *finger;
 858   struct Trail *trail;
 859
 860   random_walk_task = NULL;
 861   friend = pick_random_friend ();
 862
 863   trail = GNUNET_new (struct Trail);
 864   /* We create the random walk so, no predecessor */
 865   trail->succ = friend;
 866   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_NONCE,
 867                                     &trail->succ_id);
 868   if (GNUNET_OK !=
 869       GNUNET_CONTAINER_multihashmap_put (trail_map,
 870                                          &trail->succ_id,
 871                                          trail,
 872                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
 873   {
 874     GNUNET_break (0);
 875     GNUNET_free (trail);
 876     return;
 877   }
 878   GNUNET_CONTAINER_MDLL_insert (succ,
 879                                 friend->succ_head,
 880                                 friend->succ_tail,
 881                                 trail);
 882   trail->expiration_time = GNUNET_TIME_relative_to_absolute (TRAIL_TIMEOUT);
 883   trail->hn = GNUNET_CONTAINER_heap_insert (trail_heap,
 884                                             trail,
 885                                             trail->expiration_time.abs_value_us);
 886   if (NULL == trail_timeout_task)
 887     trail_timeout_task = GNUNET_SCHEDULER_add_delayed (TRAIL_TIMEOUT,
 888                                                        &trail_timeout_callback,
 889                                                        NULL);
 890   env = GNUNET_MQ_msg (rwm,
 891                        GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK);
 892   rwm->hops_taken = htonl (0);
 893   rwm->trail_id = trail->succ_id;
 894   GNUNET_MQ_send (friend->mq,
 895                   env);
 896   /* clean up 'old' entry (implicitly via trail cleanup) */
 897   ft = &fingers[walk_layer];
 898
 899   if ( (NULL != ft->fingers) &&
 900        (NULL != (finger = ft->fingers[ft->walk_offset])) )
 901     delete_trail (finger->trail,
 902                   GNUNET_NO,
 903                   GNUNET_YES);
 904   if (ft->finger_array_size < 42)
 905   {
 906     // FIXME: must have finger array of the right size here,
 907     // FIXME: growing / shrinking are tricy -- with pointers
 908     // from Trails!!!
 909   }
 910
 911   GNUNET_assert (NULL == ft->fingers[ft->walk_offset]);
 912
 913   finger = GNUNET_new (struct Finger);
 914   finger->trail = trail;
 915   trail->finger = &ft->fingers[ft->walk_offset];
 916   finger->ft = ft;
 917   ft->fingers[ft->walk_offset] = finger;
 918   ft->is_sorted = GNUNET_NO;
 919   ft->walk_offset = (ft->walk_offset + 1) % ft->finger_array_size;
 920
 921   walk_layer = (walk_layer + 1) % NUMBER_LAYERED_ID;
 922   random_walk_task = GNUNET_SCHEDULER_add_delayed (RANDOM_WALK_DELAY,
 923                                                    &do_random_walk,
 924                                                    NULL);
 925 }
 926
 927
 928 /**
 929  * Method called whenever a peer connects.
 930  *
 931  * @param cls closure
 932  * @param peer_identity peer identity this notification is about
 933  */
 934 static void
 935 handle_core_connect (void *cls,
 936                      const struct GNUNET_PeerIdentity *peer_identity)
 937 {
 938   struct FriendInfo *friend;
 939
 940   /* Check for connect to self message */
 941   if (0 == memcmp (&my_identity,
 942                    peer_identity,
 943                    sizeof (struct GNUNET_PeerIdentity)))
 944     return;
 945
 946   /* If peer already exists in our friend_peermap, then exit. */
 947   if (GNUNET_YES ==
 948       GNUNET_CONTAINER_multipeermap_contains (friends_peermap,
 949                                               peer_identity))
 950   {
 951     GNUNET_break (0);
 952     return;
 953   }
 954
 955   friend = GNUNET_new (struct FriendInfo);
 956   friend->id = *peer_identity;
 957   friend->mq = GNUNET_CORE_mq_create (core_api,
 958                                       peer_identity);
 959   GNUNET_assert (GNUNET_OK ==
 960                  GNUNET_CONTAINER_multipeermap_put (friends_peermap,
 961                                                     peer_identity,
 962                                                     friend,
 963                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 964   if (NULL == random_walk_task)
 965   {
 966     /* random walk needs to be started -- we have a first connection */
 967     random_walk_task = GNUNET_SCHEDULER_add_now (&do_random_walk,
 968                                                  NULL);
 969   }
 970 }
 971
 972
 973 /**
 974  * To be called on core init/fail.
 975  *
 976  * @param cls service closure
 977  * @param identity the public identity of this peer
 978  */
 979 static void
 980 core_init (void *cls,
 981            const struct GNUNET_PeerIdentity *identity)
 982 {
 983   my_identity = *identity;
 984 }
 985
 986
 987 /**
 988  * Handle a `struct RandomWalkMessage` from a
 989  * #GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK message.
 990  *
 991  * @param cls closure (NULL)
 992  * @param peer sender identity
 993  * @param message the setup message
 994  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
 995  */
 996 static int
 997 handle_dht_p2p_random_walk (void *cls,
 998                             const struct GNUNET_PeerIdentity *peer,
 999                             const struct GNUNET_MessageHeader *message)
1000 {
1001   const struct RandomWalkMessage *m;
1002   struct Trail *t;
1003   struct FriendInfo *pred;
1004
1005   m = (const struct RandomWalkMessage *) message;
1006   pred = GNUNET_CONTAINER_multipeermap_get (friends_peermap,
1007                                             peer);
1008   t = GNUNET_new (struct Trail);
1009   t->pred_id = m->trail_id;
1010   t->pred = pred;
1011   if (GNUNET_OK !=
1012       GNUNET_CONTAINER_multihashmap_put (trail_map,
1013                                          &t->pred_id,
1014                                          t,
1015                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
1016   {
1017     GNUNET_break_op (0);
1018     GNUNET_free (t);
1019     return GNUNET_SYSERR;
1020   }
1021   GNUNET_CONTAINER_MDLL_insert (pred,
1022                                 pred->pred_head,
1023                                 pred->pred_tail,
1024                                 t);
1025   t->expiration_time = GNUNET_TIME_relative_to_absolute (TRAIL_TIMEOUT);
1026   t->hn = GNUNET_CONTAINER_heap_insert (trail_heap,
1027                                         t,
1028                                         t->expiration_time.abs_value_us);
1029   if (NULL == trail_timeout_task)
1030     trail_timeout_task = GNUNET_SCHEDULER_add_delayed (TRAIL_TIMEOUT,
1031                                                        &trail_timeout_callback,
1032                                                        NULL);
1033
1034   if (ntohl (m->hops_taken) > GDS_NSE_get ())
1035   {
1036     /* We are the last hop, generate response */
1037     struct GNUNET_MQ_Envelope *env;
1038     struct RandomWalkResponseMessage *rwrm;
1039     uint16_t layer;
1040
1041     env = GNUNET_MQ_msg (rwrm,
1042                          GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK_RESPONSE);
1043     rwrm->reserved = htonl (0);
1044     rwrm->trail_id = m->trail_id;
1045     layer = ntohs (m->layer);
1046     if (0 == layer)
1047       (void) GDS_DATACACHE_get_random_key (&rwrm->location);
1048     else
1049     {
1050       struct FingerTable *ft;
1051
1052       if (layer > NUMBER_LAYERED_ID)
1053       {
1054         GNUNET_break_op (0);
1055         // FIXME: clean up 't'...
1056         return GNUNET_SYSERR;
1057       }
1058       ft = &fingers[layer-1];
1059       if (0 == ft->number_valid_fingers)
1060       {
1061         GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_NONCE,
1062                                           &rwrm->location);
1063       }
1064       else
1065       {
1066         struct Finger *f;
1067
1068         f = ft->fingers[GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
1069                                                   ft->number_valid_fingers)];
1070         rwrm->location = f->destination;
1071       }
1072     }
1073     GNUNET_MQ_send (pred->mq,
1074                     env);
1075   }
1076   else
1077   {
1078     struct GNUNET_MQ_Envelope *env;
1079     struct RandomWalkMessage *rwm;
1080     struct FriendInfo *succ;
1081
1082     /* extend the trail by another random hop */
1083     succ = pick_random_friend ();
1084     GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_NONCE,
1085                                       &t->succ_id);
1086     t->succ = succ;
1087     if (GNUNET_OK !=
1088         GNUNET_CONTAINER_multihashmap_put (trail_map,
1089                                            &t->succ_id,
1090                                            t,
1091                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
1092     {
1093       GNUNET_break (0);
1094       GNUNET_CONTAINER_MDLL_remove (pred,
1095                                     pred->pred_head,
1096                                     pred->pred_tail,
1097                                     t);
1098       GNUNET_free (t);
1099       return GNUNET_OK;
1100     }
1101     GNUNET_CONTAINER_MDLL_insert (succ,
1102                                   succ->succ_head,
1103                                   succ->succ_tail,
1104                                   t);
1105     env = GNUNET_MQ_msg (rwm,
1106                          GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK);
1107     rwm->hops_taken = htons (1 + ntohs (m->hops_taken));
1108     rwm->layer = m->layer;
1109     rwm->trail_id = t->succ_id;
1110     GNUNET_MQ_send (succ->mq,
1111                     env);
1112   }
1113   return GNUNET_OK;
1114 }
1115
1116
1117 /**
1118  * Handle a `struct RandomWalkResponseMessage` from a GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK_RESPONSE
1119  * message.
1120  *
1121  * @param cls closure (NULL)
1122  * @param peer sender identity
1123  * @param message the setup response message
1124  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
1125  */
1126 static int
1127 handle_dht_p2p_random_walk_response (void *cls,
1128                                      const struct GNUNET_PeerIdentity *peer,
1129                                      const struct GNUNET_MessageHeader *message)
1130 {
1131   const struct RandomWalkResponseMessage *rwrm;
1132
1133   rwrm = (const struct RandomWalkResponseMessage *) message;
1134   // 1) lookup trail => find Finger entry => fill in 'destination' and mark valid, move to end of sorted array, mark unsorted, update links from 'trails'
1135   /*
1136    * Steps :
1137    *  1 check if we are the correct layer
1138    *  1.a if true : add the returned value (finger) in the db structure
1139    *  1.b if true : do nothing
1140    */
1141   /* FIXME: add the value in db structure 1.a */
1142
1143   return GNUNET_OK;
1144 }
1145
1146
1147 /**
1148  * Handle a `struct TrailDestroyMessage`.
1149  *
1150  * @param cls closure (NULL)
1151  * @param peer sender identity
1152  * @param message the finger destroy message
1153  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
1154  */
1155 static int
1156 handle_dht_p2p_trail_destroy (void *cls,
1157                              const struct GNUNET_PeerIdentity *peer,
1158                              const struct GNUNET_MessageHeader *message)
1159 {
1160   const struct TrailDestroyMessage *tdm;
1161   struct Trail *trail;
1162
1163   tdm = (const struct TrailDestroyMessage *) message;
1164   trail = GNUNET_CONTAINER_multihashmap_get (trail_map,
1165                                              &tdm->trail_id);
1166   delete_trail (trail,
1167                 ( (NULL != trail->succ) &&
1168                   (0 == memcmp (peer,
1169                                 &trail->succ->id,
1170                                 sizeof (struct GNUNET_PeerIdentity))) ),
1171                 ( (NULL != trail->pred) &&
1172                   (0 == memcmp (peer,
1173                                 &trail->pred->id,
1174                                 sizeof (struct GNUNET_PeerIdentity))) ));
1175   return GNUNET_OK;
1176 }
1177
1178
1179 /**
1180  * Handle a `struct FindSuccessorMessage` from a #GNUNET_MESSAGE_TYPE_WDHT_SUCCESSOR_FIND
1181  * message.
1182  *
1183  * @param cls closure (NULL)
1184  * @param trail_id path to the originator
1185  * @param message the finger setup message
1186  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
1187  */
1188 static int
1189 handle_dht_p2p_successor_find (void *cls,
1190                                const struct GNUNET_HashCode *trail_id,
1191                                const struct GNUNET_MessageHeader *message)
1192 {
1193   const struct FindSuccessorMessage *fsm;
1194
1195   fsm = (const struct FindSuccessorMessage *) message;
1196   // locate trail (for sending reply), if not exists, fail nicely.
1197   // otherwise, go to datacache and return 'top k' elements closest to 'key'
1198   // as "PUT" messages via the trail (need to extend DB API!)
1199 #if 0
1200   GDS_DATACACHE_get_successors (trail_id,
1201                                 key);
1202 #endif
1203   return GNUNET_OK;
1204 }
1205
1206
1207 /**
1208  * Handle a `struct PeerGetMessage`.
1209  *
1210  * @param cls closure (NULL)
1211  * @param trail_id path to the originator
1212  * @param message the peer get message
1213  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
1214  */
1215 static int
1216 handle_dht_p2p_peer_get (void *cls,
1217                          const struct GNUNET_HashCode *trail_id,
1218                          const struct GNUNET_MessageHeader *message)
1219 {
1220   const struct PeerGetMessage *pgm;
1221
1222   // FIXME: note: never called like this, message embedded with trail route!
1223   pgm = (const struct PeerGetMessage *) message;
1224   // -> lookup in datacache (figure out way to remember trail!)
1225      /*
1226     * steps :
1227     *   1 extract the result
1228     *   2 save the peer
1229     *   3 send it using the good trail
1230     *
1231     * What do i do when i don't have the key/value?
1232     */
1233
1234   return GNUNET_OK;
1235 }
1236
1237
1238 /**
1239  * Handle a `struct PeerGetResultMessage`.
1240  *
1241  * @param cls closure (NULL)
1242  * @param trail_id path to the originator
1243  * @param message the peer get result message
1244  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
1245  */
1246 static int
1247 handle_dht_p2p_peer_get_result (void *cls,
1248                                 const struct GNUNET_HashCode *trail_id,
1249                                 const struct GNUNET_MessageHeader *message)
1250 {
1251   const struct PeerGetResultMessage *pgrm;
1252
1253   pgrm = (const struct PeerGetResultMessage *) message;
1254   // pretty much: parse, & pass to client (there is some call for that...)
1255
1256 #if 0
1257   GDS_CLIENTS_process_get (options,
1258                            type,
1259                            0, 0,
1260                            path_length, path,
1261                            key);
1262   (void) GDS_DATACACHE_handle_get (trail_id,
1263                                    key,
1264                                    type,
1265                                    xquery,
1266                                    xquery_size,
1267                                    &reply_bf,
1268                                    reply_bf_mutator);
1269 #endif
1270   return GNUNET_OK;
1271 }
1272
1273
1274 /**
1275  * Handle a `struct PeerPutMessage`.
1276  *
1277  * @param cls closure (NULL)
1278  * @param trail_id path to the originator
1279  * @param message the peer put message
1280  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
1281  */
1282 static int
1283 handle_dht_p2p_peer_put (void *cls,
1284                          const struct GNUNET_HashCode *trail_id,
1285                          const struct GNUNET_MessageHeader *message)
1286 {
1287   const struct PeerGetResultMessage *pgrm;
1288
1289   pgrm = (const struct PeerGetResultMessage *) message;
1290   // parse & store in datacache, this is in response to us asking for successors.
1291   /*
1292    * steps :
1293    * 1 check the size of the message
1294    * 2 use the API to add the value in the "database". Check on the xdht file, how to do it.
1295    * 3 Did i a have to return a notification or did i have to return GNUNET_[OK|SYSERR]?
1296    */
1297 #if 0
1298   GDS_DATACACHE_handle_put (expiration_time,
1299                             key,
1300                             path_length, path,
1301                             block_type,
1302                             data_size,
1303                             data);
1304   GDS_CLIENTS_process_put (options,
1305                            block_type,
1306                            0, 0,
1307                            path_length, path,
1308                            expiration_time,
1309                            key,
1310                            data,
1311                            data_size);
1312 #endif
1313   return GNUNET_OK;
1314 }
1315
1316
1317
1318
1319 /**
1320  * Handler for a message we received along some trail.
1321  *
1322  * @param cls closure
1323  * @param trail_id trail identifier
1324  * @param message the message we got
1325  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
1326  */
1327 typedef int
1328 (*TrailHandlerCallback)(void *cls,
1329                         const struct GNUNET_HashCode *trail_id,
1330                         const struct GNUNET_MessageHeader *message);
1331
1332
1333 /**
1334  * Definition of a handler for a message received along some trail.
1335  */
1336 struct TrailHandler
1337 {
1338   /**
1339    * NULL for end-of-list.
1340    */
1341   TrailHandlerCallback callback;
1342
1343   /**
1344    * Closure for @e callback.
1345    */
1346   void *cls;
1347
1348   /**
1349    * Message type this handler addresses.
1350    */
1351   uint16_t message_type;
1352
1353   /**
1354    * Use 0 for variable-size.
1355    */
1356   uint16_t message_size;
1357 };
1358
1359
1360 /**
1361  * Blah.
1362  */
1363 static void
1364 forward_message_on_trail (struct FriendInfo *next_target,
1365                           const struct GNUNET_HashCode *trail_id,
1366                           int have_path,
1367                           const struct GNUNET_PeerIdentity *predecessor,
1368                           const struct GNUNET_PeerIdentity *path,
1369                           uint16_t path_length,
1370                           const struct GNUNET_MessageHeader *payload)
1371 {
1372   struct GNUNET_MQ_Envelope *env;
1373   struct TrailRouteMessage *trm;
1374   struct GNUNET_PeerIdentity *new_path;
1375   unsigned int plen;
1376   uint16_t payload_len;
1377
1378   payload_len = ntohs (payload->size);
1379   if (have_path)
1380   {
1381     plen = path_length + 1;
1382     if (plen >= (GNUNET_SERVER_MAX_MESSAGE_SIZE
1383                  - payload_len
1384                  - sizeof (struct TrailRouteMessage))
1385         / sizeof (struct GNUNET_PeerIdentity))
1386     {
1387       /* Should really not have paths this long... */
1388       GNUNET_break_op (0);
1389       plen = 0;
1390       have_path = 0;
1391     }
1392   }
1393   else
1394   {
1395     GNUNET_break_op (0 == path_length);
1396     path_length = 0;
1397     plen = 0;
1398   }
1399   env = GNUNET_MQ_msg_extra (trm,
1400                              payload_len +
1401                              plen * sizeof (struct GNUNET_PeerIdentity),
1402                              GNUNET_MESSAGE_TYPE_WDHT_TRAIL_ROUTE);
1403   trm->record_path = htons (have_path);
1404   trm->path_length = htons (plen);
1405   trm->trail_id = *trail_id;
1406   new_path = (struct GNUNET_PeerIdentity *) &trm[1];
1407   if (have_path)
1408   {
1409     memcpy (new_path,
1410             path,
1411             path_length * sizeof (struct GNUNET_PeerIdentity));
1412     new_path[path_length] = *predecessor;
1413   }
1414   memcpy (&new_path[plen],
1415           payload,
1416           payload_len);
1417   GNUNET_MQ_send (next_target->mq,
1418                   env);
1419 }
1420
1421
1422 /**
1423  * Handle a `struct TrailRouteMessage`.
1424  *
1425  * @param cls closure (NULL)
1426  * @param peer sender identity
1427  * @param message the finger destroy message
1428  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
1429  */
1430 static int
1431 handle_dht_p2p_trail_route (void *cls,
1432                             const struct GNUNET_PeerIdentity *peer,
1433                             const struct GNUNET_MessageHeader *message)
1434 {
1435   static const struct TrailHandler handlers[] = {
1436     { &handle_dht_p2p_successor_find, NULL,
1437       GNUNET_MESSAGE_TYPE_WDHT_SUCCESSOR_FIND,
1438       sizeof (struct FindSuccessorMessage) },
1439     { NULL, NULL, 0, 0 }
1440   };
1441   unsigned int i;
1442   const struct TrailRouteMessage *trm;
1443   const struct GNUNET_PeerIdentity *path;
1444   uint16_t path_length;
1445   const struct GNUNET_MessageHeader *payload;
1446   const struct TrailHandler *th;
1447   struct Trail *trail;
1448   size_t msize;
1449
1450   /* Parse and check message is well-formed */
1451   msize = ntohs (message->size);
1452   if (msize < sizeof (struct TrailRouteMessage))
1453   {
1454     GNUNET_break_op (0);
1455     return GNUNET_YES;
1456   }
1457   trm = (const struct TrailRouteMessage *) message;
1458   path_length = ntohs (trm->path_length);
1459   if (msize < sizeof (struct TrailRouteMessage) +
1460       path_length * sizeof (struct GNUNET_PeerIdentity) +
1461       sizeof (struct GNUNET_MessageHeader) )
1462   {
1463     GNUNET_break_op (0);
1464     return GNUNET_YES;
1465   }
1466   path = (const struct GNUNET_PeerIdentity *) &trm[1];
1467   payload = (const struct GNUNET_MessageHeader *) &path[path_length];
1468   if (msize != (ntohs (payload->size) +
1469                 sizeof (struct TrailRouteMessage) +
1470                 path_length * sizeof (struct GNUNET_PeerIdentity)))
1471   {
1472     GNUNET_break_op (0);
1473     return GNUNET_YES;
1474   }
1475
1476   /* Is this message for us? */
1477   trail = GNUNET_CONTAINER_multihashmap_get (trail_map,
1478                                              &trm->trail_id);
1479   if ( (NULL != trail->pred) &&
1480        (0 == memcmp (peer,
1481                      &trail->pred->id,
1482                      sizeof (struct GNUNET_PeerIdentity))) )
1483   {
1484     /* forward to 'successor' */
1485     if (NULL != trail->succ)
1486     {
1487       forward_message_on_trail (trail->succ,
1488                                 &trail->succ_id,
1489                                 ntohs (trm->record_path),
1490                                 peer,
1491                                 path,
1492                                 path_length,
1493                                 payload);
1494       return GNUNET_OK;
1495     }
1496   }
1497   else
1498   {
1499     /* forward to 'predecessor' */
1500     GNUNET_break_op ( (NULL != trail->succ) &&
1501                       (0 == memcmp (peer,
1502                                     &trail->succ->id,
1503                                     sizeof (struct GNUNET_PeerIdentity))) );
1504     if (NULL != trail->pred)
1505     {
1506       forward_message_on_trail (trail->pred,
1507                                 &trail->pred_id,
1508                                 ntohs (trm->record_path),
1509                                 peer,
1510                                 path,
1511                                 path_length,
1512                                 payload);
1513       return GNUNET_OK;
1514     }
1515   }
1516
1517   /* Message is for us, dispatch to handler */
1518   th = NULL;
1519   for (i=0; NULL != handlers[i].callback; i++)
1520   {
1521     th = &handlers[i];
1522     if (ntohs (payload->type) == th->message_type)
1523     {
1524       if ( (0 == th->message_size) ||
1525            (ntohs (payload->size) == th->message_size) )
1526         th->callback (th->cls,
1527                       &trm->trail_id,
1528                       payload);
1529       else
1530         GNUNET_break_op (0);
1531       break;
1532     }
1533   }
1534   GNUNET_break_op (NULL != th);
1535   return GNUNET_OK;
1536 }
1537
1538
1539 /**
1540  * Initialize neighbours subsystem.
1541  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
1542  */
1543 int
1544 GDS_NEIGHBOURS_init (void)
1545 {
1546   static const struct GNUNET_CORE_MessageHandler core_handlers[] = {
1547     { &handle_dht_p2p_random_walk,
1548       GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK,
1549       sizeof (struct RandomWalkMessage) },
1550     { &handle_dht_p2p_random_walk_response,
1551       GNUNET_MESSAGE_TYPE_WDHT_RANDOM_WALK_RESPONSE,
1552       sizeof (struct RandomWalkResponseMessage) },
1553     { &handle_dht_p2p_trail_destroy,
1554       GNUNET_MESSAGE_TYPE_WDHT_TRAIL_DESTROY,
1555       sizeof (struct TrailDestroyMessage) },
1556     { &handle_dht_p2p_trail_route,
1557       GNUNET_MESSAGE_TYPE_WDHT_TRAIL_ROUTE,
1558       0},
1559     {NULL, 0, 0}
1560   };
1561
1562   core_api =
1563     GNUNET_CORE_connect (GDS_cfg, NULL,
1564                          &core_init,
1565                          &handle_core_connect,
1566                          &handle_core_disconnect,
1567                          NULL, GNUNET_NO,
1568                          NULL, GNUNET_NO,
1569                          core_handlers);
1570
1571   if (NULL == core_api)
1572     return GNUNET_SYSERR;
1573   friends_peermap = GNUNET_CONTAINER_multipeermap_create (256, GNUNET_NO);
1574   trail_map = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_YES);
1575   trail_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
1576   return GNUNET_OK;
1577 }
1578
1579
1580 /**
1581  * Shutdown neighbours subsystem.
1582  */
1583 void
1584 GDS_NEIGHBOURS_done (void)
1585 {
1586   if (NULL == core_api)
1587     return;
1588   GNUNET_CORE_disconnect (core_api);
1589   core_api = NULL;
1590   GNUNET_assert (0 == GNUNET_CONTAINER_multipeermap_size (friends_peermap));
1591   GNUNET_CONTAINER_multipeermap_destroy (friends_peermap);
1592   friends_peermap = NULL;
1593   GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (trail_map));
1594   GNUNET_CONTAINER_multihashmap_destroy (trail_map);
1595   trail_map = NULL;
1596   GNUNET_CONTAINER_heap_destroy (trail_heap);
1597   trail_heap = NULL;
1598   if (NULL != trail_timeout_task)
1599   {
1600     GNUNET_SCHEDULER_cancel (trail_timeout_task);
1601     trail_timeout_task = NULL;
1602   }
1603 }
1604
1605
1606 /**
1607  * Get my identity
1608  *
1609  * @return my identity
1610  */
1611 struct GNUNET_PeerIdentity
1612 GDS_NEIGHBOURS_get_my_id (void)
1613 {
1614   return my_identity;
1615 }
1616
1617 /* end of gnunet-service-wdht_neighbours.c */