gnunet-service-dht_neighbours.c File Reference

GNUnet DHT service's bucket and neighbour management code. More...

#include "gnunet_common.h"
#include "gnunet_constants.h"
#include "gnunet_datacache_lib.h"
#include "gnunet_dht_service.h"
#include "gnunet_protocols.h"
#include "gnunet_hello_uri_lib.h"
#include "gnunet_pils_service.h"
#include "gnunet-service-dht.h"
#include "gnunet-service-dht_neighbours.h"
#include "gnunet-service-dht_routing.h"
#include "dht.h"
#include "dht_helper.h"
#include "gnunet_scheduler_lib.h"
#include "gnunet_util_lib.h"

Include dependency graph for gnunet-service-dht_neighbours.c:

Go to the source code of this file.

Data Structures
struct	PeerResultMessage
	P2P Result message. More...
struct	PeerGetMessage
	P2P GET message. More...
struct	Target
	List of targets that we can use to reach this peer. More...
struct	PeerInfo
	Entry for a peer in a bucket. More...
struct	PeerBucket
	Peers are grouped into buckets. More...
struct	GDS_RoutingPutCallbackData
struct	GDS_NeighboursReply
struct	ForwardedDHTPut
struct	BlockCls
struct	HandleCallbackGet

Macros
#define	LOG_TRAFFIC(kind, ...)
#define	SANITY_CHECKS   2
	Enable slow sanity checks to debug issues.
#define	MAX_BUCKETS   sizeof(struct GNUNET_HashCode) * 8
	How many buckets will we allow in total.
#define	DEFAULT_BUCKET_SIZE   8
	What is the maximum number of peers in a given bucket.
#define	FIND_PEER_REPLICATION_LEVEL   4
	Desired replication level for FIND PEER requests.
#define	MAXIMUM_PENDING_PER_PEER   64
	Maximum allowed number of pending messages per peer.
#define	DHT_MINIMUM_FIND_PEER_INTERVAL
	How long at least to wait before sending another find peer request.
#define	DHT_AVG_FIND_PEER_INTERVAL
	How long to additionally wait on average per bucket_size to send out the FIND PEER requests if we did successfully connect (!) to a a new peer and added it to a bucket (as counted in newly_found_peers).
#define	GET_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2)
	How long at most to wait for transmission of a GET request to another peer?

Functions
static void	send_done_cb (void *cls)
	Function called whenever we finished sending to a target.
static bool	do_send (struct PeerInfo *pi, const struct GNUNET_MessageHeader *msg)
	Send msg to pi.
static int	find_bucket (const struct GNUNET_HashCode *hc)
	Find the optimal bucket for this key.
static enum GNUNET_GenericReturnValue	add_known_to_bloom (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Add each of the peers we already know to the Bloom filter of the request so that we don't get duplicate HELLOs.
static void	send_find_peer_message (void *cls)
	Task to send a find peer message for our own peer identifier so that we can find the closest peers in the network to ourselves and attempt to connect to them.
static void	update_hold (struct PeerBucket *bucket)
	The list of the first bucket_size peers of bucket changed.
void	GDS_u_connect (void *cls, struct GNUNET_DHTU_Target *target, const struct GNUNET_PeerIdentity *pid, void **ctx)
	Function to call when we connect to a peer and can henceforth transmit to that peer.
void	GDS_u_disconnect (void *ctx)
	Function to call when we disconnected from a peer and can henceforth cannot transmit to that peer anymore.
static unsigned int	get_forward_count (uint16_t hop_count, uint16_t target_replication)
	To how many peers should we (on average) forward the request to obtain the desired target_replication count (on average).
enum GNUNET_GenericReturnValue	GDS_am_closest_peer (const struct GNUNET_HashCode *key, const struct GNUNET_CONTAINER_BloomFilter *bloom)
	Check whether my identity is closer than any known peers.
static struct PeerInfo *	select_peer (const struct GNUNET_HashCode *key, const struct GNUNET_CONTAINER_BloomFilter *bloom, uint32_t hops)
	Select a peer from the routing table that would be a good routing destination for sending a message for key.
static unsigned int	get_target_peers (const struct GNUNET_HashCode *key, struct GNUNET_CONTAINER_BloomFilter *bloom, uint16_t hop_count, uint16_t target_replication, struct PeerInfo ***targets)
	Compute the set of peers that the given request should be forwarded to.
static void	hello_check (const struct GNUNET_DATACACHE_Block *bd)
	If we got a HELLO, consider it for our own routing table.
static bool	cb_routing_put_message (void *cls, size_t msize, struct PeerPutMessage *ppm)
void	GDS_NEIGHBOURS_handle_put (const struct GNUNET_DATACACHE_Block *bd, uint16_t desired_replication_level, uint16_t hop_count, struct GNUNET_CONTAINER_BloomFilter *bf, GDS_PutOperationCallback cb, void *cb_cls)
	Perform a PUT operation.
enum GNUNET_GenericReturnValue	GDS_NEIGHBOURS_handle_get (enum GNUNET_BLOCK_Type type, enum GNUNET_DHT_RouteOption options, uint16_t desired_replication_level, uint16_t hop_count, const struct GNUNET_HashCode *key, const void *xquery, size_t xquery_size, struct GNUNET_BLOCK_Group *bg, struct GNUNET_CONTAINER_BloomFilter *peer_bf)
	Perform a GET operation.
struct PeerInfo *	GDS_NEIGHBOURS_lookup_peer (const struct GNUNET_PeerIdentity *target)
	Lookup peer by peer's identity.
static void	cleanup_neighbours_reply (struct GDS_NeighboursReply *reply)
static void	safe_neighbours_callback (void *cls, GNUNET_SCHEDULER_TaskCallback cb, bool success)
static bool	cb_path_signed (void *cls, const struct GNUNET_CRYPTO_EddsaSignature *sig)
void	GDS_NEIGHBOURS_handle_reply (struct PeerInfo *pi, const struct GNUNET_DATACACHE_Block *bd, const struct GNUNET_HashCode *query_hash, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *get_path, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
	Handle a reply (route to origin).
static enum GNUNET_GenericReturnValue	check_dht_p2p_put (void *cls, const struct PeerPutMessage *put)
	Check validity of a p2p put request.
static void	cb_forwarded_dht_p2p_put (void *cls, enum GNUNET_GenericReturnValue forwarded)
static void	handle_dht_p2p_put (void *cls, const struct PeerPutMessage *put)
	Core handler for p2p put requests.
static void	handle_find_my_hello (struct PeerInfo *pi, const struct GNUNET_HashCode *query_hash, struct GNUNET_BLOCK_Group *bg, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
	We have received a request for a HELLO.
static void	handle_find_local_hello (struct PeerInfo *pi, const struct GNUNET_HashCode *query_hash, struct GNUNET_BLOCK_Group *bg, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
	We have received a request for nearby HELLOs.
static void	handle_local_result (void *cls, const struct GNUNET_DATACACHE_Block *bd)
	Handle an exact result from local datacache for a GET operation.
static enum GNUNET_GenericReturnValue	check_dht_p2p_get (void *cls, const struct PeerGetMessage *get)
	Check validity of p2p get request.
static void	cb_handle_dht_p2p_get_local_result (void *cls)
static void	cb_handle_dht_p2p_get_local_hello (void *cls)
static void	cb_handle_dht_p2p_get_my_hello (void *cls)
static void	handle_dht_p2p_get (void *cls, const struct PeerGetMessage *get)
	Core handler for p2p get requests.
static void	process_reply_with_path (const struct GNUNET_DATACACHE_Block *bd, const struct GNUNET_HashCode *query_hash, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *get_path)
	Process a reply, after the get_path has been updated.
static enum GNUNET_GenericReturnValue	check_dht_p2p_result (void *cls, const struct PeerResultMessage *prm)
	Check validity of p2p result message.
static void	handle_dht_p2p_result (void *cls, const struct PeerResultMessage *prm)
	Core handler for p2p result messages.
static enum GNUNET_GenericReturnValue	check_dht_p2p_hello (void *cls, const struct GNUNET_MessageHeader *hello)
	Check validity of a p2p hello message.
static void	handle_dht_p2p_hello (void *cls, const struct GNUNET_MessageHeader *hello)
	Core handler for p2p HELLO messages.
void	GDS_u_receive (void *cls, void **tctx, void **sctx, const void *message, size_t message_size)
	Function to call when we receive a message.
void	GDS_try_connect (void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
	Callback function used to extract URIs from a builder.
void	GDS_NEIGHBOURS_broadcast (const struct GNUNET_MessageHeader *msg)
	Send msg to all peers in our buckets.
enum GNUNET_GenericReturnValue	GDS_NEIGHBOURS_init ()
	Initialize neighbours subsystem.
void	GDS_NEIGHBOURS_done ()
	Shutdown neighbours subsystem.
const struct GNUNET_PeerIdentity *	GDS_NEIGHBOURS_get_id ()
	Get the ID of the local node.

Variables
static int	cache_results
	Do we cache all results that we are routing in the local datacache?
static unsigned int	closest_bucket
	One past the deepest currently used bucket, initially 0 (no peers at all).
static unsigned int	newly_found_peers
	How many peers have we added since we sent out our last find peer request?
static int	disable_try_connect
	Option for testing that disables the 'connect' function of the DHT.
static struct PeerBucket	k_buckets [sizeof(struct GNUNET_HashCode) *8]
	The buckets.
static struct GNUNET_CONTAINER_MultiPeerMap *	all_connected_peers
	Hash map of all CORE-connected peers, for easy removal from k_buckets on disconnect.
static unsigned int	bucket_size = 8
	Maximum size for each bucket.
static struct GNUNET_SCHEDULER_Task *	find_peer_task
	Task that sends FIND PEER requests.

Detailed Description

GNUnet DHT service's bucket and neighbour management code.

Author

Christian Grothoff

Nathan Evans

Definition in file gnunet-service-dht_neighbours.c.

Macro Definition Documentation

LOG_TRAFFIC

#define LOG_TRAFFIC	(		kind,
			...
	)

Value:

                                                GNUNET_log_from (kind, "dht-traffic", \
                                                __VA_ARGS__)

Definition at line 42 of file gnunet-service-dht_neighbours.c.

{
  struct GNUNET_MessageHeader header;
 
  uint32_t type GNUNET_PACKED;
 
  uint16_t reserved GNUNET_PACKED;
 
  uint16_t options GNUNET_PACKED;
 
  uint16_t put_path_length GNUNET_PACKED;
 
  uint16_t get_path_length GNUNET_PACKED;
 
  struct GNUNET_TIME_AbsoluteNBO expiration_time;
 
  struct GNUNET_HashCode key;
 
  /* trunc_peer (if truncated) */
 
  /* put path (if tracked) */
 
  /* get path (if tracked) */
 
  /* sender_sig (if path tracking is on) */
 
  /* Payload */
};
 
 
struct PeerGetMessage
{
  struct GNUNET_MessageHeader header;
 
  uint32_t type GNUNET_PACKED;
 
  uint16_t options GNUNET_PACKED;
 
  uint16_t hop_count GNUNET_PACKED;
 
  uint16_t desired_replication_level GNUNET_PACKED;
 
  uint16_t result_filter_size GNUNET_PACKED;
 
  char bloomfilter[DHT_BLOOM_SIZE];
 
  struct GNUNET_HashCode key;
 
  /* result bloomfilter */
 
  /* xquery */
 
};
GNUNET_NETWORK_STRUCT_END
 
 
struct PeerInfo;
 
 
struct Target
{
  struct Target *next;
 
  struct Target *prev;
 
  struct GNUNET_DHTU_Target *utarget;
 
  struct GDS_Underlay *u;
 
  struct PeerInfo *pi;
 
  struct GNUNET_DHTU_PreferenceHandle *ph;
 
  unsigned int load;
 
  bool dropped;
 
};
 
 
struct PeerInfo
{
  struct GNUNET_PeerIdentity id;
 
  struct GNUNET_HashCode phash;
 
  struct GNUNET_TIME_Absolute hello_expiration;
 
  struct PeerInfo *next;
 
  struct PeerInfo *prev;
 
  struct Target *t_head;
 
  struct Target *t_tail;
 
  void *hello;
 
  size_t hello_size;
 
  int peer_bucket;
};
 
 
struct PeerBucket
{
  struct PeerInfo *head;
 
  struct PeerInfo *tail;
 
  unsigned int peers_size;
};
 
 
static int cache_results;
 
static unsigned int closest_bucket;
 
static unsigned int newly_found_peers;
 
static int disable_try_connect;
 
static struct PeerBucket k_buckets[MAX_BUCKETS];
 
static struct GNUNET_CONTAINER_MultiPeerMap *all_connected_peers;
 
static unsigned int bucket_size = DEFAULT_BUCKET_SIZE;
 
static struct GNUNET_SCHEDULER_Task *find_peer_task;
 
 
static void
send_done_cb (void *cls)
{
  struct Target *t = cls;
  struct PeerInfo *pi = t->pi; /* NULL if t->dropped! */
 
  GNUNET_assert (t->load > 0);
  t->load--;
  if (0 < t->load)
    return;
  if (t->dropped)
  {
    GNUNET_free (t);
    return;
  }
  /* move target back to the front */
  GNUNET_CONTAINER_DLL_remove (pi->t_head,
                               pi->t_tail,
                               t);
  GNUNET_CONTAINER_DLL_insert (pi->t_head,
                               pi->t_tail,
                               t);
}
 
 
static bool
do_send (struct PeerInfo *pi,
         const struct GNUNET_MessageHeader *msg)
{
  struct Target *t;
 
  for (t = pi->t_head;
       NULL != t;
       t = t->next)
    if (t->load < MAXIMUM_PENDING_PER_PEER)
      break;
  if (NULL == t)
  {
    /* all targets busy, drop message */
    GNUNET_STATISTICS_update (GDS_stats,
                              "# messages dropped (underlays busy)",
                              1,
                              GNUNET_NO);
    return false;
  }
  t->load++;
  /* rotate busy targets to the end */
  if (MAXIMUM_PENDING_PER_PEER == t->load)
  {
    GNUNET_CONTAINER_DLL_remove (pi->t_head,
                                 pi->t_tail,
                                 t);
    GNUNET_CONTAINER_DLL_insert_tail (pi->t_head,
                                      pi->t_tail,
                                      t);
  }
  GDS_u_send (t->u,
              t->utarget,
              msg,
              ntohs (msg->size),
              &send_done_cb,
              t);
  return true;
}
 
 
static int
find_bucket (const struct GNUNET_HashCode *hc)
{
  const struct GNUNET_HashCode *my_identity_hash;
  struct GNUNET_HashCode xor;
  unsigned int bits;
 
  my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
  GNUNET_assert (NULL != my_identity_hash);
 
  GNUNET_CRYPTO_hash_xor (hc,
                          my_identity_hash,
                          &xor);
  bits = GNUNET_CRYPTO_hash_count_leading_zeros (&xor);
  if (bits == MAX_BUCKETS)
  {
    /* How can all bits match? Got my own ID? */
    GNUNET_break (0);
    return -1;
  }
  return bits;
}
 
 
static enum GNUNET_GenericReturnValue
add_known_to_bloom (void *cls,
                    const struct GNUNET_PeerIdentity *key,
                    void *value)
{
  struct GNUNET_BLOCK_Group *bg = cls;
  struct PeerInfo *pi = value;
 
  GNUNET_BLOCK_group_set_seen (bg,
                               &pi->phash,
                               1);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Adding known peer (%s) to Bloom filter for FIND PEER\n",
              GNUNET_i2s (key));
  return GNUNET_YES;
}
 
 
static void
send_find_peer_message (void *cls)
{
  (void) cls;
 
  /* Compute when to do this again (and if we should
     even send a message right now) */
  {
    struct GNUNET_TIME_Relative next_send_time;
    bool done_early;
 
    find_peer_task = NULL;
    done_early = (newly_found_peers > bucket_size);
    /* schedule next round, taking longer if we found more peers
       in the last round. */
    next_send_time.rel_value_us =
      DHT_MINIMUM_FIND_PEER_INTERVAL.rel_value_us
      + GNUNET_CRYPTO_random_u64 (
        GNUNET_TIME_relative_multiply (
          DHT_AVG_FIND_PEER_INTERVAL,
          1 + 100 * (1 + newly_found_peers) / bucket_size).rel_value_us);
    newly_found_peers = 0;
    GNUNET_assert (NULL == find_peer_task);
    find_peer_task =
      GNUNET_SCHEDULER_add_delayed (next_send_time,
                                    &send_find_peer_message,
                                    NULL);
    if (done_early)
      return;
  }
 
  /* actually send 'find peer' request */
  {
    const struct GNUNET_HashCode *my_identity_hash;
    struct GNUNET_BLOCK_Group *bg;
    struct GNUNET_CONTAINER_BloomFilter *peer_bf;
 
    my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
    GNUNET_assert (NULL != my_identity_hash);
 
    bg = GNUNET_BLOCK_group_create (GDS_block_context,
                                    GNUNET_BLOCK_TYPE_DHT_HELLO,
                                    NULL,
                                    0,
                                    "seen-set-size",
                                    GNUNET_CONTAINER_multipeermap_size (
                                      all_connected_peers),
                                    NULL);
    GNUNET_CONTAINER_multipeermap_iterate (all_connected_peers,
                                           &add_known_to_bloom,
                                           bg);
    peer_bf
      = GNUNET_CONTAINER_bloomfilter_init (NULL,
                                           DHT_BLOOM_SIZE,
                                           GNUNET_CONSTANTS_BLOOMFILTER_K);
    if (GNUNET_OK !=
        GDS_NEIGHBOURS_handle_get (GNUNET_BLOCK_TYPE_DHT_HELLO,
                                   GNUNET_DHT_RO_FIND_APPROXIMATE
                                   | GNUNET_DHT_RO_RECORD_ROUTE,
                                   FIND_PEER_REPLICATION_LEVEL,
                                   0, /* hop count */
                                   my_identity_hash,
                                   NULL, 0, /* xquery */
                                   bg,
                                   peer_bf))
    {
      GNUNET_STATISTICS_update (GDS_stats,
                                "# Failed to initiate FIND PEER lookup",
                                1,
                                GNUNET_NO);
    }
    else
    {
      GNUNET_STATISTICS_update (GDS_stats,
                                "# FIND PEER messages initiated",
                                1,
                                GNUNET_NO);
    }
    GNUNET_CONTAINER_bloomfilter_free (peer_bf);
    GNUNET_BLOCK_group_destroy (bg);
  }
}
 
 
static void
update_hold (struct PeerBucket *bucket)
{
  unsigned int off = 0;
 
  /* find the peer -- we just go over all of them, should
     be hardly any more expensive than just finding the 'right'
     one. */
  for (struct PeerInfo *pos = bucket->head;
       NULL != pos;
       pos = pos->next)
  {
    if (off > bucket_size)
      break;   /* We only hold up to #bucket_size peers per bucket */
    off++;
    for (struct Target *tp = pos->t_head;
         NULL != tp;
         tp = tp->next)
      if (NULL == tp->ph)
        tp->ph = GDS_u_hold (tp->u,
                             tp->utarget);
  }
}
 
 
void
GDS_u_connect (void *cls,
               struct GNUNET_DHTU_Target *target,
               const struct GNUNET_PeerIdentity *pid,
               void **ctx)
{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GDS_Underlay *u = cls;
  struct PeerInfo *pi;
  struct PeerBucket *bucket;
  bool do_hold = false;
 
  my_identity = GNUNET_PILS_get_identity (GDS_pils);
  GNUNET_assert (NULL != my_identity);
 
  /* Check for connect to self message */
  if (0 == GNUNET_memcmp (my_identity, pid))
    return;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Connected to peer %s\n",
              GNUNET_i2s (pid));
  pi = GNUNET_CONTAINER_multipeermap_get (all_connected_peers,
                                          pid);
  if (NULL == pi)
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# peers connected",
                              1,
                              GNUNET_NO);
    pi = GNUNET_new (struct PeerInfo);
    pi->id = *pid;
    GNUNET_CRYPTO_hash (pid,
                        sizeof(*pid),
                        &pi->phash);
    pi->peer_bucket = find_bucket (&pi->phash);
    GNUNET_assert ( (pi->peer_bucket >= 0) &&
                    ((unsigned int) pi->peer_bucket < MAX_BUCKETS));
    bucket = &k_buckets[pi->peer_bucket];
    GNUNET_CONTAINER_DLL_insert_tail (bucket->head,
                                      bucket->tail,
                                      pi);
    bucket->peers_size++;
    closest_bucket = GNUNET_MAX (closest_bucket,
                                 (unsigned int) pi->peer_bucket + 1);
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_multipeermap_put (all_connected_peers,
                                                      &pi->id,
                                                      pi,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    if (bucket->peers_size <= bucket_size)
    {
      newly_found_peers++;
      do_hold = true;
    }
    if ( (1 == GNUNET_CONTAINER_multipeermap_size (all_connected_peers)) &&
         (GNUNET_YES != disable_try_connect) )
    {
      /* got a first connection, good time to start with FIND PEER requests... */
      GNUNET_assert (NULL == find_peer_task);
      find_peer_task = GNUNET_SCHEDULER_add_now (&send_find_peer_message,
                                                 NULL);
    }
    /* A pending GET that found no route is sitting on an exponential
       back-off of up to 15 minutes; now that we have somewhere to send
       it, do so immediately.  A PUT that found no route was not sent at
       all and nothing else will ever send it. */
    GDS_CLIENTS_retry_requests ();
    GDS_CLIENTS_retry_puts ();
  }
  {
    struct Target *t;
 
    t = GNUNET_new (struct Target);
    t->u = u;
    t->utarget = target;
    t->pi = pi;
    GNUNET_CONTAINER_DLL_insert (pi->t_head,
                                 pi->t_tail,
                                 t);
    *ctx = t;
 
  }
  if (do_hold)
    update_hold (bucket);
}
 
 
void
GDS_u_disconnect (void *ctx)
{
  struct Target *t = ctx;
  struct PeerInfo *pi;
  struct PeerBucket *bucket;
  bool was_held = false;
 
  /* Check for disconnect from self message (on shutdown) */
  if (NULL == t)
    return;
  pi = t->pi;
  GNUNET_CONTAINER_DLL_remove (pi->t_head,
                               pi->t_tail,
                               t);
  if (NULL != t->ph)
  {
    GDS_u_drop (t->u,
                t->ph);
    t->ph = NULL;
    was_held = true;
  }
  if (t->load > 0)
  {
    t->dropped = true;
    t->pi = NULL;
  }
  else
  {
    GNUNET_free (t);
  }
  if (NULL != pi->t_head)
    return; /* got other connections still */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Disconnected from peer %s\n",
              GNUNET_i2s (&pi->id));
  GNUNET_STATISTICS_update (GDS_stats,
                            "# peers connected",
                            -1,
                            GNUNET_NO);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (all_connected_peers,
                                                       &pi->id,
                                                       pi));
  if ( (0 == GNUNET_CONTAINER_multipeermap_size (all_connected_peers)) &&
       (GNUNET_YES != disable_try_connect))
  {
    GNUNET_SCHEDULER_cancel (find_peer_task);
    find_peer_task = NULL;
  }
  GNUNET_assert (pi->peer_bucket >= 0);
  bucket = &k_buckets[pi->peer_bucket];
  GNUNET_CONTAINER_DLL_remove (bucket->head,
                               bucket->tail,
                               pi);
  GNUNET_assert (bucket->peers_size > 0);
  bucket->peers_size--;
  if ( (was_held) &&
       (bucket->peers_size >= bucket_size - 1) )
    update_hold (bucket);
  while ( (closest_bucket > 0) &&
          (0 == k_buckets[closest_bucket - 1].peers_size))
    closest_bucket--;
  GNUNET_free (pi->hello);
  GNUNET_free (pi);
}
 
 
static unsigned int
get_forward_count (uint16_t hop_count,
                   uint16_t target_replication)
{
  uint32_t random_value;
  uint32_t forward_count;
  float target_value;
  double rm1;
  double nse = GDS_NSE_get ();
 
  /* Guard the divisor below: an NSE of zero would make target_value
     infinite (or NaN), and the conversion to uint32_t undefined. */
  if (! (nse >= MINIMUM_LOG_NSE))
    nse = MINIMUM_LOG_NSE;
  if (hop_count > nse * 4.0)
  {
    /* forcefully terminate */
    GNUNET_STATISTICS_update (GDS_stats,
                              "# requests TTL-dropped",
                              1,
                              GNUNET_NO);
    return 0;
  }
  if (hop_count > nse * 2.0)
  {
    /* Once we have reached our ideal number of hops, only forward to 1 peer */
    return 1;
  }
  /* bound by system-wide maximum and minimum */
  if (0 == target_replication)
    target_replication = 1; /* 0 is verboten */
  target_replication =
    GNUNET_MIN (GNUNET_DHT_MAXIMUM_REPLICATION_LEVEL,
                target_replication);
  rm1 = target_replication - 1.0;
  target_value =
    1 + (rm1) / (nse + (rm1 * hop_count));
 
  /* Set forward count to floor of target_value */
  forward_count = (uint32_t) target_value;
  /* Subtract forward_count (floor) from target_value (yields value between 0 and 1) */
  target_value = target_value - forward_count;
  random_value = GNUNET_CRYPTO_random_u32 (UINT32_MAX);
  if (random_value < (target_value * UINT32_MAX))
    forward_count++;
  return GNUNET_MIN (forward_count,
                     GNUNET_DHT_MAXIMUM_REPLICATION_LEVEL);
}
 
 
enum GNUNET_GenericReturnValue
GDS_am_closest_peer (const struct GNUNET_HashCode *key,
                     const struct GNUNET_CONTAINER_BloomFilter *bloom)
{
  const struct GNUNET_HashCode *my_identity_hash;
  int delta;
  my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
  GNUNET_assert (NULL != my_identity_hash);
  if (0 == GNUNET_memcmp (my_identity_hash, key))
    return GNUNET_YES;
  for (int bucket_num = find_bucket (key);
       bucket_num < closest_bucket;
       bucket_num++)
  {
    unsigned int count = 0;
    GNUNET_assert (bucket_num >= 0);
    for (struct PeerInfo *pos = k_buckets[bucket_num].head;
         NULL != pos;
         pos = pos->next)
    {
      if (count >= bucket_size)
        break; /* we only consider first #bucket_size entries per bucket */
      count++;
      if ( (NULL != bloom) &&
           (GNUNET_YES ==
            GNUNET_CONTAINER_bloomfilter_test (bloom,
                                               &pos->phash)) )
        continue;               /* Ignore filtered peers */
      /* All peers in this bucket must be closer than us, as
         they mismatch with our PID on the pivotal bit. So
         because an unfiltered peer exists, we are not the
         closest. */
      delta = GNUNET_CRYPTO_hash_xorcmp (&pos->phash,
                                         my_identity_hash,
                                         key);
      switch (delta)
      {
      case -1: /* pos closer */
        return GNUNET_NO;
      case 0: /* identical, impossible! */
        GNUNET_assert (0);
        break;
      case 1: /* I am closer */
        break;
      }
    }
  }
  /* No closer (unfiltered) peers found; we must be the closest! */
  return GNUNET_YES;
}
 
 
static struct PeerInfo *
select_peer (const struct GNUNET_HashCode *key,
             const struct GNUNET_CONTAINER_BloomFilter *bloom,
             uint32_t hops)
{
  if (0 == closest_bucket)
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# Peer selection failed",
                              1,
                              GNUNET_NO);
    return NULL; /* we have zero connections */
  }
  if (hops >= GDS_NSE_get ())
  {
    /* greedy selection (closest peer that is not in Bloom filter) */
    struct PeerInfo *chosen = NULL;
    int best_bucket;
    int bucket_offset;
 
    {
      const struct GNUNET_HashCode *my_identity_hash;
      struct GNUNET_HashCode xor;
      my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
      GNUNET_assert (NULL != my_identity_hash);
      GNUNET_CRYPTO_hash_xor (key,
                              my_identity_hash,
                              &xor);
      best_bucket = GNUNET_CRYPTO_hash_count_leading_zeros (&xor);
    }
    if (best_bucket >= closest_bucket)
      bucket_offset = closest_bucket - 1;
    else
      bucket_offset = best_bucket;
    while (-1 != bucket_offset)
    {
      struct PeerBucket *bucket = &k_buckets[bucket_offset];
      unsigned int count = 0;
 
      for (struct PeerInfo *pos = bucket->head;
           NULL != pos;
           pos = pos->next)
      {
        if (count >= bucket_size)
          break; /* we only consider first #bucket_size entries per bucket */
        count++;
        if ( (NULL != bloom) &&
             (GNUNET_YES ==
              GNUNET_CONTAINER_bloomfilter_test (bloom,
                                                 &pos->phash)) )
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Excluded peer `%s' due to BF match in greedy routing for %s\n",
                      GNUNET_i2s (&pos->id),
                      GNUNET_h2s (key));
          continue;
        }
        if (NULL == chosen)
        {
          /* First candidate */
          chosen = pos;
        }
        else
        {
          int delta = GNUNET_CRYPTO_hash_xorcmp (&pos->phash,
                                                 &chosen->phash,
                                                 key);
          switch (delta)
          {
          case -1: /* pos closer */
            chosen = pos;
            break;
          case 0: /* identical, impossible! */
            GNUNET_assert (0);
            break;
          case 1: /* chosen closer */
            break;
          }
        }
      } /* for all (#bucket_size) peers in bucket */
      if (NULL != chosen)
        break;
 
      /* If we chose nothing in first iteration, first go through deeper
         buckets (best chance to find a good match), and if we still found
         nothing, then to shallower buckets.  Terminate on any match in the
         current bucket, as this search order guarantees that it can only get
         worse as we keep going. */
      /* Both upward steps must be bounded by #closest_bucket, and the test
         has to be `>=': stepping from #best_bucket to #best_bucket + 1
         below can jump straight over an `==' test, after which nothing
         stops the offset from running off the end of #k_buckets. */
      if (bucket_offset > best_bucket)
      {
        /* Go through more deeper buckets */
        bucket_offset++;
        if (bucket_offset >= closest_bucket)
        {
          /* Can't go any deeper, if nothing selected,
             go for shallower buckets */
          bucket_offset = best_bucket - 1;
        }
      }
      else
      {
        /* We're either at the 'best_bucket' or already moving
           on to shallower buckets. */
        if (bucket_offset == best_bucket)
        {
          bucket_offset++; /* go for deeper buckets */
          if (bucket_offset >= closest_bucket)
            bucket_offset = best_bucket - 1;
        }
        else
          bucket_offset--; /* go for shallower buckets */
      }
    } /* for applicable buckets (starting at best match) */
    if (NULL == chosen)
    {
      GNUNET_STATISTICS_update (GDS_stats,
                                "# Peer selection failed",
                                1,
                                GNUNET_NO);
      return NULL;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Selected peer `%s' in greedy routing for %s\n",
                GNUNET_i2s (&chosen->id),
                GNUNET_h2s (key));
    return chosen;
  } /* end of 'greedy' peer selection */
 
  /* select "random" peer */
  /* count number of peers that are available and not filtered,
     but limit to at most #bucket_size peers, starting with
     those 'furthest' from us. */
  {
    unsigned int total = 0;
    unsigned int selected;
 
    for (unsigned int bc = 0; bc < closest_bucket; bc++)
    {
      struct PeerBucket *bucket = &k_buckets[bc];
      unsigned int count = 0;
 
      for (struct PeerInfo *pos = bucket->head;
           NULL != pos;
           pos = pos->next)
      {
        count++;
        if (count > bucket_size)
          break; /* limits search to #bucket_size peers per bucket */
        if ( (NULL != bloom) &&
             (GNUNET_YES ==
              GNUNET_CONTAINER_bloomfilter_test (bloom,
                                                 &pos->phash)) )
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Excluded peer `%s' due to BF match in random routing for %s\n",
                      GNUNET_i2s (&pos->id),
                      GNUNET_h2s (key));
          continue;             /* Ignore filtered peers */
        }
        total++;
      } /* for all peers in bucket */
    } /* for all buckets */
    if (0 == total)             /* No peers to select from! */
    {
      GNUNET_STATISTICS_update (GDS_stats,
                                "# Peer selection failed",
                                1,
                                GNUNET_NO);
      return NULL;
    }
 
    /* Now actually choose a peer */
    selected = GNUNET_CRYPTO_random_u32 (total);
    for (unsigned int bc = 0; bc < closest_bucket; bc++)
    {
      unsigned int count = 0;
 
      for (struct PeerInfo *pos = k_buckets[bc].head;
           pos != NULL;
           pos = pos->next)
      {
        count++;
        if (count > bucket_size)
          break; /* limits search to #bucket_size peers per bucket */
 
        if ( (NULL != bloom) &&
             (GNUNET_YES ==
              GNUNET_CONTAINER_bloomfilter_test (bloom,
                                                 &pos->phash)) )
          continue;             /* Ignore bloomfiltered peers */
        if (0 == selected--)
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Selected peer `%s' in random routing for %s\n",
                      GNUNET_i2s (&pos->id),
                      GNUNET_h2s (key));
          return pos;
        }
      } /* for peers in bucket */
    } /* for all buckets */
  } /* random peer selection scope */
  GNUNET_break (0);
  return NULL;
}
 
 
static unsigned int
get_target_peers (const struct GNUNET_HashCode *key,
                  struct GNUNET_CONTAINER_BloomFilter *bloom,
                  uint16_t hop_count,
                  uint16_t target_replication,
                  struct PeerInfo ***targets)
{
  unsigned int target;
  unsigned int off;
  struct PeerInfo **rtargets;
 
