src/dv/gnunet-service-dv.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009 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 dv/gnunet-service-dv.c
  23  * @brief the distance vector service, primarily handles gossip of nearby
  24  * peers and sending/receiving DV messages from core and decapsulating
  25  * them
  26  *
  27  * @author Christian Grothoff
  28  * @author Nathan Evans
  29  *
  30  * TODO: The gossip rates need to be worked out.  Probably many other things
  31  * as well.
  32  *
  33  */
  34 #include "platform.h"
  35 #include "gnunet_client_lib.h"
  36 #include "gnunet_getopt_lib.h"
  37 #include "gnunet_os_lib.h"
  38 #include "gnunet_protocols.h"
  39 #include "gnunet_service_lib.h"
  40 #include "gnunet_core_service.h"
  41 #include "gnunet_signal_lib.h"
  42 #include "gnunet_util_lib.h"
  43 #include "gnunet_hello_lib.h"
  44 #include "gnunet_peerinfo_service.h"
  45 #include "gnunet_crypto_lib.h"
  46 #include "gnunet_statistics_service.h"
  47 #include "dv.h"
  48
  49 /**
  50  * For testing mostly, remember only the
  51  * shortest path to a distant neighbor.
  52  */
  53 #define AT_MOST_ONE GNUNET_NO
  54
  55 #define USE_PEER_ID GNUNET_YES
  56
  57 /**
  58  * How many outstanding messages (unknown sender) will we allow per peer?
  59  */
  60 #define MAX_OUTSTANDING_MESSAGES 5
  61
  62 /**
  63  * How often do we check about sending out more peer information (if
  64  * we are connected to no peers previously).
  65  */
  66 #define GNUNET_DV_DEFAULT_SEND_INTERVAL GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 500000)
  67
  68 /**
  69  * How long do we wait at most between sending out information?
  70  */
  71 #define GNUNET_DV_MAX_SEND_INTERVAL GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 500000)
  72
  73 /**
  74  * How long can we have not heard from a peer and
  75  * still have it in our tables?
  76  */
  77 #define GNUNET_DV_PEER_EXPIRATION_TIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1000))
  78
  79 /**
  80  * Priority for gossip.
  81  */
  82 #define GNUNET_DV_DHT_GOSSIP_PRIORITY (GNUNET_EXTREME_PRIORITY / 10)
  83
  84 /**
  85  * How often should we check if expiration time has elapsed for
  86  * some peer?
  87  */
  88 #define GNUNET_DV_MAINTAIN_FREQUENCY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5))
  89
  90 /**
  91  * How long to allow a message to be delayed?
  92  */
  93 #define DV_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5))
  94
  95 /**
  96  * Priority to use for DV data messages.
  97  */
  98 #define DV_PRIORITY 0
  99
 100 /**
 101  * The cost to a direct neighbor.  We used to use 0, but 1 makes more sense.
 102  */
 103 #define DIRECT_NEIGHBOR_COST 1
 104
 105 /**
 106  * The default number of direct connections to store in DV (max)
 107  */
 108 #define DEFAULT_DIRECT_CONNECTIONS 50
 109
 110 /**
 111  * The default size of direct + extended peers in DV (max)
 112  */
 113 #define DEFAULT_DV_SIZE 100
 114
 115 /**
 116  * The default fisheye depth, from how many hops away will
 117  * we keep peers?
 118  */
 119 #define DEFAULT_FISHEYE_DEPTH 4
 120
 121 /**
 122  * Linked list of messages to send to clients.
 123  */
 124 struct PendingMessage
 125 {
 126   /**
 127    * Pointer to next item in the list
 128    */
 129   struct PendingMessage *next;
 130
 131   /**
 132    * Pointer to previous item in the list
 133    */
 134   struct PendingMessage *prev;
 135
 136   /**
 137    * The PeerIdentity to send to
 138    */
 139   struct GNUNET_PeerIdentity recipient;
 140
 141   /**
 142    * The result of message sending.
 143    */
 144   struct GNUNET_DV_SendResultMessage *send_result;
 145
 146   /**
 147    * Message importance level.
 148    */
 149   unsigned int importance;
 150
 151   /**
 152    * Size of message.
 153    */
 154   unsigned int msg_size;
 155
 156   /**
 157    * How long to wait before sending message.
 158    */
 159   struct GNUNET_TIME_Relative timeout;
 160
 161   /**
 162    * Actual message to be sent; // avoid allocation
 163    */
 164   const struct GNUNET_MessageHeader *msg; // msg = (cast) &pm[1]; // memcpy (&pm[1], data, len);
 165
 166 };
 167
 168 struct FastGossipNeighborList
 169 {
 170   /**
 171    * Next element of DLL
 172    */
 173   struct FastGossipNeighborList *next;
 174
 175   /**
 176    * Prev element of DLL
 177    */
 178   struct FastGossipNeighborList *prev;
 179
 180   /**
 181    * The neighbor to gossip about
 182    */
 183   struct DistantNeighbor *about;
 184 };
 185
 186 /**
 187  * Context created whenever a direct peer connects to us,
 188  * used to gossip other peers to it.
 189  */
 190 struct NeighborSendContext
 191 {
 192   /**
 193    * The peer we will gossip to.
 194    */
 195   struct DirectNeighbor *toNeighbor;
 196
 197   /**
 198    * The task associated with this context.
 199    */
 200   GNUNET_SCHEDULER_TaskIdentifier task;
 201
 202   /**
 203    * Head of DLL of peers to gossip about
 204    * as fast as possible to this peer, for initial
 205    * set up.
 206    */
 207   struct FastGossipNeighborList *fast_gossip_list_head;
 208
 209   /**
 210    * Tail of DLL of peers to gossip about
 211    * as fast as possible to this peer, for initial
 212    * set up.
 213    */
 214   struct FastGossipNeighborList *fast_gossip_list_tail;
 215
 216 };
 217
 218
 219 /**
 220  * Struct to hold information for updating existing neighbors
 221  */
 222 struct NeighborUpdateInfo
 223 {
 224   /**
 225    * Cost
 226    */
 227   unsigned int cost;
 228
 229   /**
 230    * The existing neighbor
 231    */
 232   struct DistantNeighbor *neighbor;
 233
 234   /**
 235    * The referrer of the possibly existing peer
 236    */
 237   struct DirectNeighbor *referrer;
 238
 239   /**
 240    * The time we heard about this peer
 241    */
 242   struct GNUNET_TIME_Absolute now;
 243
 244   /**
 245    * Peer id this peer uses to refer to neighbor.
 246    */
 247   unsigned int referrer_peer_id;
 248
 249 };
 250
 251 /**
 252  * Struct to store a single message received with
 253  * an unknown sender.
 254  */
 255 struct UnknownSenderMessage
 256 {
 257   /**
 258    * Message sender (immediate)
 259    */
 260   struct GNUNET_PeerIdentity sender;
 261
 262   /**
 263    * The actual message received
 264    */
 265   struct GNUNET_MessageHeader *message;
 266
 267   /**
 268    * Latency of connection
 269    */
 270   struct GNUNET_TIME_Relative latency;
 271
 272   /**
 273    * Distance to destination
 274    */
 275   uint32_t distance;
 276
 277   /**
 278    * Unknown sender id
 279    */
 280   uint32_t sender_id;
 281 };
 282
 283 /**
 284  * Struct where actual neighbor information is stored,
 285  * referenced by min_heap and max_heap.  Freeing dealt
 286  * with when items removed from hashmap.
 287  */
 288 struct DirectNeighbor
 289 {
 290   /**
 291    * Identity of neighbor.
 292    */
 293   struct GNUNET_PeerIdentity identity;
 294
 295   /**
 296    * PublicKey of neighbor.
 297    */
 298   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
 299
 300   /**
 301    * Head of DLL of nodes that this direct neighbor referred to us.
 302    */
 303   struct DistantNeighbor *referee_head;
 304
 305   /**
 306    * Tail of DLL of nodes that this direct neighbor referred to us.
 307    */
 308   struct DistantNeighbor *referee_tail;
 309
 310   /**
 311    * The sending context for gossiping peers to this neighbor.
 312    */
 313   struct NeighborSendContext *send_context;
 314
 315   /**
 316    * Is this one of the direct neighbors that we are "hiding"
 317    * from DV?
 318    */
 319   int hidden;
 320
 321   /**
 322    * Save messages immediately from this direct neighbor from a
 323    * distan peer we don't know on the chance that it will be
 324    * gossiped about and we can deliver the message.
 325    */
 326   struct UnknownSenderMessage pending_messages[MAX_OUTSTANDING_MESSAGES];
 327 };
 328
 329
 330 /**
 331  * Struct where actual neighbor information is stored,
 332  * referenced by min_heap and max_heap.  Freeing dealt
 333  * with when items removed from hashmap.
 334  */
 335 struct DistantNeighbor
 336 {
 337   /**
 338    * We keep distant neighbor's of the same referrer in a DLL.
 339    */
 340   struct DistantNeighbor *next;
 341
 342   /**
 343    * We keep distant neighbor's of the same referrer in a DLL.
 344    */
 345   struct DistantNeighbor *prev;
 346
 347   /**
 348    * Node in min heap
 349    */
 350   struct GNUNET_CONTAINER_HeapNode *min_loc;
 351
 352   /**
 353    * Node in max heap
 354    */
 355   struct GNUNET_CONTAINER_HeapNode *max_loc;
 356
 357   /**
 358    * Identity of referrer (next hop towards 'neighbor').
 359    */
 360   struct DirectNeighbor *referrer;
 361
 362   /**
 363    * Identity of neighbor.
 364    */
 365   struct GNUNET_PeerIdentity identity;
 366
 367   /**
 368    * PublicKey of neighbor.
 369    */
 370   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pkey;
 371
 372   /**
 373    * Last time we received routing information from this peer
 374    */
 375   struct GNUNET_TIME_Absolute last_activity;
 376
 377   /**
 378    * Last time we sent routing information about this peer
 379    */
 380   struct GNUNET_TIME_Absolute last_gossip;
 381
 382   /**
 383    * Cost to neighbor, used for actual distance vector computations
 384    */
 385   unsigned int cost;
 386
 387   /**
 388    * Random identifier *we* use for this peer, to be used as shortcut
 389    * instead of sending full peer id for each message
 390    */
 391   unsigned int our_id;
 392
 393   /**
 394    * Random identifier the *referrer* uses for this peer.
 395    */
 396   unsigned int referrer_id;
 397
 398   /**
 399    * Is this one of the direct neighbors that we are "hiding"
 400    * from DV?
 401    */
 402   int hidden;
 403
 404 };
 405
 406 struct PeerIteratorContext
 407 {
 408   /**
 409    * The actual context, to be freed later.
 410    */
 411   struct GNUNET_PEERINFO_IteratorContext *ic;
 412
 413   /**
 414    * The neighbor about which we are concerned.
 415    */
 416   struct DirectNeighbor *neighbor;
 417
 418   /**
 419    * The distant neighbor entry for this direct neighbor.
 420    */
 421   struct DistantNeighbor *distant;
 422
 423 };
 424
 425 /**
 426  * Context used for creating hello messages when
 427  * gossips are received.
 428  */
 429 struct HelloContext
 430 {
 431   /**
 432    * Identity of distant neighbor.
 433    */
 434   struct GNUNET_PeerIdentity distant_peer;
 435
 436   /**
 437    * Identity of direct neighbor, via which we send this message.
 438    */
 439   const struct GNUNET_PeerIdentity *direct_peer;
 440
 441   /**
 442    * How many addresses do we need to add (always starts at 1, then set to 0)
 443    */
 444   int addresses_to_add;
 445
 446 };
 447
 448 struct DV_SendContext
 449 {
 450   /**
 451    * The distant peer (should always match)
 452    */
 453   struct GNUNET_PeerIdentity *distant_peer;
 454
 455   /**
 456    * The direct peer, we need to verify the referrer of.
 457    */
 458   struct GNUNET_PeerIdentity *direct_peer;
 459
 460   /**
 461    * The message to be sent
 462    */
 463   struct GNUNET_MessageHeader *message;
 464
 465   /**
 466    * The pre-built send result message.  Simply needs to be queued
 467    * and freed once send has been called!
 468    */
 469   struct GNUNET_DV_SendResultMessage *send_result;
 470
 471   /**
 472    * The size of the message being sent, may be larger
 473    * than message->header.size because it's multiple
 474    * messages packed into one!
 475    */
 476   size_t message_size;
 477
 478   /**
 479    * How important is this message?
 480    */
 481   unsigned int importance;
 482
 483   /**
 484    * Timeout for this message
 485    */
 486   struct GNUNET_TIME_Relative timeout;
 487
 488   /**
 489    * Unique ID for DV message
 490    */
 491   unsigned int uid;
 492 };
 493
 494 struct FindDestinationContext
 495 {
 496   unsigned int tid;
 497   struct DistantNeighbor *dest;
 498 };
 499
 500 struct FindIDContext
 501 {
 502   unsigned int tid;
 503   struct GNUNET_PeerIdentity *dest;
 504   const struct GNUNET_PeerIdentity *via;
 505 };
 506
 507 struct DisconnectContext
 508 {
 509   /**
 510    * Distant neighbor to get pid from.
 511    */
 512   struct DistantNeighbor *distant;
 513
 514   /**
 515    * Direct neighbor that disconnected.
 516    */
 517   struct DirectNeighbor *direct;
 518 };
 519
 520 struct TokenizedMessageContext
 521 {
 522   /**
 523    * Immediate sender of this message
 524    */
 525   const struct GNUNET_PeerIdentity *peer;
 526
 527   /**
 528    * Distant sender of the message
 529    */
 530   struct DistantNeighbor *distant;
 531
 532   /**
 533    * Uid for this set of messages
 534    */
 535   uint32_t uid;
 536 };
 537
 538 /**
 539  * Context for finding the least cost peer to send to.
 540  * Transport selection can only go so far.
 541  */
 542 struct FindLeastCostContext
 543 {
 544   struct DistantNeighbor *target;
 545   unsigned int least_cost;
 546 };
 547
 548 /**
 549  * Handle to the core service api.
 550  */
 551 static struct GNUNET_CORE_Handle *coreAPI;
 552
 553 /**
 554  * Stream tokenizer to handle messages coming in from core.
 555  */
 556 static struct GNUNET_SERVER_MessageStreamTokenizer *coreMST;
 557
 558 /**
 559  * The identity of our peer.
 560  */
 561 static struct GNUNET_PeerIdentity my_identity;
 562
 563 /**
 564  * The configuration for this service.
 565  */
 566 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 567
 568
 569 /**
 570  * The client, the DV plugin connected to us.  Hopefully
 571  * this client will never change, although if the plugin dies
 572  * and returns for some reason it may happen.
 573  */
 574 static struct GNUNET_SERVER_Client * client_handle;
 575
 576 /**
 577  * Task to run when we shut down, cleaning up all our trash
 578  */
 579 static GNUNET_SCHEDULER_TaskIdentifier cleanup_task;
 580
 581 static size_t default_dv_priority = 0;
 582
 583 static char *my_short_id;
 584
 585 /**
 586  * Transmit handle to the plugin.
 587  */
 588 static struct GNUNET_CONNECTION_TransmitHandle * plugin_transmit_handle;
 589
 590 /**
 591  * Head of DLL for client messages
 592  */
 593 static struct PendingMessage *plugin_pending_head;
 594
 595 /**
 596  * Tail of DLL for client messages
 597  */
 598 static struct PendingMessage *plugin_pending_tail;
 599
 600 /**
 601  * Handle to the peerinfo service
 602  */
 603 static struct GNUNET_PEERINFO_Handle *peerinfo_handle;
 604
 605 /**
 606  * Transmit handle to core service.
 607  */
 608 static struct GNUNET_CORE_TransmitHandle * core_transmit_handle;
 609
 610 /**
 611  * Head of DLL for core messages
 612  */
 613 static struct PendingMessage *core_pending_head;
 614
 615 /**
 616  * Tail of DLL for core messages
 617  */
 618 static struct PendingMessage *core_pending_tail;
 619
 620 /**
 621  * Map of PeerIdentifiers to 'struct GNUNET_dv_neighbor*'s for all
 622  * directly connected peers.
 623  */
 624 static struct GNUNET_CONTAINER_MultiHashMap *direct_neighbors;
 625
 626 /**
 627  * Map of PeerIdentifiers to 'struct GNUNET_dv_neighbor*'s for
 628  * peers connected via DV (extended neighborhood).  Does ALSO
 629  * include any peers that are in 'direct_neighbors'; for those
 630  * peers, the cost will be zero and the referrer all zeros.
 631  */
 632 static struct GNUNET_CONTAINER_MultiHashMap *extended_neighbors;
 633
 634 /**
 635  * We use the min heap (min refers to cost) to prefer
 636  * gossipping about peers with small costs.
 637  */
 638 static struct GNUNET_CONTAINER_Heap *neighbor_min_heap;
 639
 640 /**
 641  * We use the max heap (max refers to cost) for general
 642  * iterations over all peers and to remove the most costly
 643  * connection if we have too many.
 644  */
 645 static struct GNUNET_CONTAINER_Heap *neighbor_max_heap;
 646
 647 /**
 648  * Handle for the statistics service.
 649  */
 650 struct GNUNET_STATISTICS_Handle *stats;
 651
 652 /**
 653  * How far out to keep peers we learn about.
 654  */
 655 static unsigned long long fisheye_depth;
 656
 657 /**
 658  * How many peers to store at most.
 659  */
 660 static unsigned long long max_table_size;
 661
 662 /**
 663  * We've been given a target ID based on the random numbers that
 664  * we assigned to our DV-neighborhood.  Find the entry for the
 665  * respective neighbor.
 666  */
 667 static int
 668 find_destination (void *cls,
 669                   struct GNUNET_CONTAINER_HeapNode *node,
 670                   void *element, GNUNET_CONTAINER_HeapCostType cost)
 671 {
 672   struct FindDestinationContext *fdc = cls;
 673   struct DistantNeighbor *dn = element;
 674
 675   if (fdc->tid != dn->our_id)
 676     return GNUNET_YES;
 677   fdc->dest = dn;
 678   return GNUNET_NO;
 679 }
 680
 681
 682 /**
 683  * We've been given a target ID based on the random numbers that
 684  * we assigned to our DV-neighborhood.  Find the entry for the
 685  * respective neighbor.
 686  */
 687 static int
 688 find_specific_id (void *cls,
 689                   const GNUNET_HashCode *key,
 690                   void *value)
 691 {
 692   struct FindIDContext *fdc = cls;
 693   struct DistantNeighbor *dn = value;
 694
 695   if (memcmp(&dn->referrer->identity, fdc->via, sizeof(struct GNUNET_PeerIdentity)) == 0)
 696     {
 697       fdc->tid = dn->referrer_id;
 698       return GNUNET_NO;
 699     }
 700   return GNUNET_YES;
 701 }
 702
 703 /**
 704  * Find a distant peer whose referrer_id matches what we're
 705  * looking for.  For looking up a peer we've gossipped about
 706  * but is now disconnected.  Need to do this because we don't
 707  * want to remove those that may be accessible via a different
 708  * route.
 709  */
 710 static int find_distant_peer (void *cls,
 711                               const GNUNET_HashCode * key,
 712                               void *value)
 713 {
 714   struct FindDestinationContext *fdc = cls;
 715   struct DistantNeighbor *distant = value;
 716
 717   if (fdc->tid == distant->referrer_id)
 718     {
 719       fdc->dest = distant;
 720       return GNUNET_NO;
 721     }
 722   return GNUNET_YES;
 723 }
 724
 725 /**
 726  * Function called to notify a client about the socket
 727  * begin ready to queue more data.  "buf" will be
 728  * NULL and "size" zero if the socket was closed for
 729  * writing in the meantime.
 730  *
 731  * @param cls closure
 732  * @param size number of bytes available in buf
 733  * @param buf where the callee should write the message
 734  * @return number of bytes written to buf
 735  */
 736 size_t transmit_to_plugin (void *cls,
 737                            size_t size, void *buf)
 738 {
 739   char *cbuf = buf;
 740   struct PendingMessage *reply;
 741   size_t off;
 742   size_t msize;
 743
 744   if (buf == NULL)
 745     {
 746       /* client disconnected */
 747 #if DEBUG_DV_MESSAGES
 748       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s: %s buffer was NULL (client disconnect?)\n", my_short_id, "transmit_to_plugin");
 749 #endif
 750       return 0;
 751     }
 752   plugin_transmit_handle = NULL;
 753   off = 0;
 754   while ( (NULL != (reply = plugin_pending_head)) &&
 755           (size >= off + (msize = ntohs (reply->msg->size))))
 756     {
 757       GNUNET_CONTAINER_DLL_remove (plugin_pending_head,
 758                                    plugin_pending_tail,
 759                                    reply);
 760       memcpy (&cbuf[off], reply->msg, msize);
 761       GNUNET_free (reply);
 762       off += msize;
 763     }
 764
 765   if (plugin_pending_head != NULL)
 766     plugin_transmit_handle = GNUNET_SERVER_notify_transmit_ready (client_handle,
 767                                                                   ntohs(plugin_pending_head->msg->size),
 768                                                                   GNUNET_TIME_UNIT_FOREVER_REL,
 769                                                                   &transmit_to_plugin, NULL);
 770
 771   return off;
 772 }
 773
 774 /**
 775  * Send a message to the dv plugin.
 776  *
 777  * @param sender the direct sender of the message
 778  * @param message the message to send to the plugin
 779  *        (may be an encapsulated type)
 780  * @param message_size the size of the message to be sent
 781  * @param distant_neighbor the original sender of the message
 782  * @param cost the cost to the original sender of the message
 783  */
 784 void send_to_plugin(const struct GNUNET_PeerIdentity * sender,
 785                     const struct GNUNET_MessageHeader *message,
 786                     size_t message_size,
 787                     struct GNUNET_PeerIdentity *distant_neighbor,
 788                     size_t cost)
 789 {
 790   struct GNUNET_DV_MessageReceived *received_msg;
 791   struct PendingMessage *pending_message;
 792   char *sender_address;
 793   size_t sender_address_len;
 794   char *packed_msg_start;
 795   int size;
 796
 797 #if DEBUG_DV
 798   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "send_to_plugin called with peer %s as sender\n", GNUNET_i2s(distant_neighbor));
 799 #endif
 800
 801   if (memcmp(sender, distant_neighbor, sizeof(struct GNUNET_PeerIdentity)) != 0)
 802   {
 803     sender_address_len = sizeof(struct GNUNET_PeerIdentity) * 2;
 804     sender_address = GNUNET_malloc(sender_address_len);
 805     memcpy(sender_address, distant_neighbor, sizeof(struct GNUNET_PeerIdentity));
 806     memcpy(&sender_address[sizeof(struct GNUNET_PeerIdentity)], sender, sizeof(struct GNUNET_PeerIdentity));
 807   }
 808   else
 809   {
 810     sender_address_len = sizeof(struct GNUNET_PeerIdentity);
 811     sender_address = GNUNET_malloc(sender_address_len);
 812     memcpy(sender_address, sender, sizeof(struct GNUNET_PeerIdentity));
 813   }
 814
 815   size = sizeof(struct GNUNET_DV_MessageReceived) + sender_address_len + message_size;
 816   received_msg = GNUNET_malloc(size);
 817   received_msg->header.size = htons(size);
 818   received_msg->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_DV_RECEIVE);
 819   received_msg->distance = htonl(cost);
 820   received_msg->msg_len = htonl(message_size);
 821   /* Set the sender in this message to be the original sender! */
 822   memcpy(&received_msg->sender, distant_neighbor, sizeof(struct GNUNET_PeerIdentity));
 823   /* Copy the intermediate sender to the end of the message, this is how the transport identifies this peer */
 824   memcpy(&received_msg[1], sender_address, sender_address_len);
 825   GNUNET_free(sender_address);
 826   /* Copy the actual message after the sender */
 827   packed_msg_start = (char *)&received_msg[1];
 828   packed_msg_start = &packed_msg_start[sender_address_len];
 829   memcpy(packed_msg_start, message, message_size);
 830   pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + size);
 831   pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1];
 832   memcpy(&pending_message[1], received_msg, size);
 833   GNUNET_free(received_msg);
 834
 835   GNUNET_CONTAINER_DLL_insert_after(plugin_pending_head, plugin_pending_tail, plugin_pending_tail, pending_message);
 836
 837   if (client_handle != NULL)
 838     {
 839       if (plugin_transmit_handle == NULL)
 840         {
 841           plugin_transmit_handle = GNUNET_SERVER_notify_transmit_ready (client_handle,
 842                                                                         size, GNUNET_TIME_UNIT_FOREVER_REL,
 843                                                                         &transmit_to_plugin, NULL);
 844         }
 845     }
 846   else
 847     {
 848       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to queue message for plugin, client_handle not yet set (how?)!\n");
 849     }
 850 }
 851
 852 /* Declare here so retry_core_send is aware of it */
 853 size_t core_transmit_notify (void *cls,
 854                              size_t size, void *buf);
 855
 856 /**
 857  *  Try to send another message from our core sending list
 858  */
 859 static void
 860 try_core_send (void *cls,
 861                  const struct GNUNET_SCHEDULER_TaskContext *tc)
 862 {
 863   struct PendingMessage *pending;
 864   pending = core_pending_head;
 865
 866   if (core_transmit_handle != NULL)
 867     return; /* Message send already in progress */
 868
 869   if (pending != NULL)
 870     core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, pending->importance, pending->timeout, &pending->recipient, pending->msg_size, &core_transmit_notify, NULL);
 871 }
 872
 873 /**
 874  * Function called to notify a client about the socket
 875  * being ready to queue more data.  "buf" will be
 876  * NULL and "size" zero if the socket was closed for
 877  * writing in the meantime.
 878  *
 879  * @param cls closure (NULL)
 880  * @param size number of bytes available in buf
 881  * @param buf where the callee should write the message
 882  * @return number of bytes written to buf
 883  */
 884 size_t core_transmit_notify (void *cls,
 885                              size_t size, void *buf)
 886 {
 887   char *cbuf = buf;
 888   struct PendingMessage *pending;
 889   struct PendingMessage *client_reply;
 890   size_t off;
 891   size_t msize;
 892
 893   if (buf == NULL)
 894     {
 895       /* client disconnected */
 896 #if DEBUG_DV
 897       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s': buffer was NULL\n", "DHT");
 898 #endif
 899       return 0;
 900     }
 901
 902   core_transmit_handle = NULL;
 903   off = 0;
 904   pending = core_pending_head;
 905   if ( (pending != NULL) &&
 906           (size >= (msize = ntohs (pending->msg->size))))
 907     {
 908 #if DEBUG_DV
 909       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "`%s' : transmit_notify (core) called with size %d\n", "dv service", msize);
 910 #endif
 911       GNUNET_CONTAINER_DLL_remove (core_pending_head,
 912                                    core_pending_tail,
 913                                    pending);
 914       if (pending->send_result != NULL) /* Will only be non-null if a real client asked for this send */
 915         {
 916           client_reply = GNUNET_malloc(sizeof(struct PendingMessage) + sizeof(struct GNUNET_DV_SendResultMessage));
 917           client_reply->msg = (struct GNUNET_MessageHeader *)&client_reply[1];
 918           memcpy(&client_reply[1], pending->send_result, sizeof(struct GNUNET_DV_SendResultMessage));
 919           GNUNET_free(pending->send_result);
 920
 921           GNUNET_CONTAINER_DLL_insert_after(plugin_pending_head, plugin_pending_tail, plugin_pending_tail, client_reply);
 922           if (client_handle != NULL)
 923             {
 924               if (plugin_transmit_handle == NULL)
 925                 {
 926                   plugin_transmit_handle = GNUNET_SERVER_notify_transmit_ready (client_handle,
 927                                                                                 sizeof(struct GNUNET_DV_SendResultMessage),
 928                                                                                 GNUNET_TIME_UNIT_FOREVER_REL,
 929                                                                                 &transmit_to_plugin, NULL);
 930                 }
 931               else
 932                 {
 933                   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to queue message for plugin, must be one in progress already!!\n");
 934                 }
 935             }
 936         }
 937       memcpy (&cbuf[off], pending->msg, msize);
 938       GNUNET_free (pending);
 939       off += msize;
 940     }
 941   /*reply = core_pending_head;*/
 942
 943   GNUNET_SCHEDULER_add_now(&try_core_send, NULL);
 944   /*if (reply != NULL)
 945     core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, reply->importance, reply->timeout, &reply->recipient, reply->msg_size, &core_transmit_notify, NULL);*/
 946
 947   return off;
 948 }
 949
 950
 951 /**
 952  * Send a DV data message via DV.
 953  *
 954  * @param sender the original sender of the message
 955  * @param recipient the next hop recipient, may be our direct peer, maybe not
 956  * @param send_context the send context
 957  */
 958 static int
 959 send_message_via (const struct GNUNET_PeerIdentity *sender,
 960                   const struct GNUNET_PeerIdentity *recipient,
 961                   struct DV_SendContext *send_context)
 962 {
 963   p2p_dv_MESSAGE_Data *toSend;
 964   unsigned int msg_size;
 965   unsigned int recipient_id;
 966   unsigned int sender_id;
 967   struct DistantNeighbor *source;
 968   struct PendingMessage *pending_message;
 969   struct FindIDContext find_context;
 970 #if DEBUG_DV
 971   char shortname[5];
 972 #endif
 973
 974   msg_size = send_context->message_size + sizeof (p2p_dv_MESSAGE_Data);
 975
 976   find_context.dest = send_context->distant_peer;
 977   find_context.via = recipient;
 978   find_context.tid = 0;
 979   GNUNET_CONTAINER_multihashmap_get_multiple (extended_neighbors, &send_context->distant_peer->hashPubKey,
 980                                               &find_specific_id, &find_context);
 981
 982   if (find_context.tid == 0)
 983     {
 984       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s: find_specific_id failed to find peer!\n", my_short_id);
 985       /* target unknown to us, drop! */
 986       return GNUNET_SYSERR;
 987     }
 988   recipient_id = find_context.tid;
 989
 990   if (0 == (memcmp (&my_identity,
 991                         sender, sizeof (struct GNUNET_PeerIdentity))))
 992   {
 993     sender_id = 0;
 994     source = GNUNET_CONTAINER_multihashmap_get (extended_neighbors,
 995                                                     &sender->hashPubKey);
 996     if (source != NULL)
 997       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s: send_message_via found %s, myself in extended peer list???\n", my_short_id, GNUNET_i2s(&source->identity));
 998   }
 999   else
1000   {
1001     source = GNUNET_CONTAINER_multihashmap_get (extended_neighbors,
1002                                                 &sender->hashPubKey);
1003     if (source == NULL)
1004       {
1005               /* sender unknown to us, drop! */
1006         return GNUNET_SYSERR;
1007       }
1008     sender_id = source->our_id;
1009   }
1010
1011   pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + msg_size);
1012   pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1];
1013   pending_message->send_result = send_context->send_result;
1014   memcpy(&pending_message->recipient, recipient, sizeof(struct GNUNET_PeerIdentity));
1015   pending_message->msg_size = msg_size;
1016   pending_message->importance = send_context->importance;
1017   pending_message->timeout = send_context->timeout;
1018   toSend = (p2p_dv_MESSAGE_Data *)pending_message->msg;
1019   toSend->header.size = htons (msg_size);
1020   toSend->header.type = htons (GNUNET_MESSAGE_TYPE_DV_DATA);
1021   toSend->sender = htonl (sender_id);
1022   toSend->recipient = htonl (recipient_id);
1023 #if DEBUG_DV_MESSAGES
1024   toSend->uid = send_context->uid; /* Still sent around in network byte order */
1025 #else
1026   toSend->uid = htonl(0);
1027 #endif
1028
1029   memcpy (&toSend[1], send_context->message, send_context->message_size);
1030
1031 #if DEBUG_DV
1032   memcpy(&shortname, GNUNET_i2s(send_context->distant_peer), 4);
1033   shortname[4] = '\0';
1034   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Notifying core of send to destination `%s' via `%s' size %u\n", "DV", &shortname, GNUNET_i2s(recipient), msg_size);
1035 #endif
1036
1037   GNUNET_CONTAINER_DLL_insert_after (core_pending_head,
1038                                      core_pending_tail,
1039                                      core_pending_tail,
1040                                      pending_message);
1041
1042   GNUNET_SCHEDULER_add_now(try_core_send, NULL);
1043
1044   return GNUNET_YES;
1045 }
1046
1047 /**
1048  * Given a FindLeastCostContext, and a set
1049  * of peers that match the target, return the cheapest.
1050  *
1051  * @param cls closure, a struct FindLeastCostContext
1052  * @param key the key identifying the target peer
1053  * @param value the target peer
1054  *
1055  * @return GNUNET_YES to continue iteration, GNUNET_NO to stop
1056  */
1057 static int
1058 find_least_cost_peer (void *cls,
1059                   const GNUNET_HashCode *key,
1060                   void *value)
1061 {
1062   struct FindLeastCostContext *find_context = cls;
1063   struct DistantNeighbor *dn = value;
1064
1065   if (dn->cost < find_context->least_cost)
1066     {
1067       find_context->target = dn;
1068     }
1069   if (dn->cost == DIRECT_NEIGHBOR_COST)
1070     return GNUNET_NO;
1071   return GNUNET_YES;
1072 }
1073
1074 /**
1075  * Send a DV data message via DV.
1076  *
1077  * @param recipient the ultimate recipient of this message
1078  * @param sender the original sender of the message
1079  * @param specific_neighbor the specific neighbor to send this message via
1080  * @param message the packed message
1081  * @param message_size size of the message
1082  * @param importance what priority to send this message with
1083  * @param uid the unique identifier of this message (or 0 for none)
1084  * @param timeout how long to possibly delay sending this message
1085  */
1086 static int
1087 send_message (const struct GNUNET_PeerIdentity * recipient,
1088               const struct GNUNET_PeerIdentity * sender,
1089               const struct DistantNeighbor * specific_neighbor,
1090               const struct GNUNET_MessageHeader * message,
1091               size_t message_size,
1092               unsigned int importance,
1093               unsigned int uid,
1094               struct GNUNET_TIME_Relative timeout)
1095 {
1096   p2p_dv_MESSAGE_Data *toSend;
1097   unsigned int msg_size;
1098   unsigned int cost;
1099   unsigned int recipient_id;
1100   unsigned int sender_id;
1101   struct DistantNeighbor *target;
1102   struct DistantNeighbor *source;
1103   struct PendingMessage *pending_message;
1104   struct FindLeastCostContext find_least_ctx;
1105 #if DEBUG_DV_PEER_NUMBERS
1106   struct GNUNET_CRYPTO_HashAsciiEncoded encPeerFrom;
1107   struct GNUNET_CRYPTO_HashAsciiEncoded encPeerTo;
1108   struct GNUNET_CRYPTO_HashAsciiEncoded encPeerVia;
1109 #endif
1110   msg_size = message_size + sizeof (p2p_dv_MESSAGE_Data);
1111
1112   find_least_ctx.least_cost = -1;
1113   find_least_ctx.target = NULL;
1114   /*
1115    * Need to find the least cost peer, lest the transport selection keep
1116    * picking the same DV route for the same destination which results
1117    * in messages looping forever.  Relatively cheap, we don't iterate
1118    * over all known peers, just those that apply.
1119    */
1120   GNUNET_CONTAINER_multihashmap_get_multiple (extended_neighbors,
1121                                                        &recipient->hashPubKey,  &find_least_cost_peer, &find_least_ctx);
1122   target = find_least_ctx.target;
1123
1124   if (target == NULL)
1125     {
1126       /* target unknown to us, drop! */
1127       return GNUNET_SYSERR;
1128     }
1129   recipient_id = target->referrer_id;
1130
1131   source = GNUNET_CONTAINER_multihashmap_get (extended_neighbors,
1132                                               &sender->hashPubKey);
1133   if (source == NULL)
1134     {
1135       if (0 != (memcmp (&my_identity,
1136                         sender, sizeof (struct GNUNET_PeerIdentity))))
1137         {
1138           /* sender unknown to us, drop! */
1139           return GNUNET_SYSERR;
1140         }
1141       sender_id = 0;            /* 0 == us */
1142     }
1143   else
1144     {
1145       /* find out the number that we use when we gossip about
1146          the sender */
1147       sender_id = source->our_id;
1148     }
1149
1150 #if DEBUG_DV_PEER_NUMBERS
1151   GNUNET_CRYPTO_hash_to_enc (&source->identity.hashPubKey, &encPeerFrom);
1152   GNUNET_CRYPTO_hash_to_enc (&target->referrer->identity.hashPubKey, &encPeerVia);
1153   encPeerFrom.encoding[4] = '\0';
1154   encPeerVia.encoding[4] = '\0';
1155 #endif
1156   if ((sender_id != 0) && (0 == memcmp(&source->identity, &target->referrer->identity, sizeof(struct GNUNET_PeerIdentity))))
1157     {
1158       return 0;
1159     }
1160
1161   cost = target->cost;
1162   pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + msg_size);
1163   pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1];
1164   pending_message->send_result = NULL;
1165   pending_message->importance = importance;
1166   pending_message->timeout = timeout;
1167   memcpy(&pending_message->recipient, &target->referrer->identity, sizeof(struct GNUNET_PeerIdentity));
1168   pending_message->msg_size = msg_size;
1169   toSend = (p2p_dv_MESSAGE_Data *)pending_message->msg;
1170   toSend->header.size = htons (msg_size);
1171   toSend->header.type = htons (GNUNET_MESSAGE_TYPE_DV_DATA);
1172   toSend->sender = htonl (sender_id);
1173   toSend->recipient = htonl (recipient_id);
1174 #if DEBUG_DV_MESSAGES
1175   toSend->uid = htonl(uid);
1176 #else
1177   toSend->uid = htonl(0);
1178 #endif
1179
1180 #if DEBUG_DV_PEER_NUMBERS
1181   GNUNET_CRYPTO_hash_to_enc (&target->identity.hashPubKey, &encPeerTo);
1182   encPeerTo.encoding[4] = '\0';
1183   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Sending DATA message. Sender id %u, source %s, destination %s, via %s\n", GNUNET_i2s(&my_identity), sender_id, &encPeerFrom, &encPeerTo, &encPeerVia);
1184 #endif
1185   memcpy (&toSend[1], message, message_size);
1186   if ((source != NULL) && (source->pkey == NULL)) /* Test our hypothesis about message failures! */
1187     {
1188       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s: Sending message, but anticipate recipient will not know sender!!!\n\n\n", my_short_id);
1189     }
1190   GNUNET_CONTAINER_DLL_insert_after (core_pending_head,
1191                                      core_pending_tail,
1192                                      core_pending_tail,
1193                                      pending_message);
1194 #if DEBUG_DV
1195   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Notifying core of send size %d to destination `%s'\n", "DV SEND MESSAGE", msg_size, GNUNET_i2s(recipient));
1196 #endif
1197
1198   GNUNET_SCHEDULER_add_now(try_core_send, NULL);
1199   return (int) cost;
1200 }
1201
1202 #if USE_PEER_ID
1203 struct CheckPeerContext
1204 {
1205   /**
1206    * Peer we found
1207    */
1208   struct DistantNeighbor *peer;
1209
1210   /**
1211    * Sender id to search for
1212    */
1213   unsigned int sender_id;
1214 };
1215
1216 /**
1217  * Iterator over hash map entries.
1218  *
1219  * @param cls closure
1220  * @param key current key code
1221  * @param value value in the hash map
1222  * @return GNUNET_YES if we should continue to
1223  *         iterate,
1224  *         GNUNET_NO if not.
1225  */
1226 int checkPeerID (void *cls,
1227                  const GNUNET_HashCode * key,
1228                  void *value)
1229 {
1230   struct CheckPeerContext *ctx = cls;
1231   struct DistantNeighbor *distant = value;
1232
1233   if (memcmp(key, &ctx->sender_id, sizeof(unsigned int)) == 0)
1234   {
1235     ctx->peer = distant;
1236     return GNUNET_NO;
1237   }
1238   return GNUNET_YES;
1239
1240 }
1241 #endif
1242
1243
1244 /**
1245  * Handler for messages parsed out by the tokenizer from
1246  * DV DATA received for this peer.
1247  *
1248  * @param cls NULL
1249  * @param client the TokenizedMessageContext which contains message information
1250  * @param message the actual message
1251  */
1252 void tokenized_message_handler (void *cls,
1253                                 void *client,
1254                                 const struct GNUNET_MessageHeader *message)
1255 {
1256   struct TokenizedMessageContext *ctx = client;
1257   GNUNET_break_op (ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_GOSSIP);
1258   GNUNET_break_op (ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_DATA);
1259   if ( (ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_GOSSIP) &&
1260       (ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_DATA) )
1261   {
1262 #if DEBUG_DV_MESSAGES
1263     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1264                 "%s: Receives %s message for me, uid %u, size %d, type %d cost %u from %s!\n", my_short_id, "DV DATA", ctx->uid, ntohs(message->size), ntohs(message->type), ctx->distant->cost, GNUNET_i2s(&ctx->distant->identity));
1265 #endif
1266     GNUNET_assert(memcmp(ctx->peer, &ctx->distant->identity, sizeof(struct GNUNET_PeerIdentity)) != 0);
1267     send_to_plugin(ctx->peer, message, ntohs(message->size), &ctx->distant->identity, ctx->distant->cost);
1268   }
1269 }
1270
1271 #if DELAY_FORWARDS
1272 struct DelayedMessageContext
1273 {
1274   struct GNUNET_PeerIdentity dest;
1275   struct GNUNET_PeerIdentity sender;
1276   struct GNUNET_MessageHeader *message;
1277   size_t message_size;
1278   uint32_t uid;
1279 };
1280
1281 void send_message_delayed (void *cls,
1282                            const struct GNUNET_SCHEDULER_TaskContext *tc)
1283 {
1284   struct DelayedMessageContext *msg_ctx = cls;
1285   if (msg_ctx != NULL)
1286     {
1287       send_message(&msg_ctx->dest,
1288                    &msg_ctx->sender,
1289                    NULL,
1290                    msg_ctx->message,
1291                    msg_ctx->message_size,
1292                    default_dv_priority,
1293                    msg_ctx->uid,
1294                    GNUNET_TIME_relative_get_forever());
1295       GNUNET_free(msg_ctx->message);
1296       GNUNET_free(msg_ctx);
1297     }
1298 }
1299 #endif
1300
1301
1302 /**
1303  * Core handler for dv data messages.  Whatever this message
1304  * contains all we really have to do is rip it out of its
1305  * DV layering and give it to our pal the DV plugin to report
1306  * in with.
1307  *
1308  * @param cls closure
1309  * @param peer peer which sent the message (immediate sender)
1310  * @param message the message
1311  * @param latency the latency of the connection we received the message from
1312  * @param distance the distance to the immediate peer
1313  */
1314 static int
1315 handle_dv_data_message (void *cls,
1316                         const struct GNUNET_PeerIdentity * peer,
1317                         const struct GNUNET_MessageHeader * message,
1318                         const struct GNUNET_TRANSPORT_ATS_Information *atsi)
1319 {
1320   const p2p_dv_MESSAGE_Data *incoming = (const p2p_dv_MESSAGE_Data *) message;
1321   const struct GNUNET_MessageHeader *packed_message;
1322   struct DirectNeighbor *dn;
1323   struct DistantNeighbor *pos;
1324   unsigned int sid;             /* Sender id */
1325   unsigned int tid;             /* Target id */
1326   struct GNUNET_PeerIdentity *original_sender;
1327   struct GNUNET_PeerIdentity *destination;
1328   struct FindDestinationContext fdc;
1329   struct TokenizedMessageContext tkm_ctx;
1330   int i;
1331   int found_pos;
1332 #if DELAY_FORWARDS
1333   struct DelayedMessageContext *delayed_context;
1334 #endif
1335 #if USE_PEER_ID
1336   struct CheckPeerContext checkPeerCtx;
1337 #endif
1338 #if DEBUG_DV_MESSAGES
1339   char *sender_id;
1340 #endif
1341   int ret;
1342   size_t packed_message_size;
1343   char *cbuf;
1344
1345   packed_message_size = ntohs(incoming->header.size) - sizeof(p2p_dv_MESSAGE_Data);
1346 #if DEBUG_DV
1347   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1348               "%s: Receives DATA message from %s size %d, packed size %d!\n", my_short_id, GNUNET_i2s(peer) , ntohs(incoming->header.size), packed_message_size);
1349 #endif
1350
1351   if (ntohs (incoming->header.size) <  sizeof (p2p_dv_MESSAGE_Data) + sizeof (struct GNUNET_MessageHeader))
1352     {
1353
1354 #if DEBUG_DV
1355     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1356                 "`%s': Message sizes don't add up, total size %u, expected at least %u!\n", "dv service", ntohs(incoming->header.size), sizeof (p2p_dv_MESSAGE_Data) + sizeof (struct GNUNET_MessageHeader));
1357 #endif
1358       return GNUNET_SYSERR;
1359     }
1360
1361   dn = GNUNET_CONTAINER_multihashmap_get (direct_neighbors,
1362                                           &peer->hashPubKey);
1363   if (dn == NULL)
1364     return GNUNET_OK;
1365
1366   sid = ntohl (incoming->sender);
1367 #if USE_PEER_ID
1368   if (sid != 0)
1369   {
1370     checkPeerCtx.sender_id = sid;
1371     checkPeerCtx.peer = NULL;
1372     GNUNET_CONTAINER_multihashmap_iterate(extended_neighbors, &checkPeerID, &checkPeerCtx);
1373     pos = checkPeerCtx.peer;
1374   }
1375   else
1376   {
1377     pos = GNUNET_CONTAINER_multihashmap_get (extended_neighbors,
1378                                              &peer->hashPubKey);
1379   }
1380 #else
1381   pos = dn->referee_head;
1382   while ((NULL != pos) && (pos->referrer_id != sid))
1383     pos = pos->next;
1384 #endif
1385
1386   if (pos == NULL)
1387     {
1388 #if DEBUG_DV_MESSAGES
1389       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1390                   "%s: unknown sender (%u), Message uid %u from %s!\n", my_short_id, ntohl(incoming->sender), ntohl(incoming->uid), GNUNET_i2s(&dn->identity));
1391       pos = dn->referee_head;
1392       while ((NULL != pos) && (pos->referrer_id != sid))
1393       {
1394         sender_id = strdup(GNUNET_i2s(&pos->identity));
1395         GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "I know sender %u %s\n", pos->referrer_id, sender_id);
1396         GNUNET_free(sender_id);
1397         pos = pos->next;
1398       }
1399 #endif
1400       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1401                   "%s: unknown sender (%u), Message uid %u from %s!\n", my_short_id, ntohl(incoming->sender), ntohl(incoming->uid), GNUNET_i2s(&dn->identity));
1402
1403       found_pos = -1;
1404       for (i = 0; i< MAX_OUTSTANDING_MESSAGES; i++)
1405         {
1406           if (dn->pending_messages[i].sender_id == 0)
1407             {
1408               found_pos = i;
1409               break;
1410             }
1411         }
1412
1413       if (found_pos == -1)
1414         {
1415           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1416                       "%s: Too many unknown senders (%u), ignoring message! Message uid %llu from %s!\n", my_short_id, ntohl(incoming->sender), ntohl(incoming->uid), GNUNET_i2s(&dn->identity));
1417         }
1418       else
1419         {
1420             dn->pending_messages[found_pos].message = GNUNET_malloc(ntohs (message->size));
1421             memcpy(dn->pending_messages[found_pos].message, message, ntohs(message->size));
1422             dn->pending_messages[found_pos].distance = distance;
1423             dn->pending_messages[found_pos].latency = latency;
1424             memcpy(&dn->pending_messages[found_pos].sender, peer, sizeof(struct GNUNET_PeerIdentity));
1425             dn->pending_messages[found_pos].sender_id = sid;
1426         }
1427       /* unknown sender */
1428       return GNUNET_OK;
1429     }
1430   original_sender = &pos->identity;
1431   tid = ntohl (incoming->recipient);
1432   if (tid == 0)
1433     {
1434       /* 0 == us */
1435       cbuf = (char *)&incoming[1];
1436
1437       tkm_ctx.peer = peer;
1438       tkm_ctx.distant = pos;
1439       tkm_ctx.uid = ntohl(incoming->uid);
1440       if (GNUNET_OK != GNUNET_SERVER_mst_receive (coreMST,
1441                                                   &tkm_ctx,
1442                                                   cbuf,
1443                                                   packed_message_size,
1444                                                   GNUNET_NO,
1445                                                   GNUNET_NO))
1446         {
1447           GNUNET_break_op(0);
1448           GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s: %s Received corrupt data, discarding!", my_short_id, "DV SERVICE");
1449         }
1450       return GNUNET_OK;
1451     }
1452   else
1453     {
1454       packed_message = (struct GNUNET_MessageHeader *)&incoming[1];
1455     }
1456
1457   /* FIXME: this is the *only* per-request operation we have in DV
1458      that is O(n) in relation to the number of connected peers; a
1459      hash-table lookup could easily solve this (minor performance
1460      issue) */
1461   fdc.tid = tid;
1462   fdc.dest = NULL;
1463   GNUNET_CONTAINER_heap_iterate (neighbor_max_heap,
1464                                  &find_destination, &fdc);
1465
1466 #if DEBUG_DV
1467       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1468                   "%s: Receives %s message for someone else!\n", "dv", "DV DATA");
1469 #endif
1470
1471   if (fdc.dest == NULL)
1472     {
1473 #if DEBUG_DV_MESSAGES
1474       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1475                   "%s: Receives %s message uid %u for someone we don't know (id %u)!\n", my_short_id, "DV DATA", ntohl(incoming->uid), tid);
1476 #endif
1477       return GNUNET_OK;
1478     }
1479   destination = &fdc.dest->identity;
1480
1481   if (0 == memcmp (destination, peer, sizeof (struct GNUNET_PeerIdentity)))
1482     {
1483       /* FIXME: create stat: routing loop-discard! */
1484 #if DEBUG_DV_PEER_NUMBERS
1485       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "\n\n\nLoopy loo message\n\n\n");
1486 #endif
1487
1488 #if DEBUG_DV_MESSAGES
1489       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1490                   "%s: DROPPING MESSAGE uid %u type %d, routing loop! Message immediately from %s!\n", my_short_id, ntohl(incoming->uid), ntohs(packed_message->type), GNUNET_i2s(&dn->identity));
1491 #endif
1492       return GNUNET_OK;
1493     }
1494
1495   /* At this point we have a message, and we need to forward it on to the
1496    * next DV hop.
1497    */
1498 #if DEBUG_DV_MESSAGES
1499   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1500               "%s: FORWARD %s message for %s, uid %u, size %d type %d, cost %u!\n", my_short_id, "DV DATA", GNUNET_i2s(destination), ntohl(incoming->uid), ntohs(packed_message->size), ntohs(packed_message->type), pos->cost);
1501 #endif
1502
1503 #if DELAY_FORWARDS
1504   if (GNUNET_TIME_absolute_get_duration(pos->last_gossip).abs_value < GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2).abs_value)
1505     {
1506       delayed_context = GNUNET_malloc(sizeof(struct DelayedMessageContext));
1507       memcpy(&delayed_context->dest, destination, sizeof(struct GNUNET_PeerIdentity));
1508       memcpy(&delayed_context->sender, original_sender, sizeof(struct GNUNET_PeerIdentity));
1509       delayed_context->message = GNUNET_malloc(packed_message_size);
1510       memcpy(delayed_context->message, packed_message, packed_message_size);
1511       delayed_context->message_size = packed_message_size;
1512       delayed_context->uid = ntohl(incoming->uid);
1513       GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 2500), &send_message_delayed, delayed_context);
1514       return GNUNET_OK;
1515     }
1516   else
1517 #endif
1518     {
1519       ret = send_message(destination,
1520                          original_sender,
1521                          NULL,
1522                          packed_message,
1523                          packed_message_size,
1524                          default_dv_priority,
1525                          ntohl(incoming->uid),
1526                          GNUNET_TIME_relative_get_forever());
1527     }
1528   if (ret != GNUNET_SYSERR)
1529     return GNUNET_OK;
1530   else
1531     {
1532 #if DEBUG_MESSAGE_DROP
1533       char *direct_id = GNUNET_strdup(GNUNET_i2s(&dn->identity));
1534       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1535                   "%s: DROPPING MESSAGE type %d, forwarding failed! Message immediately from %s!\n", GNUNET_i2s(&my_identity), ntohs(((struct GNUNET_MessageHeader *)&incoming[1])->type), direct_id);
1536       GNUNET_free (direct_id);
1537 #endif
1538       return GNUNET_SYSERR;
1539     }
1540 }
1541
1542 #if DEBUG_DV
1543 /**
1544  * Iterator over hash map entries.
1545  *
1546  * @param cls closure (NULL)
1547  * @param key current key code
1548  * @param value value in the hash map (DistantNeighbor)
1549  * @return GNUNET_YES if we should continue to
1550  *         iterate,
1551  *         GNUNET_NO if not.
1552  */
1553 int print_neighbors (void *cls,
1554                      const GNUNET_HashCode * key,
1555                      void *abs_value)
1556 {
1557   struct DistantNeighbor *distant_neighbor = abs_value;
1558   char my_shortname[5];
1559   char referrer_shortname[5];
1560   memcpy(&my_shortname, GNUNET_i2s(&my_identity), 4);
1561   my_shortname[4] = '\0';
1562   memcpy(&referrer_shortname, GNUNET_i2s(&distant_neighbor->referrer->identity), 4);
1563   referrer_shortname[4] = '\0';
1564
1565   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "`%s' %s: Peer `%s', distance %d, referrer `%s' pkey: %s\n", &my_shortname, "DV", GNUNET_i2s(&distant_neighbor->identity), distant_neighbor->cost, &referrer_shortname, distant_neighbor->pkey == NULL ? "no" : "yes");
1566   return GNUNET_YES;
1567 }
1568 #endif
1569
1570 /**
1571  *  Scheduled task which gossips about known direct peers to other connected
1572  *  peers.  Will run until called with reason shutdown.
1573  */
1574 static void
1575 neighbor_send_task (void *cls,
1576                     const struct GNUNET_SCHEDULER_TaskContext *tc)
1577 {
1578   struct NeighborSendContext *send_context = cls;
1579 #if DEBUG_DV_GOSSIP_SEND
1580   char * encPeerAbout;
1581   char * encPeerTo;
1582 #endif
1583   struct DistantNeighbor *about;
1584   struct DirectNeighbor *to;
1585   struct FastGossipNeighborList *about_list;
1586
1587   p2p_dv_MESSAGE_NeighborInfo *message;
1588   struct PendingMessage *pending_message;
1589
1590   if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
1591   {
1592 #if DEBUG_DV_GOSSIP
1593   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1594               "%s: Called with reason shutdown, shutting down!\n",
1595               GNUNET_i2s(&my_identity));
1596 #endif
1597     return;
1598   }
1599
1600   if (send_context->fast_gossip_list_head != NULL)
1601     {
1602       about_list = send_context->fast_gossip_list_head;
1603       about = about_list->about;
1604       GNUNET_CONTAINER_DLL_remove(send_context->fast_gossip_list_head,
1605                                   send_context->fast_gossip_list_tail,
1606                                   about_list);
1607       GNUNET_free(about_list);
1608     }
1609   else
1610     {
1611       /* FIXME: this may become a problem, because the heap walk has only one internal "walker".  This means
1612        * that if two neighbor_send_tasks are operating in lockstep (which is quite possible, given default
1613        * values for all connected peers) there may be a serious bias as to which peers get gossiped about!
1614        * Probably the *best* way to fix would be to have an opaque pointer to the walk position passed as
1615        * part of the walk_get_next call.  Then the heap would have to keep a list of walks, or reset the walk
1616        * whenever a modification has been detected.  Yuck either way.  Perhaps we could iterate over the heap
1617        * once to get a list of peers to gossip about and gossip them over time... But then if one goes away
1618        * in the mean time that becomes nasty.  For now we'll just assume that the walking is done
1619        * asynchronously enough to avoid major problems (-;
1620        *
1621        * NOTE: probably fixed once we decided send rate based on allowed bandwidth.
1622        */
1623       about = GNUNET_CONTAINER_heap_walk_get_next (neighbor_min_heap);
1624     }
1625   to = send_context->toNeighbor;
1626
1627   if ((about != NULL) && (to != about->referrer /* split horizon */ ) &&
1628 #if SUPPORT_HIDING
1629       (about->hidden == GNUNET_NO) &&
1630 #endif
1631       (to != NULL) &&
1632       (0 != memcmp (&about->identity,
1633                         &to->identity, sizeof (struct GNUNET_PeerIdentity))) &&
1634       (about->pkey != NULL))
1635     {
1636 #if DEBUG_DV_GOSSIP_SEND
1637       encPeerAbout = GNUNET_strdup(GNUNET_i2s(&about->identity));
1638       encPeerTo = GNUNET_strdup(GNUNET_i2s(&to->identity));
1639       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1640                   "%s: Sending info about peer %s id %u to directly connected peer %s\n",
1641                   GNUNET_i2s(&my_identity),
1642                   encPeerAbout, about->our_id, encPeerTo);
1643       GNUNET_free(encPeerAbout);
1644       GNUNET_free(encPeerTo);
1645 #endif
1646       about->last_gossip = GNUNET_TIME_absolute_get();
1647       pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + sizeof(p2p_dv_MESSAGE_NeighborInfo));
1648       pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1];
1649       pending_message->importance = default_dv_priority;
1650       pending_message->timeout = GNUNET_TIME_relative_get_forever();
1651       memcpy(&pending_message->recipient, &to->identity, sizeof(struct GNUNET_PeerIdentity));
1652       pending_message->msg_size = sizeof(p2p_dv_MESSAGE_NeighborInfo);
1653       message = (p2p_dv_MESSAGE_NeighborInfo *)pending_message->msg;
1654       message->header.size = htons (sizeof (p2p_dv_MESSAGE_NeighborInfo));
1655       message->header.type = htons (GNUNET_MESSAGE_TYPE_DV_GOSSIP);
1656       message->cost = htonl (about->cost);
1657       message->neighbor_id = htonl (about->our_id);
1658
1659       memcpy (&message->pkey, about->pkey, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
1660       memcpy (&message->neighbor,
1661               &about->identity, sizeof (struct GNUNET_PeerIdentity));
1662
1663       GNUNET_CONTAINER_DLL_insert_after (core_pending_head,
1664                                          core_pending_tail,
1665                                          core_pending_tail,
1666                                          pending_message);
1667
1668       GNUNET_SCHEDULER_add_now(try_core_send, NULL);
1669       /*if (core_transmit_handle == NULL)
1670         core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, default_dv_priority, GNUNET_TIME_relative_get_forever(), &to->identity, sizeof(p2p_dv_MESSAGE_NeighborInfo), &core_transmit_notify, NULL);*/
1671
1672     }
1673
1674   if (send_context->fast_gossip_list_head != NULL) /* If there are other peers in the fast list, schedule right away */
1675     {
1676 #if DEBUG_DV_PEER_NUMBERS
1677       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "DV SERVICE: still in fast send mode\n");
1678 #endif
1679       send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, send_context);
1680     }
1681   else
1682     {
1683 #if DEBUG_DV_PEER_NUMBERS
1684       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "DV SERVICE: entering slow send mode\n");
1685 #endif
1686       send_context->task = GNUNET_SCHEDULER_add_delayed(GNUNET_DV_DEFAULT_SEND_INTERVAL, &neighbor_send_task, send_context);
1687     }
1688
1689   return;
1690 }
1691
1692
1693 /**
1694  * Handle START-message.  This is the first message sent to us
1695  * by the client (can only be one!).
1696  *
1697  * @param cls closure (always NULL)
1698  * @param client identification of the client
1699  * @param message the actual message
1700  */
1701 static void
1702 handle_start (void *cls,
1703               struct GNUNET_SERVER_Client *client,
1704               const struct GNUNET_MessageHeader *message)
1705 {
1706
1707 #if DEBUG_DV
1708   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1709               "Received `%s' request from client\n", "START");
1710 #endif
1711
1712   client_handle = client;
1713
1714   GNUNET_SERVER_client_keep(client_handle);
1715   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1716 }
1717
1718 #if UNSIMPLER
1719 /**
1720  * Iterate over hash map entries for a distant neighbor,
1721  * if direct neighbor matches context call send message
1722  *
1723  * @param cls closure, a DV_SendContext
1724  * @param key current key code
1725  * @param value value in the hash map
1726  * @return GNUNET_YES if we should continue to
1727  *         iterate,
1728  *         GNUNET_NO if not.
1729  */
1730 int send_iterator (void *cls,
1731                    const GNUNET_HashCode * key,
1732                    void *abs_value)
1733 {
1734   struct DV_SendContext *send_context = cls;
1735   struct DistantNeighbor *distant_neighbor = abs_value;
1736
1737   if (memcmp(distant_neighbor->referrer, send_context->direct_peer, sizeof(struct GNUNET_PeerIdentity)) == 0) /* They match, send and free */
1738     {
1739       send_message_via(&my_identity, distant_neighbor, send_context);
1740       return GNUNET_NO;
1741     }
1742   return GNUNET_YES;
1743 }
1744 #endif
1745
1746 /**
1747  * Service server's handler for message send requests (which come
1748  * bubbling up to us through the DV plugin).
1749  *
1750  * @param cls closure
1751  * @param client identification of the client
1752  * @param message the actual message
1753  */
1754 void handle_dv_send_message (void *cls,
1755                              struct GNUNET_SERVER_Client * client,
1756                              const struct GNUNET_MessageHeader * message)
1757 {
1758   struct GNUNET_DV_SendMessage *send_msg;
1759   struct GNUNET_DV_SendResultMessage *send_result_msg;
1760   struct PendingMessage *pending_message;
1761   size_t address_len;
1762   size_t message_size;
1763   struct GNUNET_PeerIdentity *destination;
1764   struct GNUNET_PeerIdentity *direct;
1765   struct GNUNET_MessageHeader *message_buf;
1766   char *temp_pos;
1767   int offset;
1768   static struct GNUNET_CRYPTO_HashAsciiEncoded dest_hash;
1769   struct DV_SendContext *send_context;
1770 #if DEBUG_DV_MESSAGES
1771   char *cbuf;
1772   struct GNUNET_MessageHeader *packed_message;
1773 #endif
1774
1775   if (client_handle == NULL)
1776   {
1777     client_handle = client;
1778     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1779               "%s: Setting initial client handle, never received `%s' message?\n", "dv", "START");
1780   }
1781   else if (client_handle != client)
1782   {
1783     client_handle = client;
1784     /* What should we do in this case, assert fail or just log the warning? */
1785 #if DEBUG_DV
1786     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1787                 "%s: Setting client handle (was a different client!)!\n", "dv");
1788 #endif
1789   }
1790
1791   GNUNET_assert(ntohs(message->size) > sizeof(struct GNUNET_DV_SendMessage));
1792   send_msg = (struct GNUNET_DV_SendMessage *)message;
1793
1794   address_len = ntohl(send_msg->addrlen);
1795   GNUNET_assert(address_len == sizeof(struct GNUNET_PeerIdentity) * 2);
1796   message_size = ntohs(message->size) - sizeof(struct GNUNET_DV_SendMessage) - address_len;
1797   destination = GNUNET_malloc(sizeof(struct GNUNET_PeerIdentity));
1798   direct = GNUNET_malloc(sizeof(struct GNUNET_PeerIdentity));
1799   message_buf = GNUNET_malloc(message_size);
1800
1801   temp_pos = (char *)&send_msg[1]; /* Set pointer to end of message */
1802   offset = 0; /* Offset starts at zero */
1803
1804   memcpy(destination, &temp_pos[offset], sizeof(struct GNUNET_PeerIdentity));
1805   offset += sizeof(struct GNUNET_PeerIdentity);
1806
1807   memcpy(direct, &temp_pos[offset], sizeof(struct GNUNET_PeerIdentity));
1808   offset += sizeof(struct GNUNET_PeerIdentity);
1809
1810
1811   memcpy(message_buf, &temp_pos[offset], message_size);
1812   if (memcmp(&send_msg->target, destination, sizeof(struct GNUNET_PeerIdentity)) != 0)
1813     {
1814       GNUNET_CRYPTO_hash_to_enc (&destination->hashPubKey, &dest_hash); /* GNUNET_i2s won't properly work, need to hash one ourselves */
1815       dest_hash.encoding[4] = '\0';
1816       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s: asked to send message to `%s', but address is for `%s'!", "DV SERVICE", GNUNET_i2s(&send_msg->target), (const char *)&dest_hash.encoding);
1817     }
1818
1819 #if DEBUG_DV_MESSAGES
1820   cbuf = (char *)message_buf;
1821   offset = 0;
1822   while(offset < message_size)
1823     {
1824       packed_message = (struct GNUNET_MessageHeader *)&cbuf[offset];
1825       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: DV PLUGIN SEND uid %u type %d to %s\n", my_short_id, ntohl(send_msg->uid), ntohs(packed_message->type), GNUNET_i2s(destination));
1826       offset += ntohs(packed_message->size);
1827     }
1828   /*GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: DV PLUGIN SEND uid %u type %d to %s\n", my_short_id, ntohl(send_msg->uid), ntohs(message_buf->type), GNUNET_i2s(destination));*/
1829 #endif
1830   GNUNET_CRYPTO_hash_to_enc (&destination->hashPubKey, &dest_hash); /* GNUNET_i2s won't properly work, need to hash one ourselves */
1831   dest_hash.encoding[4] = '\0';
1832   send_context = GNUNET_malloc(sizeof(struct DV_SendContext));
1833
1834   send_result_msg = GNUNET_malloc(sizeof(struct GNUNET_DV_SendResultMessage));
1835   send_result_msg->header.size = htons(sizeof(struct GNUNET_DV_SendResultMessage));
1836   send_result_msg->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND_RESULT);
1837   send_result_msg->uid = send_msg->uid; /* No need to ntohl->htonl this */
1838
1839   send_context->importance = ntohl(send_msg->priority);
1840   send_context->timeout = send_msg->timeout;
1841   send_context->direct_peer = direct;
1842   send_context->distant_peer = destination;
1843   send_context->message = message_buf;
1844   send_context->message_size = message_size;
1845   send_context->send_result = send_result_msg;
1846 #if DEBUG_DV_MESSAGES
1847   send_context->uid = send_msg->uid;
1848 #endif
1849
1850   if (send_message_via(&my_identity, direct, send_context) != GNUNET_YES)
1851     {
1852       send_result_msg->result = htons(1);
1853       pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + sizeof(struct GNUNET_DV_SendResultMessage));
1854       pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1];
1855       memcpy(&pending_message[1], send_result_msg, sizeof(struct GNUNET_DV_SendResultMessage));
1856       GNUNET_free(send_result_msg);
1857
1858       GNUNET_CONTAINER_DLL_insert_after(plugin_pending_head, plugin_pending_tail, plugin_pending_tail, pending_message);
1859
1860       if (client_handle != NULL)
1861         {
1862           if (plugin_transmit_handle == NULL)
1863             {
1864               plugin_transmit_handle = GNUNET_SERVER_notify_transmit_ready (client_handle,
1865                                                                             sizeof(struct GNUNET_DV_SendResultMessage),
1866                                                                             GNUNET_TIME_UNIT_FOREVER_REL,
1867                                                                             &transmit_to_plugin, NULL);
1868             }
1869           else
1870             {
1871               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to queue message for plugin, must be one in progress already!!\n");
1872             }
1873         }
1874       GNUNET_CRYPTO_hash_to_enc (&destination->hashPubKey, &dest_hash); /* GNUNET_i2s won't properly work, need to hash one ourselves */
1875       dest_hash.encoding[4] = '\0';
1876       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s DV SEND failed to send message to destination `%s' via `%s'\n", my_short_id, (const char *)&dest_hash.encoding, GNUNET_i2s(direct));
1877     }
1878
1879   /* In bizarro world GNUNET_SYSERR indicates that we succeeded */
1880 #if UNSIMPLER
1881   if (GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_get_multiple(extended_neighbors, &destination->hashPubKey, &send_iterator, send_context))
1882     {
1883       send_result_msg->result = htons(1);
1884       pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + sizeof(struct GNUNET_DV_SendResultMessage));
1885       pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1];
1886       memcpy(&pending_message[1], send_result_msg, sizeof(struct GNUNET_DV_SendResultMessage));
1887       GNUNET_free(send_result_msg);
1888
1889       GNUNET_CONTAINER_DLL_insert_after(plugin_pending_head, plugin_pending_tail, plugin_pending_tail, pending_message);
1890
1891       if (client_handle != NULL)
1892         {
1893           if (plugin_transmit_handle == NULL)
1894             {
1895               plugin_transmit_handle = GNUNET_SERVER_notify_transmit_ready (client_handle,
1896                                                                             sizeof(struct GNUNET_DV_SendResultMessage),
1897                                                                             GNUNET_TIME_UNIT_FOREVER_REL,
1898                                                                             &transmit_to_plugin, NULL);
1899             }
1900           else
1901             {
1902               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to queue message for plugin, must be one in progress already!!\n");
1903             }
1904         }
1905       GNUNET_CRYPTO_hash_to_enc (&destination->hashPubKey, &dest_hash); /* GNUNET_i2s won't properly work, need to hash one ourselves */
1906       dest_hash.encoding[4] = '\0';
1907       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s DV SEND failed to send message to destination `%s' via `%s'\n", my_short_id, (const char *)&dest_hash.encoding, GNUNET_i2s(direct));
1908     }
1909 #endif
1910   GNUNET_free(message_buf);
1911   GNUNET_free(send_context);
1912   GNUNET_free(direct);
1913   GNUNET_free(destination);
1914
1915   GNUNET_SERVER_receive_done(client, GNUNET_OK);
1916 }
1917
1918 /** Forward declarations **/
1919 static int handle_dv_gossip_message (void *cls,
1920                                      const struct GNUNET_PeerIdentity *peer,
1921                                      const struct GNUNET_MessageHeader *message,
1922                                      const struct GNUNET_TRANSPORT_ATS_Information *atsi);
1923
1924 static int handle_dv_disconnect_message (void *cls,
1925                                          const struct GNUNET_PeerIdentity *peer,
1926                                          const struct GNUNET_MessageHeader *message,
1927                                          const struct GNUNET_TRANSPORT_ATS_Information *atsi);
1928 /** End forward declarations **/
1929
1930
1931 /**
1932  * List of handlers for the messages understood by this
1933  * service.
1934  *
1935  * Hmm... will we need to register some handlers with core and
1936  * some handlers with our server here?  Because core should be
1937  * getting the incoming DV messages (from whichever lower level
1938  * transport) and then our server should be getting messages
1939  * from the dv_plugin, right?
1940  */
1941 static struct GNUNET_CORE_MessageHandler core_handlers[] = {
1942   {&handle_dv_data_message, GNUNET_MESSAGE_TYPE_DV_DATA, 0},
1943   {&handle_dv_gossip_message, GNUNET_MESSAGE_TYPE_DV_GOSSIP, 0},
1944   {&handle_dv_disconnect_message, GNUNET_MESSAGE_TYPE_DV_DISCONNECT, 0},
1945   {NULL, 0, 0}
1946 };
1947
1948 static struct GNUNET_SERVER_MessageHandler plugin_handlers[] = {
1949   {&handle_dv_send_message, NULL, GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND, 0},
1950   {&handle_start, NULL, GNUNET_MESSAGE_TYPE_DV_START, 0},
1951   {NULL, NULL, 0, 0}
1952 };
1953
1954 /**
1955  * Free a DistantNeighbor node, including removing it
1956  * from the referer's list.
1957  */
1958 static void
1959 distant_neighbor_free (struct DistantNeighbor *referee)
1960 {
1961   struct DirectNeighbor *referrer;
1962
1963   referrer = referee->referrer;
1964   if (referrer != NULL)
1965     {
1966       GNUNET_CONTAINER_DLL_remove (referrer->referee_head,
1967                          referrer->referee_tail, referee);
1968     }
1969   GNUNET_CONTAINER_heap_remove_node (neighbor_max_heap, referee->max_loc);
1970   GNUNET_CONTAINER_heap_remove_node (neighbor_min_heap, referee->min_loc);
1971   GNUNET_CONTAINER_multihashmap_remove_all (extended_neighbors,
1972                                     &referee->identity.hashPubKey);
1973   GNUNET_free_non_null (referee->pkey);
1974   GNUNET_free (referee);
1975 }
1976
1977 /**
1978  * Free a DirectNeighbor node, including removing it
1979  * from the referer's list.
1980  */
1981 static void
1982 direct_neighbor_free (struct DirectNeighbor *direct)
1983 {
1984   struct NeighborSendContext *send_context;
1985   struct FastGossipNeighborList *about_list;
1986   struct FastGossipNeighborList *prev_about;
1987
1988   send_context = direct->send_context;
1989
1990   if (send_context->task != GNUNET_SCHEDULER_NO_TASK)
1991     GNUNET_SCHEDULER_cancel(send_context->task);
1992
1993   about_list = send_context->fast_gossip_list_head;
1994   while (about_list != NULL)
1995     {
1996       GNUNET_CONTAINER_DLL_remove(send_context->fast_gossip_list_head, send_context->fast_gossip_list_tail, about_list);
1997       prev_about = about_list;
1998       about_list = about_list->next;
1999       GNUNET_free(prev_about);
2000     }
2001   GNUNET_free(send_context);
2002   GNUNET_free(direct);
2003 }
2004
2005 /**
2006  * Multihashmap iterator for sending out disconnect messages
2007  * for a peer.
2008  *
2009  * @param cls the peer that was disconnected
2010  * @param key key value stored under
2011  * @param value the direct neighbor to send disconnect to
2012  *
2013  * @return GNUNET_YES to continue iteration, GNUNET_NO to stop
2014  */
2015 static int schedule_disconnect_messages (void *cls,
2016                                     const GNUNET_HashCode * key,
2017                                     void *value)
2018 {
2019   struct DisconnectContext *disconnect_context = cls;
2020   struct DirectNeighbor *disconnected = disconnect_context->direct;
2021   struct DirectNeighbor *notify = value;
2022   struct PendingMessage *pending_message;
2023   p2p_dv_MESSAGE_Disconnect *disconnect_message;
2024
2025   if (memcmp(&notify->identity, &disconnected->identity, sizeof(struct GNUNET_PeerIdentity)) == 0)
2026     return GNUNET_YES; /* Don't send disconnect message to peer that disconnected! */
2027
2028   pending_message = GNUNET_malloc(sizeof(struct PendingMessage) + sizeof(p2p_dv_MESSAGE_Disconnect));
2029   pending_message->msg = (struct GNUNET_MessageHeader *)&pending_message[1];
2030   pending_message->importance = default_dv_priority;
2031   pending_message->timeout = GNUNET_TIME_relative_get_forever();
2032   memcpy(&pending_message->recipient, &notify->identity, sizeof(struct GNUNET_PeerIdentity));
2033   pending_message->msg_size = sizeof(p2p_dv_MESSAGE_Disconnect);
2034   disconnect_message = (p2p_dv_MESSAGE_Disconnect *)pending_message->msg;
2035   disconnect_message->header.size = htons (sizeof (p2p_dv_MESSAGE_Disconnect));
2036   disconnect_message->header.type = htons (GNUNET_MESSAGE_TYPE_DV_DISCONNECT);
2037   disconnect_message->peer_id = htonl(disconnect_context->distant->our_id);
2038
2039   GNUNET_CONTAINER_DLL_insert_after (core_pending_head,
2040                                      core_pending_tail,
2041                                      core_pending_tail,
2042                                      pending_message);
2043
2044   GNUNET_SCHEDULER_add_now(try_core_send, NULL);
2045   /*if (core_transmit_handle == NULL)
2046     core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, default_dv_priority, GNUNET_TIME_relative_get_forever(), &notify->identity, sizeof(p2p_dv_MESSAGE_Disconnect), &core_transmit_notify, NULL);*/
2047
2048   return GNUNET_YES;
2049 }
2050
2051 /**
2052  * Multihashmap iterator for freeing extended neighbors.
2053  *
2054  * @param cls NULL
2055  * @param key key value stored under
2056  * @param value the distant neighbor to be freed
2057  *
2058  * @return GNUNET_YES to continue iteration, GNUNET_NO to stop
2059  */
2060 static int free_extended_neighbors (void *cls,
2061                                     const GNUNET_HashCode * key,
2062                                     void *value)
2063 {
2064   struct DistantNeighbor *distant = value;
2065   distant_neighbor_free(distant);
2066   return GNUNET_YES;
2067 }
2068
2069 /**
2070  * Multihashmap iterator for freeing direct neighbors.
2071  *
2072  * @param cls NULL
2073  * @param key key value stored under
2074  * @param value the direct neighbor to be freed
2075  *
2076  * @return GNUNET_YES to continue iteration, GNUNET_NO to stop
2077  */
2078 static int free_direct_neighbors (void *cls,
2079                                     const GNUNET_HashCode * key,
2080                                     void *value)
2081 {
2082   struct DirectNeighbor *direct = value;
2083   direct_neighbor_free(direct);
2084   return GNUNET_YES;
2085 }
2086
2087
2088 /**
2089  * Task run during shutdown.
2090  *
2091  * @param cls unused
2092  * @param tc unused
2093  */
2094 static void
2095 shutdown_task (void *cls,
2096                const struct GNUNET_SCHEDULER_TaskContext *tc)
2097 {
2098 #if DEBUG_DV
2099   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "calling CORE_DISCONNECT\n");
2100   GNUNET_CONTAINER_multihashmap_iterate(extended_neighbors, &print_neighbors, NULL);
2101 #endif
2102   GNUNET_CONTAINER_multihashmap_iterate(extended_neighbors, &free_extended_neighbors, NULL);
2103   GNUNET_CONTAINER_multihashmap_destroy(extended_neighbors);
2104   GNUNET_CONTAINER_multihashmap_iterate(direct_neighbors, &free_direct_neighbors, NULL);
2105   GNUNET_CONTAINER_multihashmap_destroy(direct_neighbors);
2106
2107   GNUNET_CONTAINER_heap_destroy(neighbor_max_heap);
2108   GNUNET_CONTAINER_heap_destroy(neighbor_min_heap);
2109
2110   GNUNET_CORE_disconnect (coreAPI);
2111   GNUNET_PEERINFO_disconnect(peerinfo_handle);
2112   GNUNET_SERVER_mst_destroy(coreMST);
2113   GNUNET_free_non_null(my_short_id);
2114 #if DEBUG_DV
2115   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "CORE_DISCONNECT completed\n");
2116 #endif
2117 }
2118
2119 /**
2120  * To be called on core init/fail.
2121  */
2122 void core_init (void *cls,
2123                 struct GNUNET_CORE_Handle * server,
2124                 const struct GNUNET_PeerIdentity *identity,
2125                 const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded * publicKey)
2126 {
2127
2128   if (server == NULL)
2129     {
2130       GNUNET_SCHEDULER_cancel(cleanup_task);
2131       GNUNET_SCHEDULER_add_now(&shutdown_task, NULL);
2132       return;
2133     }
2134 #if DEBUG_DV
2135   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2136               "%s: Core connection initialized, I am peer: %s\n", "dv", GNUNET_i2s(identity));
2137 #endif
2138   memcpy(&my_identity, identity, sizeof(struct GNUNET_PeerIdentity));
2139   my_short_id = GNUNET_strdup(GNUNET_i2s(&my_identity));
2140   coreAPI = server;
2141 }
2142
2143
2144 #if PKEY_NO_NEIGHBOR_ON_ADD
2145 /**
2146  * Iterator over hash map entries.
2147  *
2148  * @param cls closure
2149  * @param key current key code
2150  * @param value value in the hash map
2151  * @return GNUNET_YES if we should continue to
2152  *         iterate,
2153  *         GNUNET_NO if not.
2154  */
2155 static int add_pkey_to_extended (void *cls,
2156                                  const GNUNET_HashCode * key,
2157                                  void *abs_value)
2158 {
2159   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pkey = cls;
2160   struct DistantNeighbor *distant_neighbor = abs_value;
2161
2162   if (distant_neighbor->pkey == NULL)
2163   {
2164     distant_neighbor->pkey = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2165     memcpy(distant_neighbor->pkey, pkey, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2166   }
2167
2168   return GNUNET_YES;
2169 }
2170 #endif
2171
2172 /**
2173  * Iterator over hash map entries.
2174  *
2175  * @param cls closure
2176  * @param key current key code
2177  * @param value value in the hash map
2178  * @return GNUNET_YES if we should continue to
2179  *         iterate,
2180  *         GNUNET_NO if not.
2181  */
2182 static int update_matching_neighbors (void *cls,
2183                                       const GNUNET_HashCode * key,
2184                                       void *value)
2185 {
2186   struct NeighborUpdateInfo * update_info = cls;
2187   struct DistantNeighbor *distant_neighbor = value;
2188
2189   if (update_info->referrer == distant_neighbor->referrer) /* Direct neighbor matches, update it's info and return GNUNET_NO */
2190   {
2191     /* same referrer, cost change! */
2192     GNUNET_CONTAINER_heap_update_cost (neighbor_max_heap,
2193                                        update_info->neighbor->max_loc, update_info->cost);
2194     GNUNET_CONTAINER_heap_update_cost (neighbor_min_heap,
2195                                        update_info->neighbor->min_loc, update_info->cost);
2196     update_info->neighbor->last_activity = update_info->now;
2197     update_info->neighbor->cost = update_info->cost;
2198     update_info->neighbor->referrer_id = update_info->referrer_peer_id;
2199     return GNUNET_NO;
2200   }
2201
2202   return GNUNET_YES;
2203 }
2204
2205
2206 /**
2207  * Iterate over all current direct peers, add DISTANT newly connected
2208  * peer to the fast gossip list for that peer so we get DV routing
2209  * information out as fast as possible!
2210  *
2211  * @param cls the newly connected neighbor we will gossip about
2212  * @param key the hashcode of the peer
2213  * @param value the direct neighbor we should gossip to
2214  *
2215  * @return GNUNET_YES to continue iteration, GNUNET_NO otherwise
2216  */
2217 static int add_distant_all_direct_neighbors (void *cls,
2218                                      const GNUNET_HashCode * key,
2219                                      void *value)
2220 {
2221   struct DirectNeighbor *direct = (struct DirectNeighbor *)value;
2222   struct DistantNeighbor *distant = (struct DistantNeighbor *)cls;
2223   struct NeighborSendContext *send_context = direct->send_context;
2224   struct FastGossipNeighborList *gossip_entry;
2225 #if DEBUG_DV
2226   char *encPeerAbout;
2227   char *encPeerTo;
2228 #endif
2229
2230   if (distant == NULL)
2231     {
2232       return GNUNET_YES;
2233     }
2234
2235   if (memcmp(&direct->identity, &distant->identity, sizeof(struct GNUNET_PeerIdentity)) == 0)
2236     {
2237       return GNUNET_YES; /* Don't gossip to a peer about itself! */
2238     }
2239
2240 #if SUPPORT_HIDING
2241   if (distant->hidden == GNUNET_YES)
2242     return GNUNET_YES; /* This peer should not be gossipped about (hidden) */
2243 #endif
2244   gossip_entry = GNUNET_malloc(sizeof(struct FastGossipNeighborList));
2245   gossip_entry->about = distant;
2246
2247   GNUNET_CONTAINER_DLL_insert_after(send_context->fast_gossip_list_head,
2248                                     send_context->fast_gossip_list_tail,
2249                                     send_context->fast_gossip_list_tail,
2250                                     gossip_entry);
2251 #if DEBUG_DV
2252   encPeerAbout = GNUNET_strdup(GNUNET_i2s(&distant->identity));
2253   encPeerTo = GNUNET_strdup(GNUNET_i2s(&direct->identity));
2254
2255   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Fast send info about peer %s id %u for directly connected peer %s\n",
2256              GNUNET_i2s(&my_identity),
2257              encPeerAbout, distant->our_id, encPeerTo);
2258   GNUNET_free(encPeerAbout);
2259   GNUNET_free(encPeerTo);
2260 #endif
2261   /*if (send_context->task != GNUNET_SCHEDULER_NO_TASK)
2262     GNUNET_SCHEDULER_cancel(send_context->task);*/
2263
2264   send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, send_context);
2265   return GNUNET_YES;
2266 }
2267
2268 /**
2269  * Callback for hello address creation.
2270  *
2271  * @param cls closure, a struct HelloContext
2272  * @param max maximum number of bytes that can be written to buf
2273  * @param buf where to write the address information
2274  *
2275  * @return number of bytes written, 0 to signal the
2276  *         end of the iteration.
2277  */
2278 static size_t
2279 generate_hello_address (void *cls, size_t max, void *buf)
2280 {
2281   struct HelloContext *hello_context = cls;
2282   char *addr_buffer;
2283   size_t offset;
2284   size_t size;
2285   size_t ret;
2286
2287   if (hello_context->addresses_to_add == 0)
2288     return 0;
2289
2290   /* Hello "address" will be concatenation of distant peer and direct peer identities */
2291   size = 2 * sizeof(struct GNUNET_PeerIdentity);
2292   GNUNET_assert(max >= size);
2293
2294   addr_buffer = GNUNET_malloc(size);
2295   offset = 0;
2296   /* Copy the distant peer identity to buffer */
2297   memcpy(addr_buffer, &hello_context->distant_peer, sizeof(struct GNUNET_PeerIdentity));
2298   offset += sizeof(struct GNUNET_PeerIdentity);
2299   /* Copy the direct peer identity to buffer */
2300   memcpy(&addr_buffer[offset], hello_context->direct_peer, sizeof(struct GNUNET_PeerIdentity));
2301   ret = GNUNET_HELLO_add_address ("dv",
2302                                   GNUNET_TIME_relative_to_absolute
2303                                   (GNUNET_TIME_UNIT_HOURS), addr_buffer, size,
2304                                   buf, max);
2305
2306   hello_context->addresses_to_add--;
2307
2308   GNUNET_free(addr_buffer);
2309   return ret;
2310 }
2311
2312
2313 /**
2314  * Handles when a peer is either added due to being newly connected
2315  * or having been gossiped about, also called when the cost for a neighbor
2316  * needs to be updated.
2317  *
2318  * @param peer identity of the peer whose info is being added/updated
2319  * @param pkey public key of the peer whose info is being added/updated
2320  * @param referrer_peer_id id to use when sending to 'peer'
2321  * @param referrer if this is a gossiped peer, who did we hear it from?
2322  * @param cost the cost of communicating with this peer via 'referrer'
2323  *
2324  * @return the added neighbor, the updated neighbor or NULL (neighbor
2325  *         not added)
2326  */
2327 static struct DistantNeighbor *
2328 addUpdateNeighbor (const struct GNUNET_PeerIdentity * peer,
2329                    struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pkey,
2330                    unsigned int referrer_peer_id,
2331                    struct DirectNeighbor *referrer, unsigned int cost)
2332 {
2333   struct DistantNeighbor *neighbor;
2334   struct DistantNeighbor *max;
2335   struct GNUNET_TIME_Absolute now;
2336   struct NeighborUpdateInfo *neighbor_update;
2337   struct HelloContext *hello_context;
2338   struct GNUNET_HELLO_Message *hello_msg;
2339   unsigned int our_id;
2340   char *addr1;
2341   char *addr2;
2342   int i;
2343
2344 #if DEBUG_DV_PEER_NUMBERS
2345   char *encAbout;
2346   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2347               "%s Received sender id (%u)!\n", "DV SERVICE", referrer_peer_id);
2348 #endif
2349
2350   now = GNUNET_TIME_absolute_get ();
2351   neighbor = GNUNET_CONTAINER_multihashmap_get (extended_neighbors,
2352                                                 &peer->hashPubKey);
2353   neighbor_update = GNUNET_malloc(sizeof(struct NeighborUpdateInfo));
2354   neighbor_update->neighbor = neighbor;
2355   neighbor_update->cost = cost;
2356   neighbor_update->now = now;
2357   neighbor_update->referrer = referrer;
2358   neighbor_update->referrer_peer_id = referrer_peer_id;
2359
2360   if (neighbor != NULL)
2361     {
2362 #if USE_PEER_ID
2363       memcpy(&our_id, &neighbor->identity, sizeof(unsigned int));
2364 #else
2365       our_id = neighbor->our_id;
2366 #endif
2367     }
2368   else
2369     {
2370 #if USE_PEER_ID
2371       memcpy(&our_id, peer, sizeof(unsigned int));
2372 #else
2373       our_id = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, RAND_MAX - 1) + 1;
2374 #endif
2375     }
2376
2377   /* Either we do not know this peer, or we already do but via a different immediate peer */
2378   if ((neighbor == NULL) ||
2379       (GNUNET_CONTAINER_multihashmap_get_multiple(extended_neighbors,
2380                                                   &peer->hashPubKey,
2381                                                   &update_matching_neighbors,
2382                                                   neighbor_update) != GNUNET_SYSERR))
2383     {
2384
2385 #if AT_MOST_ONE
2386     if ((neighbor != NULL) && (cost < neighbor->cost)) /* New cost is less than old, remove old */
2387       {
2388         distant_neighbor_free(neighbor);
2389       }
2390     else if (neighbor != NULL) /* Only allow one DV connection to each peer */
2391       {
2392         return NULL;
2393       }
2394 #endif
2395       /* new neighbor! */
2396       if (cost > fisheye_depth)
2397         {
2398           /* too costly */
2399           GNUNET_free(neighbor_update);
2400           return NULL;
2401         }
2402
2403 #if DEBUG_DV_PEER_NUMBERS
2404       encAbout = GNUNET_strdup(GNUNET_i2s(peer));
2405       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2406                   "%s: %s Chose NEW id (%u) for peer %s!\n", GNUNET_i2s(&my_identity), "DV SERVICE", our_id, encAbout);
2407       GNUNET_free(encAbout);
2408 #endif
2409
2410       if (max_table_size <=
2411           GNUNET_CONTAINER_multihashmap_size (extended_neighbors))
2412         {
2413           /* remove most expensive entry */
2414           max = GNUNET_CONTAINER_heap_peek (neighbor_max_heap);
2415           GNUNET_assert(max != NULL);
2416           if (cost > max->cost)
2417             {
2418               /* new entry most expensive, don't create */
2419               GNUNET_free(neighbor_update);
2420               return NULL;
2421             }
2422           if (max->cost > 1)
2423             {
2424               /* only free if this is not a direct connection;
2425                  we could theoretically have more direct
2426                  connections than DV entries allowed total! */
2427               distant_neighbor_free (max);
2428             }
2429         }
2430
2431       neighbor = GNUNET_malloc (sizeof (struct DistantNeighbor));
2432       GNUNET_CONTAINER_DLL_insert (referrer->referee_head,
2433                          referrer->referee_tail, neighbor);
2434       neighbor->max_loc = GNUNET_CONTAINER_heap_insert (neighbor_max_heap,
2435                                                         neighbor, cost);
2436       neighbor->min_loc = GNUNET_CONTAINER_heap_insert (neighbor_min_heap,
2437                                                         neighbor, cost);
2438       neighbor->referrer = referrer;
2439       memcpy (&neighbor->identity, peer, sizeof (struct GNUNET_PeerIdentity));
2440       if (pkey != NULL) /* pkey will be null on direct neighbor addition */
2441       {
2442         neighbor->pkey = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2443         memcpy (neighbor->pkey, pkey, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2444       }
2445       else
2446         neighbor->pkey = pkey;
2447
2448       neighbor->last_activity = now;
2449       neighbor->cost = cost;
2450       neighbor->referrer_id = referrer_peer_id;
2451       neighbor->our_id = our_id;
2452       neighbor->hidden =
2453         (cost == DIRECT_NEIGHBOR_COST) ? (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 4) ==
2454                        0) : GNUNET_NO;
2455
2456       GNUNET_CONTAINER_multihashmap_put (extended_neighbors, &peer->hashPubKey,
2457                                  neighbor,
2458                                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
2459       if (referrer_peer_id != 0)
2460         {
2461           for (i = 0; i< MAX_OUTSTANDING_MESSAGES; i++)
2462             {
2463               if (referrer->pending_messages[i].sender_id == referrer_peer_id) /* We have a queued message from just learned about peer! */
2464                 {
2465 #if DEBUG_DV_MESSAGES
2466                   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: learned about peer %llu from which we have a previous unknown message, processing!\n", my_short_id, referrer_peer_id);
2467 #endif
2468                   handle_dv_data_message(NULL, &referrer->pending_messages[i].sender,
2469                                          referrer->pending_messages[i].message,
2470                                          referrer->pending_messages[i].latency,
2471                                          referrer->pending_messages[i].distance);
2472                   GNUNET_free(referrer->pending_messages[i].message);
2473                   referrer->pending_messages[i].sender_id = 0;
2474                 }
2475             }
2476         }
2477       if ((cost != DIRECT_NEIGHBOR_COST) && (neighbor->pkey != NULL))
2478         {
2479           /* Added neighbor, now send HELLO to transport */
2480           hello_context = GNUNET_malloc(sizeof(struct HelloContext));
2481           hello_context->direct_peer = &referrer->identity;
2482           memcpy(&hello_context->distant_peer, peer, sizeof(struct GNUNET_PeerIdentity));
2483           hello_context->addresses_to_add = 1;
2484           hello_msg = GNUNET_HELLO_create(pkey, &generate_hello_address, hello_context);
2485           GNUNET_assert(memcmp(hello_context->direct_peer, &hello_context->distant_peer, sizeof(struct GNUNET_PeerIdentity)) != 0);
2486           addr1 = GNUNET_strdup(GNUNET_i2s(hello_context->direct_peer));
2487           addr2 = GNUNET_strdup(GNUNET_i2s(&hello_context->distant_peer));
2488 #if DEBUG_DV
2489           GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: GIVING HELLO size %d for %s via %s to TRANSPORT\n", my_short_id, GNUNET_HELLO_size(hello_msg), addr2, addr1);
2490 #endif
2491           GNUNET_free(addr1);
2492           GNUNET_free(addr2);
2493           send_to_plugin(hello_context->direct_peer, GNUNET_HELLO_get_header(hello_msg), GNUNET_HELLO_size(hello_msg), &hello_context->distant_peer, cost);
2494           GNUNET_free(hello_context);
2495           GNUNET_free(hello_msg);
2496         }
2497
2498     }
2499   else
2500     {
2501 #if DEBUG_DV_GOSSIP
2502       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2503                   "%s: Already know peer %s distance %d, referrer id %d!\n", "dv", GNUNET_i2s(peer), cost, referrer_peer_id);
2504 #endif
2505     }
2506 #if DEBUG_DV
2507     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2508                 "%s: Size of extended_neighbors is %d\n", "dv", GNUNET_CONTAINER_multihashmap_size(extended_neighbors));
2509 #endif
2510
2511   GNUNET_free(neighbor_update);
2512   return neighbor;
2513 }
2514
2515
2516 /**
2517  * Core handler for dv disconnect messages.  These will be used
2518  * by us to tell transport via the dv plugin that a peer can
2519  * no longer be contacted by us via a certain address.  We should
2520  * then propagate these messages on, given that the distance to
2521  * the peer indicates we would have gossiped about it to others.
2522  *
2523  * @param cls closure
2524  * @param peer peer which sent the message (immediate sender)
2525  * @param message the message
2526  * @param atsi performance data
2527  */
2528 static int handle_dv_disconnect_message (void *cls,
2529                                          const struct GNUNET_PeerIdentity *peer,
2530                                          const struct GNUNET_MessageHeader *message,
2531                                          const struct GNUNET_TRANSPORT_ATS_Information *atsi)
2532 {
2533   struct DirectNeighbor *referrer;
2534   struct DistantNeighbor *distant;
2535   p2p_dv_MESSAGE_Disconnect *enc_message = (p2p_dv_MESSAGE_Disconnect *)message;
2536
2537   if (ntohs (message->size) < sizeof (p2p_dv_MESSAGE_Disconnect))
2538     {
2539       return GNUNET_SYSERR;     /* invalid message */
2540     }
2541
2542   referrer = GNUNET_CONTAINER_multihashmap_get (direct_neighbors,
2543                                                 &peer->hashPubKey);
2544   if (referrer == NULL)
2545     return GNUNET_OK;
2546
2547   distant = referrer->referee_head;
2548   while (distant != NULL)
2549     {
2550       if (distant->referrer_id == ntohl(enc_message->peer_id))
2551         {
2552           distant_neighbor_free(distant);
2553           distant = referrer->referee_head;
2554         }
2555       else
2556         distant = distant->next;
2557     }
2558
2559   return GNUNET_OK;
2560 }
2561
2562
2563 /**
2564  * Core handler for dv gossip messages.  These will be used
2565  * by us to create a HELLO message for the newly peer containing
2566  * which direct peer we can connect through, and what the cost
2567  * is.  This HELLO will then be scheduled for validation by the
2568  * transport service so that it can be used by all others.
2569  *
2570  * @param cls closure
2571  * @param peer peer which sent the message (immediate sender)
2572  * @param message the message
2573  * @param atsi performance data
2574  */
2575 static int
2576 handle_dv_gossip_message (void *cls,
2577                           const struct GNUNET_PeerIdentity *peer,
2578                           const struct GNUNET_MessageHeader *message,
2579                           const struct GNUNET_TRANSPORT_ATS_Information *atsi)
2580 {
2581   struct DirectNeighbor *referrer;
2582   p2p_dv_MESSAGE_NeighborInfo *enc_message = (p2p_dv_MESSAGE_NeighborInfo *)message;
2583
2584   if (ntohs (message->size) < sizeof (p2p_dv_MESSAGE_NeighborInfo))
2585     {
2586       return GNUNET_SYSERR;     /* invalid message */
2587     }
2588
2589 #if DEBUG_DV_GOSSIP_RECEIPT
2590   char * encPeerAbout;
2591   char * encPeerFrom;
2592
2593   encPeerAbout = GNUNET_strdup(GNUNET_i2s(&enc_message->neighbor));
2594   encPeerFrom = GNUNET_strdup(GNUNET_i2s(peer));
2595   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2596               "%s: Received %s message from peer %s about peer %s id %u distance %d!\n", GNUNET_i2s(&my_identity), "DV GOSSIP", encPeerFrom, encPeerAbout, ntohl(enc_message->neighbor_id), ntohl (enc_message->cost) + 1);
2597   GNUNET_free(encPeerAbout);
2598   GNUNET_free(encPeerFrom);
2599 #endif
2600
2601   referrer = GNUNET_CONTAINER_multihashmap_get (direct_neighbors,
2602                                                 &peer->hashPubKey);
2603   if (referrer == NULL)
2604     return GNUNET_OK;
2605
2606   addUpdateNeighbor (&enc_message->neighbor, &enc_message->pkey,
2607                      ntohl (enc_message->neighbor_id),
2608                      referrer, ntohl (enc_message->cost) + 1);
2609
2610   return GNUNET_OK;
2611 }
2612
2613
2614 /**
2615  * Iterate over all currently known peers, add them to the
2616  * fast gossip list for this peer so we get DV routing information
2617  * out as fast as possible!
2618  *
2619  * @param cls the direct neighbor we will gossip to
2620  * @param key the hashcode of the peer
2621  * @param value the distant neighbor we should add to the list
2622  *
2623  * @return GNUNET_YES to continue iteration, GNUNET_NO otherwise
2624  */
2625 static int
2626 add_all_extended_peers (void *cls,
2627                         const GNUNET_HashCode * key,
2628                         void *value)
2629 {
2630   struct NeighborSendContext *send_context = (struct NeighborSendContext *)cls;
2631   struct DistantNeighbor *distant = (struct DistantNeighbor *)value;
2632   struct FastGossipNeighborList *gossip_entry;
2633
2634   if (memcmp(&send_context->toNeighbor->identity, &distant->identity, sizeof(struct GNUNET_PeerIdentity)) == 0)
2635     return GNUNET_YES; /* Don't gossip to a peer about itself! */
2636
2637 #if SUPPORT_HIDING
2638   if (distant->hidden == GNUNET_YES)
2639     return GNUNET_YES; /* This peer should not be gossipped about (hidden) */
2640 #endif
2641   gossip_entry = GNUNET_malloc(sizeof(struct FastGossipNeighborList));
2642   gossip_entry->about = distant;
2643
2644   GNUNET_CONTAINER_DLL_insert_after(send_context->fast_gossip_list_head,
2645                                     send_context->fast_gossip_list_tail,
2646                                     send_context->fast_gossip_list_tail,
2647                                     gossip_entry);
2648
2649   return GNUNET_YES;
2650 }
2651
2652 #if INSANE_GOSSIP
2653 /**
2654  * Iterator over hash map entries.
2655  *
2656  * @param cls closure
2657  * @param key current key code
2658  * @param value value in the hash map
2659  * @return GNUNET_YES if we should continue to
2660  *         iterate,
2661  *         GNUNET_NO if not.
2662  */
2663 static int
2664 gossip_all_to_all_iterator (void *cls,
2665                             const GNUNET_HashCode * key,
2666                             void *abs_value)
2667 {
2668   struct DirectNeighbor *direct = abs_value;
2669
2670   GNUNET_CONTAINER_multihashmap_iterate (extended_neighbors, &add_all_extended_peers, direct->send_context);
2671
2672   if (direct->send_context->task != GNUNET_SCHEDULER_NO_TASK)
2673     GNUNET_SCHEDULER_cancel(direct->send_context->task);
2674
2675   direct->send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, direct->send_context);
2676   return GNUNET_YES;
2677 }
2678
2679 /**
2680  * Task run during shutdown.
2681  *
2682  * @param cls unused
2683  * @param tc unused
2684  */
2685 static void
2686 gossip_all_to_all (void *cls,
2687                    const struct GNUNET_SCHEDULER_TaskContext *tc)
2688 {
2689   GNUNET_CONTAINER_multihashmap_iterate (direct_neighbors, &gossip_all_to_all_iterator, NULL);
2690
2691   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5),
2692                                 &gossip_all_to_all,
2693                                 NULL);
2694
2695 }
2696 #endif
2697 /**
2698  * Iterate over all current direct peers, add newly connected peer
2699  * to the fast gossip list for that peer so we get DV routing
2700  * information out as fast as possible!
2701  *
2702  * @param cls the newly connected neighbor we will gossip about
2703  * @param key the hashcode of the peer
2704  * @param value the direct neighbor we should gossip to
2705  *
2706  * @return GNUNET_YES to continue iteration, GNUNET_NO otherwise
2707  */
2708 static int
2709 add_all_direct_neighbors (void *cls,
2710                           const GNUNET_HashCode * key,
2711                           void *value)
2712 {
2713   struct DirectNeighbor *direct = (struct DirectNeighbor *)value;
2714   struct DirectNeighbor *to = (struct DirectNeighbor *)cls;
2715   struct DistantNeighbor *distant;
2716   struct NeighborSendContext *send_context = direct->send_context;
2717   struct FastGossipNeighborList *gossip_entry;
2718   char *direct_id;
2719
2720
2721   distant = GNUNET_CONTAINER_multihashmap_get(extended_neighbors, &to->identity.hashPubKey);
2722   if (distant == NULL)
2723     {
2724       return GNUNET_YES;
2725     }
2726
2727   if (memcmp(&direct->identity, &to->identity, sizeof(struct GNUNET_PeerIdentity)) == 0)
2728     {
2729       return GNUNET_YES; /* Don't gossip to a peer about itself! */
2730     }
2731
2732 #if SUPPORT_HIDING
2733   if (distant->hidden == GNUNET_YES)
2734     return GNUNET_YES; /* This peer should not be gossipped about (hidden) */
2735 #endif
2736   direct_id = GNUNET_strdup(GNUNET_i2s(&direct->identity));
2737 #if DEBUG_DV_GOSSIP
2738   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s: adding peer %s to fast send list for %s\n", my_short_id, GNUNET_i2s(&distant->identity), direct_id);
2739 #endif
2740   GNUNET_free(direct_id);
2741   gossip_entry = GNUNET_malloc(sizeof(struct FastGossipNeighborList));
2742   gossip_entry->about = distant;
2743
2744   GNUNET_CONTAINER_DLL_insert_after(send_context->fast_gossip_list_head,
2745                                     send_context->fast_gossip_list_tail,
2746                                     send_context->fast_gossip_list_tail,
2747                                     gossip_entry);
2748   if (send_context->task != GNUNET_SCHEDULER_NO_TASK)
2749     GNUNET_SCHEDULER_cancel(send_context->task);
2750
2751   send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, send_context);
2752   //tc.reason = GNUNET_SCHEDULER_REASON_TIMEOUT;
2753   //neighbor_send_task(send_context, &tc);
2754   return GNUNET_YES;
2755 }
2756
2757 /**
2758  * Type of an iterator over the hosts.  Note that each
2759  * host will be called with each available protocol.
2760  *
2761  * @param cls closure
2762  * @param peer id of the peer, NULL for last call
2763  * @param hello hello message for the peer (can be NULL)
2764  */
2765 static void
2766 process_peerinfo (void *cls,
2767                   const struct GNUNET_PeerIdentity *peer,
2768                   const struct GNUNET_HELLO_Message *hello)
2769 {
2770   struct PeerIteratorContext *peerinfo_iterator = cls;
2771   struct DirectNeighbor *neighbor = peerinfo_iterator->neighbor;
2772   struct DistantNeighbor *distant = peerinfo_iterator->distant;
2773 #if DEBUG_DV_PEER_NUMBERS
2774   char *neighbor_pid;
2775 #endif
2776   int sent;
2777
2778   if (peer == NULL)
2779     {
2780       if (distant->pkey == NULL)
2781         {
2782 #if DEBUG_DV
2783           GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Failed to get peerinfo information for this peer, retrying!\n");
2784 #endif
2785           peerinfo_iterator->ic = GNUNET_PEERINFO_iterate(peerinfo_handle,
2786                                                           &peerinfo_iterator->neighbor->identity,
2787                                                           GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3),
2788                                                           &process_peerinfo,
2789                                                           peerinfo_iterator);
2790         }
2791       else
2792         {
2793           GNUNET_free(peerinfo_iterator);
2794         }
2795       return;
2796     }
2797
2798   if (memcmp(&neighbor->identity, peer, sizeof(struct GNUNET_PeerIdentity) != 0))
2799     return;
2800
2801   if ((hello != NULL) && (GNUNET_HELLO_get_key (hello, &neighbor->pkey) == GNUNET_OK))
2802     {
2803       if (distant->pkey == NULL)
2804         {
2805           distant->pkey = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2806           memcpy(distant->pkey, &neighbor->pkey, sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2807         }
2808
2809       sent = GNUNET_CONTAINER_multihashmap_iterate (extended_neighbors, &add_all_extended_peers, neighbor->send_context);
2810       if (stats != NULL)
2811         {
2812           GNUNET_STATISTICS_update (stats, "# distant peers gossiped to direct neighbors", sent, GNUNET_NO);
2813         }
2814 #if DEBUG_DV_PEER_NUMBERS
2815       neighbor_pid = GNUNET_strdup(GNUNET_i2s(&neighbor->identity));
2816       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Gossipped %d extended peers to %s\n", GNUNET_i2s(&my_identity), sent, neighbor_pid);
2817 #endif
2818       sent = GNUNET_CONTAINER_multihashmap_iterate (direct_neighbors, &add_all_direct_neighbors, neighbor);
2819       if (stats != NULL)
2820         {
2821           GNUNET_STATISTICS_update (stats, "# direct peers gossiped to direct neighbors", sent, GNUNET_NO);
2822         }
2823 #if DEBUG_DV_PEER_NUMBERS
2824       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Gossipped about %s to %d direct peers\n", GNUNET_i2s(&my_identity), neighbor_pid, sent);
2825       GNUNET_free(neighbor_pid);
2826 #endif
2827       neighbor->send_context->task = GNUNET_SCHEDULER_add_now(&neighbor_send_task, neighbor->send_context);
2828     }
2829 }
2830
2831
2832 /**
2833  * Method called whenever a peer connects.
2834  *
2835  * @param cls closure
2836  * @param peer peer identity this notification is about
2837  * @param atsi performance data
2838  */
2839 static void
2840 handle_core_connect (void *cls,
2841                      const struct GNUNET_PeerIdentity * peer,
2842                      const struct GNUNET_TRANSPORT_ATS_Information *atsi)
2843 {
2844   struct DirectNeighbor *neighbor;
2845   struct DistantNeighbor *about;
2846   struct PeerIteratorContext *peerinfo_iterator;
2847   int sent;
2848 #if DEBUG_DV
2849   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2850               "%s: Receives core connect message for peer %s distance %d!\n", "dv", GNUNET_i2s(peer), distance);
2851 #endif
2852
2853   if ((distance == DIRECT_NEIGHBOR_COST) && (GNUNET_CONTAINER_multihashmap_get(direct_neighbors, &peer->hashPubKey) == NULL))
2854   {
2855     peerinfo_iterator = GNUNET_malloc(sizeof(struct PeerIteratorContext));
2856     neighbor = GNUNET_malloc (sizeof (struct DirectNeighbor));
2857     neighbor->send_context = GNUNET_malloc(sizeof(struct NeighborSendContext));
2858     neighbor->send_context->toNeighbor = neighbor;
2859     memcpy (&neighbor->identity, peer, sizeof (struct GNUNET_PeerIdentity));
2860
2861     GNUNET_assert(GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_put (direct_neighbors,
2862                                &peer->hashPubKey,
2863                                neighbor, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
2864     about = addUpdateNeighbor (peer, NULL, 0, neighbor, DIRECT_NEIGHBOR_COST);
2865     peerinfo_iterator->distant = about;
2866     peerinfo_iterator->neighbor = neighbor;
2867     peerinfo_iterator->ic = GNUNET_PEERINFO_iterate (peerinfo_handle,
2868                                                      peer,
2869                                                      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3),
2870                                                      &process_peerinfo,
2871                                                      peerinfo_iterator);
2872
2873     if ((about != NULL) && (about->pkey == NULL))
2874       {
2875 #if DEBUG_DV
2876         GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Newly added peer %s has NULL pkey!\n", GNUNET_i2s(peer));
2877 #endif
2878       }
2879     else if (about != NULL)
2880       {
2881         GNUNET_free(peerinfo_iterator);
2882       }
2883   }
2884   else
2885   {
2886     about = GNUNET_CONTAINER_multihashmap_get(extended_neighbors, &peer->hashPubKey);
2887     if ((GNUNET_CONTAINER_multihashmap_get(direct_neighbors, &peer->hashPubKey) == NULL) && (about != NULL))
2888       {
2889         sent = GNUNET_CONTAINER_multihashmap_iterate(direct_neighbors, &add_distant_all_direct_neighbors, about);
2890         if (stats != NULL)
2891           {
2892             GNUNET_STATISTICS_update (stats, "# direct peers gossiped to new direct neighbors", sent, GNUNET_NO);
2893           }
2894       }
2895 #if DEBUG_DV
2896     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2897                 "%s: Distance (%d) greater than %d or already know about peer (%s), not re-adding!\n", "dv", distance, DIRECT_NEIGHBOR_COST, GNUNET_i2s(peer));
2898 #endif
2899     return;
2900   }
2901 }
2902
2903 /**
2904  * Method called whenever a given peer disconnects.
2905  *
2906  * @param cls closure
2907  * @param peer peer identity this notification is about
2908  */
2909 void handle_core_disconnect (void *cls,
2910                              const struct GNUNET_PeerIdentity * peer)
2911 {
2912   struct DirectNeighbor *neighbor;
2913   struct DistantNeighbor *referee;
2914   struct FindDestinationContext fdc;
2915   struct DisconnectContext disconnect_context;
2916
2917 #if DEBUG_DV
2918   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2919               "%s: Receives core peer disconnect message!\n", "dv");
2920 #endif
2921
2922   neighbor =
2923     GNUNET_CONTAINER_multihashmap_get (direct_neighbors, &peer->hashPubKey);
2924   if (neighbor == NULL)
2925     {
2926       return;
2927     }
2928   while (NULL != (referee = neighbor->referee_head))
2929     distant_neighbor_free (referee);
2930
2931   fdc.dest = NULL;
2932   fdc.tid = 0;
2933
2934   GNUNET_CONTAINER_multihashmap_iterate (extended_neighbors, &find_distant_peer, &fdc);
2935
2936   if (fdc.dest != NULL)
2937     {
2938       disconnect_context.direct = neighbor;
2939       disconnect_context.distant = fdc.dest;
2940       GNUNET_CONTAINER_multihashmap_iterate (direct_neighbors, &schedule_disconnect_messages, &disconnect_context);
2941     }
2942
2943   GNUNET_assert (neighbor->referee_tail == NULL);
2944   if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (direct_neighbors,
2945                                         &peer->hashPubKey, neighbor))
2946     {
2947       GNUNET_break(0);
2948     }
2949   if ((neighbor->send_context != NULL) && (neighbor->send_context->task != GNUNET_SCHEDULER_NO_TASK))
2950     GNUNET_SCHEDULER_cancel(neighbor->send_context->task);
2951   GNUNET_free (neighbor);
2952 }
2953
2954
2955 /**
2956  * Process dv requests.
2957  *
2958  * @param cls closure
2959  * @param server the initialized server
2960  * @param c configuration to use
2961  */
2962 static void
2963 run (void *cls,
2964      struct GNUNET_SERVER_Handle *server,
2965      const struct GNUNET_CONFIGURATION_Handle *c)
2966 {
2967   unsigned long long max_hosts;
2968   cfg = c;
2969
2970   /* FIXME: Read from config, or calculate, or something other than this! */
2971   max_hosts = DEFAULT_DIRECT_CONNECTIONS;
2972   max_table_size = DEFAULT_DV_SIZE;
2973   fisheye_depth = DEFAULT_FISHEYE_DEPTH;
2974
2975   if (GNUNET_CONFIGURATION_have_value(cfg, "dv", "max_direct_connections"))
2976     GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "dv", "max_direct_connections", &max_hosts));
2977
2978   if (GNUNET_CONFIGURATION_have_value(cfg, "dv", "max_total_connections"))
2979     GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "dv", "max_total_connections", &max_table_size));
2980
2981
2982   if (GNUNET_CONFIGURATION_have_value(cfg, "dv", "fisheye_depth"))
2983     GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "dv", "fisheye_depth", &fisheye_depth));
2984
2985   neighbor_min_heap =
2986     GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
2987   neighbor_max_heap =
2988     GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX);
2989
2990   direct_neighbors = GNUNET_CONTAINER_multihashmap_create (max_hosts);
2991   extended_neighbors =
2992     GNUNET_CONTAINER_multihashmap_create (max_table_size * 3);
2993
2994   GNUNET_SERVER_add_handlers (server, plugin_handlers);
2995   coreAPI =
2996   GNUNET_CORE_connect (cfg,
2997                        1,
2998                        NULL, /* FIXME: anything we want to pass around? */
2999                        &core_init,
3000                        &handle_core_connect,
3001                        &handle_core_disconnect,
3002                        NULL,
3003                        NULL,
3004                        GNUNET_NO,
3005                        NULL,
3006                        GNUNET_NO,
3007                        core_handlers);
3008
3009   if (coreAPI == NULL)
3010     return;
3011
3012   coreMST = GNUNET_SERVER_mst_create (&tokenized_message_handler,
3013                                       NULL);
3014
3015    peerinfo_handle = GNUNET_PEERINFO_connect(cfg);
3016
3017    if (peerinfo_handle == NULL)
3018      {
3019        GNUNET_CORE_disconnect(coreAPI);
3020        return;
3021      }
3022
3023   /* Scheduled the task to clean up when shutdown is called */
3024   cleanup_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
3025                                 &shutdown_task,
3026                                 NULL);
3027 }
3028
3029
3030 /**
3031  * The main function for the dv service.
3032  *
3033  * @param argc number of arguments from the command line
3034  * @param argv command line arguments
3035  * @return 0 ok, 1 on error
3036  */
3037 int
3038 main (int argc, char *const *argv)
3039 {
3040   return (GNUNET_OK ==
3041           GNUNET_SERVICE_run (argc,
3042                               argv,
3043                               "dv",
3044                               GNUNET_SERVICE_OPTION_NONE,
3045                               &run, NULL)) ? 0 : 1;
3046 }