  GNUNET_assert (NULL != bloom);
  target = get_forward_count (hop_count,
                              target_replication);
  if (0 == target)
  {
    *targets = NULL;
    return 0;
  }
  rtargets = GNUNET_new_array (target,
                               struct PeerInfo *);
  for (off = 0; off < target; off++)
  {
    struct PeerInfo *nxt;
 
    nxt = select_peer (key,
                       bloom,
                       hop_count);
    if (NULL == nxt)
      break;
    rtargets[off] = nxt;
    /* Exclude the peer we just picked from the next round, or
       select_peer() would hand us the same peer again. */
    GNUNET_break (GNUNET_NO ==
                  GNUNET_CONTAINER_bloomfilter_test (bloom,
                                                     &nxt->phash));
    GNUNET_CONTAINER_bloomfilter_add (bloom,
                                      &nxt->phash);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Selected %u/%u peers at hop %u for %s (target was %u)\n",
              off,
              GNUNET_CONTAINER_multipeermap_size (all_connected_peers),
              (unsigned int) hop_count,
              GNUNET_h2s (key),
              target);
  if (0 == off)
  {
    GNUNET_free (rtargets);
    *targets = NULL;
    return 0;
  }
  *targets = rtargets;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Forwarding query `%s' to %u peers (goal was %u peers)\n",
              GNUNET_h2s (key),
              off,
              target);
  return off;
}
 
 
static void
hello_check (const struct GNUNET_DATACACHE_Block *bd)
{
  struct GNUNET_HELLO_Parser *b;
 
  if (GNUNET_BLOCK_TYPE_DHT_HELLO != bd->type)
    return;
 
  b = GNUNET_HELLO_parser_from_block (bd->data,
                                      bd->data_size);
  if (GNUNET_YES != disable_try_connect)
  {
    GNUNET_HELLO_parser_iterate (b,
                                 &GDS_try_connect,
                                 NULL);
  }
  GNUNET_HELLO_parser_free (b);
}
 
 
struct GDS_RoutingPutCallbackData
{
  unsigned int hop_count;
  unsigned int target_count;
  struct PeerInfo **targets;
  struct GNUNET_HashCode key;
  unsigned int index;
  unsigned int *queued;
  bool *sent;
  GDS_PutOperationCallback cb;
  void *cb_cls;
};
 
 
static bool
cb_routing_put_message (void *cls,
                        size_t msize,
                        struct PeerPutMessage *ppm)
{
  struct GDS_RoutingPutCallbackData *gds_routing = cls;
  struct PeerInfo *target;
 
  if (NULL == ppm)
  {
    *(gds_routing->queued) = *(gds_routing->queued) + 1;
    if (*(gds_routing->queued) >= gds_routing->target_count)
    {
      if (gds_routing->cb)
        gds_routing->cb (gds_routing->cb_cls,
                         *(gds_routing->sent)
                         ? GNUNET_OK
                         : GNUNET_SYSERR);
 
      GNUNET_free (gds_routing->targets);
      GNUNET_free (gds_routing->queued);
      GNUNET_free (gds_routing->sent);
    }
 
    return true;
  }
 
  target = gds_routing->targets[gds_routing->index];
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Routing PUT for %s after %u hops to %s\n",
              GNUNET_h2s (&(gds_routing->key)),
              (unsigned int) gds_routing->hop_count,
              GNUNET_i2s (&target->id));
  if (do_send (target,
               &ppm->header))
    *(gds_routing->sent) = true;
  *(gds_routing->queued) = *(gds_routing->queued) + 1;
 
  if (*(gds_routing->queued) >= gds_routing->target_count)
  {
    /* Report success only if some underlay actually took the message:
       otherwise nothing stores this block and the caller has to keep
       it and try again. */
    if (gds_routing->cb)
      gds_routing->cb (gds_routing->cb_cls,
                       *(gds_routing->sent)
                       ? GNUNET_OK
                       : GNUNET_NO);
 
    GNUNET_free (gds_routing->targets);
    GNUNET_STATISTICS_update (GDS_stats,
                              "# PUT messages queued for transmission",
                              gds_routing->target_count,
                              GNUNET_NO);
    GNUNET_free (gds_routing->queued);
    GNUNET_free (gds_routing->sent);
  }
 
  return true;
}
 
 
void
GDS_NEIGHBOURS_handle_put (const struct GNUNET_DATACACHE_Block *bd,
                           uint16_t desired_replication_level,
                           uint16_t hop_count,
                           struct GNUNET_CONTAINER_BloomFilter *bf,
                           GDS_PutOperationCallback cb,
                           void *cb_cls)
{
  const struct GNUNET_PeerIdentity *my_identity;
  const struct GNUNET_HashCode *my_identity_hash;
  struct GDS_RoutingPutCallbackData gds_routing;
  size_t msize;
  enum GNUNET_DHT_RouteOption ro = bd->ro;
  unsigned int put_path_length = bd->put_path_length;
  const struct GNUNET_DHT_PathElement *put_path = bd->put_path;
  bool truncated = (0 != (bd->ro & GNUNET_DHT_RO_TRUNCATED));
  const struct GNUNET_PeerIdentity *trunc_peer
    = truncated
    ? &bd->trunc_peer
    : NULL;
  struct GNUNET_PeerIdentity trunc_peer_out;
  enum GNUNET_GenericReturnValue ret;
 
  my_identity = GNUNET_PILS_get_identity (GDS_pils);
  my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
  GNUNET_assert (NULL != my_identity);
 
  ret = GDS_helper_put_message_get_size (&msize,
                                         my_identity,
                                         bd->ro, &ro,
                                         bd->expiration_time,
                                         bd->data, bd->data_size,
                                         put_path, put_path_length,
                                         &put_path_length,
                                         trunc_peer,
                                         &trunc_peer_out,
                                         &truncated);
  if (truncated)
    trunc_peer = &trunc_peer_out;
  /* Path may have been truncated by the call above */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Adding myself (%s) to PUT bloomfilter for %s with RO(%s/%s)\n",
              GNUNET_i2s (my_identity),
              GNUNET_h2s (&bd->key),
              (bd->ro & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE) ? "x" : "-",
              (bd->ro & GNUNET_DHT_RO_RECORD_ROUTE) ? "R" : "-");
 
  /* if we got a HELLO, consider it for our own routing table */
  hello_check (bd);
  GNUNET_assert ((NULL != bf) && (NULL != my_identity_hash));
  GNUNET_CONTAINER_bloomfilter_add (bf, my_identity_hash);
  GNUNET_STATISTICS_update (GDS_stats,
                            "# PUT requests routed",
                            1,
                            GNUNET_NO);
  if (GNUNET_OK != ret)
  {
    if (cb)
      cb (cb_cls, ret);
    return;
  }
  gds_routing.target_count
    = get_target_peers (&bd->key,
                        bf,
                        hop_count,
                        desired_replication_level,
                        &(gds_routing.targets));
  if (0 == gds_routing.target_count)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Routing PUT for %s terminates after %u hops at %s\n",
                GNUNET_h2s (&bd->key),
                (unsigned int) hop_count,
                GNUNET_i2s (my_identity));
    if (cb)
      cb (cb_cls, GNUNET_NO);
    if (gds_routing.targets)
      GNUNET_free (gds_routing.targets);
    return;
  }
  GNUNET_memcpy (&(gds_routing.key), &(bd->key),
                 sizeof (gds_routing.key));
  gds_routing.hop_count = hop_count;
  /* targets were added to @a bf by get_target_peers() */
 
  gds_routing.queued = GNUNET_new (unsigned int);
  *(gds_routing.queued) = 0;
  gds_routing.sent = GNUNET_new (bool);
  *(gds_routing.sent) = false;
 
  gds_routing.cb = cb;
  gds_routing.cb_cls = cb_cls;
 
  for (unsigned int i = 0; i < gds_routing.target_count; i++)
  {
    struct PeerInfo *target = gds_routing.targets[i];
    struct PeerPutMessage *ppm;
    char buf[msize] GNUNET_ALIGN;
 
    gds_routing.index = i;
 
    ppm = (struct PeerPutMessage *) buf;
    GDS_helper_make_put_message (ppm, msize,
                                 GNUNET_PILS_get_private_key (GDS_pils),
                                 &target->id,
                                 &target->phash,
                                 bf,
                                 &bd->key,
                                 ro,
                                 bd->type,
                                 bd->expiration_time,
                                 bd->data, bd->data_size,
                                 put_path, put_path_length,
                                 hop_count,
                                 desired_replication_level,
                                 trunc_peer,
                                 &cb_routing_put_message,
                                 sizeof (gds_routing),
                                 &gds_routing);
  }
}
 
 
enum GNUNET_GenericReturnValue
GDS_NEIGHBOURS_handle_get (enum GNUNET_BLOCK_Type type,
                           enum GNUNET_DHT_RouteOption options,
                           uint16_t desired_replication_level,
                           uint16_t hop_count,
                           const struct GNUNET_HashCode *key,
                           const void *xquery,
                           size_t xquery_size,
                           struct GNUNET_BLOCK_Group *bg,
                           struct GNUNET_CONTAINER_BloomFilter *peer_bf)
{
  const struct GNUNET_PeerIdentity *my_identity;
  const struct GNUNET_HashCode *my_identity_hash;
  unsigned int target_count;
  struct PeerInfo **targets;
  size_t msize;
  size_t result_filter_size;
  void *result_filter;
  bool sent = false;
 
  my_identity = GNUNET_PILS_get_identity (GDS_pils);
  my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
 
  if (NULL == my_identity_hash)
    return GNUNET_NO;
 
  GNUNET_assert (NULL != peer_bf);
  GNUNET_STATISTICS_update (GDS_stats,
                            "# GET requests routed",
                            1,
                            GNUNET_NO);
  target_count = get_target_peers (key,
                                   peer_bf,
                                   hop_count,
                                   desired_replication_level,
                                   &targets);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Adding myself (%s) to GET bloomfilter for %s with RO(%s/%s)\n",
              GNUNET_i2s (my_identity),
              GNUNET_h2s (key),
              (options & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE) ? "x" : "-",
              (options & GNUNET_DHT_RO_RECORD_ROUTE) ? "R" : "-");
  GNUNET_assert (NULL != my_identity_hash);
  GNUNET_CONTAINER_bloomfilter_add (peer_bf, my_identity_hash);
  if (0 == target_count)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Routing GET for %s terminates after %u hops at %s\n",
                GNUNET_h2s (key),
                (unsigned int) hop_count,
                GNUNET_i2s (my_identity));
    return GNUNET_NO;
  }
  if (GNUNET_OK !=
      GNUNET_BLOCK_group_serialize (bg,
                                    &result_filter,
                                    &result_filter_size))
  {
    result_filter = NULL;
    result_filter_size = 0;
  }
  msize = xquery_size + result_filter_size;
  if (msize + sizeof(struct PeerGetMessage) >= GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    GNUNET_free (result_filter);
    GNUNET_free (targets);
    return GNUNET_NO;
  }
  /* targets were added to @a peer_bf by get_target_peers() */
  /* forward request */
  for (unsigned int i = 0; i < target_count; i++)
  {
    struct PeerInfo *target = targets[i];
    struct PeerGetMessage *pgm;
    char buf[sizeof (*pgm) + msize] GNUNET_ALIGN;
    char *rf;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Routing GET for %s after %u hops to %s\n",
                GNUNET_h2s (key),
                (unsigned int) hop_count,
                GNUNET_i2s (&target->id));
    pgm = (struct PeerGetMessage *) buf;
    pgm->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_P2P_GET);
    pgm->header.size = htons (sizeof (buf));
    pgm->type = htonl (type);
    pgm->options = htons (options);
    pgm->hop_count = htons (hop_count + 1);
    pgm->desired_replication_level = htons (desired_replication_level);
    pgm->result_filter_size = htons ((uint16_t) result_filter_size);
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_bloomfilter_get_raw_data (peer_bf,
                                                              pgm->bloomfilter,
                                                              DHT_BLOOM_SIZE));
    pgm->key = *key;
    rf = (char *) &pgm[1];
    GNUNET_memcpy (rf,
                   result_filter,
                   result_filter_size);
    GNUNET_memcpy (&rf[result_filter_size],
                   xquery,
                   xquery_size);
    if (do_send (target,
                 &pgm->header))
      sent = true;
  }
  GNUNET_STATISTICS_update (GDS_stats,
                            "# GET messages queued for transmission",
                            target_count,
                            GNUNET_NO);
  GNUNET_free (targets);
  GNUNET_free (result_filter);
  /* Having picked a target is not the same as having sent to one: if
     every underlay dropped the message, the request was not routed and
     must go on the fast retry, not on the regular back-off. */
  return sent ? GNUNET_OK : GNUNET_NO;
}
 
 
struct PeerInfo *
GDS_NEIGHBOURS_lookup_peer (const struct GNUNET_PeerIdentity *target)
{
  return GNUNET_CONTAINER_multipeermap_get (all_connected_peers,
                                            target);
}
 
 
struct GDS_NeighboursReply
{
  struct PeerInfo *pi;
  struct PeerResultMessage *prm;
  struct GNUNET_DHT_PathElement *paths;
  struct GNUNET_DATACACHE_Block bd;
  void *block_data;
  struct GNUNET_DHT_PathElement *put_path;
  struct GNUNET_PeerIdentity trunc_peer_id;
  bool trunc_peer_is_null;
  char *buf;
 
  GNUNET_SCHEDULER_TaskCallback cb;
  void *cb_cls;
};
 
 
static void
cleanup_neighbours_reply (struct GDS_NeighboursReply *reply)
{
  if (reply->block_data)
    GNUNET_free (reply->block_data);
  if ((reply->bd.put_path_length > 0) && (reply->put_path))
    GNUNET_free (reply->put_path);
  if (reply->buf)
    GNUNET_free (reply->buf);
}
 
 
static void
safe_neighbours_callback (void *cls,
                          GNUNET_SCHEDULER_TaskCallback cb,
                          bool success)
{
  GNUNET_break (success);
  if (cb)
    cb (cls);
}
 
 
static bool
cb_path_signed (void *cls,
                const struct GNUNET_CRYPTO_EddsaSignature *sig)
{
  struct GDS_NeighboursReply *reply = cls;
  struct PeerResultMessage *prm = reply->prm;
  struct GNUNET_DHT_PathElement *paths = reply->paths;
  unsigned int ppl = ntohs (prm->put_path_length);
  unsigned int get_path_length = ntohs (prm->get_path_length);
  void *tgt = &paths[get_path_length + ppl];
  void *data;
 
  if (! sig)
  {
    cleanup_neighbours_reply (reply);
    safe_neighbours_callback (reply->cb_cls, reply->cb, false);
    return true;
  }
 
  memcpy (tgt,
          sig,
          sizeof (*sig));
  data = tgt + sizeof (*sig);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Signing GET PATH %u/%u of %s => %s\n",
              ppl,
              get_path_length,
              GNUNET_h2s (&prm->key),
              GNUNET_B2S (sig));
#if SANITY_CHECKS > 1
  {
    const struct GNUNET_PeerIdentity *my_identity;
    struct GNUNET_DHT_PathElement xpaths[get_path_length + 1];
    const struct GNUNET_PeerIdentity *trunc_peer = reply->trunc_peer_is_null?
                                                   NULL : &reply->trunc_peer_id;
 
    my_identity = GNUNET_PILS_get_identity (GDS_pils);
    GNUNET_assert (NULL != my_identity);
 
    memcpy (xpaths,
            &paths[ppl],
            get_path_length * sizeof (struct GNUNET_DHT_PathElement));
    xpaths[get_path_length].sig = *sig;
    xpaths[get_path_length].pred = *my_identity;
    if (0 !=
        GNUNET_DHT_verify_path (reply->bd.data,
                                reply->bd.data_size,
                                reply->bd.expiration_time,
                                trunc_peer,
                                paths,
                                ppl,
                                xpaths,
                                get_path_length + 1,
                                &reply->pi->id))
    {
      GNUNET_break (0);
      cleanup_neighbours_reply (reply);
      safe_neighbours_callback (reply->cb_cls, reply->cb, false);
      return true;
    }
  }
#endif
  GNUNET_memcpy (data,
                 reply->bd.data,
                 reply->bd.data_size);
  do_send (reply->pi,
           &prm->header);
  cleanup_neighbours_reply (reply);
  safe_neighbours_callback (reply->cb_cls, reply->cb, true);
  return true;
}
 
 
void
GDS_NEIGHBOURS_handle_reply (struct PeerInfo *pi,
                             const struct GNUNET_DATACACHE_Block *bd,
                             const struct GNUNET_HashCode *query_hash,
                             unsigned int get_path_length,
                             const struct GNUNET_DHT_PathElement *get_path,
                             GNUNET_SCHEDULER_TaskCallback cb,
                             void *cb_cls)
{
  struct GNUNET_DHT_PathElement *paths;
  size_t msize;
  unsigned int ppl = bd->put_path_length;
  const struct GNUNET_DHT_PathElement *put_path = bd->put_path;
  enum GNUNET_DHT_RouteOption ro = bd->ro;
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  const struct GNUNET_PeerIdentity *trunc_peer
    = truncated
    ? &bd->trunc_peer
    : NULL;
  bool tracking = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
#if SANITY_CHECKS > 1
  const struct GNUNET_PeerIdentity *my_identity;
  unsigned int failure_offset;
 
  my_identity = GNUNET_PILS_get_identity (GDS_pils);
  GNUNET_assert (NULL != my_identity);
 
  failure_offset
    = GNUNET_DHT_verify_path (bd->data,
                              bd->data_size,
                              bd->expiration_time,
                              trunc_peer,
                              put_path,
                              ppl,
                              get_path,
                              get_path_length,
                              my_identity);
  if (0 != failure_offset)
  {
    GNUNET_assert (failure_offset <= ppl + get_path_length);
    GNUNET_break_op (0);
    if (failure_offset < ppl)
    {
      trunc_peer = &put_path[failure_offset - 1].pred;
      put_path += failure_offset;
      ppl -= failure_offset;
      truncated = true;
      ro |= GNUNET_DHT_RO_TRUNCATED;
    }
    else
    {
      failure_offset -= ppl;
      if (0 == failure_offset)
        trunc_peer = &put_path[ppl - 1].pred;
      else
        trunc_peer = &get_path[failure_offset - 1].pred;
      ppl = 0;
      put_path = NULL;
      truncated = true;
      ro |= GNUNET_DHT_RO_TRUNCATED;
      get_path += failure_offset;
      get_path_length -= failure_offset;
    }
  }
#endif
  msize = bd->data_size + sizeof (struct PeerResultMessage);
  if (msize > GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break_op (0);
    safe_neighbours_callback (cb_cls, cb, false);
    return;
  }
  if (truncated)
    msize += sizeof (struct GNUNET_PeerIdentity);
  if (tracking)
    msize += sizeof (struct GNUNET_CRYPTO_EddsaSignature);
  if (msize < bd->data_size)
  {
    GNUNET_break_op (0);
    safe_neighbours_callback (cb_cls, cb, false);
    return;
  }
  if ( (GNUNET_MAX_MESSAGE_SIZE - msize)
       / sizeof(struct GNUNET_DHT_PathElement)
       < (get_path_length + ppl) )
  {
    get_path_length = 0;
    ppl = 0;
  }
  if ( (get_path_length > UINT16_MAX) ||
       (ppl > UINT16_MAX) )
  {
    GNUNET_break (0);
    get_path_length = 0;
    ppl = 0;
  }
  msize += (get_path_length + ppl)
           * sizeof(struct GNUNET_DHT_PathElement);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Forwarding reply for key %s to peer %s\n",
              GNUNET_h2s (query_hash),
              GNUNET_i2s (&pi->id));
  GNUNET_STATISTICS_update (GDS_stats,
                            "# RESULT messages queued for transmission",
                            1,
                            GNUNET_NO);
  {
    struct PeerResultMessage *prm;
    char buf[msize] GNUNET_ALIGN;
 
    prm = (struct PeerResultMessage *) buf;
    prm->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT);
    prm->header.size = htons (sizeof (buf));
    prm->type = htonl ((uint32_t) bd->type);
    prm->reserved = htons (0);
    prm->options = htons ((uint16_t) ro);
    prm->put_path_length = htons ((uint16_t) ppl);
    prm->get_path_length = htons ((uint16_t) get_path_length);
    prm->expiration_time = GNUNET_TIME_absolute_hton (bd->expiration_time);
    prm->key = *query_hash;
    if (truncated)
    {
      void *tgt = &prm[1];
 
      GNUNET_memcpy (tgt,
                     trunc_peer,
                     sizeof (struct GNUNET_PeerIdentity));
      paths = (struct GNUNET_DHT_PathElement *)
              (tgt + sizeof (struct GNUNET_PeerIdentity));
    }
    else
    {
      paths = (struct GNUNET_DHT_PathElement *) &prm[1];
    }
    if (NULL != put_path)
    {
      GNUNET_memcpy (paths,
                     put_path,
                     ppl * sizeof(struct GNUNET_DHT_PathElement));
    }
    else
    {
      GNUNET_assert (0 == ppl);
    }
    if (NULL != get_path)
    {
      GNUNET_memcpy (&paths[ppl],
                     get_path,
                     get_path_length * sizeof(struct GNUNET_DHT_PathElement));
    }
    else
    {
      GNUNET_assert (0 == get_path_length);
    }
    if (tracking)
    {
      struct GDS_NeighboursReply reply;
      const struct GNUNET_PeerIdentity *pred;
 
      reply.pi = pi;
      GNUNET_memcpy (&reply.bd, bd, sizeof (reply.bd));
      reply.block_data = GNUNET_memdup (bd->data, bd->data_size);
      reply.put_path = GNUNET_memdup (bd->put_path,
                                      sizeof (struct GNUNET_DHT_PathElement)
                                      * bd->put_path_length);
 
      reply.bd.data = reply.block_data;
      reply.bd.put_path = reply.put_path;
 
      reply.buf = GNUNET_memdup (buf, msize);
      reply.prm = (struct PeerResultMessage*) reply.buf;
      reply.paths = (struct GNUNET_DHT_PathElement*)
                    (reply.buf + ((const char *) paths - buf));
 
      if (trunc_peer)
      {
        reply.trunc_peer_is_null = false;
        GNUNET_memcpy (&reply.trunc_peer_id, trunc_peer,
                       sizeof (reply.trunc_peer_id));
      }
      else
      {
        reply.trunc_peer_is_null = true;
      }
 
      reply.cb = cb;
      reply.cb_cls = cb_cls;
 
      if (ppl + get_path_length > 0)
        pred = &paths[ppl + get_path_length - 1].pred;
      else if (truncated)
        pred = trunc_peer;
      else
        pred = NULL; /* we are first! */
      /* Note that the last signature in 'paths' was not initialized before,
         so this is crucial to avoid sending garbage. */
      GDS_helper_sign_path (bd->data,
                            bd->data_size,
                            GNUNET_PILS_get_private_key (GDS_pils),
                            bd->expiration_time,
                            pred,
                            &pi->id,
                            &cb_path_signed,
                            sizeof (reply),
                            &reply);
    }
    else
    {
      void *data;
      data = &prm[1];
      GNUNET_memcpy (data,
                     bd->data,
                     bd->data_size);
      do_send (pi,
               &prm->header);
      safe_neighbours_callback (cb_cls, cb, true);
      return;
    }
  }
}
 
 
static enum GNUNET_GenericReturnValue
check_dht_p2p_put (void *cls,
                   const struct PeerPutMessage *put)
{
  enum GNUNET_DHT_RouteOption ro = ntohs (put->options);
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  bool has_path = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
  uint16_t msize = ntohs (put->header.size);
  uint16_t putlen = ntohs (put->put_path_length);
  size_t xsize = (has_path
                  ? sizeof (struct GNUNET_CRYPTO_EddsaSignature)
                  : 0)
                 + (truncated
                    ? sizeof (struct GNUNET_PeerIdentity)
                    : 0);
  size_t var_meta_size
    = putlen * sizeof(struct GNUNET_DHT_PathElement)
      + xsize;
 
  (void) cls;
  if ( (msize <
        sizeof (struct PeerPutMessage) + var_meta_size) ||
       (putlen >
        (GNUNET_MAX_MESSAGE_SIZE
         - sizeof (struct PeerPutMessage)
         - xsize)
        / sizeof(struct GNUNET_DHT_PathElement)) )
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (GNUNET_BLOCK_TYPE_ANY == htonl (put->type))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
struct ForwardedDHTPut
{
  struct GNUNET_DATACACHE_Block block;
 
  struct GNUNET_DHT_PathElement *put_path;
  void *data;
 
  uint32_t hop_count;
  uint32_t desired_replication_level;
};
 
 
static void
cb_forwarded_dht_p2p_put (void *cls,
                          enum GNUNET_GenericReturnValue forwarded)
{
  struct ForwardedDHTPut *put = cls;
 
  /* notify monitoring clients; we are the last hop exactly when we did
     not manage to forward, as in the GET case */
  put->block.ro |= ((GNUNET_OK == forwarded)
            ? 0
            : GNUNET_DHT_RO_LAST_HOP);
  GDS_CLIENTS_process_put (&put->block,
                           put->hop_count,
                           put->desired_replication_level);
 
  if (put->put_path)
    GNUNET_free (put->put_path);
  GNUNET_free (put->data);
  GNUNET_free (put);
}
 
 
static void
handle_dht_p2p_put (void *cls,
                    const struct PeerPutMessage *put)
{
  struct Target *t = cls;
  struct PeerInfo *peer = t->pi;
  enum GNUNET_DHT_RouteOption ro = ntohs (put->options);
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  bool has_path = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
  uint16_t msize = ntohs (put->header.size);
  uint16_t putlen = ntohs (put->put_path_length);
  const struct GNUNET_PeerIdentity *trunc_peer
    = truncated
    ? (const struct GNUNET_PeerIdentity *) &put[1]
    : NULL;
  const struct GNUNET_DHT_PathElement *put_path
    = truncated
    ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
    : (const struct GNUNET_DHT_PathElement *) &put[1];
  const struct GNUNET_CRYPTO_EddsaSignature *last_sig
    = has_path
    ? (const struct GNUNET_CRYPTO_EddsaSignature *) &put_path[putlen]
    : NULL;
  const char *data
    = has_path
    ? (const char *) &last_sig[1]
    : (const char *) &put_path[putlen];
  size_t var_meta_size
    = putlen * sizeof(struct GNUNET_DHT_PathElement)
      + (has_path ? sizeof (*last_sig) : 0)
      + (truncated ? sizeof (*trunc_peer) : 0);
  struct GNUNET_DATACACHE_Block bd = {
    .key = put->key,
    .expiration_time = GNUNET_TIME_absolute_ntoh (put->expiration_time),
    .type = ntohl (put->type),
    .ro = ro,
    .data_size = msize - sizeof(*put) - var_meta_size,
    .data = data
  };
 
  if (NULL != trunc_peer)
    bd.trunc_peer = *trunc_peer;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "PUT for `%s' from %s with RO (%s/%s)\n",
              GNUNET_h2s (&put->key),
              GNUNET_i2s (&peer->id),
              (bd.ro & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE) ? "x" : "-",
              has_path ? "R" : "-");
  if (GNUNET_TIME_absolute_is_past (bd.expiration_time))
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# Expired PUTs discarded",
                              1,
                              GNUNET_NO);
    return;
  }
  {
    /* Only call 'check_block' if that keeps our CPU load (from
       the cryptography) below 50% on average */
    static struct GNUNET_TIME_Relative avg_latency;
    static struct GNUNET_TIME_Absolute next_time;
 
    if (GNUNET_TIME_absolute_is_past (next_time))
    {
      struct GNUNET_TIME_Absolute now
        = GNUNET_TIME_absolute_get ();
      struct GNUNET_TIME_Relative latency;
      struct GNUNET_TIME_Relative delta;
 
      if (GNUNET_NO ==
          GNUNET_BLOCK_check_block (GDS_block_context,
                                    bd.type,
                                    bd.data,
                                    bd.data_size))
      {
        GNUNET_break_op (0);
        return;
      }
      latency = GNUNET_TIME_absolute_get_duration (now);
      /* Use *moving average* to estimate check_block latency */
      avg_latency
        = GNUNET_TIME_relative_divide (
            GNUNET_TIME_relative_add (
              GNUNET_TIME_relative_multiply (avg_latency,
                                             7),
              latency),
            8);
      /* average delay = 50% of avg_latency => 50% CPU load from crypto (at most) */
      delta.rel_value_us
        = GNUNET_CRYPTO_random_u64 (avg_latency.rel_value_us > 0
                                        ? avg_latency.rel_value_us
                                        : 1LLU);
      next_time = GNUNET_TIME_relative_to_absolute (delta);
    }
  }
  if (! has_path)
    putlen = 0;
  GNUNET_STATISTICS_update (GDS_stats,
                            "# P2P PUT requests received",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (GDS_stats,
                            "# P2P PUT bytes received",
                            msize,
                            GNUNET_NO);
  {
    struct GNUNET_HashCode test_key;
    enum GNUNET_GenericReturnValue ret;
 
    ret = GNUNET_BLOCK_get_key (GDS_block_context,
                                bd.type,
                                bd.data,
                                bd.data_size,
                                &test_key);
    switch (ret)
    {
    case GNUNET_YES:
      if (0 != GNUNET_memcmp (&test_key,
                              &bd.key))
      {
        GNUNET_break_op (0);
        return;
      }
      break;
    case GNUNET_NO:
      /* cannot verify, good luck */
      break;
    case GNUNET_SYSERR:
      /* block type not supported, good luck */
      break;
    }
  }
 
  {
    struct GNUNET_CONTAINER_BloomFilter *bf;
    struct GNUNET_DHT_PathElement pp[putlen + 1];
 
    bf = GNUNET_CONTAINER_bloomfilter_init (put->bloomfilter,
                                            DHT_BLOOM_SIZE,
                                            GNUNET_CONSTANTS_BLOOMFILTER_K);
    GNUNET_break_op (GNUNET_YES ==
                     GNUNET_CONTAINER_bloomfilter_test (bf,
                                                        &peer->phash));
    /* extend 'put path' by sender */
    bd.put_path = pp;
    bd.put_path_length = putlen + 1;
    if (has_path)
    {
      unsigned int failure_offset;
 
      GNUNET_memcpy (pp,
                     put_path,
                     putlen * sizeof(struct GNUNET_DHT_PathElement));
      pp[putlen].pred = peer->id;
      pp[putlen].sig = *last_sig;
#if SANITY_CHECKS
      {
        const struct GNUNET_PeerIdentity *my_identity;
        my_identity = GNUNET_PILS_get_identity (GDS_pils);
        GNUNET_assert (NULL != my_identity);
        /* TODO: might want to eventually implement probabilistic
          load-based path verification, but for now it is all or nothing */
        failure_offset
          = GNUNET_DHT_verify_path (bd.data,
                                    bd.data_size,
                                    bd.expiration_time,
                                    trunc_peer,
                                    pp,
                                    putlen + 1,
                                    NULL, 0,   /* get_path */
                                    my_identity);
      }
#else
      failure_offset = 0;
#endif
      if (0 != failure_offset)
      {
        GNUNET_break_op (0);
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Recorded put path invalid at offset %u, truncating\n",
                    failure_offset);
        GNUNET_assert (failure_offset <= putlen + 1);
        bd.put_path = &pp[failure_offset];
        bd.put_path_length = (putlen + 1) - failure_offset;
        bd.ro |= GNUNET_DHT_RO_TRUNCATED;
        bd.trunc_peer = pp[failure_offset - 1].pred;
      }
    }
    else
    {
      bd.put_path_length = 0;
    }
 
    /* give to local clients */
    GNUNET_break (GDS_CLIENTS_handle_reply (&bd,
                                            &bd.key,
                                            0, NULL /* get path */));
 
    /* store locally */
    if ( (0 != (bd.ro & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE)) ||
         (GDS_am_closest_peer (&put->key,
                               bf)) )
      GDS_DATACACHE_handle_put (&bd);
 
    {
      struct ForwardedDHTPut *forward = GNUNET_new (struct ForwardedDHTPut);
      GNUNET_memcpy (&forward->block, &bd, sizeof (bd));
 
      if (bd.put_path_length > 0)
      {
        forward->put_path = GNUNET_memdup (
          bd.put_path,
          sizeof (struct GNUNET_DHT_PathElement) * bd.put_path_length);
        forward->block.put_path = forward->put_path;
      }
 
      forward->data = GNUNET_memdup (bd.data, bd.data_size);
      forward->block.data = forward->data;
 
      forward->desired_replication_level = ntohs (put->desired_replication_level
                                                  );
      forward->hop_count = ntohs (put->hop_count);
 
      /* route to other peers */
      GDS_NEIGHBOURS_handle_put (&forward->block,
                                 forward->desired_replication_level,
                                 forward->hop_count,
                                 bf,
                                 &cb_forwarded_dht_p2p_put,
                                 forward);
    }
    GNUNET_CONTAINER_bloomfilter_free (bf);
  }
}
 
 
struct BlockCls
{
  struct PeerInfo *pi;
  const struct GNUNET_HashCode *query_hash;
  struct GNUNET_BLOCK_Group *bg;
};
 
 
static void
handle_find_my_hello (struct PeerInfo *pi,
                      const struct GNUNET_HashCode *query_hash,
                      struct GNUNET_BLOCK_Group *bg,
                      GNUNET_SCHEDULER_TaskCallback cb,
                      void *cb_cls)
{
  const struct GNUNET_HashCode *my_identity_hash;
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_TIME_Absolute block_expiration;
  size_t block_size;
  void *block;
 
  my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
  my_identity = GNUNET_PILS_get_identity (GDS_pils);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handle finding my own HELLO %s\n",
              GNUNET_h2s (my_identity_hash));
  if (NULL == GDS_my_hello)
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# FIND PEER requests ignored due to lack of HELLO",
                              1,
                              GNUNET_NO);
    if (cb)
      cb (cb_cls);
    return;
  }
 
  if (GNUNET_SYSERR == GNUNET_HELLO_dht_msg_to_block (GDS_my_hello,
                                                      my_identity,
                                                      &block,
                                                      &block_size,
                                                      &block_expiration))
  {
    if (cb)
      cb (cb_cls);
    return;
  }
 
  if (GNUNET_BLOCK_REPLY_OK_MORE ==
      GNUNET_BLOCK_check_reply (GDS_block_context,
                                GNUNET_BLOCK_TYPE_DHT_HELLO,
                                bg,
                                my_identity_hash,
                                NULL, 0,
                                block,
                                block_size))
  {
    struct GNUNET_DATACACHE_Block bd = {
      .type = GNUNET_BLOCK_TYPE_DHT_HELLO,
      .expiration_time
        = GNUNET_TIME_relative_to_absolute (
            GNUNET_HELLO_ADDRESS_EXPIRATION),
      .key = *my_identity_hash,
      .data = block,
      .data_size = block_size
    };
 
    GDS_NEIGHBOURS_handle_reply (pi,
                                 &bd,
                                 query_hash,
                                 0, NULL /* get path */,
                                 cb,
                                 cb_cls);
  }
  else
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# FIND PEER requests ignored due to Bloomfilter",
                              1,
                              GNUNET_NO);
    if (cb)
      cb (cb_cls);
  }
 
  GNUNET_free (block);
}
 
 
static void
handle_find_local_hello (struct PeerInfo *pi,
                         const struct GNUNET_HashCode *query_hash,
                         struct GNUNET_BLOCK_Group *bg,
                         GNUNET_SCHEDULER_TaskCallback cb,
                         void *cb_cls)
{
  /* Force non-random selection by hop count */
  struct PeerInfo *peer;
 
  peer = select_peer (query_hash,
                      NULL,
                      GDS_NSE_get () + 1);
  if (NULL == peer)
  {
    /* no neighbour at all, nothing to answer with */
    if (cb)
      cb (cb_cls);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handle finding local HELLO %s\n",
              GNUNET_h2s (&peer->phash));
  if ( (NULL != peer->hello) &&
       (! GNUNET_TIME_absolute_is_past (peer->hello_expiration)) &&
       (GNUNET_BLOCK_REPLY_OK_MORE ==
        GNUNET_BLOCK_check_reply (
          GDS_block_context,
          GNUNET_BLOCK_TYPE_DHT_HELLO,
          bg,
          &peer->phash,
          NULL, 0,        /* xquery */
          peer->hello,
          peer->hello_size)) )
  {
    struct GNUNET_DATACACHE_Block bd = {
      .type = GNUNET_BLOCK_TYPE_DHT_HELLO,
      .expiration_time = peer->hello_expiration,
      .key = peer->phash,
      .data = peer->hello,
      .data_size = peer->hello_size
    };
 
    GDS_NEIGHBOURS_handle_reply (pi,
                                 &bd,
                                 query_hash,
                                 0, NULL /* get path */,
                                 cb,
                                 cb_cls);
  }
  else if (cb)
    cb (cb_cls);
}
 
 
static void
handle_local_result (void *cls,
                     const struct GNUNET_DATACACHE_Block *bd)
{
  struct PeerInfo *peer = cls;
 
  GDS_NEIGHBOURS_handle_reply (peer,
                               bd,
                               &bd->key,
                               0, NULL /* get path */,
                               NULL,
                               NULL);
}
 
 
static enum GNUNET_GenericReturnValue
check_dht_p2p_get (void *cls,
                   const struct PeerGetMessage *get)
{
  uint16_t msize = ntohs (get->header.size);
  uint16_t result_filter_size = ntohs (get->result_filter_size);
 
  (void) cls;
  if (msize < sizeof(*get) + result_filter_size)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
struct HandleCallbackGet
{
  struct Target *t;
  struct PeerGetMessage *get;
  struct GNUNET_CONTAINER_BloomFilter *peer_bf;
  struct GNUNET_BLOCK_Group *bg;
  enum GNUNET_BLOCK_ReplyEvaluationResult eval;
};
 
 
static void
cb_handle_dht_p2p_get_local_result (void *cls)
{
  struct HandleCallbackGet *handle = cls;
  enum GNUNET_DHT_RouteOption options = ntohs (handle->get->options);
  enum GNUNET_BLOCK_Type type = ntohl (handle->get->type);
  const void *result_filter = (const void *) &handle->get[1];
  uint16_t msize = ntohs (handle->get->header.size);
  uint16_t result_filter_size = ntohs (handle->get->result_filter_size);
  const void *xquery = result_filter + result_filter_size;
  size_t xquery_size = msize - sizeof (*handle->get) - result_filter_size;
 
  /* remember request for routing replies
      TODO: why should we do this if GNUNET_BLOCK_REPLY_OK_LAST == eval?
  */
  GDS_ROUTING_add (&handle->t->pi->id,
                   type,
                   handle->bg, /* bg now owned by routing, but valid at least until end of this function! */
                   options,
                   &handle->get->key,
                   xquery,
                   xquery_size);
 
  /* P2P forwarding */
  {
    bool forwarded = false;
    uint16_t desired_replication_level = ntohs (
      handle->get->desired_replication_level);
    uint16_t hop_count = ntohs (handle->get->hop_count);
 
    if (handle->eval != GNUNET_BLOCK_REPLY_OK_LAST)
      forwarded = (GNUNET_OK ==
                   GDS_NEIGHBOURS_handle_get (type,
                                              options,
                                              desired_replication_level,
                                              hop_count,
                                              &handle->get->key,
                                              xquery,
                                              xquery_size,
                                              handle->bg,
                                              handle->peer_bf));
    GDS_CLIENTS_process_get (
      options
      | (forwarded
        ? 0
        : GNUNET_DHT_RO_LAST_HOP),
      type,
      hop_count,
      desired_replication_level,
      &handle->get->key);
  }
  /* clean up; note that 'bg' is owned by routing now! */
  GNUNET_CONTAINER_bloomfilter_free (handle->peer_bf);
 
  GNUNET_free (handle->get);
  GNUNET_free (handle);
}
 
 
static void
cb_handle_dht_p2p_get_local_hello (void *cls)
{
  struct HandleCallbackGet *handle = cls;
  enum GNUNET_BLOCK_Type type = ntohl (handle->get->type);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handle getting local HELLO %s of type %u\n",
              GNUNET_h2s (&handle->get->key),
              type);
 
  if (GNUNET_BLOCK_TYPE_DHT_HELLO != type)
  {
    enum GNUNET_DHT_RouteOption options = ntohs (handle->get->options);
    const void *result_filter = (const void *) &handle->get[1];
    uint16_t msize = ntohs (handle->get->header.size);
    uint16_t result_filter_size = ntohs (handle->get->result_filter_size);
    const void *xquery = result_filter + result_filter_size;
    size_t xquery_size = msize - sizeof (*handle->get) - result_filter_size;
    /* The datacache callback runs once per *result*, never on completion,
       so it must not carry the continuation: no result would drop the
       request, several would run the continuation several times.  Both
       lookups below are synchronous. */
    if (0 != (options & GNUNET_DHT_RO_FIND_APPROXIMATE))
      handle->eval = GDS_DATACACHE_get_closest (&handle->get->key,
                                                type,
                                                xquery,
                                                xquery_size,
                                                handle->bg,
                                                &handle_local_result,
                                                handle->t->pi);
    else
      handle->eval = GDS_DATACACHE_handle_get (&handle->get->key,
                                               type,
                                               xquery,
                                               xquery_size,
                                               handle->bg,
                                               &handle_local_result,
                                               handle->t->pi);
  }
  cb_handle_dht_p2p_get_local_result (handle);
}
 
 
static void
cb_handle_dht_p2p_get_my_hello (void *cls)
{
  struct HandleCallbackGet *handle = cls;
  enum GNUNET_DHT_RouteOption options = ntohs (handle->get->options);
 
  if (0 != (options & GNUNET_DHT_RO_FIND_APPROXIMATE))
    handle_find_local_hello (handle->t->pi,
                             &handle->get->key,
                             handle->bg,
                             &cb_handle_dht_p2p_get_local_hello,
                             handle);
  else
    cb_handle_dht_p2p_get_local_hello (handle);
}
 
 
static void
handle_dht_p2p_get (void *cls,
                    const struct PeerGetMessage *get)
{
  struct Target *t = cls;
  struct PeerInfo *peer = t->pi;
  uint16_t msize = ntohs (get->header.size);
  uint16_t result_filter_size = ntohs (get->result_filter_size);
  uint16_t hop_count = ntohs (get->hop_count);
  enum GNUNET_BLOCK_Type type = ntohl (get->type);
  enum GNUNET_DHT_RouteOption options = ntohs (get->options);
  const void *result_filter = (const void *) &get[1];
  const void *xquery = result_filter + result_filter_size;
  size_t xquery_size = msize - sizeof (*get) - result_filter_size;
 
  /* parse and validate message */
  GNUNET_STATISTICS_update (GDS_stats,
                            "# P2P GET requests received",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (GDS_stats,
                            "# P2P GET bytes received",
                            msize,
                            GNUNET_NO);
  if (GNUNET_NO ==
      GNUNET_BLOCK_check_query (GDS_block_context,
                                type,
                                &get->key,
                                xquery,
                                xquery_size))
  {
    /* request invalid */
    GNUNET_break_op (0);
    return;
  }
 
  {
    const struct GNUNET_PeerIdentity *my_identity;
    struct HandleCallbackGet *handle;
 
    handle = GNUNET_new (struct HandleCallbackGet);
    handle->t = t;
    handle->get = GNUNET_memdup (get, msize);
    handle->eval = GNUNET_BLOCK_REPLY_OK_MORE;
 
    my_identity = GNUNET_PILS_get_identity (GDS_pils);
    GNUNET_assert (NULL != my_identity);
 
    handle->peer_bf = GNUNET_CONTAINER_bloomfilter_init (get->bloomfilter,
                                                         DHT_BLOOM_SIZE,
                                                         GNUNET_CONSTANTS_BLOOMFILTER_K);
    GNUNET_break_op (GNUNET_YES ==
                     GNUNET_CONTAINER_bloomfilter_test (handle->peer_bf,
                                                        &peer->phash));
    handle->bg = GNUNET_BLOCK_group_create (GDS_block_context,
                                            type,
                                            result_filter,
                                            result_filter_size,
                                            "filter-size",
                                            result_filter_size,
                                            NULL);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "GET for %s at %s after %u hops\n",
                GNUNET_h2s (&get->key),
                GNUNET_i2s (my_identity),
                (unsigned int) hop_count);
    /* local lookup (this may update the bg) */
    if ( (0 != (options & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE)) ||
         (GDS_am_closest_peer (&get->key,
                               handle->peer_bf)) )
    {
      if ( (GNUNET_BLOCK_TYPE_DHT_HELLO == type) ||
           (GNUNET_BLOCK_TYPE_ANY == type) )
      {
        GNUNET_STATISTICS_update (GDS_stats,
                                  "# P2P HELLO lookup requests processed",
                                  1,
                                  GNUNET_NO);
        handle_find_my_hello (peer,
                              &get->key,
                              handle->bg,
                              &cb_handle_dht_p2p_get_my_hello,
                              handle);
      }
      else
        cb_handle_dht_p2p_get_local_hello (handle);
    }
    else
    {
      GNUNET_STATISTICS_update (GDS_stats,
                                "# P2P GET requests ONLY routed",
                                1,
                                GNUNET_NO);
      cb_handle_dht_p2p_get_local_result (handle);
    }
  }
}
 
 
static void
process_reply_with_path (const struct GNUNET_DATACACHE_Block *bd,
                         const struct GNUNET_HashCode *query_hash,
                         unsigned int get_path_length,
                         const struct GNUNET_DHT_PathElement *get_path)
{
  /* forward to local clients */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Forwarding reply to local clients\n");
  if (! GDS_CLIENTS_handle_reply (bd,
                                  query_hash,
                                  get_path_length,
                                  get_path))
  {
    GNUNET_break (0);
    return;
  }
  GDS_CLIENTS_process_get_resp (bd,
                                get_path,
                                get_path_length);
  if (GNUNET_YES == cache_results)
  {
    struct GNUNET_DHT_PathElement xput_path[GNUNET_NZL (get_path_length
                                                        + bd->put_path_length)];
    struct GNUNET_DATACACHE_Block bdx = *bd;
 
    if (NULL != bd->put_path)
      GNUNET_memcpy (xput_path,
                     bd->put_path,
                     bd->put_path_length * sizeof(struct
                                                  GNUNET_DHT_PathElement));
    GNUNET_memcpy (&xput_path[bd->put_path_length],
                   get_path,
                   get_path_length * sizeof(struct GNUNET_DHT_PathElement));
    bdx.put_path = xput_path;
    bdx.put_path_length += get_path_length;
    GDS_DATACACHE_handle_put (&bdx);
  }
  /* forward to other peers */
  GDS_ROUTING_process (bd,
                       query_hash,
                       get_path_length,
                       get_path);
}
 
 
static enum GNUNET_GenericReturnValue
check_dht_p2p_result (void *cls,
                      const struct PeerResultMessage *prm)
{
  uint16_t msize = ntohs (prm->header.size) - sizeof (*prm);
  enum GNUNET_DHT_RouteOption ro = ntohs (prm->options);
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  bool tracked = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
 
  uint16_t get_path_length = ntohs (prm->get_path_length);
  uint16_t put_path_length = ntohs (prm->put_path_length);
  size_t vsize = (truncated ? sizeof (struct GNUNET_PeerIdentity) : 0)
                 + (tracked ? sizeof (struct GNUNET_CRYPTO_EddsaSignature) : 0);
 
  (void) cls;
  if ( (msize < vsize) ||
       (msize - vsize <
        (get_path_length + put_path_length)
        * sizeof(struct GNUNET_DHT_PathElement)) ||
       (get_path_length >
        GNUNET_MAX_MESSAGE_SIZE / sizeof(struct GNUNET_DHT_PathElement)) ||
       (put_path_length >
        GNUNET_MAX_MESSAGE_SIZE / sizeof(struct GNUNET_DHT_PathElement)) )
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
static void
handle_dht_p2p_result (void *cls,
                       const struct PeerResultMessage *prm)
{
  struct Target *t = cls;
  struct PeerInfo *peer = t->pi;
  uint16_t msize = ntohs (prm->header.size) - sizeof (*prm);
  enum GNUNET_DHT_RouteOption ro = ntohs (prm->options);
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  bool tracked = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
  uint16_t get_path_length = ntohs (prm->get_path_length);
  uint16_t put_path_length = ntohs (prm->put_path_length);
  const struct GNUNET_PeerIdentity *trunc_peer
    = truncated
    ? (const struct GNUNET_PeerIdentity *) &prm[1]
    : NULL;
  const struct GNUNET_DHT_PathElement *put_path
    = truncated
    ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
    : (const struct GNUNET_DHT_PathElement *) &prm[1];
  const struct GNUNET_DHT_PathElement *get_path
    = &put_path[put_path_length];
  const struct GNUNET_CRYPTO_EddsaSignature *last_sig
    = tracked
    ? (const struct GNUNET_CRYPTO_EddsaSignature *) &get_path[get_path_length]
    : NULL;
  const void *data
    = tracked
    ? (const void *) &last_sig[1]
    : (const void *) &get_path[get_path_length];
  size_t vsize = (truncated ? sizeof (struct GNUNET_PeerIdentity) : 0)
                 + (tracked ? sizeof (struct GNUNET_CRYPTO_EddsaSignature) : 0);
  struct GNUNET_DATACACHE_Block bd = {
    .expiration_time  = GNUNET_TIME_absolute_ntoh (prm->expiration_time),
    .put_path = put_path,
    .put_path_length = put_path_length,
    .key = prm->key,
    .type = ntohl (prm->type),
    .ro = ro,
    .data = data,
    .data_size = msize - vsize - (get_path_length + put_path_length)
                 * sizeof(struct GNUNET_DHT_PathElement)
  };
 
  /* parse and validate message */
  if (GNUNET_TIME_absolute_is_past (bd.expiration_time))
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# Expired results discarded",
                              1,
                              GNUNET_NO);
    return;
  }
  if (GNUNET_OK !=
      GNUNET_BLOCK_check_block (GDS_block_context,
                                bd.type,
                                bd.data,
                                bd.data_size))
  {
    GNUNET_break_op (0);
    return;
  }
  GNUNET_STATISTICS_update (GDS_stats,
                            "# P2P RESULTS received",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (GDS_stats,
                            "# P2P RESULT bytes received",
                            msize,
                            GNUNET_NO);
  {
    enum GNUNET_GenericReturnValue ret;
 
    ret = GNUNET_BLOCK_get_key (GDS_block_context,
                                bd.type,
                                bd.data,
                                bd.data_size,
                                &bd.key);
    if (GNUNET_NO == ret)
      bd.key = prm->key;
  }
 
  /* if we got a HELLO, consider it for our own routing table */
  hello_check (&bd);
 
  /* Need to append 'peer' to 'get_path' */
  if (tracked)
  {
    struct GNUNET_DHT_PathElement xget_path[get_path_length + 1];
    struct GNUNET_DHT_PathElement *gp = xget_path;
    unsigned int failure_offset;
 
    GNUNET_memcpy (xget_path,
                   get_path,
                   get_path_length * sizeof(struct GNUNET_DHT_PathElement));
    xget_path[get_path_length].pred = peer->id;
    /* use memcpy(), as last_sig may not be aligned */
    memcpy (&xget_path[get_path_length].sig,
            last_sig,
            sizeof (*last_sig));
#if SANITY_CHECKS
    {
      const struct GNUNET_PeerIdentity *my_identity;
      my_identity = GNUNET_PILS_get_identity (GDS_pils);
      GNUNET_assert (NULL != my_identity);
      /* TODO: might want to eventually implement probabilistic
        load-based path verification, but for now it is all or nothing */
      failure_offset
        = GNUNET_DHT_verify_path (bd.data,
                                  bd.data_size,
                                  bd.expiration_time,
                                  trunc_peer,
                                  put_path,
                                  put_path_length,
                                  gp,
                                  get_path_length + 1,
                                  my_identity);
    }
#else
    failure_offset = 0;
#endif
    if (0 != failure_offset)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Recorded path invalid at offset %u, truncating\n",
                  failure_offset);
      GNUNET_assert (failure_offset <= bd.put_path_length + get_path_length
                     + 1);
      if (failure_offset < bd.put_path_length)
      {
        /* failure on put path */
        trunc_peer = &bd.put_path[failure_offset - 1].pred;
        bd.ro |= GNUNET_DHT_RO_TRUNCATED;
        bd.put_path = &bd.put_path[failure_offset];
        bd.put_path_length -= failure_offset;
        truncated = true;
      }
      else
      {
        /* failure on get path */
        failure_offset -= bd.put_path_length;
        if (0 == failure_offset)
          trunc_peer = &bd.put_path[bd.put_path_length - 1].pred;
        else
          trunc_peer = &gp[failure_offset - 1].pred;
        get_path_length -= failure_offset;
        gp = &gp[failure_offset];
        bd.put_path_length = 0;
        bd.put_path = NULL;
        bd.ro |= GNUNET_DHT_RO_TRUNCATED;
        truncated = true;
      }
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Extending GET path of length %u with %s\n",
                get_path_length,
                GNUNET_i2s (&peer->id));
    if (truncated)
    {
      GNUNET_assert (NULL != trunc_peer);
      bd.trunc_peer = *trunc_peer;
    }
    process_reply_with_path (&bd,
                             &prm->key,
                             get_path_length + 1,
                             gp);
  }
  else
  {
    if (truncated)
    {
      GNUNET_assert (NULL != trunc_peer);
      bd.trunc_peer = *trunc_peer;
    }
    process_reply_with_path (&bd,
                             &prm->key,
                             0,
                             NULL);
  }
}
 
 
static enum GNUNET_GenericReturnValue
check_dht_p2p_hello (void *cls,
                     const struct GNUNET_MessageHeader *hello)
{
  struct Target *t = cls;
  struct PeerInfo *peer = t->pi;
  enum GNUNET_GenericReturnValue ret;
  size_t hellob_size;
  void *hellob;
  struct GNUNET_TIME_Absolute expiration;
 
  ret = GNUNET_HELLO_dht_msg_to_block (hello,
                                       &peer->id,
                                       &hellob,
                                       &hellob_size,
                                       &expiration);
  GNUNET_free (hellob);
  return ret;
}
 
 
static void
handle_dht_p2p_hello (void *cls,
                      const struct GNUNET_MessageHeader *hello)
{
  struct Target *t = cls;
  struct PeerInfo *peer = t->pi;
 
  GNUNET_free (peer->hello);
  peer->hello_size = 0;
  GNUNET_break (GNUNET_OK ==
                GNUNET_HELLO_dht_msg_to_block (hello,
                                               &peer->id,
                                               &peer->hello,
                                               &peer->hello_size,
                                               &peer->hello_expiration));
}
 
 
void
GDS_u_receive (void *cls,
               void **tctx,
               void **sctx,
               const void *message,
               size_t message_size)
{
  struct Target *t = *tctx;
  struct GNUNET_MQ_MessageHandler core_handlers[] = {
    GNUNET_MQ_hd_var_size (dht_p2p_get,
                           GNUNET_MESSAGE_TYPE_DHT_P2P_GET,
                           struct PeerGetMessage,
                           t),
    GNUNET_MQ_hd_var_size (dht_p2p_put,
                           GNUNET_MESSAGE_TYPE_DHT_P2P_PUT,
                           struct PeerPutMessage,
                           t),
    GNUNET_MQ_hd_var_size (dht_p2p_result,
                           GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT,
                           struct PeerResultMessage,
                           t),
    GNUNET_MQ_hd_var_size (dht_p2p_hello,
                           GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO,
                           struct GNUNET_MessageHeader,
                           t),
    GNUNET_MQ_handler_end ()
  };
  const struct GNUNET_MessageHeader *mh = message;
 
  (void) cls; /* the 'struct GDS_Underlay' */
  (void) sctx; /* our receiver address */
  if (NULL == t)
  {
    /* Received message claiming to originate from myself?
       Ignore! */
    GNUNET_break_op (0);
    return;
  }
  if (message_size < sizeof (*mh))
  {
    GNUNET_break_op (0);
    return;
  }
  if (message_size != ntohs (mh->size))
  {
    GNUNET_break_op (0);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handling message of type %u from peer %s\n",
              ntohs (mh->type),
              GNUNET_i2s (&t->pi->id));
  if (GNUNET_OK !=
      GNUNET_MQ_handle_message (core_handlers,
                                mh))
  {
    GNUNET_break_op (0);
    return;
  }
}
 
 
void
GDS_try_connect (void *cls,
                 const struct GNUNET_PeerIdentity *pid,
                 const char *uri)
{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_HashCode phash;
  int peer_bucket;
  struct PeerBucket *bucket;
  (void) cls;
 
  my_identity = GNUNET_PILS_get_identity (GDS_pils);
  GNUNET_assert (NULL != my_identity);
 
  if (0 == GNUNET_memcmp (my_identity, pid))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Got a HELLO for my own PID, ignoring it\n");
    return; /* that's us! */
  }
  GNUNET_CRYPTO_hash (pid,
                      sizeof(*pid),
                      &phash);
  peer_bucket = find_bucket (&phash);
  GNUNET_assert ( (peer_bucket >= 0) &&
                  ((unsigned int) peer_bucket < MAX_BUCKETS));
  bucket = &k_buckets[peer_bucket];
  for (struct PeerInfo *pi = bucket->head;
       NULL != pi;
       pi = pi->next)
    if (0 ==
        GNUNET_memcmp (&pi->id,
                       pid))
    {
      /* already connected */
      GDS_u_try_connect (pid,
                         uri);
      return;
    }
  if (bucket->peers_size >= bucket_size)
    return; /* do not care */
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Discovered peer %s at %s suitable for bucket %d (%u/%u), trying to connect\n",
              GNUNET_i2s (pid),
              uri,
              peer_bucket,
              bucket->peers_size,
              bucket_size);
  /* new peer that we like! */
  GDS_u_try_connect (pid,
                     uri);
}
 
 
void
GDS_NEIGHBOURS_broadcast (const struct GNUNET_MessageHeader *msg)
{
  for (unsigned int bc = 0; bc<closest_bucket; bc++)
  {
    struct PeerBucket *bucket = &k_buckets[bc];
    unsigned int count = 0;
 
    for (struct PeerInfo *pos = bucket->head;
         NULL != pos;
         pos = pos->next)
    {
      if (count >= bucket_size)
        break;   /* we only consider first #bucket_size entries per bucket */
      count++;
      do_send (pos,
               msg);
    }
  }
}
 
 
enum GNUNET_GenericReturnValue
GDS_NEIGHBOURS_init ()
{
 
  unsigned long long temp_config_num;
 
  disable_try_connect
    = GNUNET_CONFIGURATION_get_value_yesno (GDS_cfg,
                                            "DHT",
                                            "DISABLE_TRY_CONNECT");
  if (GNUNET_OK ==
      GNUNET_CONFIGURATION_get_value_number (GDS_cfg,
                                             "DHT",
                                             "bucket_size",
                                             &temp_config_num))
    bucket_size = (unsigned int) temp_config_num;
  cache_results
    = GNUNET_CONFIGURATION_get_value_yesno (GDS_cfg,
                                            "DHT",
                                            "CACHE_RESULTS");
  all_connected_peers = GNUNET_CONTAINER_multipeermap_create (256,
                                                              GNUNET_YES);
  return GNUNET_OK;
}
 
 
void
GDS_NEIGHBOURS_done ()
{
  if (NULL == all_connected_peers)
    return;
  GNUNET_assert (0 ==
                 GNUNET_CONTAINER_multipeermap_size (all_connected_peers));
  GNUNET_CONTAINER_multipeermap_destroy (all_connected_peers);
  all_connected_peers = NULL;
  GNUNET_assert (NULL == find_peer_task);
}
 
 
const struct GNUNET_PeerIdentity *
GDS_NEIGHBOURS_get_id ()
{
  return GNUNET_PILS_get_identity (GDS_pils);
}
 
 
/* end of gnunet-service-dht_neighbours.c */

SANITY_CHECKS

#define SANITY_CHECKS   2

Enable slow sanity checks to debug issues.

TODO: might want to eventually implement probabilistic load-based path verification, but for now it is all or nothing based on this define.

0: do not check – if signatures become performance critical 1: check all external inputs – normal production for now 2: check internal computations as well – for debugging

Definition at line 56 of file gnunet-service-dht_neighbours.c.

MAX_BUCKETS

#define MAX_BUCKETS   sizeof(struct GNUNET_HashCode) * 8

How many buckets will we allow in total.

Definition at line 61 of file gnunet-service-dht_neighbours.c.

DEFAULT_BUCKET_SIZE

#define DEFAULT_BUCKET_SIZE   8

What is the maximum number of peers in a given bucket.

Definition at line 66 of file gnunet-service-dht_neighbours.c.

FIND_PEER_REPLICATION_LEVEL

#define FIND_PEER_REPLICATION_LEVEL   4

Desired replication level for FIND PEER requests.

Definition at line 71 of file gnunet-service-dht_neighbours.c.

MAXIMUM_PENDING_PER_PEER

#define MAXIMUM_PENDING_PER_PEER   64

Maximum allowed number of pending messages per peer.

Definition at line 76 of file gnunet-service-dht_neighbours.c.

DHT_MINIMUM_FIND_PEER_INTERVAL

#define DHT_MINIMUM_FIND_PEER_INTERVAL

Value:

          GNUNET_TIME_relative_multiply ( \
          GNUNET_TIME_UNIT_MINUTES, 2)

How long at least to wait before sending another find peer request.

This is basically the frequency at which we will usually send out requests when we are 'perfectly' connected.

Definition at line 83 of file gnunet-service-dht_neighbours.c.

DHT_AVG_FIND_PEER_INTERVAL

#define DHT_AVG_FIND_PEER_INTERVAL

Value:

          GNUNET_TIME_relative_multiply (    \
          GNUNET_TIME_UNIT_SECONDS, 6)

How long to additionally wait on average per bucket_size to send out the FIND PEER requests if we did successfully connect (!) to a a new peer and added it to a bucket (as counted in newly_found_peers).

This time is Multiplied by 100 * newly_found_peers / bucket_size to get the new delay for finding peers (the DHT_MINIMUM_FIND_PEER_INTERVAL is still added on top). Also the range in which we randomize, so the effective value is half of the number given here.

Definition at line 96 of file gnunet-service-dht_neighbours.c.

GET_TIMEOUT

#define GET_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2)

How long at most to wait for transmission of a GET request to another peer?

Definition at line 102 of file gnunet-service-dht_neighbours.c.

Function Documentation

send_done_cb()

static void send_done_cb ( void *  cls )

static

Function called whenever we finished sending to a target.

Marks the transmission as finished (and the target as ready for the next message).

Parameters

cls	a struct Target *

Definition at line 404 of file gnunet-service-dht_neighbours.c.

{
  struct Target *t = cls;
  struct PeerInfo *pi = t->pi; /* NULL if t->dropped! */
 
  GNUNET_assert (t->load > 0);
  t->load--;
  if (0 < t->load)
    return;
  if (t->dropped)
  {
    GNUNET_free (t);
    return;
  }
  /* move target back to the front */
  GNUNET_CONTAINER_DLL_remove (pi->t_head,
                               pi->t_tail,
                               t);
  GNUNET_CONTAINER_DLL_insert (pi->t_head,
                               pi->t_tail,
                               t);
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, t, PeerInfo::t_head, and PeerInfo::t_tail.

Referenced by do_send().

Here is the caller graph for this function:

do_send()

static bool do_send ( struct PeerInfo *  pi, const struct GNUNET_MessageHeader *  msg  )

static

Send msg to pi.

Parameters

pi	where to send the message
msg	message to send

Returns

true if the message was handed to an underlay, false if it was dropped because no target of pi could take it

Definition at line 437 of file gnunet-service-dht_neighbours.c.

{
  struct Target *t;
 
  for (t = pi->t_head;
       NULL != t;
       t = t->next)
    if (t->load < MAXIMUM_PENDING_PER_PEER)
      break;
  if (NULL == t)
  {
    /* all targets busy, drop message */
    GNUNET_STATISTICS_update (GDS_stats,
                              "# messages dropped (underlays busy)",
                              1,
                              GNUNET_NO);
    return false;
  }
  t->load++;
  /* rotate busy targets to the end */
  if (MAXIMUM_PENDING_PER_PEER == t->load)
  {
    GNUNET_CONTAINER_DLL_remove (pi->t_head,
                                 pi->t_tail,
                                 t);
    GNUNET_CONTAINER_DLL_insert_tail (pi->t_head,
                                      pi->t_tail,
                                      t);
  }
  GDS_u_send (t->u,
              t->utarget,
              msg,
              ntohs (msg->size),
              &send_done_cb,
              t);
  return true;
}

References GDS_stats, GDS_u_send(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_NO, GNUNET_STATISTICS_update(), MAXIMUM_PENDING_PER_PEER, msg, GNUNET_SCHEDULER_Task::next, Target::pi, send_done_cb(), GNUNET_MessageHeader::size, t, PeerInfo::t_head, and PeerInfo::t_tail.

Referenced by cb_path_signed(), cb_routing_put_message(), GDS_NEIGHBOURS_broadcast(), GDS_NEIGHBOURS_handle_get(), and GDS_NEIGHBOURS_handle_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

find_bucket()

static int find_bucket ( const struct GNUNET_HashCode *  hc )

static

Find the optimal bucket for this key.

Buckets are indexed by the number of leading bits hc shares with our own identity, so offset 0 holds the peers that differ from us in the very first bit (see k_buckets).

Parameters

hc	the hashcode to compare our identity to

Returns

the proper bucket index, or -1 on error (same hashcode)

Definition at line 488 of file gnunet-service-dht_neighbours.c.

{
  const struct GNUNET_HashCode *my_identity_hash;
  struct GNUNET_HashCode xor;
  unsigned int bits;
 
  my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
  GNUNET_assert (NULL != my_identity_hash);
 
  GNUNET_CRYPTO_hash_xor (hc,
                          my_identity_hash,
                          &xor);
  bits = GNUNET_CRYPTO_hash_count_leading_zeros (&xor);
  if (bits == MAX_BUCKETS)
  {
    /* How can all bits match? Got my own ID? */
    GNUNET_break (0);
    return -1;
  }
  return bits;
}

References GNUNET_HashCode::bits, GDS_pils, GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_hash_count_leading_zeros(), GNUNET_CRYPTO_hash_xor(), GNUNET_PILS_get_identity_hash(), and MAX_BUCKETS.

Referenced by GDS_am_closest_peer(), GDS_try_connect(), and GDS_u_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

add_known_to_bloom()

static enum GNUNET_GenericReturnValue add_known_to_bloom ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Add each of the peers we already know to the Bloom filter of the request so that we don't get duplicate HELLOs.

Parameters

cls	the struct GNUNET_BLOCK_Group
key	peer identity to add to the bloom filter
value	the peer information

Returns

GNUNET_YES (we should continue to iterate)

Definition at line 521 of file gnunet-service-dht_neighbours.c.

{
  struct GNUNET_BLOCK_Group *bg = cls;
  struct PeerInfo *pi = value;
 
  GNUNET_BLOCK_group_set_seen (bg,
                               &pi->phash,
                               1);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Adding known peer (%s) to Bloom filter for FIND PEER\n",
              GNUNET_i2s (key));
  return GNUNET_YES;
}

References GNUNET_BLOCK_group_set_seen(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_YES, key, PeerInfo::phash, and value.

Referenced by send_find_peer_message().

Here is the call graph for this function:

Here is the caller graph for this function:

send_find_peer_message()

static void send_find_peer_message ( void *  cls )

static

Task to send a find peer message for our own peer identifier so that we can find the closest peers in the network to ourselves and attempt to connect to them.

Parameters

cls	closure for this task, NULL

Definition at line 546 of file gnunet-service-dht_neighbours.c.

{
  (void) cls;
 
  /* Compute when to do this again (and if we should
     even send a message right now) */
  {
    struct GNUNET_TIME_Relative next_send_time;
    bool done_early;
 
    find_peer_task = NULL;
    done_early = (newly_found_peers > bucket_size);
    /* schedule next round, taking longer if we found more peers
       in the last round. */
    next_send_time.rel_value_us =
      DHT_MINIMUM_FIND_PEER_INTERVAL.rel_value_us
      + GNUNET_CRYPTO_random_u64 (
        GNUNET_TIME_relative_multiply (
          DHT_AVG_FIND_PEER_INTERVAL,
          1 + 100 * (1 + newly_found_peers) / bucket_size).rel_value_us);
    newly_found_peers = 0;
    GNUNET_assert (NULL == find_peer_task);
    find_peer_task =
      GNUNET_SCHEDULER_add_delayed (next_send_time,
                                    &send_find_peer_message,
                                    NULL);
    if (done_early)
      return;
  }
 
  /* actually send 'find peer' request */
  {
    const struct GNUNET_HashCode *my_identity_hash;
    struct GNUNET_BLOCK_Group *bg;
    struct GNUNET_CONTAINER_BloomFilter *peer_bf;
 
    my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
    GNUNET_assert (NULL != my_identity_hash);
 
    bg = GNUNET_BLOCK_group_create (GDS_block_context,
                                    GNUNET_BLOCK_TYPE_DHT_HELLO,
                                    NULL,
                                    0,
                                    "seen-set-size",
                                    GNUNET_CONTAINER_multipeermap_size (
                                      all_connected_peers),
                                    NULL);
    GNUNET_CONTAINER_multipeermap_iterate (all_connected_peers,
                                           &add_known_to_bloom,
                                           bg);
    peer_bf
      = GNUNET_CONTAINER_bloomfilter_init (NULL,
                                           DHT_BLOOM_SIZE,
                                           GNUNET_CONSTANTS_BLOOMFILTER_K);
    if (GNUNET_OK !=
        GDS_NEIGHBOURS_handle_get (GNUNET_BLOCK_TYPE_DHT_HELLO,
                                   GNUNET_DHT_RO_FIND_APPROXIMATE
                                   | GNUNET_DHT_RO_RECORD_ROUTE,
                                   FIND_PEER_REPLICATION_LEVEL,
                                   0, /* hop count */
                                   my_identity_hash,
                                   NULL, 0, /* xquery */
                                   bg,
                                   peer_bf))
    {
      GNUNET_STATISTICS_update (GDS_stats,
                                "# Failed to initiate FIND PEER lookup",
                                1,
                                GNUNET_NO);
    }
    else
    {
      GNUNET_STATISTICS_update (GDS_stats,
                                "# FIND PEER messages initiated",
                                1,
                                GNUNET_NO);
    }
    GNUNET_CONTAINER_bloomfilter_free (peer_bf);
    GNUNET_BLOCK_group_destroy (bg);
  }
}

References add_known_to_bloom(), all_connected_peers, bucket_size, DHT_AVG_FIND_PEER_INTERVAL, DHT_BLOOM_SIZE, DHT_MINIMUM_FIND_PEER_INTERVAL, FIND_PEER_REPLICATION_LEVEL, find_peer_task, GDS_block_context, GDS_NEIGHBOURS_handle_get(), GDS_pils, GDS_stats, GNUNET_assert, GNUNET_BLOCK_group_create(), GNUNET_BLOCK_group_destroy(), GNUNET_BLOCK_TYPE_DHT_HELLO, GNUNET_CONSTANTS_BLOOMFILTER_K, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_CRYPTO_random_u64(), GNUNET_DHT_RO_FIND_APPROXIMATE, GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_NO, GNUNET_OK, GNUNET_PILS_get_identity_hash(), GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_TIME_relative_multiply(), newly_found_peers, GNUNET_TIME_Relative::rel_value_us, and send_find_peer_message().

Referenced by GDS_u_connect(), and send_find_peer_message().

Here is the call graph for this function:

Here is the caller graph for this function:

update_hold()

static void update_hold ( struct PeerBucket *  bucket )

static

The list of the first bucket_size peers of bucket changed.

We should thus make sure we have called 'hold' all of the first bucket_size peers!

Parameters

[in,out]

bucket

the bucket where the peer set changed

Definition at line 637 of file gnunet-service-dht_neighbours.c.

{
  unsigned int off = 0;
 
  /* find the peer -- we just go over all of them, should
     be hardly any more expensive than just finding the 'right'
     one. */
  for (struct PeerInfo *pos = bucket->head;
       NULL != pos;
       pos = pos->next)
  {
    if (off > bucket_size)
      break;   /* We only hold up to #bucket_size peers per bucket */
    off++;
    for (struct Target *tp = pos->t_head;
         NULL != tp;
         tp = tp->next)
      if (NULL == tp->ph)
        tp->ph = GDS_u_hold (tp->u,
                             tp->utarget);
  }
}

References bucket_size, GDS_u_hold(), and PeerBucket::head.

Referenced by GDS_u_connect(), and GDS_u_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_u_connect()

void GDS_u_connect	(	void *	cls,
		struct GNUNET_DHTU_Target *	target,
		const struct GNUNET_PeerIdentity *	pid,
		void **	ctx
	)

Function to call when we connect to a peer and can henceforth transmit to that peer.

Parameters

	cls	the closure, must be a struct GDS_Underlay
	target	handle to the target, pointer will remain valid until disconnect_cb is called
	pid	peer identity, pointer will remain valid until disconnect_cb is called
[out]	ctx	storage space for DHT to use in association with this target

Definition at line 662 of file gnunet-service-dht_neighbours.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GDS_Underlay *u = cls;
  struct PeerInfo *pi;
  struct PeerBucket *bucket;
  bool do_hold = false;
 
  my_identity = GNUNET_PILS_get_identity (GDS_pils);
  GNUNET_assert (NULL != my_identity);
 
  /* Check for connect to self message */
  if (0 == GNUNET_memcmp (my_identity, pid))
    return;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Connected to peer %s\n",
              GNUNET_i2s (pid));
  pi = GNUNET_CONTAINER_multipeermap_get (all_connected_peers,
                                          pid);
  if (NULL == pi)
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# peers connected",
                              1,
                              GNUNET_NO);
    pi = GNUNET_new (struct PeerInfo);
    pi->id = *pid;
    GNUNET_CRYPTO_hash (pid,
                        sizeof(*pid),
                        &pi->phash);
    pi->peer_bucket = find_bucket (&pi->phash);
    GNUNET_assert ( (pi->peer_bucket >= 0) &&
                    ((unsigned int) pi->peer_bucket < MAX_BUCKETS));
    bucket = &k_buckets[pi->peer_bucket];
    GNUNET_CONTAINER_DLL_insert_tail (bucket->head,
                                      bucket->tail,
                                      pi);
    bucket->peers_size++;
    closest_bucket = GNUNET_MAX (closest_bucket,
                                 (unsigned int) pi->peer_bucket + 1);
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_multipeermap_put (all_connected_peers,
                                                      &pi->id,
                                                      pi,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    if (bucket->peers_size <= bucket_size)
    {
      newly_found_peers++;
      do_hold = true;
    }
    if ( (1 == GNUNET_CONTAINER_multipeermap_size (all_connected_peers)) &&
         (GNUNET_YES != disable_try_connect) )
    {
      /* got a first connection, good time to start with FIND PEER requests... */
      GNUNET_assert (NULL == find_peer_task);
      find_peer_task = GNUNET_SCHEDULER_add_now (&send_find_peer_message,
                                                 NULL);
    }
    /* A pending GET that found no route is sitting on an exponential
       back-off of up to 15 minutes; now that we have somewhere to send
       it, do so immediately.  A PUT that found no route was not sent at
       all and nothing else will ever send it. */
    GDS_CLIENTS_retry_requests ();
    GDS_CLIENTS_retry_puts ();
  }
  {
    struct Target *t;
 
    t = GNUNET_new (struct Target);
    t->u = u;
    t->utarget = target;
    t->pi = pi;
    GNUNET_CONTAINER_DLL_insert (pi->t_head,
                                 pi->t_tail,
                                 t);
    *ctx = t;
 
  }
  if (do_hold)
    update_hold (bucket);
}

References all_connected_peers, bucket_size, closest_bucket, ctx, disable_try_connect, find_bucket(), find_peer_task, GDS_CLIENTS_retry_puts(), GDS_CLIENTS_retry_requests(), GDS_pils, GDS_stats, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MAX, GNUNET_memcmp, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_PILS_get_identity(), GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_update(), GNUNET_YES, PeerBucket::head, PeerInfo::id, k_buckets, MAX_BUCKETS, my_identity, newly_found_peers, PeerInfo::peer_bucket, PeerBucket::peers_size, PeerInfo::phash, Target::pi, send_find_peer_message(), t, PeerInfo::t_head, PeerInfo::t_tail, PeerBucket::tail, u, and update_hold().

Referenced by load_underlay().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_u_disconnect()

void GDS_u_disconnect

(

void *

ctx

)

Function to call when we disconnected from a peer and can henceforth cannot transmit to that peer anymore.

Parameters

[in]

ctx

storage space used by the DHT in association with this target

Definition at line 749 of file gnunet-service-dht_neighbours.c.

{
  struct Target *t = ctx;
  struct PeerInfo *pi;
  struct PeerBucket *bucket;
  bool was_held = false;
 
  /* Check for disconnect from self message (on shutdown) */
  if (NULL == t)
    return;
  pi = t->pi;
  GNUNET_CONTAINER_DLL_remove (pi->t_head,
                               pi->t_tail,
                               t);
  if (NULL != t->ph)
  {
    GDS_u_drop (t->u,
                t->ph);
    t->ph = NULL;
    was_held = true;
  }
  if (t->load > 0)
  {
    t->dropped = true;
    t->pi = NULL;
  }
  else
  {
    GNUNET_free (t);
  }
  if (NULL != pi->t_head)
    return; /* got other connections still */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Disconnected from peer %s\n",
              GNUNET_i2s (&pi->id));
  GNUNET_STATISTICS_update (GDS_stats,
                            "# peers connected",
                            -1,
                            GNUNET_NO);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (all_connected_peers,
                                                       &pi->id,
                                                       pi));
  if ( (0 == GNUNET_CONTAINER_multipeermap_size (all_connected_peers)) &&
       (GNUNET_YES != disable_try_connect))
  {
    GNUNET_SCHEDULER_cancel (find_peer_task);
    find_peer_task = NULL;
  }
  GNUNET_assert (pi->peer_bucket >= 0);
  bucket = &k_buckets[pi->peer_bucket];
  GNUNET_CONTAINER_DLL_remove (bucket->head,
                               bucket->tail,
                               pi);
  GNUNET_assert (bucket->peers_size > 0);
  bucket->peers_size--;
  if ( (was_held) &&
       (bucket->peers_size >= bucket_size - 1) )
    update_hold (bucket);
  while ( (closest_bucket > 0) &&
          (0 == k_buckets[closest_bucket - 1].peers_size))
    closest_bucket--;
  GNUNET_free (pi->hello);
  GNUNET_free (pi);
}

References all_connected_peers, bucket_size, closest_bucket, ctx, disable_try_connect, find_peer_task, GDS_stats, GDS_u_drop(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), GNUNET_YES, PeerBucket::head, PeerInfo::hello, PeerInfo::id, k_buckets, PeerInfo::peer_bucket, PeerBucket::peers_size, t, PeerInfo::t_head, PeerInfo::t_tail, PeerBucket::tail, and update_hold().

Referenced by load_underlay().

Here is the call graph for this function:

Here is the caller graph for this function:

get_forward_count()

static unsigned int get_forward_count ( uint16_t  hop_count, uint16_t  target_replication  )

static

To how many peers should we (on average) forward the request to obtain the desired target_replication count (on average).

Parameters

hop_count	number of hops the message has traversed
target_replication	the number of total paths desired

Returns

Some number of peers to forward the message to

Definition at line 825 of file gnunet-service-dht_neighbours.c.

{
  uint32_t random_value;
  uint32_t forward_count;
  float target_value;
  double rm1;
  double nse = GDS_NSE_get ();
 
  /* Guard the divisor below: an NSE of zero would make target_value
     infinite (or NaN), and the conversion to uint32_t undefined. */
  if (! (nse >= MINIMUM_LOG_NSE))
    nse = MINIMUM_LOG_NSE;
  if (hop_count > nse * 4.0)
  {
    /* forcefully terminate */
    GNUNET_STATISTICS_update (GDS_stats,
                              "# requests TTL-dropped",
                              1,
                              GNUNET_NO);
    return 0;
  }
  if (hop_count > nse * 2.0)
  {
    /* Once we have reached our ideal number of hops, only forward to 1 peer */
    return 1;
  }
  /* bound by system-wide maximum and minimum */
  if (0 == target_replication)
    target_replication = 1; /* 0 is verboten */
  target_replication =
    GNUNET_MIN (GNUNET_DHT_MAXIMUM_REPLICATION_LEVEL,
                target_replication);
  rm1 = target_replication - 1.0;
  target_value =
    1 + (rm1) / (nse + (rm1 * hop_count));
 
  /* Set forward count to floor of target_value */
  forward_count = (uint32_t) target_value;
  /* Subtract forward_count (floor) from target_value (yields value between 0 and 1) */
  target_value = target_value - forward_count;
  random_value = GNUNET_CRYPTO_random_u32 (UINT32_MAX);
  if (random_value < (target_value * UINT32_MAX))
    forward_count++;
  return GNUNET_MIN (forward_count,
                     GNUNET_DHT_MAXIMUM_REPLICATION_LEVEL);
}

References GDS_NSE_get(), GDS_stats, GNUNET_CRYPTO_random_u32(), GNUNET_DHT_MAXIMUM_REPLICATION_LEVEL, GNUNET_MIN, GNUNET_NO, GNUNET_STATISTICS_update(), MINIMUM_LOG_NSE, and nse.

Referenced by get_target_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_am_closest_peer()

enum GNUNET_GenericReturnValue GDS_am_closest_peer	(	const struct GNUNET_HashCode *	key,
		const struct GNUNET_CONTAINER_BloomFilter *	bloom
	)

Check whether my identity is closer than any known peers.

If a non-null bloomfilter is given, check if this is the closest peer that hasn't already been routed to.

Parameters

key	hash code to check closeness to
bloom	bloomfilter, exclude these entries from the decision

Returns

GNUNET_YES if node location is closest, GNUNET_NO otherwise.

Definition at line 885 of file gnunet-service-dht_neighbours.c.

{
  const struct GNUNET_HashCode *my_identity_hash;
  int delta;
  my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
  GNUNET_assert (NULL != my_identity_hash);
  if (0 == GNUNET_memcmp (my_identity_hash, key))
    return GNUNET_YES;
  for (int bucket_num = find_bucket (key);
       bucket_num < closest_bucket;
       bucket_num++)
  {
    unsigned int count = 0;
    GNUNET_assert (bucket_num >= 0);
    for (struct PeerInfo *pos = k_buckets[bucket_num].head;
         NULL != pos;
         pos = pos->next)
    {
      if (count >= bucket_size)
        break; /* we only consider first #bucket_size entries per bucket */
      count++;
      if ( (NULL != bloom) &&
           (GNUNET_YES ==
            GNUNET_CONTAINER_bloomfilter_test (bloom,
                                               &pos->phash)) )
        continue;               /* Ignore filtered peers */
      /* All peers in this bucket must be closer than us, as
         they mismatch with our PID on the pivotal bit. So
         because an unfiltered peer exists, we are not the
         closest. */
      delta = GNUNET_CRYPTO_hash_xorcmp (&pos->phash,
                                         my_identity_hash,
                                         key);
      switch (delta)
      {
      case -1: /* pos closer */
        return GNUNET_NO;
      case 0: /* identical, impossible! */
        GNUNET_assert (0);
        break;
      case 1: /* I am closer */
        break;
      }
    }
  }
  /* No closer (unfiltered) peers found; we must be the closest! */
  return GNUNET_YES;
}

References bucket_size, closest_bucket, delta, find_bucket(), GDS_pils, GNUNET_assert, GNUNET_CONTAINER_bloomfilter_test(), GNUNET_CRYPTO_hash_xorcmp(), GNUNET_memcmp, GNUNET_NO, GNUNET_PILS_get_identity_hash(), GNUNET_YES, k_buckets, and key.

Referenced by handle_dht_local_put(), handle_dht_p2p_get(), and handle_dht_p2p_put().

Here is the call graph for this function:

Here is the caller graph for this function:

select_peer()

static struct PeerInfo * select_peer ( const struct GNUNET_HashCode *  key, const struct GNUNET_CONTAINER_BloomFilter *  bloom, uint32_t  hops  )

static

Select a peer from the routing table that would be a good routing destination for sending a message for key.

The resulting peer must not be in the set of bloom blocked peers.

Note that we should not ALWAYS select the closest peer to the target, we do a "random" peer selection if the number of hops is below the logarithm of the network size estimate.

In all cases, we only consider at most the first bucket_size peers of any k_buckets. The other peers in the bucket are there because GNUnet doesn't really allow the DHT to "reject" connections, but we only use the first bucket_size, even if more exist. (The idea is to ensure that those connections are frequently used, and for others to be not used by the DHT, and thus possibly dropped by transport due to disuse).

Parameters

key	the key we are selecting a peer to route to
bloom	a Bloom filter containing entries this request has seen already
hops	how many hops has this message traversed thus far

Returns

Peer to route to, or NULL on error

Definition at line 958 of file gnunet-service-dht_neighbours.c.

{
  if (0 == closest_bucket)
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# Peer selection failed",
                              1,
                              GNUNET_NO);
    return NULL; /* we have zero connections */
  }
  if (hops >= GDS_NSE_get ())
  {
    /* greedy selection (closest peer that is not in Bloom filter) */
    struct PeerInfo *chosen = NULL;
    int best_bucket;
    int bucket_offset;
 
    {
      const struct GNUNET_HashCode *my_identity_hash;
      struct GNUNET_HashCode xor;
      my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
      GNUNET_assert (NULL != my_identity_hash);
      GNUNET_CRYPTO_hash_xor (key,
                              my_identity_hash,
                              &xor);
      best_bucket = GNUNET_CRYPTO_hash_count_leading_zeros (&xor);
    }
    if (best_bucket >= closest_bucket)
      bucket_offset = closest_bucket - 1;
    else
      bucket_offset = best_bucket;
    while (-1 != bucket_offset)
    {
      struct PeerBucket *bucket = &k_buckets[bucket_offset];
      unsigned int count = 0;
 
      for (struct PeerInfo *pos = bucket->head;
           NULL != pos;
           pos = pos->next)
      {
        if (count >= bucket_size)
          break; /* we only consider first #bucket_size entries per bucket */
        count++;
        if ( (NULL != bloom) &&
             (GNUNET_YES ==
              GNUNET_CONTAINER_bloomfilter_test (bloom,
                                                 &pos->phash)) )
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Excluded peer `%s' due to BF match in greedy routing for %s\n",
                      GNUNET_i2s (&pos->id),
                      GNUNET_h2s (key));
          continue;
        }
        if (NULL == chosen)
        {
          /* First candidate */
          chosen = pos;
        }
        else
        {
          int delta = GNUNET_CRYPTO_hash_xorcmp (&pos->phash,
                                                 &chosen->phash,
                                                 key);
          switch (delta)
          {
          case -1: /* pos closer */
            chosen = pos;
            break;
          case 0: /* identical, impossible! */
            GNUNET_assert (0);
            break;
          case 1: /* chosen closer */
            break;
          }
        }
      } /* for all (#bucket_size) peers in bucket */
      if (NULL != chosen)
        break;
 
      /* If we chose nothing in first iteration, first go through deeper
         buckets (best chance to find a good match), and if we still found
         nothing, then to shallower buckets.  Terminate on any match in the
         current bucket, as this search order guarantees that it can only get
         worse as we keep going. */
      /* Both upward steps must be bounded by #closest_bucket, and the test
         has to be `>=': stepping from #best_bucket to #best_bucket + 1
         below can jump straight over an `==' test, after which nothing
         stops the offset from running off the end of #k_buckets. */
      if (bucket_offset > best_bucket)
      {
        /* Go through more deeper buckets */
        bucket_offset++;
        if (bucket_offset >= closest_bucket)
        {
          /* Can't go any deeper, if nothing selected,
             go for shallower buckets */
          bucket_offset = best_bucket - 1;
        }
      }
      else
      {
        /* We're either at the 'best_bucket' or already moving
           on to shallower buckets. */
        if (bucket_offset == best_bucket)
        {
          bucket_offset++; /* go for deeper buckets */
          if (bucket_offset >= closest_bucket)
            bucket_offset = best_bucket - 1;
        }
        else
          bucket_offset--; /* go for shallower buckets */
      }
    } /* for applicable buckets (starting at best match) */
    if (NULL == chosen)
    {
      GNUNET_STATISTICS_update (GDS_stats,
                                "# Peer selection failed",
                                1,
                                GNUNET_NO);
      return NULL;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Selected peer `%s' in greedy routing for %s\n",
                GNUNET_i2s (&chosen->id),
                GNUNET_h2s (key));
    return chosen;
  } /* end of 'greedy' peer selection */
 
  /* select "random" peer */
  /* count number of peers that are available and not filtered,
     but limit to at most #bucket_size peers, starting with
     those 'furthest' from us. */
  {
    unsigned int total = 0;
    unsigned int selected;
 
    for (unsigned int bc = 0; bc < closest_bucket; bc++)
    {
      struct PeerBucket *bucket = &k_buckets[bc];
      unsigned int count = 0;
 
      for (struct PeerInfo *pos = bucket->head;
           NULL != pos;
           pos = pos->next)
      {
        count++;
        if (count > bucket_size)
          break; /* limits search to #bucket_size peers per bucket */
        if ( (NULL != bloom) &&
             (GNUNET_YES ==
              GNUNET_CONTAINER_bloomfilter_test (bloom,
                                                 &pos->phash)) )
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Excluded peer `%s' due to BF match in random routing for %s\n",
                      GNUNET_i2s (&pos->id),
                      GNUNET_h2s (key));
          continue;             /* Ignore filtered peers */
        }
        total++;
      } /* for all peers in bucket */
    } /* for all buckets */
    if (0 == total)             /* No peers to select from! */
    {
      GNUNET_STATISTICS_update (GDS_stats,
                                "# Peer selection failed",
                                1,
                                GNUNET_NO);
      return NULL;
    }
 
    /* Now actually choose a peer */
    selected = GNUNET_CRYPTO_random_u32 (total);
    for (unsigned int bc = 0; bc < closest_bucket; bc++)
    {
      unsigned int count = 0;
 
      for (struct PeerInfo *pos = k_buckets[bc].head;
           pos != NULL;
           pos = pos->next)
      {
        count++;
        if (count > bucket_size)
          break; /* limits search to #bucket_size peers per bucket */
 
        if ( (NULL != bloom) &&
             (GNUNET_YES ==
              GNUNET_CONTAINER_bloomfilter_test (bloom,
                                                 &pos->phash)) )
          continue;             /* Ignore bloomfiltered peers */
        if (0 == selected--)
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Selected peer `%s' in random routing for %s\n",
                      GNUNET_i2s (&pos->id),
                      GNUNET_h2s (key));
          return pos;
        }
      } /* for peers in bucket */
    } /* for all buckets */
  } /* random peer selection scope */
  GNUNET_break (0);
  return NULL;
}

References bucket_size, closest_bucket, delta, GDS_NSE_get(), GDS_pils, GDS_stats, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_bloomfilter_test(), GNUNET_CRYPTO_hash_count_leading_zeros(), GNUNET_CRYPTO_hash_xor(), GNUNET_CRYPTO_hash_xorcmp(), GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_PILS_get_identity_hash(), GNUNET_STATISTICS_update(), GNUNET_YES, PeerBucket::head, PeerInfo::id, k_buckets, key, PeerInfo::next, and PeerInfo::phash.

Referenced by get_target_peers(), and handle_find_local_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

get_target_peers()

static unsigned int get_target_peers ( const struct GNUNET_HashCode *  key, struct GNUNET_CONTAINER_BloomFilter *  bloom, uint16_t  hop_count, uint16_t  target_replication, struct PeerInfo ***  targets  )

static

Compute the set of peers that the given request should be forwarded to.

Parameters

	key	routing key
[in,out]	bloom	Bloom filter excluding peers as targets, all selected peers will be added to the Bloom filter
	hop_count	number of hops the request has traversed so far
	target_replication	desired number of replicas
[out]	targets	where to store an array of target peers (to be free()ed by the caller)

Returns

number of peers returned in targets.

Definition at line 1181 of file gnunet-service-dht_neighbours.c.

{
  unsigned int target;
  unsigned int off;
  struct PeerInfo **rtargets;
 
  GNUNET_assert (NULL != bloom);
  target = get_forward_count (hop_count,
                              target_replication);
  if (0 == target)
  {
    *targets = NULL;
    return 0;
  }
  rtargets = GNUNET_new_array (target,
                               struct PeerInfo *);
  for (off = 0; off < target; off++)
  {
    struct PeerInfo *nxt;
 
    nxt = select_peer (key,
                       bloom,
                       hop_count);
    if (NULL == nxt)
      break;
    rtargets[off] = nxt;
    /* Exclude the peer we just picked from the next round, or
       select_peer() would hand us the same peer again. */
    GNUNET_break (GNUNET_NO ==
                  GNUNET_CONTAINER_bloomfilter_test (bloom,
                                                     &nxt->phash));
    GNUNET_CONTAINER_bloomfilter_add (bloom,
                                      &nxt->phash);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Selected %u/%u peers at hop %u for %s (target was %u)\n",
              off,
              GNUNET_CONTAINER_multipeermap_size (all_connected_peers),
              (unsigned int) hop_count,
              GNUNET_h2s (key),
              target);
  if (0 == off)
  {
    GNUNET_free (rtargets);
    *targets = NULL;
    return 0;
  }
  *targets = rtargets;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Forwarding query `%s' to %u peers (goal was %u peers)\n",
              GNUNET_h2s (key),
              off,
              target);
  return off;
}

References all_connected_peers, get_forward_count(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_bloomfilter_add(), GNUNET_CONTAINER_bloomfilter_test(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_new_array, GNUNET_NO, key, PeerInfo::phash, and select_peer().

Referenced by GDS_NEIGHBOURS_handle_get(), and GDS_NEIGHBOURS_handle_put().

Here is the call graph for this function:

Here is the caller graph for this function:

hello_check()

static void hello_check ( const struct GNUNET_DATACACHE_Block *  bd )

static

If we got a HELLO, consider it for our own routing table.

Parameters

bd	block data we got

Definition at line 1248 of file gnunet-service-dht_neighbours.c.

{
  struct GNUNET_HELLO_Parser *b;
 
  if (GNUNET_BLOCK_TYPE_DHT_HELLO != bd->type)
    return;
 
  b = GNUNET_HELLO_parser_from_block (bd->data,
                                      bd->data_size);
  if (GNUNET_YES != disable_try_connect)
  {
    GNUNET_HELLO_parser_iterate (b,
                                 &GDS_try_connect,
                                 NULL);
  }
  GNUNET_HELLO_parser_free (b);
}

References GNUNET_DATACACHE_Block::data, GNUNET_DATACACHE_Block::data_size, disable_try_connect, GDS_try_connect(), GNUNET_BLOCK_TYPE_DHT_HELLO, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_block(), GNUNET_HELLO_parser_iterate(), GNUNET_YES, and GNUNET_DATACACHE_Block::type.

Referenced by GDS_NEIGHBOURS_handle_put(), and handle_dht_p2p_result().

Here is the call graph for this function:

Here is the caller graph for this function:

cb_routing_put_message()

static bool cb_routing_put_message ( void *  cls, size_t  msize, struct PeerPutMessage *  ppm  )

static

Definition at line 1286 of file gnunet-service-dht_neighbours.c.

{
  struct GDS_RoutingPutCallbackData *gds_routing = cls;
  struct PeerInfo *target;
 
  if (NULL == ppm)
  {
    *(gds_routing->queued) = *(gds_routing->queued) + 1;
    if (*(gds_routing->queued) >= gds_routing->target_count)
    {
      if (gds_routing->cb)
        gds_routing->cb (gds_routing->cb_cls,
                         *(gds_routing->sent)
                         ? GNUNET_OK
                         : GNUNET_SYSERR);
 
      GNUNET_free (gds_routing->targets);
      GNUNET_free (gds_routing->queued);
      GNUNET_free (gds_routing->sent);
    }
 
    return true;
  }
 
  target = gds_routing->targets[gds_routing->index];
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Routing PUT for %s after %u hops to %s\n",
              GNUNET_h2s (&(gds_routing->key)),
              (unsigned int) gds_routing->hop_count,
              GNUNET_i2s (&target->id));
  if (do_send (target,
               &ppm->header))
    *(gds_routing->sent) = true;
  *(gds_routing->queued) = *(gds_routing->queued) + 1;
 
  if (*(gds_routing->queued) >= gds_routing->target_count)
  {
    /* Report success only if some underlay actually took the message:
       otherwise nothing stores this block and the caller has to keep
       it and try again. */
    if (gds_routing->cb)
      gds_routing->cb (gds_routing->cb_cls,
                       *(gds_routing->sent)
                       ? GNUNET_OK
                       : GNUNET_NO);
 
    GNUNET_free (gds_routing->targets);
    GNUNET_STATISTICS_update (GDS_stats,
                              "# PUT messages queued for transmission",
                              gds_routing->target_count,
                              GNUNET_NO);
    GNUNET_free (gds_routing->queued);
    GNUNET_free (gds_routing->sent);
  }
 
  return true;
}

References GDS_RoutingPutCallbackData::cb, GDS_RoutingPutCallbackData::cb_cls, do_send(), GDS_stats, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, PeerPutMessage::header, GDS_RoutingPutCallbackData::hop_count, PeerInfo::id, GDS_RoutingPutCallbackData::index, GDS_RoutingPutCallbackData::key, GDS_RoutingPutCallbackData::queued, GDS_RoutingPutCallbackData::sent, GDS_RoutingPutCallbackData::target_count, and GDS_RoutingPutCallbackData::targets.

Referenced by GDS_NEIGHBOURS_handle_put().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_NEIGHBOURS_handle_put()

void GDS_NEIGHBOURS_handle_put	(	const struct GNUNET_DATACACHE_Block *	bd,
		uint16_t	desired_replication_level,
		uint16_t	hop_count,
		struct GNUNET_CONTAINER_BloomFilter *	bf,
		GDS_PutOperationCallback	cb,
		void *	cb_cls
	)

Perform a PUT operation.

Forwards the given request to other peers. Does not store the data locally. Does not give the data to local clients. May do nothing if this is the only peer in the network (or if we are the closest peer in the network).

Parameters

bd	data about the block
desired_replication_level	desired replication level
hop_count	how many hops has this message traversed so far
bf	Bloom filter of peers this PUT has already traversed

Returns

GNUNET_OK if the request was forwarded, GNUNET_NO if not

Definition at line 1349 of file gnunet-service-dht_neighbours.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  const struct GNUNET_HashCode *my_identity_hash;
  struct GDS_RoutingPutCallbackData gds_routing;
  size_t msize;
  enum GNUNET_DHT_RouteOption ro = bd->ro;
  unsigned int put_path_length = bd->put_path_length;
  const struct GNUNET_DHT_PathElement *put_path = bd->put_path;
  bool truncated = (0 != (bd->ro & GNUNET_DHT_RO_TRUNCATED));
  const struct GNUNET_PeerIdentity *trunc_peer
    = truncated
    ? &bd->trunc_peer
    : NULL;
  struct GNUNET_PeerIdentity trunc_peer_out;
  enum GNUNET_GenericReturnValue ret;
 
  my_identity = GNUNET_PILS_get_identity (GDS_pils);
  my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
  GNUNET_assert (NULL != my_identity);
 
  ret = GDS_helper_put_message_get_size (&msize,
                                         my_identity,
                                         bd->ro, &ro,
                                         bd->expiration_time,
                                         bd->data, bd->data_size,
                                         put_path, put_path_length,
                                         &put_path_length,
                                         trunc_peer,
                                         &trunc_peer_out,
                                         &truncated);
  if (truncated)
    trunc_peer = &trunc_peer_out;
  /* Path may have been truncated by the call above */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Adding myself (%s) to PUT bloomfilter for %s with RO(%s/%s)\n",
              GNUNET_i2s (my_identity),
              GNUNET_h2s (&bd->key),
              (bd->ro & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE) ? "x" : "-",
              (bd->ro & GNUNET_DHT_RO_RECORD_ROUTE) ? "R" : "-");
 
  /* if we got a HELLO, consider it for our own routing table */
  hello_check (bd);
  GNUNET_assert ((NULL != bf) && (NULL != my_identity_hash));
  GNUNET_CONTAINER_bloomfilter_add (bf, my_identity_hash);
  GNUNET_STATISTICS_update (GDS_stats,
                            "# PUT requests routed",
                            1,
                            GNUNET_NO);
  if (GNUNET_OK != ret)
  {
    if (cb)
      cb (cb_cls, ret);
    return;
  }
  gds_routing.target_count
    = get_target_peers (&bd->key,
                        bf,
                        hop_count,
                        desired_replication_level,
                        &(gds_routing.targets));
  if (0 == gds_routing.target_count)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Routing PUT for %s terminates after %u hops at %s\n",
                GNUNET_h2s (&bd->key),
                (unsigned int) hop_count,
                GNUNET_i2s (my_identity));
    if (cb)
      cb (cb_cls, GNUNET_NO);
    if (gds_routing.targets)
      GNUNET_free (gds_routing.targets);
    return;
  }
  GNUNET_memcpy (&(gds_routing.key), &(bd->key),
                 sizeof (gds_routing.key));
  gds_routing.hop_count = hop_count;
  /* targets were added to @a bf by get_target_peers() */
 
  gds_routing.queued = GNUNET_new (unsigned int);
  *(gds_routing.queued) = 0;
  gds_routing.sent = GNUNET_new (bool);
  *(gds_routing.sent) = false;
 
  gds_routing.cb = cb;
  gds_routing.cb_cls = cb_cls;
 
  for (unsigned int i = 0; i < gds_routing.target_count; i++)
  {
    struct PeerInfo *target = gds_routing.targets[i];
    struct PeerPutMessage *ppm;
    char buf[msize] GNUNET_ALIGN;
 
    gds_routing.index = i;
 
    ppm = (struct PeerPutMessage *) buf;
    GDS_helper_make_put_message (ppm, msize,
                                 GNUNET_PILS_get_private_key (GDS_pils),
                                 &target->id,
                                 &target->phash,
                                 bf,
                                 &bd->key,
                                 ro,
                                 bd->type,
                                 bd->expiration_time,
                                 bd->data, bd->data_size,
                                 put_path, put_path_length,
                                 hop_count,
                                 desired_replication_level,
                                 trunc_peer,
                                 &cb_routing_put_message,
                                 sizeof (gds_routing),
                                 &gds_routing);
  }
}

References GDS_RoutingPutCallbackData::cb, GDS_RoutingPutCallbackData::cb_cls, cb_routing_put_message(), GNUNET_DATACACHE_Block::data, GNUNET_DATACACHE_Block::data_size, PeerPutMessage::desired_replication_level, GNUNET_DATACACHE_Block::expiration_time, GDS_helper_make_put_message(), GDS_helper_put_message_get_size(), GDS_pils, GDS_stats, get_target_peers(), GNUNET_ALIGN, GNUNET_assert, GNUNET_CONTAINER_bloomfilter_add(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_DHT_RO_TRUNCATED, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_PILS_get_identity(), GNUNET_PILS_get_identity_hash(), GNUNET_PILS_get_private_key(), GNUNET_STATISTICS_update(), hello_check(), PeerPutMessage::hop_count, GDS_RoutingPutCallbackData::hop_count, PeerInfo::id, GDS_RoutingPutCallbackData::index, GNUNET_DATACACHE_Block::key, GDS_RoutingPutCallbackData::key, my_identity, PeerInfo::phash, GNUNET_DATACACHE_Block::put_path, GNUNET_DATACACHE_Block::put_path_length, PeerPutMessage::put_path_length, GDS_RoutingPutCallbackData::queued, ret, GNUNET_DATACACHE_Block::ro, GDS_RoutingPutCallbackData::sent, GDS_RoutingPutCallbackData::target_count, GDS_RoutingPutCallbackData::targets, GNUNET_DATACACHE_Block::trunc_peer, and GNUNET_DATACACHE_Block::type.

Referenced by handle_dht_p2p_put(), and route_pending_put().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_NEIGHBOURS_handle_get()

enum GNUNET_GenericReturnValue GDS_NEIGHBOURS_handle_get	(	enum GNUNET_BLOCK_Type	type,
		enum GNUNET_DHT_RouteOption	options,
		uint16_t	desired_replication_level,
		uint16_t	hop_count,
		const struct GNUNET_HashCode *	key,
		const void *	xquery,
		size_t	xquery_size,
		struct GNUNET_BLOCK_Group *	bg,
		struct GNUNET_CONTAINER_BloomFilter *	peer_bf
	)

Perform a GET operation.

Forwards the given request to other peers. Does not lookup the key locally. May do nothing if this is the only peer in the network (or if we are the closest peer in the network).

Parameters

type	type of the block
options	routing options
desired_replication_level	desired replication count
hop_count	how many hops did this request traverse so far?
key	key for the content
xquery	extended query
xquery_size	number of bytes in xquery
bg	block group to filter replies
peer_bf	filter for peers not to select (again, updated)

Returns

GNUNET_OK if the request was forwarded, GNUNET_NO if not

Definition at line 1472 of file gnunet-service-dht_neighbours.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  const struct GNUNET_HashCode *my_identity_hash;
  unsigned int target_count;
  struct PeerInfo **targets;
  size_t msize;
  size_t result_filter_size;
  void *result_filter;
  bool sent = false;
 
  my_identity = GNUNET_PILS_get_identity (GDS_pils);
  my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
 
  if (NULL == my_identity_hash)
    return GNUNET_NO;
 
  GNUNET_assert (NULL != peer_bf);
  GNUNET_STATISTICS_update (GDS_stats,
                            "# GET requests routed",
                            1,
                            GNUNET_NO);
  target_count = get_target_peers (key,
                                   peer_bf,
                                   hop_count,
                                   desired_replication_level,
                                   &targets);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Adding myself (%s) to GET bloomfilter for %s with RO(%s/%s)\n",
              GNUNET_i2s (my_identity),
              GNUNET_h2s (key),
              (options & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE) ? "x" : "-",
              (options & GNUNET_DHT_RO_RECORD_ROUTE) ? "R" : "-");
  GNUNET_assert (NULL != my_identity_hash);
  GNUNET_CONTAINER_bloomfilter_add (peer_bf, my_identity_hash);
  if (0 == target_count)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Routing GET for %s terminates after %u hops at %s\n",
                GNUNET_h2s (key),
                (unsigned int) hop_count,
                GNUNET_i2s (my_identity));
    return GNUNET_NO;
  }
  if (GNUNET_OK !=
      GNUNET_BLOCK_group_serialize (bg,
                                    &result_filter,
                                    &result_filter_size))
  {
    result_filter = NULL;
    result_filter_size = 0;
  }
  msize = xquery_size + result_filter_size;
  if (msize + sizeof(struct PeerGetMessage) >= GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    GNUNET_free (result_filter);
    GNUNET_free (targets);
    return GNUNET_NO;
  }
  /* targets were added to @a peer_bf by get_target_peers() */
  /* forward request */
  for (unsigned int i = 0; i < target_count; i++)
  {
    struct PeerInfo *target = targets[i];
    struct PeerGetMessage *pgm;
    char buf[sizeof (*pgm) + msize] GNUNET_ALIGN;
    char *rf;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Routing GET for %s after %u hops to %s\n",
                GNUNET_h2s (key),
                (unsigned int) hop_count,
                GNUNET_i2s (&target->id));
    pgm = (struct PeerGetMessage *) buf;
    pgm->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_P2P_GET);
    pgm->header.size = htons (sizeof (buf));
    pgm->type = htonl (type);
    pgm->options = htons (options);
    pgm->hop_count = htons (hop_count + 1);
    pgm->desired_replication_level = htons (desired_replication_level);
    pgm->result_filter_size = htons ((uint16_t) result_filter_size);
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_bloomfilter_get_raw_data (peer_bf,
                                                              pgm->bloomfilter,
                                                              DHT_BLOOM_SIZE));
    pgm->key = *key;
    rf = (char *) &pgm[1];
    GNUNET_memcpy (rf,
                   result_filter,
                   result_filter_size);
    GNUNET_memcpy (&rf[result_filter_size],
                   xquery,
                   xquery_size);
    if (do_send (target,
                 &pgm->header))
      sent = true;
  }
  GNUNET_STATISTICS_update (GDS_stats,
                            "# GET messages queued for transmission",
                            target_count,
                            GNUNET_NO);
  GNUNET_free (targets);
  GNUNET_free (result_filter);
  /* Having picked a target is not the same as having sent to one: if
     every underlay dropped the message, the request was not routed and
     must go on the fast retry, not on the regular back-off. */
  return sent ? GNUNET_OK : GNUNET_NO;
}

References PeerGetMessage::bloomfilter, PeerGetMessage::desired_replication_level, DHT_BLOOM_SIZE, do_send(), GDS_pils, GDS_stats, get_target_peers(), GNUNET_ALIGN, GNUNET_assert, GNUNET_BLOCK_group_serialize(), GNUNET_break, GNUNET_CONTAINER_bloomfilter_add(), GNUNET_CONTAINER_bloomfilter_get_raw_data(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_P2P_GET, GNUNET_NO, GNUNET_OK, GNUNET_PILS_get_identity(), GNUNET_PILS_get_identity_hash(), GNUNET_STATISTICS_update(), PeerGetMessage::header, PeerGetMessage::hop_count, PeerInfo::id, key, PeerGetMessage::key, my_identity, options, PeerGetMessage::options, PeerGetMessage::result_filter_size, GNUNET_MessageHeader::size, type, GNUNET_MessageHeader::type, and PeerGetMessage::type.

Referenced by cb_handle_dht_p2p_get_local_result(), send_find_peer_message(), and transmit_request().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_NEIGHBOURS_lookup_peer()

struct PeerInfo * GDS_NEIGHBOURS_lookup_peer

(

const struct GNUNET_PeerIdentity *

target

)

Lookup peer by peer's identity.

Parameters

target

peer to look up

Returns

NULL if we are not connected to target

Definition at line 1592 of file gnunet-service-dht_neighbours.c.

{
  return GNUNET_CONTAINER_multipeermap_get (all_connected_peers,
                                            target);
}

References all_connected_peers, and GNUNET_CONTAINER_multipeermap_get().

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_neighbours_reply()

static void cleanup_neighbours_reply ( struct GDS_NeighboursReply *  reply )

static

Definition at line 1617 of file gnunet-service-dht_neighbours.c.

{
  if (reply->block_data)
    GNUNET_free (reply->block_data);
  if ((reply->bd.put_path_length > 0) && (reply->put_path))
    GNUNET_free (reply->put_path);
  if (reply->buf)
    GNUNET_free (reply->buf);
}

References GDS_NeighboursReply::bd, GDS_NeighboursReply::block_data, GDS_NeighboursReply::buf, GNUNET_free, GDS_NeighboursReply::put_path, and GNUNET_DATACACHE_Block::put_path_length.

Referenced by cb_path_signed().

Here is the caller graph for this function:

safe_neighbours_callback()

static void safe_neighbours_callback ( void *  cls, GNUNET_SCHEDULER_TaskCallback  cb, bool  success  )

static

Definition at line 1629 of file gnunet-service-dht_neighbours.c.

{
  GNUNET_break (success);
  if (cb)
    cb (cls);
}

References GNUNET_break.

Referenced by cb_path_signed(), and GDS_NEIGHBOURS_handle_reply().

Here is the caller graph for this function:

cb_path_signed()

static bool cb_path_signed ( void *  cls, const struct GNUNET_CRYPTO_EddsaSignature *  sig  )

static

Definition at line 1640 of file gnunet-service-dht_neighbours.c.

{
  struct GDS_NeighboursReply *reply = cls;
  struct PeerResultMessage *prm = reply->prm;
  struct GNUNET_DHT_PathElement *paths = reply->paths;
  unsigned int ppl = ntohs (prm->put_path_length);
  unsigned int get_path_length = ntohs (prm->get_path_length);
  void *tgt = &paths[get_path_length + ppl];
  void *data;
 
  if (! sig)
  {
    cleanup_neighbours_reply (reply);
    safe_neighbours_callback (reply->cb_cls, reply->cb, false);
    return true;
  }
 
  memcpy (tgt,
          sig,
          sizeof (*sig));
  data = tgt + sizeof (*sig);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Signing GET PATH %u/%u of %s => %s\n",
              ppl,
              get_path_length,
              GNUNET_h2s (&prm->key),
              GNUNET_B2S (sig));
#if SANITY_CHECKS > 1
  {
    const struct GNUNET_PeerIdentity *my_identity;
    struct GNUNET_DHT_PathElement xpaths[get_path_length + 1];
    const struct GNUNET_PeerIdentity *trunc_peer = reply->trunc_peer_is_null?
                                                   NULL : &reply->trunc_peer_id;
 
    my_identity = GNUNET_PILS_get_identity (GDS_pils);
    GNUNET_assert (NULL != my_identity);
 
    memcpy (xpaths,
            &paths[ppl],
            get_path_length * sizeof (struct GNUNET_DHT_PathElement));
    xpaths[get_path_length].sig = *sig;
    xpaths[get_path_length].pred = *my_identity;
    if (0 !=
        GNUNET_DHT_verify_path (reply->bd.data,
                                reply->bd.data_size,
                                reply->bd.expiration_time,
                                trunc_peer,
                                paths,
                                ppl,
                                xpaths,
                                get_path_length + 1,
                                &reply->pi->id))
    {
      GNUNET_break (0);
      cleanup_neighbours_reply (reply);
      safe_neighbours_callback (reply->cb_cls, reply->cb, false);
      return true;
    }
  }
#endif
  GNUNET_memcpy (data,
                 reply->bd.data,
                 reply->bd.data_size);
  do_send (reply->pi,
           &prm->header);
  cleanup_neighbours_reply (reply);
  safe_neighbours_callback (reply->cb_cls, reply->cb, true);
  return true;
}

References GDS_NeighboursReply::bd, GDS_NeighboursReply::cb, GDS_NeighboursReply::cb_cls, cleanup_neighbours_reply(), data, GNUNET_DATACACHE_Block::data, GNUNET_DATACACHE_Block::data_size, do_send(), GNUNET_DATACACHE_Block::expiration_time, GDS_pils, PeerResultMessage::get_path_length, GNUNET_assert, GNUNET_B2S, GNUNET_break, GNUNET_DHT_verify_path(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_PILS_get_identity(), PeerResultMessage::header, PeerInfo::id, PeerResultMessage::key, my_identity, GDS_NeighboursReply::paths, GDS_NeighboursReply::pi, GNUNET_DHT_PathElement::pred, GDS_NeighboursReply::prm, PeerResultMessage::put_path_length, safe_neighbours_callback(), GNUNET_DHT_PathElement::sig, GDS_NeighboursReply::trunc_peer_id, and GDS_NeighboursReply::trunc_peer_is_null.

Referenced by GDS_NEIGHBOURS_handle_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_NEIGHBOURS_handle_reply()

void GDS_NEIGHBOURS_handle_reply	(	struct PeerInfo *	pi,
		const struct GNUNET_DATACACHE_Block *	bd,
		const struct GNUNET_HashCode *	query_hash,
		unsigned int	get_path_length,
		const struct GNUNET_DHT_PathElement *	get_path,
		GNUNET_SCHEDULER_TaskCallback	cb,
		void *	cb_cls
	)

Handle a reply (route to origin).

Only forwards the reply back to other peers waiting for it. Does not do local caching or forwarding to local clients.

Parameters

pi	neighbour that should receive the block
bd	details about the reply
query_hash	query that was used for the request
get_path_length	number of entries in put_path
get_path	peers this reply has traversed so far (if tracked)

Returns

true on success

Definition at line 1713 of file gnunet-service-dht_neighbours.c.

{
  struct GNUNET_DHT_PathElement *paths;
  size_t msize;
  unsigned int ppl = bd->put_path_length;
  const struct GNUNET_DHT_PathElement *put_path = bd->put_path;
  enum GNUNET_DHT_RouteOption ro = bd->ro;
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  const struct GNUNET_PeerIdentity *trunc_peer
    = truncated
    ? &bd->trunc_peer
    : NULL;
  bool tracking = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
#if SANITY_CHECKS > 1
  const struct GNUNET_PeerIdentity *my_identity;
  unsigned int failure_offset;
 
  my_identity = GNUNET_PILS_get_identity (GDS_pils);
  GNUNET_assert (NULL != my_identity);
 
  failure_offset
    = GNUNET_DHT_verify_path (bd->data,
                              bd->data_size,
                              bd->expiration_time,
                              trunc_peer,
                              put_path,
                              ppl,
                              get_path,
                              get_path_length,
                              my_identity);
  if (0 != failure_offset)
  {
    GNUNET_assert (failure_offset <= ppl + get_path_length);
    GNUNET_break_op (0);
    if (failure_offset < ppl)
    {
      trunc_peer = &put_path[failure_offset - 1].pred;
      put_path += failure_offset;
      ppl -= failure_offset;
      truncated = true;
      ro |= GNUNET_DHT_RO_TRUNCATED;
    }
    else
    {
      failure_offset -= ppl;
      if (0 == failure_offset)
        trunc_peer = &put_path[ppl - 1].pred;
      else
        trunc_peer = &get_path[failure_offset - 1].pred;
      ppl = 0;
      put_path = NULL;
      truncated = true;
      ro |= GNUNET_DHT_RO_TRUNCATED;
      get_path += failure_offset;
      get_path_length -= failure_offset;
    }
  }
#endif
  msize = bd->data_size + sizeof (struct PeerResultMessage);
  if (msize > GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break_op (0);
    safe_neighbours_callback (cb_cls, cb, false);
    return;
  }
  if (truncated)
    msize += sizeof (struct GNUNET_PeerIdentity);
  if (tracking)
    msize += sizeof (struct GNUNET_CRYPTO_EddsaSignature);
  if (msize < bd->data_size)
  {
    GNUNET_break_op (0);
    safe_neighbours_callback (cb_cls, cb, false);
    return;
  }
  if ( (GNUNET_MAX_MESSAGE_SIZE - msize)
       / sizeof(struct GNUNET_DHT_PathElement)
       < (get_path_length + ppl) )
  {
    get_path_length = 0;
    ppl = 0;
  }
  if ( (get_path_length > UINT16_MAX) ||
       (ppl > UINT16_MAX) )
  {
    GNUNET_break (0);
    get_path_length = 0;
    ppl = 0;
  }
  msize += (get_path_length + ppl)
           * sizeof(struct GNUNET_DHT_PathElement);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Forwarding reply for key %s to peer %s\n",
              GNUNET_h2s (query_hash),
              GNUNET_i2s (&pi->id));
  GNUNET_STATISTICS_update (GDS_stats,
                            "# RESULT messages queued for transmission",
                            1,
                            GNUNET_NO);
  {
    struct PeerResultMessage *prm;
    char buf[msize] GNUNET_ALIGN;
 
    prm = (struct PeerResultMessage *) buf;
    prm->header.type = htons (GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT);
    prm->header.size = htons (sizeof (buf));
    prm->type = htonl ((uint32_t) bd->type);
    prm->reserved = htons (0);
    prm->options = htons ((uint16_t) ro);
    prm->put_path_length = htons ((uint16_t) ppl);
    prm->get_path_length = htons ((uint16_t) get_path_length);
    prm->expiration_time = GNUNET_TIME_absolute_hton (bd->expiration_time);
    prm->key = *query_hash;
    if (truncated)
    {
      void *tgt = &prm[1];
 
      GNUNET_memcpy (tgt,
                     trunc_peer,
                     sizeof (struct GNUNET_PeerIdentity));
      paths = (struct GNUNET_DHT_PathElement *)
              (tgt + sizeof (struct GNUNET_PeerIdentity));
    }
    else
    {
      paths = (struct GNUNET_DHT_PathElement *) &prm[1];
    }
    if (NULL != put_path)
    {
      GNUNET_memcpy (paths,
                     put_path,
                     ppl * sizeof(struct GNUNET_DHT_PathElement));
    }
    else
    {
      GNUNET_assert (0 == ppl);
    }
    if (NULL != get_path)
    {
      GNUNET_memcpy (&paths[ppl],
                     get_path,
                     get_path_length * sizeof(struct GNUNET_DHT_PathElement));
    }
    else
    {
      GNUNET_assert (0 == get_path_length);
    }
    if (tracking)
    {
      struct GDS_NeighboursReply reply;
      const struct GNUNET_PeerIdentity *pred;
 
      reply.pi = pi;
      GNUNET_memcpy (&reply.bd, bd, sizeof (reply.bd));
      reply.block_data = GNUNET_memdup (bd->data, bd->data_size);
      reply.put_path = GNUNET_memdup (bd->put_path,
                                      sizeof (struct GNUNET_DHT_PathElement)
                                      * bd->put_path_length);
 
      reply.bd.data = reply.block_data;
      reply.bd.put_path = reply.put_path;
 
      reply.buf = GNUNET_memdup (buf, msize);
      reply.prm = (struct PeerResultMessage*) reply.buf;
      reply.paths = (struct GNUNET_DHT_PathElement*)
                    (reply.buf + ((const char *) paths - buf));
 
      if (trunc_peer)
      {
        reply.trunc_peer_is_null = false;
        GNUNET_memcpy (&reply.trunc_peer_id, trunc_peer,
                       sizeof (reply.trunc_peer_id));
      }
      else
      {
        reply.trunc_peer_is_null = true;
      }
 
      reply.cb = cb;
      reply.cb_cls = cb_cls;
 
      if (ppl + get_path_length > 0)
        pred = &paths[ppl + get_path_length - 1].pred;
      else if (truncated)
        pred = trunc_peer;
      else
        pred = NULL; /* we are first! */
      /* Note that the last signature in 'paths' was not initialized before,
         so this is crucial to avoid sending garbage. */
      GDS_helper_sign_path (bd->data,
                            bd->data_size,
                            GNUNET_PILS_get_private_key (GDS_pils),
                            bd->expiration_time,
                            pred,
                            &pi->id,
                            &cb_path_signed,
                            sizeof (reply),
                            &reply);
    }
    else
    {
      void *data;
      data = &prm[1];
      GNUNET_memcpy (data,
                     bd->data,
                     bd->data_size);
      do_send (pi,
               &prm->header);
      safe_neighbours_callback (cb_cls, cb, true);
      return;
    }
  }
}

References GDS_NeighboursReply::bd, GDS_NeighboursReply::block_data, GDS_NeighboursReply::buf, GDS_NeighboursReply::cb, GDS_NeighboursReply::cb_cls, cb_path_signed(), data, GNUNET_DATACACHE_Block::data, data_size, GNUNET_DATACACHE_Block::data_size, do_send(), GNUNET_DATACACHE_Block::expiration_time, PeerResultMessage::expiration_time, GDS_helper_sign_path(), GDS_pils, GDS_stats, PeerResultMessage::get_path_length, GNUNET_ALIGN, GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_DHT_RO_TRUNCATED, GNUNET_DHT_verify_path(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_memdup, GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT, GNUNET_NO, GNUNET_PILS_get_identity(), GNUNET_PILS_get_private_key(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_hton(), PeerResultMessage::header, PeerInfo::id, PeerResultMessage::key, my_identity, PeerResultMessage::options, GDS_NeighboursReply::paths, GDS_NeighboursReply::pi, GNUNET_DHT_PathElement::pred, GDS_NeighboursReply::prm, GNUNET_DATACACHE_Block::put_path, GDS_NeighboursReply::put_path, GNUNET_DATACACHE_Block::put_path_length, PeerResultMessage::put_path_length, PeerResultMessage::reserved, GNUNET_DATACACHE_Block::ro, safe_neighbours_callback(), GNUNET_MessageHeader::size, GNUNET_DATACACHE_Block::trunc_peer, GDS_NeighboursReply::trunc_peer_id, GDS_NeighboursReply::trunc_peer_is_null, GNUNET_MessageHeader::type, GNUNET_DATACACHE_Block::type, and PeerResultMessage::type.

Referenced by handle_find_local_hello(), handle_find_my_hello(), handle_local_result(), and process().

Here is the call graph for this function:

Here is the caller graph for this function:

check_dht_p2p_put()

static enum GNUNET_GenericReturnValue check_dht_p2p_put ( void *  cls, const struct PeerPutMessage *  put  )

static

Check validity of a p2p put request.

Parameters

cls	closure with the struct PeerInfo of the sender
put	message

Returns

GNUNET_OK if the message is valid

Definition at line 1942 of file gnunet-service-dht_neighbours.c.

{
  enum GNUNET_DHT_RouteOption ro = ntohs (put->options);
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  bool has_path = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
  uint16_t msize = ntohs (put->header.size);
  uint16_t putlen = ntohs (put->put_path_length);
  size_t xsize = (has_path
                  ? sizeof (struct GNUNET_CRYPTO_EddsaSignature)
                  : 0)
                 + (truncated
                    ? sizeof (struct GNUNET_PeerIdentity)
                    : 0);
  size_t var_meta_size
    = putlen * sizeof(struct GNUNET_DHT_PathElement)
      + xsize;
 
  (void) cls;
  if ( (msize <
        sizeof (struct PeerPutMessage) + var_meta_size) ||
       (putlen >
        (GNUNET_MAX_MESSAGE_SIZE
         - sizeof (struct PeerPutMessage)
         - xsize)
        / sizeof(struct GNUNET_DHT_PathElement)) )
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (GNUNET_BLOCK_TYPE_ANY == htonl (put->type))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_BLOCK_TYPE_ANY, GNUNET_break_op, GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_DHT_RO_TRUNCATED, GNUNET_OK, GNUNET_SYSERR, PeerPutMessage::header, PeerPutMessage::options, PeerPutMessage::put_path_length, GNUNET_MessageHeader::size, and PeerPutMessage::type.

cb_forwarded_dht_p2p_put()

static void cb_forwarded_dht_p2p_put ( void *  cls, enum GNUNET_GenericReturnValue  forwarded  )

static

Definition at line 1994 of file gnunet-service-dht_neighbours.c.

{
  struct ForwardedDHTPut *put = cls;
 
  /* notify monitoring clients; we are the last hop exactly when we did
     not manage to forward, as in the GET case */
  put->block.ro |= ((GNUNET_OK == forwarded)
            ? 0
            : GNUNET_DHT_RO_LAST_HOP);
  GDS_CLIENTS_process_put (&put->block,
                           put->hop_count,
                           put->desired_replication_level);
 
  if (put->put_path)
    GNUNET_free (put->put_path);
  GNUNET_free (put->data);
  GNUNET_free (put);
}

References ForwardedDHTPut::block, ForwardedDHTPut::data, ForwardedDHTPut::desired_replication_level, GDS_CLIENTS_process_put(), GNUNET_DHT_RO_LAST_HOP, GNUNET_free, GNUNET_OK, ForwardedDHTPut::hop_count, ForwardedDHTPut::put_path, and GNUNET_DATACACHE_Block::ro.

Referenced by handle_dht_p2p_put().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_dht_p2p_put()

static void handle_dht_p2p_put ( void *  cls, const struct PeerPutMessage *  put  )

static

Core handler for p2p put requests.

Parameters

cls	closure with the struct Target of the sender
put	message

Definition at line 2022 of file gnunet-service-dht_neighbours.c.

{
  struct Target *t = cls;
  struct PeerInfo *peer = t->pi;
  enum GNUNET_DHT_RouteOption ro = ntohs (put->options);
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  bool has_path = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
  uint16_t msize = ntohs (put->header.size);
  uint16_t putlen = ntohs (put->put_path_length);
  const struct GNUNET_PeerIdentity *trunc_peer
    = truncated
    ? (const struct GNUNET_PeerIdentity *) &put[1]
    : NULL;
  const struct GNUNET_DHT_PathElement *put_path
    = truncated
    ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
    : (const struct GNUNET_DHT_PathElement *) &put[1];
  const struct GNUNET_CRYPTO_EddsaSignature *last_sig
    = has_path
    ? (const struct GNUNET_CRYPTO_EddsaSignature *) &put_path[putlen]
    : NULL;
  const char *data
    = has_path
    ? (const char *) &last_sig[1]
    : (const char *) &put_path[putlen];
  size_t var_meta_size
    = putlen * sizeof(struct GNUNET_DHT_PathElement)
      + (has_path ? sizeof (*last_sig) : 0)
      + (truncated ? sizeof (*trunc_peer) : 0);
  struct GNUNET_DATACACHE_Block bd = {
    .key = put->key,
    .expiration_time = GNUNET_TIME_absolute_ntoh (put->expiration_time),
    .type = ntohl (put->type),
    .ro = ro,
    .data_size = msize - sizeof(*put) - var_meta_size,
    .data = data
  };
 
  if (NULL != trunc_peer)
    bd.trunc_peer = *trunc_peer;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "PUT for `%s' from %s with RO (%s/%s)\n",
              GNUNET_h2s (&put->key),
              GNUNET_i2s (&peer->id),
              (bd.ro & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE) ? "x" : "-",
              has_path ? "R" : "-");
  if (GNUNET_TIME_absolute_is_past (bd.expiration_time))
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# Expired PUTs discarded",
                              1,
                              GNUNET_NO);
    return;
  }
  {
    /* Only call 'check_block' if that keeps our CPU load (from
       the cryptography) below 50% on average */
    static struct GNUNET_TIME_Relative avg_latency;
    static struct GNUNET_TIME_Absolute next_time;
 
    if (GNUNET_TIME_absolute_is_past (next_time))
    {
      struct GNUNET_TIME_Absolute now
        = GNUNET_TIME_absolute_get ();
      struct GNUNET_TIME_Relative latency;
      struct GNUNET_TIME_Relative delta;
 
      if (GNUNET_NO ==
          GNUNET_BLOCK_check_block (GDS_block_context,
                                    bd.type,
                                    bd.data,
                                    bd.data_size))
      {
        GNUNET_break_op (0);
        return;
      }
      latency = GNUNET_TIME_absolute_get_duration (now);
      /* Use *moving average* to estimate check_block latency */
      avg_latency
        = GNUNET_TIME_relative_divide (
            GNUNET_TIME_relative_add (
              GNUNET_TIME_relative_multiply (avg_latency,
                                             7),
              latency),
            8);
      /* average delay = 50% of avg_latency => 50% CPU load from crypto (at most) */
      delta.rel_value_us
        = GNUNET_CRYPTO_random_u64 (avg_latency.rel_value_us > 0
                                        ? avg_latency.rel_value_us
                                        : 1LLU);
      next_time = GNUNET_TIME_relative_to_absolute (delta);
    }
  }
  if (! has_path)
    putlen = 0;
  GNUNET_STATISTICS_update (GDS_stats,
                            "# P2P PUT requests received",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (GDS_stats,
                            "# P2P PUT bytes received",
                            msize,
                            GNUNET_NO);
  {
    struct GNUNET_HashCode test_key;
    enum GNUNET_GenericReturnValue ret;
 
    ret = GNUNET_BLOCK_get_key (GDS_block_context,
                                bd.type,
                                bd.data,
                                bd.data_size,
                                &test_key);
    switch (ret)
    {
    case GNUNET_YES:
      if (0 != GNUNET_memcmp (&test_key,
                              &bd.key))
      {
        GNUNET_break_op (0);
        return;
      }
      break;
    case GNUNET_NO:
      /* cannot verify, good luck */
      break;
    case GNUNET_SYSERR:
      /* block type not supported, good luck */
      break;
    }
  }
 
  {
    struct GNUNET_CONTAINER_BloomFilter *bf;
    struct GNUNET_DHT_PathElement pp[putlen + 1];
 
    bf = GNUNET_CONTAINER_bloomfilter_init (put->bloomfilter,
                                            DHT_BLOOM_SIZE,
                                            GNUNET_CONSTANTS_BLOOMFILTER_K);
    GNUNET_break_op (GNUNET_YES ==
                     GNUNET_CONTAINER_bloomfilter_test (bf,
                                                        &peer->phash));
    /* extend 'put path' by sender */
    bd.put_path = pp;
    bd.put_path_length = putlen + 1;
    if (has_path)
    {
      unsigned int failure_offset;
 
      GNUNET_memcpy (pp,
                     put_path,
                     putlen * sizeof(struct GNUNET_DHT_PathElement));
      pp[putlen].pred = peer->id;
      pp[putlen].sig = *last_sig;
#if SANITY_CHECKS
      {
        const struct GNUNET_PeerIdentity *my_identity;
        my_identity = GNUNET_PILS_get_identity (GDS_pils);
        GNUNET_assert (NULL != my_identity);
        /* TODO: might want to eventually implement probabilistic
          load-based path verification, but for now it is all or nothing */
        failure_offset
          = GNUNET_DHT_verify_path (bd.data,
                                    bd.data_size,
                                    bd.expiration_time,
                                    trunc_peer,
                                    pp,
                                    putlen + 1,
                                    NULL, 0,   /* get_path */
                                    my_identity);
      }
#else
      failure_offset = 0;
#endif
      if (0 != failure_offset)
      {
        GNUNET_break_op (0);
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Recorded put path invalid at offset %u, truncating\n",
                    failure_offset);
        GNUNET_assert (failure_offset <= putlen + 1);
        bd.put_path = &pp[failure_offset];
        bd.put_path_length = (putlen + 1) - failure_offset;
        bd.ro |= GNUNET_DHT_RO_TRUNCATED;
        bd.trunc_peer = pp[failure_offset - 1].pred;
      }
    }
    else
    {
      bd.put_path_length = 0;
    }
 
    /* give to local clients */
    GNUNET_break (GDS_CLIENTS_handle_reply (&bd,
                                            &bd.key,
                                            0, NULL /* get path */));
 
    /* store locally */
    if ( (0 != (bd.ro & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE)) ||
         (GDS_am_closest_peer (&put->key,
                               bf)) )
      GDS_DATACACHE_handle_put (&bd);
 
    {
      struct ForwardedDHTPut *forward = GNUNET_new (struct ForwardedDHTPut);
      GNUNET_memcpy (&forward->block, &bd, sizeof (bd));
 
      if (bd.put_path_length > 0)
      {
        forward->put_path = GNUNET_memdup (
          bd.put_path,
          sizeof (struct GNUNET_DHT_PathElement) * bd.put_path_length);
        forward->block.put_path = forward->put_path;
      }
 
      forward->data = GNUNET_memdup (bd.data, bd.data_size);
      forward->block.data = forward->data;
 
      forward->desired_replication_level = ntohs (put->desired_replication_level
                                                  );
      forward->hop_count = ntohs (put->hop_count);
 
      /* route to other peers */
      GDS_NEIGHBOURS_handle_put (&forward->block,
                                 forward->desired_replication_level,
                                 forward->hop_count,
                                 bf,
                                 &cb_forwarded_dht_p2p_put,
                                 forward);
    }
    GNUNET_CONTAINER_bloomfilter_free (bf);
  }
}

References PeerPutMessage::bloomfilter, cb_forwarded_dht_p2p_put(), data, GNUNET_DATACACHE_Block::data, GNUNET_DATACACHE_Block::data_size, delta, PeerPutMessage::desired_replication_level, DHT_BLOOM_SIZE, GNUNET_DATACACHE_Block::expiration_time, PeerPutMessage::expiration_time, forward, GDS_am_closest_peer(), GDS_block_context, GDS_CLIENTS_handle_reply(), GDS_DATACACHE_handle_put(), GDS_NEIGHBOURS_handle_put(), GDS_pils, GDS_stats, GNUNET_assert, GNUNET_BLOCK_check_block(), GNUNET_BLOCK_get_key(), GNUNET_break, GNUNET_break_op, GNUNET_CONSTANTS_BLOOMFILTER_K, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_CONTAINER_bloomfilter_test(), GNUNET_CRYPTO_random_u64(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_DHT_RO_TRUNCATED, GNUNET_DHT_verify_path(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_memcpy, GNUNET_memdup, GNUNET_new, GNUNET_NO, GNUNET_PILS_get_identity(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_absolute_is_past(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_add(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, PeerPutMessage::header, PeerPutMessage::hop_count, PeerInfo::id, GNUNET_DATACACHE_Block::key, PeerPutMessage::key, my_identity, PeerPutMessage::options, PeerInfo::phash, GNUNET_DHT_PathElement::pred, GNUNET_DATACACHE_Block::put_path, GNUNET_DATACACHE_Block::put_path_length, PeerPutMessage::put_path_length, GNUNET_TIME_Relative::rel_value_us, ret, GNUNET_DATACACHE_Block::ro, GNUNET_DHT_PathElement::sig, GNUNET_MessageHeader::size, t, GNUNET_DATACACHE_Block::trunc_peer, GNUNET_DATACACHE_Block::type, and PeerPutMessage::type.

Here is the call graph for this function:

handle_find_my_hello()

static void handle_find_my_hello ( struct PeerInfo *  pi, const struct GNUNET_HashCode *  query_hash, struct GNUNET_BLOCK_Group *  bg, GNUNET_SCHEDULER_TaskCallback  cb, void *  cb_cls  )

static

We have received a request for a HELLO.

Sends our HELLO back.

Parameters

pi	sender of the request
key	peers close to this key are desired
bg	group for filtering peers

Definition at line 2274 of file gnunet-service-dht_neighbours.c.

{
  const struct GNUNET_HashCode *my_identity_hash;
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_TIME_Absolute block_expiration;
  size_t block_size;
  void *block;
 
  my_identity_hash = GNUNET_PILS_get_identity_hash (GDS_pils);
  my_identity = GNUNET_PILS_get_identity (GDS_pils);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handle finding my own HELLO %s\n",
              GNUNET_h2s (my_identity_hash));
  if (NULL == GDS_my_hello)
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# FIND PEER requests ignored due to lack of HELLO",
                              1,
                              GNUNET_NO);
    if (cb)
      cb (cb_cls);
    return;
  }
 
  if (GNUNET_SYSERR == GNUNET_HELLO_dht_msg_to_block (GDS_my_hello,
                                                      my_identity,
                                                      &block,
                                                      &block_size,
                                                      &block_expiration))
  {
    if (cb)
      cb (cb_cls);
    return;
  }
 
  if (GNUNET_BLOCK_REPLY_OK_MORE ==
      GNUNET_BLOCK_check_reply (GDS_block_context,
                                GNUNET_BLOCK_TYPE_DHT_HELLO,
                                bg,
                                my_identity_hash,
                                NULL, 0,
                                block,
                                block_size))
  {
    struct GNUNET_DATACACHE_Block bd = {
      .type = GNUNET_BLOCK_TYPE_DHT_HELLO,
      .expiration_time
        = GNUNET_TIME_relative_to_absolute (
            GNUNET_HELLO_ADDRESS_EXPIRATION),
      .key = *my_identity_hash,
      .data = block,
      .data_size = block_size
    };
 
    GDS_NEIGHBOURS_handle_reply (pi,
                                 &bd,
                                 query_hash,
                                 0, NULL /* get path */,
                                 cb,
                                 cb_cls);
  }
  else
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# FIND PEER requests ignored due to Bloomfilter",
                              1,
                              GNUNET_NO);
    if (cb)
      cb (cb_cls);
  }
 
  GNUNET_free (block);
}

References GDS_block_context, GDS_my_hello, GDS_NEIGHBOURS_handle_reply(), GDS_pils, GDS_stats, GNUNET_BLOCK_check_reply(), GNUNET_BLOCK_REPLY_OK_MORE, GNUNET_BLOCK_TYPE_DHT_HELLO, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_HELLO_ADDRESS_EXPIRATION, GNUNET_HELLO_dht_msg_to_block(), GNUNET_log, GNUNET_NO, GNUNET_PILS_get_identity(), GNUNET_PILS_get_identity_hash(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_relative_to_absolute(), my_identity, and GNUNET_DATACACHE_Block::type.

Referenced by handle_dht_p2p_get().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_find_local_hello()

static void handle_find_local_hello ( struct PeerInfo *  pi, const struct GNUNET_HashCode *  query_hash, struct GNUNET_BLOCK_Group *  bg, GNUNET_SCHEDULER_TaskCallback  cb, void *  cb_cls  )

static

We have received a request for nearby HELLOs.

Sends matching HELLOs back.

Parameters

pi	sender of the request
key	peers close to this key are desired
bg	group for filtering peers

Definition at line 2362 of file gnunet-service-dht_neighbours.c.

{
  /* Force non-random selection by hop count */
  struct PeerInfo *peer;
 
  peer = select_peer (query_hash,
                      NULL,
                      GDS_NSE_get () + 1);
  if (NULL == peer)
  {
    /* no neighbour at all, nothing to answer with */
    if (cb)
      cb (cb_cls);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handle finding local HELLO %s\n",
              GNUNET_h2s (&peer->phash));
  if ( (NULL != peer->hello) &&
       (! GNUNET_TIME_absolute_is_past (peer->hello_expiration)) &&
       (GNUNET_BLOCK_REPLY_OK_MORE ==
        GNUNET_BLOCK_check_reply (
          GDS_block_context,
          GNUNET_BLOCK_TYPE_DHT_HELLO,
          bg,
          &peer->phash,
          NULL, 0,        /* xquery */
          peer->hello,
          peer->hello_size)) )
  {
    struct GNUNET_DATACACHE_Block bd = {
      .type = GNUNET_BLOCK_TYPE_DHT_HELLO,
      .expiration_time = peer->hello_expiration,
      .key = peer->phash,
      .data = peer->hello,
      .data_size = peer->hello_size
    };
 
    GDS_NEIGHBOURS_handle_reply (pi,
                                 &bd,
                                 query_hash,
                                 0, NULL /* get path */,
                                 cb,
                                 cb_cls);
  }
  else if (cb)
    cb (cb_cls);
}

References GDS_block_context, GDS_NEIGHBOURS_handle_reply(), GDS_NSE_get(), GNUNET_BLOCK_check_reply(), GNUNET_BLOCK_REPLY_OK_MORE, GNUNET_BLOCK_TYPE_DHT_HELLO, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_TIME_absolute_is_past(), PeerInfo::hello, PeerInfo::hello_expiration, PeerInfo::hello_size, PeerInfo::phash, select_peer(), and GNUNET_DATACACHE_Block::type.

Referenced by cb_handle_dht_p2p_get_my_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_local_result()

static void handle_local_result ( void *  cls, const struct GNUNET_DATACACHE_Block *  bd  )

static

Handle an exact result from local datacache for a GET operation.

Parameters

cls	the struct PeerInfo for which this is a reply
bd	details about the block we found locally

Definition at line 2423 of file gnunet-service-dht_neighbours.c.

{
  struct PeerInfo *peer = cls;
 
  GDS_NEIGHBOURS_handle_reply (peer,
                               bd,
                               &bd->key,
                               0, NULL /* get path */,
                               NULL,
                               NULL);
}

References GDS_NEIGHBOURS_handle_reply(), and GNUNET_DATACACHE_Block::key.

Referenced by cb_handle_dht_p2p_get_local_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

check_dht_p2p_get()

static enum GNUNET_GenericReturnValue check_dht_p2p_get ( void *  cls, const struct PeerGetMessage *  get  )

static

Check validity of p2p get request.

Parameters

cls	closure with the struct Target of the sender
get	the message

Returns

GNUNET_OK if the message is well-formed

Definition at line 2445 of file gnunet-service-dht_neighbours.c.

{
  uint16_t msize = ntohs (get->header.size);
  uint16_t result_filter_size = ntohs (get->result_filter_size);
 
  (void) cls;
  if (msize < sizeof(*get) + result_filter_size)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References get, GNUNET_break_op, GNUNET_OK, and GNUNET_SYSERR.

cb_handle_dht_p2p_get_local_result()

static void cb_handle_dht_p2p_get_local_result ( void *  cls )

static

Definition at line 2472 of file gnunet-service-dht_neighbours.c.

{
  struct HandleCallbackGet *handle = cls;
  enum GNUNET_DHT_RouteOption options = ntohs (handle->get->options);
  enum GNUNET_BLOCK_Type type = ntohl (handle->get->type);
  const void *result_filter = (const void *) &handle->get[1];
  uint16_t msize = ntohs (handle->get->header.size);
  uint16_t result_filter_size = ntohs (handle->get->result_filter_size);
  const void *xquery = result_filter + result_filter_size;
  size_t xquery_size = msize - sizeof (*handle->get) - result_filter_size;
 
  /* remember request for routing replies
      TODO: why should we do this if GNUNET_BLOCK_REPLY_OK_LAST == eval?
  */
  GDS_ROUTING_add (&handle->t->pi->id,
                   type,
                   handle->bg, /* bg now owned by routing, but valid at least until end of this function! */
                   options,
                   &handle->get->key,
                   xquery,
                   xquery_size);
 
  /* P2P forwarding */
  {
    bool forwarded = false;
    uint16_t desired_replication_level = ntohs (
      handle->get->desired_replication_level);
    uint16_t hop_count = ntohs (handle->get->hop_count);
 
    if (handle->eval != GNUNET_BLOCK_REPLY_OK_LAST)
      forwarded = (GNUNET_OK ==
                   GDS_NEIGHBOURS_handle_get (type,
                                              options,
                                              desired_replication_level,
                                              hop_count,
                                              &handle->get->key,
                                              xquery,
                                              xquery_size,
                                              handle->bg,
                                              handle->peer_bf));
    GDS_CLIENTS_process_get (
      options
      | (forwarded
        ? 0
        : GNUNET_DHT_RO_LAST_HOP),
      type,
      hop_count,
      desired_replication_level,
      &handle->get->key);
  }
  /* clean up; note that 'bg' is owned by routing now! */
  GNUNET_CONTAINER_bloomfilter_free (handle->peer_bf);
 
  GNUNET_free (handle->get);
  GNUNET_free (handle);
}

References GDS_CLIENTS_process_get(), GDS_NEIGHBOURS_handle_get(), GDS_ROUTING_add(), GNUNET_BLOCK_REPLY_OK_LAST, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_DHT_RO_LAST_HOP, GNUNET_free, GNUNET_OK, handle, options, and type.

Referenced by cb_handle_dht_p2p_get_local_hello(), and handle_dht_p2p_get().

Here is the call graph for this function:

Here is the caller graph for this function:

cb_handle_dht_p2p_get_local_hello()

static void cb_handle_dht_p2p_get_local_hello ( void *  cls )

static

Definition at line 2531 of file gnunet-service-dht_neighbours.c.

{
  struct HandleCallbackGet *handle = cls;
  enum GNUNET_BLOCK_Type type = ntohl (handle->get->type);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handle getting local HELLO %s of type %u\n",
              GNUNET_h2s (&handle->get->key),
              type);
 
  if (GNUNET_BLOCK_TYPE_DHT_HELLO != type)
  {
    enum GNUNET_DHT_RouteOption options = ntohs (handle->get->options);
    const void *result_filter = (const void *) &handle->get[1];
    uint16_t msize = ntohs (handle->get->header.size);
    uint16_t result_filter_size = ntohs (handle->get->result_filter_size);
    const void *xquery = result_filter + result_filter_size;
    size_t xquery_size = msize - sizeof (*handle->get) - result_filter_size;
    /* The datacache callback runs once per *result*, never on completion,
       so it must not carry the continuation: no result would drop the
       request, several would run the continuation several times.  Both
       lookups below are synchronous. */
    if (0 != (options & GNUNET_DHT_RO_FIND_APPROXIMATE))
      handle->eval = GDS_DATACACHE_get_closest (&handle->get->key,
                                                type,
                                                xquery,
                                                xquery_size,
                                                handle->bg,
                                                &handle_local_result,
                                                handle->t->pi);
    else
      handle->eval = GDS_DATACACHE_handle_get (&handle->get->key,
                                               type,
                                               xquery,
                                               xquery_size,
                                               handle->bg,
                                               &handle_local_result,
                                               handle->t->pi);
  }
  cb_handle_dht_p2p_get_local_result (handle);
}

References cb_handle_dht_p2p_get_local_result(), GDS_DATACACHE_get_closest(), GDS_DATACACHE_handle_get(), GNUNET_BLOCK_TYPE_DHT_HELLO, GNUNET_DHT_RO_FIND_APPROXIMATE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, handle, handle_local_result(), options, and type.

Referenced by cb_handle_dht_p2p_get_my_hello(), and handle_dht_p2p_get().

Here is the call graph for this function:

Here is the caller graph for this function:

cb_handle_dht_p2p_get_my_hello()

static void cb_handle_dht_p2p_get_my_hello ( void *  cls )

static

Definition at line 2575 of file gnunet-service-dht_neighbours.c.

{
  struct HandleCallbackGet *handle = cls;
  enum GNUNET_DHT_RouteOption options = ntohs (handle->get->options);
 
  if (0 != (options & GNUNET_DHT_RO_FIND_APPROXIMATE))
    handle_find_local_hello (handle->t->pi,
                             &handle->get->key,
                             handle->bg,
                             &cb_handle_dht_p2p_get_local_hello,
                             handle);
  else
    cb_handle_dht_p2p_get_local_hello (handle);
}

References cb_handle_dht_p2p_get_local_hello(), GNUNET_DHT_RO_FIND_APPROXIMATE, handle, handle_find_local_hello(), and options.

Referenced by handle_dht_p2p_get().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_dht_p2p_get()

static void handle_dht_p2p_get ( void *  cls, const struct PeerGetMessage *  get  )

static

Core handler for p2p get requests.

Parameters

cls	closure with the struct Target of the sender
get	the message

Definition at line 2598 of file gnunet-service-dht_neighbours.c.

{
  struct Target *t = cls;
  struct PeerInfo *peer = t->pi;
  uint16_t msize = ntohs (get->header.size);
  uint16_t result_filter_size = ntohs (get->result_filter_size);
  uint16_t hop_count = ntohs (get->hop_count);
  enum GNUNET_BLOCK_Type type = ntohl (get->type);
  enum GNUNET_DHT_RouteOption options = ntohs (get->options);
  const void *result_filter = (const void *) &get[1];
  const void *xquery = result_filter + result_filter_size;
  size_t xquery_size = msize - sizeof (*get) - result_filter_size;
 
  /* parse and validate message */
  GNUNET_STATISTICS_update (GDS_stats,
                            "# P2P GET requests received",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (GDS_stats,
                            "# P2P GET bytes received",
                            msize,
                            GNUNET_NO);
  if (GNUNET_NO ==
      GNUNET_BLOCK_check_query (GDS_block_context,
                                type,
                                &get->key,
                                xquery,
                                xquery_size))
  {
    /* request invalid */
    GNUNET_break_op (0);
    return;
  }
 
  {
    const struct GNUNET_PeerIdentity *my_identity;
    struct HandleCallbackGet *handle;
 
    handle = GNUNET_new (struct HandleCallbackGet);
    handle->t = t;
    handle->get = GNUNET_memdup (get, msize);
    handle->eval = GNUNET_BLOCK_REPLY_OK_MORE;
 
    my_identity = GNUNET_PILS_get_identity (GDS_pils);
    GNUNET_assert (NULL != my_identity);
 
    handle->peer_bf = GNUNET_CONTAINER_bloomfilter_init (get->bloomfilter,
                                                         DHT_BLOOM_SIZE,
                                                         GNUNET_CONSTANTS_BLOOMFILTER_K);
    GNUNET_break_op (GNUNET_YES ==
                     GNUNET_CONTAINER_bloomfilter_test (handle->peer_bf,
                                                        &peer->phash));
    handle->bg = GNUNET_BLOCK_group_create (GDS_block_context,
                                            type,
                                            result_filter,
                                            result_filter_size,
                                            "filter-size",
                                            result_filter_size,
                                            NULL);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "GET for %s at %s after %u hops\n",
                GNUNET_h2s (&get->key),
                GNUNET_i2s (my_identity),
                (unsigned int) hop_count);
    /* local lookup (this may update the bg) */
    if ( (0 != (options & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE)) ||
         (GDS_am_closest_peer (&get->key,
                               handle->peer_bf)) )
    {
      if ( (GNUNET_BLOCK_TYPE_DHT_HELLO == type) ||
           (GNUNET_BLOCK_TYPE_ANY == type) )
      {
        GNUNET_STATISTICS_update (GDS_stats,
                                  "# P2P HELLO lookup requests processed",
                                  1,
                                  GNUNET_NO);
        handle_find_my_hello (peer,
                              &get->key,
                              handle->bg,
                              &cb_handle_dht_p2p_get_my_hello,
                              handle);
      }
      else
        cb_handle_dht_p2p_get_local_hello (handle);
    }
    else
    {
      GNUNET_STATISTICS_update (GDS_stats,
                                "# P2P GET requests ONLY routed",
                                1,
                                GNUNET_NO);
      cb_handle_dht_p2p_get_local_result (handle);
    }
  }
}

References cb_handle_dht_p2p_get_local_hello(), cb_handle_dht_p2p_get_local_result(), cb_handle_dht_p2p_get_my_hello(), DHT_BLOOM_SIZE, GDS_am_closest_peer(), GDS_block_context, GDS_pils, GDS_stats, get, GNUNET_assert, GNUNET_BLOCK_check_query(), GNUNET_BLOCK_group_create(), GNUNET_BLOCK_REPLY_OK_MORE, GNUNET_BLOCK_TYPE_ANY, GNUNET_BLOCK_TYPE_DHT_HELLO, GNUNET_break_op, GNUNET_CONSTANTS_BLOOMFILTER_K, GNUNET_CONTAINER_bloomfilter_init(), GNUNET_CONTAINER_bloomfilter_test(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_memdup, GNUNET_new, GNUNET_NO, GNUNET_PILS_get_identity(), GNUNET_STATISTICS_update(), GNUNET_YES, handle, handle_find_my_hello(), my_identity, options, PeerInfo::phash, t, and type.

Here is the call graph for this function:

process_reply_with_path()

static void process_reply_with_path ( const struct GNUNET_DATACACHE_Block *  bd, const struct GNUNET_HashCode *  query_hash, unsigned int  get_path_length, const struct GNUNET_DHT_PathElement *  get_path  )

static

Process a reply, after the get_path has been updated.

Parameters

bd	block details
query_hash	hash of the original query, might not match key in bd
get_path_length	number of entries in get_path
get_path	path the reply has taken

Definition at line 2705 of file gnunet-service-dht_neighbours.c.

{
  /* forward to local clients */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Forwarding reply to local clients\n");
  if (! GDS_CLIENTS_handle_reply (bd,
                                  query_hash,
                                  get_path_length,
                                  get_path))
  {
    GNUNET_break (0);
    return;
  }
  GDS_CLIENTS_process_get_resp (bd,
                                get_path,
                                get_path_length);
  if (GNUNET_YES == cache_results)
  {
    struct GNUNET_DHT_PathElement xput_path[GNUNET_NZL (get_path_length
                                                        + bd->put_path_length)];
    struct GNUNET_DATACACHE_Block bdx = *bd;
 
    if (NULL != bd->put_path)
      GNUNET_memcpy (xput_path,
                     bd->put_path,
                     bd->put_path_length * sizeof(struct
                                                  GNUNET_DHT_PathElement));
    GNUNET_memcpy (&xput_path[bd->put_path_length],
                   get_path,
                   get_path_length * sizeof(struct GNUNET_DHT_PathElement));
    bdx.put_path = xput_path;
    bdx.put_path_length += get_path_length;
    GDS_DATACACHE_handle_put (&bdx);
  }
  /* forward to other peers */
  GDS_ROUTING_process (bd,
                       query_hash,
                       get_path_length,
                       get_path);
}

References cache_results, GDS_CLIENTS_handle_reply(), GDS_CLIENTS_process_get_resp(), GDS_DATACACHE_handle_put(), GDS_ROUTING_process(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_NZL, GNUNET_YES, GNUNET_DATACACHE_Block::put_path, and GNUNET_DATACACHE_Block::put_path_length.

Referenced by handle_dht_p2p_result().

Here is the call graph for this function:

Here is the caller graph for this function:

check_dht_p2p_result()

static enum GNUNET_GenericReturnValue check_dht_p2p_result ( void *  cls, const struct PeerResultMessage *  prm  )

static

Check validity of p2p result message.

Parameters

cls	closure
prm	message

Returns

GNUNET_YES if the message is well-formed

Definition at line 2758 of file gnunet-service-dht_neighbours.c.

{
  uint16_t msize = ntohs (prm->header.size) - sizeof (*prm);
  enum GNUNET_DHT_RouteOption ro = ntohs (prm->options);
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  bool tracked = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
 
  uint16_t get_path_length = ntohs (prm->get_path_length);
  uint16_t put_path_length = ntohs (prm->put_path_length);
  size_t vsize = (truncated ? sizeof (struct GNUNET_PeerIdentity) : 0)
                 + (tracked ? sizeof (struct GNUNET_CRYPTO_EddsaSignature) : 0);
 
  (void) cls;
  if ( (msize < vsize) ||
       (msize - vsize <
        (get_path_length + put_path_length)
        * sizeof(struct GNUNET_DHT_PathElement)) ||
       (get_path_length >
        GNUNET_MAX_MESSAGE_SIZE / sizeof(struct GNUNET_DHT_PathElement)) ||
       (put_path_length >
        GNUNET_MAX_MESSAGE_SIZE / sizeof(struct GNUNET_DHT_PathElement)) )
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References PeerResultMessage::get_path_length, GNUNET_break_op, GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_DHT_RO_TRUNCATED, GNUNET_OK, GNUNET_SYSERR, PeerResultMessage::header, PeerResultMessage::options, GNUNET_DATACACHE_Block::put_path_length, PeerResultMessage::put_path_length, GNUNET_DATACACHE_Block::ro, and GNUNET_MessageHeader::size.

handle_dht_p2p_result()

static void handle_dht_p2p_result ( void *  cls, const struct PeerResultMessage *  prm  )

static

Core handler for p2p result messages.

Parameters

cls	closure
prm	message

Definition at line 2795 of file gnunet-service-dht_neighbours.c.

{
  struct Target *t = cls;
  struct PeerInfo *peer = t->pi;
  uint16_t msize = ntohs (prm->header.size) - sizeof (*prm);
  enum GNUNET_DHT_RouteOption ro = ntohs (prm->options);
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  bool tracked = (0 != (ro & GNUNET_DHT_RO_RECORD_ROUTE));
  uint16_t get_path_length = ntohs (prm->get_path_length);
  uint16_t put_path_length = ntohs (prm->put_path_length);
  const struct GNUNET_PeerIdentity *trunc_peer
    = truncated
    ? (const struct GNUNET_PeerIdentity *) &prm[1]
    : NULL;
  const struct GNUNET_DHT_PathElement *put_path
    = truncated
    ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
    : (const struct GNUNET_DHT_PathElement *) &prm[1];
  const struct GNUNET_DHT_PathElement *get_path
    = &put_path[put_path_length];
  const struct GNUNET_CRYPTO_EddsaSignature *last_sig
    = tracked
    ? (const struct GNUNET_CRYPTO_EddsaSignature *) &get_path[get_path_length]
    : NULL;
  const void *data
    = tracked
    ? (const void *) &last_sig[1]
    : (const void *) &get_path[get_path_length];
  size_t vsize = (truncated ? sizeof (struct GNUNET_PeerIdentity) : 0)
                 + (tracked ? sizeof (struct GNUNET_CRYPTO_EddsaSignature) : 0);
  struct GNUNET_DATACACHE_Block bd = {
    .expiration_time  = GNUNET_TIME_absolute_ntoh (prm->expiration_time),
    .put_path = put_path,
    .put_path_length = put_path_length,
    .key = prm->key,
    .type = ntohl (prm->type),
    .ro = ro,
    .data = data,
    .data_size = msize - vsize - (get_path_length + put_path_length)
                 * sizeof(struct GNUNET_DHT_PathElement)
  };
 
  /* parse and validate message */
  if (GNUNET_TIME_absolute_is_past (bd.expiration_time))
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# Expired results discarded",
                              1,
                              GNUNET_NO);
    return;
  }
  if (GNUNET_OK !=
      GNUNET_BLOCK_check_block (GDS_block_context,
                                bd.type,
                                bd.data,
                                bd.data_size))
  {
    GNUNET_break_op (0);
    return;
  }
  GNUNET_STATISTICS_update (GDS_stats,
                            "# P2P RESULTS received",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (GDS_stats,
                            "# P2P RESULT bytes received",
                            msize,
                            GNUNET_NO);
  {
    enum GNUNET_GenericReturnValue ret;
 
    ret = GNUNET_BLOCK_get_key (GDS_block_context,
                                bd.type,
                                bd.data,
                                bd.data_size,
                                &bd.key);
    if (GNUNET_NO == ret)
      bd.key = prm->key;
  }
 
  /* if we got a HELLO, consider it for our own routing table */
  hello_check (&bd);
 
  /* Need to append 'peer' to 'get_path' */
  if (tracked)
  {
    struct GNUNET_DHT_PathElement xget_path[get_path_length + 1];
    struct GNUNET_DHT_PathElement *gp = xget_path;
    unsigned int failure_offset;
 
    GNUNET_memcpy (xget_path,
                   get_path,
                   get_path_length * sizeof(struct GNUNET_DHT_PathElement));
    xget_path[get_path_length].pred = peer->id;
    /* use memcpy(), as last_sig may not be aligned */
    memcpy (&xget_path[get_path_length].sig,
            last_sig,
            sizeof (*last_sig));
#if SANITY_CHECKS
    {
      const struct GNUNET_PeerIdentity *my_identity;
      my_identity = GNUNET_PILS_get_identity (GDS_pils);
      GNUNET_assert (NULL != my_identity);
      /* TODO: might want to eventually implement probabilistic
        load-based path verification, but for now it is all or nothing */
      failure_offset
        = GNUNET_DHT_verify_path (bd.data,
                                  bd.data_size,
                                  bd.expiration_time,
                                  trunc_peer,
                                  put_path,
                                  put_path_length,
                                  gp,
                                  get_path_length + 1,
                                  my_identity);
    }
#else
    failure_offset = 0;
#endif
    if (0 != failure_offset)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Recorded path invalid at offset %u, truncating\n",
                  failure_offset);
      GNUNET_assert (failure_offset <= bd.put_path_length + get_path_length
                     + 1);
      if (failure_offset < bd.put_path_length)
      {
        /* failure on put path */
        trunc_peer = &bd.put_path[failure_offset - 1].pred;
        bd.ro |= GNUNET_DHT_RO_TRUNCATED;
        bd.put_path = &bd.put_path[failure_offset];
        bd.put_path_length -= failure_offset;
        truncated = true;
      }
      else
      {
        /* failure on get path */
        failure_offset -= bd.put_path_length;
        if (0 == failure_offset)
          trunc_peer = &bd.put_path[bd.put_path_length - 1].pred;
        else
          trunc_peer = &gp[failure_offset - 1].pred;
        get_path_length -= failure_offset;
        gp = &gp[failure_offset];
        bd.put_path_length = 0;
        bd.put_path = NULL;
        bd.ro |= GNUNET_DHT_RO_TRUNCATED;
        truncated = true;
      }
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Extending GET path of length %u with %s\n",
                get_path_length,
                GNUNET_i2s (&peer->id));
    if (truncated)
    {
      GNUNET_assert (NULL != trunc_peer);
      bd.trunc_peer = *trunc_peer;
    }
    process_reply_with_path (&bd,
                             &prm->key,
                             get_path_length + 1,
                             gp);
  }
  else
  {
    if (truncated)
    {
      GNUNET_assert (NULL != trunc_peer);
      bd.trunc_peer = *trunc_peer;
    }
    process_reply_with_path (&bd,
                             &prm->key,
                             0,
                             NULL);
  }
}

References data, GNUNET_DATACACHE_Block::expiration_time, PeerResultMessage::expiration_time, GDS_block_context, GDS_pils, GDS_stats, PeerResultMessage::get_path_length, GNUNET_assert, GNUNET_BLOCK_check_block(), GNUNET_BLOCK_get_key(), GNUNET_break_op, GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_DHT_RO_TRUNCATED, GNUNET_DHT_verify_path(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_PILS_get_identity(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_is_past(), GNUNET_TIME_absolute_ntoh(), PeerResultMessage::header, hello_check(), PeerInfo::id, PeerResultMessage::key, my_identity, PeerResultMessage::options, GNUNET_DHT_PathElement::pred, process_reply_with_path(), PeerResultMessage::put_path_length, ret, GNUNET_DHT_PathElement::sig, GNUNET_MessageHeader::size, t, and PeerResultMessage::type.

Here is the call graph for this function:

check_dht_p2p_hello()

static enum GNUNET_GenericReturnValue check_dht_p2p_hello ( void *  cls, const struct GNUNET_MessageHeader *  hello  )

static

Check validity of a p2p hello message.

Parameters

cls	closure
hello	message

Returns

GNUNET_YES if the message is well-formed

Definition at line 2984 of file gnunet-service-dht_neighbours.c.

{
  struct Target *t = cls;
  struct PeerInfo *peer = t->pi;
  enum GNUNET_GenericReturnValue ret;
  size_t hellob_size;
  void *hellob;
  struct GNUNET_TIME_Absolute expiration;
 
  ret = GNUNET_HELLO_dht_msg_to_block (hello,
                                       &peer->id,
                                       &hellob,
                                       &hellob_size,
                                       &expiration);
  GNUNET_free (hellob);
  return ret;
}

References expiration, GNUNET_free, GNUNET_HELLO_dht_msg_to_block(), PeerInfo::id, ret, and t.

Here is the call graph for this function:

handle_dht_p2p_hello()

static void handle_dht_p2p_hello ( void *  cls, const struct GNUNET_MessageHeader *  hello  )

static

Core handler for p2p HELLO messages.

Parameters

cls	closure
hello	message

Definition at line 3011 of file gnunet-service-dht_neighbours.c.

{
  struct Target *t = cls;
  struct PeerInfo *peer = t->pi;
 
  GNUNET_free (peer->hello);
  peer->hello_size = 0;
  GNUNET_break (GNUNET_OK ==
                GNUNET_HELLO_dht_msg_to_block (hello,
                                               &peer->id,
                                               &peer->hello,
                                               &peer->hello_size,
                                               &peer->hello_expiration));
}

References GNUNET_break, GNUNET_free, GNUNET_HELLO_dht_msg_to_block(), GNUNET_OK, PeerInfo::hello, PeerInfo::hello_expiration, PeerInfo::hello_size, PeerInfo::id, and t.

Here is the call graph for this function:

GDS_u_receive()

void GDS_u_receive	(	void *	cls,
		void **	tctx,
		void **	sctx,
		const void *	message,
		size_t	message_size
	)

Function to call when we receive a message.

Parameters

	cls	the closure
[in,out]	tctx	ctx of target address where we received the message from
[in,out]	sctx	ctx of our own source address at which we received the message
	message	the message we received
	message_size	number of bytes in message

Definition at line 3029 of file gnunet-service-dht_neighbours.c.

{
  struct Target *t = *tctx;
  struct GNUNET_MQ_MessageHandler core_handlers[] = {
    GNUNET_MQ_hd_var_size (dht_p2p_get,
                           GNUNET_MESSAGE_TYPE_DHT_P2P_GET,
                           struct PeerGetMessage,
                           t),
    GNUNET_MQ_hd_var_size (dht_p2p_put,
                           GNUNET_MESSAGE_TYPE_DHT_P2P_PUT,
                           struct PeerPutMessage,
                           t),
    GNUNET_MQ_hd_var_size (dht_p2p_result,
                           GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT,
                           struct PeerResultMessage,
                           t),
    GNUNET_MQ_hd_var_size (dht_p2p_hello,
                           GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO,
                           struct GNUNET_MessageHeader,
                           t),
    GNUNET_MQ_handler_end ()
  };
  const struct GNUNET_MessageHeader *mh = message;
 
  (void) cls; /* the 'struct GDS_Underlay' */
  (void) sctx; /* our receiver address */
  if (NULL == t)
  {
    /* Received message claiming to originate from myself?
       Ignore! */
    GNUNET_break_op (0);
    return;
  }
  if (message_size < sizeof (*mh))
  {
    GNUNET_break_op (0);
    return;
  }
  if (message_size != ntohs (mh->size))
  {
    GNUNET_break_op (0);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handling message of type %u from peer %s\n",
              ntohs (mh->type),
              GNUNET_i2s (&t->pi->id));
  if (GNUNET_OK !=
      GNUNET_MQ_handle_message (core_handlers,
                                mh))
  {
    GNUNET_break_op (0);
    return;
  }
}

References GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_DHT_P2P_GET, GNUNET_MESSAGE_TYPE_DHT_P2P_HELLO, GNUNET_MESSAGE_TYPE_DHT_P2P_PUT, GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT, GNUNET_MQ_handle_message(), GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_OK, mh, and t.

Referenced by load_underlay().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_try_connect()

void GDS_try_connect	(	void *	cls,
		const struct GNUNET_PeerIdentity *	pid,
		const char *	uri
	)

Callback function used to extract URIs from a builder.

Called when we should consider connecting to a peer.

Parameters

cls	closure pointing to a struct GNUNET_PeerIdentity *
uri	one of the URIs

Definition at line 3098 of file gnunet-service-dht_neighbours.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_HashCode phash;
  int peer_bucket;
  struct PeerBucket *bucket;
  (void) cls;
 
  my_identity = GNUNET_PILS_get_identity (GDS_pils);
  GNUNET_assert (NULL != my_identity);
 
  if (0 == GNUNET_memcmp (my_identity, pid))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Got a HELLO for my own PID, ignoring it\n");
    return; /* that's us! */
  }
  GNUNET_CRYPTO_hash (pid,
                      sizeof(*pid),
                      &phash);
  peer_bucket = find_bucket (&phash);
  GNUNET_assert ( (peer_bucket >= 0) &&
                  ((unsigned int) peer_bucket < MAX_BUCKETS));
  bucket = &k_buckets[peer_bucket];
  for (struct PeerInfo *pi = bucket->head;
       NULL != pi;
       pi = pi->next)
    if (0 ==
        GNUNET_memcmp (&pi->id,
                       pid))
    {
      /* already connected */
      GDS_u_try_connect (pid,
                         uri);
      return;
    }
  if (bucket->peers_size >= bucket_size)
    return; /* do not care */
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Discovered peer %s at %s suitable for bucket %d (%u/%u), trying to connect\n",
              GNUNET_i2s (pid),
              uri,
              peer_bucket,
              bucket->peers_size,
              bucket_size);
  /* new peer that we like! */
  GDS_u_try_connect (pid,
                     uri);
}

References bucket_size, find_bucket(), GDS_pils, GDS_u_try_connect(), GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_PILS_get_identity(), PeerBucket::head, k_buckets, MAX_BUCKETS, my_identity, PeerBucket::peers_size, and uri.

Referenced by handle_dht_local_hello_offer(), and hello_check().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_NEIGHBOURS_broadcast()

void GDS_NEIGHBOURS_broadcast

(

const struct GNUNET_MessageHeader *

msg

)

Send msg to all peers in our buckets.

Parameters

msg	message to broadcast

Definition at line 3157 of file gnunet-service-dht_neighbours.c.

{
  for (unsigned int bc = 0; bc<closest_bucket; bc++)
  {
    struct PeerBucket *bucket = &k_buckets[bc];
    unsigned int count = 0;
 
    for (struct PeerInfo *pos = bucket->head;
         NULL != pos;
         pos = pos->next)
    {
      if (count >= bucket_size)
        break;   /* we only consider first #bucket_size entries per bucket */
      count++;
      do_send (pos,
               msg);
    }
  }
}

References bucket_size, closest_bucket, do_send(), PeerBucket::head, k_buckets, and msg.

Referenced by pid_change_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_NEIGHBOURS_init()

enum GNUNET_GenericReturnValue GDS_NEIGHBOURS_init

(

void

)

Initialize neighbours subsystem.

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 3179 of file gnunet-service-dht_neighbours.c.

{
 
  unsigned long long temp_config_num;
 
  disable_try_connect
    = GNUNET_CONFIGURATION_get_value_yesno (GDS_cfg,
                                            "DHT",
                                            "DISABLE_TRY_CONNECT");
  if (GNUNET_OK ==
      GNUNET_CONFIGURATION_get_value_number (GDS_cfg,
                                             "DHT",
                                             "bucket_size",
                                             &temp_config_num))
    bucket_size = (unsigned int) temp_config_num;
  cache_results
    = GNUNET_CONFIGURATION_get_value_yesno (GDS_cfg,
                                            "DHT",
                                            "CACHE_RESULTS");
  all_connected_peers = GNUNET_CONTAINER_multipeermap_create (256,
                                                              GNUNET_YES);
  return GNUNET_OK;
}

References all_connected_peers, bucket_size, cache_results, disable_try_connect, GDS_cfg, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_OK, and GNUNET_YES.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_NEIGHBOURS_done()

void GDS_NEIGHBOURS_done

(

void

)

Shutdown neighbours subsystem.

Definition at line 3205 of file gnunet-service-dht_neighbours.c.

{
  if (NULL == all_connected_peers)
    return;
  GNUNET_assert (0 ==
                 GNUNET_CONTAINER_multipeermap_size (all_connected_peers));
  GNUNET_CONTAINER_multipeermap_destroy (all_connected_peers);
  all_connected_peers = NULL;
  GNUNET_assert (NULL == find_peer_task);
}

References all_connected_peers, find_peer_task, GNUNET_assert, GNUNET_CONTAINER_multipeermap_destroy(), and GNUNET_CONTAINER_multipeermap_size().

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_NEIGHBOURS_get_id()

const struct GNUNET_PeerIdentity * GDS_NEIGHBOURS_get_id

(

void

)

Get the ID of the local node.

Returns

identity of the local node

Definition at line 3218 of file gnunet-service-dht_neighbours.c.

{
  return GNUNET_PILS_get_identity (GDS_pils);
}

References GDS_pils, and GNUNET_PILS_get_identity().

Here is the call graph for this function:

Variable Documentation

cache_results

int cache_results

static

Do we cache all results that we are routing in the local datacache?

Definition at line 355 of file gnunet-service-dht_neighbours.c.

Referenced by GDS_NEIGHBOURS_init(), and process_reply_with_path().

closest_bucket

unsigned int closest_bucket

static

One past the deepest currently used bucket, initially 0 (no peers at all).

Buckets at or beyond this offset are known to be empty.

Definition at line 361 of file gnunet-service-dht_neighbours.c.

Referenced by GDS_am_closest_peer(), GDS_NEIGHBOURS_broadcast(), GDS_u_connect(), GDS_u_disconnect(), and select_peer().

newly_found_peers

unsigned int newly_found_peers

static

How many peers have we added since we sent out our last find peer request?

Definition at line 367 of file gnunet-service-dht_neighbours.c.

Referenced by GDS_u_connect(), and send_find_peer_message().

disable_try_connect

int disable_try_connect

static

Option for testing that disables the 'connect' function of the DHT.

Definition at line 372 of file gnunet-service-dht_neighbours.c.

Referenced by GDS_NEIGHBOURS_init(), GDS_u_connect(), GDS_u_disconnect(), and hello_check().

k_buckets

struct PeerBucket k_buckets[sizeof(struct GNUNET_HashCode) *8]

static

The buckets.

Array of size MAX_BUCKETS. Offset 0 means 0 bits matching.

Definition at line 377 of file gnunet-service-dht_neighbours.c.

Referenced by GDS_am_closest_peer(), GDS_NEIGHBOURS_broadcast(), GDS_try_connect(), GDS_u_connect(), GDS_u_disconnect(), and select_peer().

all_connected_peers

struct GNUNET_CONTAINER_MultiPeerMap* all_connected_peers

static

Hash map of all CORE-connected peers, for easy removal from k_buckets on disconnect.

Values are of type struct PeerInfo.

Definition at line 383 of file gnunet-service-dht_neighbours.c.

Referenced by GDS_NEIGHBOURS_done(), GDS_NEIGHBOURS_init(), GDS_NEIGHBOURS_lookup_peer(), GDS_u_connect(), GDS_u_disconnect(), get_target_peers(), and send_find_peer_message().

bucket_size

unsigned int bucket_size = 8

static

Maximum size for each bucket.

Definition at line 388 of file gnunet-service-dht_neighbours.c.

Referenced by GDS_am_closest_peer(), GDS_NEIGHBOURS_broadcast(), GDS_NEIGHBOURS_init(), GDS_try_connect(), GDS_u_connect(), GDS_u_disconnect(), select_peer(), send_find_peer_message(), and update_hold().

find_peer_task

struct GNUNET_SCHEDULER_Task* find_peer_task

static

Task that sends FIND PEER requests.

Definition at line 393 of file gnunet-service-dht_neighbours.c.

Referenced by GDS_NEIGHBOURS_done(), GDS_u_connect(), GDS_u_disconnect(), and send_find_peer_message().