gnunet-service-dht_neighbours.c File Reference

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

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_block_lib.h"
#include "gnunet_hello_lib.h"
#include "gnunet_constants.h"
#include "gnunet_protocols.h"
#include "gnunet_nse_service.h"
#include "gnunet_ats_service.h"
#include "gnunet_core_service.h"
#include "gnunet_datacache_lib.h"
#include "gnunet_transport_service.h"
#include "gnunet_dht_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet-service-dht.h"
#include "gnunet-service-dht_datacache.h"
#include "gnunet-service-dht_hello.h"
#include "gnunet-service-dht_neighbours.h"
#include "gnunet-service-dht_nse.h"
#include "gnunet-service-dht_routing.h"
#include "dht.h"

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

Go to the source code of this file.

Data Structures
struct	PeerPutMessage
	P2P PUT message. More...
struct	PeerResultMessage
	P2P Result message. More...
struct	PeerGetMessage
	P2P GET message. More...
struct	PeerInfo
	Entry for a peer in a bucket. More...
struct	PeerBucket
	Peers are grouped into buckets. More...
struct	ConnectInfo
	Information about a peer that we would like to connect to. More...

Macros
#define	LOG_TRAFFIC(kind, ...)   GNUNET_log_from(kind, "dht-traffic", __VA_ARGS__)
#define	SANITY_CHECKS   1
	Enable slow sanity checks to debug issues. More...
#define	MAX_BUCKETS   sizeof(struct GNUNET_HashCode) * 8
	How many buckets will we allow total. More...
#define	DEFAULT_BUCKET_SIZE   8
	What is the maximum number of peers in a given bucket. More...
#define	FIND_PEER_REPLICATION_LEVEL   4
	Desired replication level for FIND PEER requests. More...
#define	MAXIMUM_REPLICATION_LEVEL   16
	Maximum allowed replication level for all requests. More...
#define	MAXIMUM_PENDING_PER_PEER   64
	Maximum allowed number of pending messages per peer. More...
#define	DHT_MINIMUM_FIND_PEER_INTERVAL   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30)
	How long at least to wait before sending another find peer request. More...
#define	DHT_MAXIMUM_FIND_PEER_INTERVAL   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 10)
	How long at most to wait before sending another find peer request. More...
#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? More...

Functions
static int	find_bucket (const struct GNUNET_HashCode *hc)
	Find the optimal bucket for this key. More...
static void	offer_hello_done (void *cls)
	Function called when GNUNET_TRANSPORT_offer_hello() is done. More...
static int	free_connect_info (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
	Function called for all entries in all_desired_peers to clean up. More...
static void	try_connect (const struct GNUNET_PeerIdentity *pid, const struct GNUNET_MessageHeader *h)
	Consider if we want to connect to a given peer, and if so let ATS know. More...
static int	update_desire_strength (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Function called for each peer in all_desired_peers during update_connect_preferences() if we have reason to adjust the strength of our desire to keep connections to certain peers. More...
static void	update_connect_preferences ()
	Update our preferences for connectivity as given to ATS. More...
static int	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. More...
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. More...
static void *	handle_core_connect (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
	Method called whenever a peer connects. More...
static void	handle_core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
	Method called whenever a peer disconnects. More...
static unsigned int	get_forward_count (uint32_t hop_count, uint32_t target_replication)
	To how many peers should we (on average) forward the request to obtain the desired target_replication count (on average). More...
static unsigned int	get_distance (const struct GNUNET_HashCode *target, const struct GNUNET_HashCode *have)
	Compute the distance between have and target as a 32-bit value. More...
int	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. More...
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". More...
static unsigned int	get_target_peers (const struct GNUNET_HashCode *key, struct GNUNET_CONTAINER_BloomFilter *bloom, uint32_t hop_count, uint32_t target_replication, struct PeerInfo ***targets)
	Compute the set of peers that the given request should be forwarded to. More...
int	GDS_NEIGHBOURS_handle_put (enum GNUNET_BLOCK_Type type, enum GNUNET_DHT_RouteOption options, uint32_t desired_replication_level, struct GNUNET_TIME_Absolute expiration_time, uint32_t hop_count, struct GNUNET_CONTAINER_BloomFilter *bf, const struct GNUNET_HashCode *key, unsigned int put_path_length, struct GNUNET_PeerIdentity *put_path, const void *data, size_t data_size)
	Perform a PUT operation. More...
int	GDS_NEIGHBOURS_handle_get (enum GNUNET_BLOCK_Type type, enum GNUNET_DHT_RouteOption options, uint32_t desired_replication_level, uint32_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. More...
void	GDS_NEIGHBOURS_handle_reply (const struct GNUNET_PeerIdentity *target, enum GNUNET_BLOCK_Type type, struct GNUNET_TIME_Absolute expiration_time, const struct GNUNET_HashCode *key, unsigned int put_path_length, const struct GNUNET_PeerIdentity *put_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *get_path, const void *data, size_t data_size)
	Handle a reply (route to origin). More...
static void	core_init (void *cls, const struct GNUNET_PeerIdentity *identity)
	To be called on core init/fail. More...
static int	check_dht_p2p_put (void *cls, const struct PeerPutMessage *put)
	Check validity of a p2p put request. More...
static void	handle_dht_p2p_put (void *cls, const struct PeerPutMessage *put)
	Core handler for p2p put requests. More...
static void	handle_find_peer (const struct GNUNET_PeerIdentity *sender, const struct GNUNET_HashCode *key, struct GNUNET_BLOCK_Group *bg)
	We have received a FIND PEER request. More...
static void	handle_local_result (void *cls, enum GNUNET_BLOCK_Type type, struct GNUNET_TIME_Absolute expiration_time, const struct GNUNET_HashCode *key, unsigned int put_path_length, const struct GNUNET_PeerIdentity *put_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *get_path, const void *data, size_t data_size)
	Handle a result from local datacache for a GET operation. More...
static int	check_dht_p2p_get (void *cls, const struct PeerGetMessage *get)
	Check validity of p2p get request. More...
static void	handle_dht_p2p_get (void *cls, const struct PeerGetMessage *get)
	Core handler for p2p get requests. More...
static int	check_dht_p2p_result (void *cls, const struct PeerResultMessage *prm)
	Check validity of p2p result message. More...
static void	process_reply_with_path (struct GNUNET_TIME_Absolute expiration_time, const struct GNUNET_HashCode *key, unsigned int get_path_length, const struct GNUNET_PeerIdentity *get_path, unsigned int put_path_length, const struct GNUNET_PeerIdentity *put_path, enum GNUNET_BLOCK_Type type, size_t data_size, const void *data)
	Process a reply, after the get_path has been updated. More...
static void	handle_dht_p2p_result (void *cls, const struct PeerResultMessage *prm)
	Core handler for p2p result messages. More...
int	GDS_NEIGHBOURS_init ()
	Initialize neighbours subsystem. More...
void	GDS_NEIGHBOURS_done ()
	Shutdown neighbours subsystem. More...
struct GNUNET_PeerIdentity *	GDS_NEIGHBOURS_get_id ()
	Get the ID of the local node. More...

Variables
struct GNUNET_TIME_Relative	hello_expiration
	Hello address expiration. More...
static int	cache_results
	Do we cache all results that we are routing in the local datacache? More...
static int	log_route_details_stderr
	Should routing details be logged to stderr (for debugging)? More...
static unsigned int	closest_bucket
	The lowest currently used bucket, initially 0 (for 0-bits matching bucket). More...
static unsigned int	newly_found_peers
	How many peers have we added since we sent out our last find peer request? More...
static int	disable_try_connect
	Option for testing that disables the 'connect' function of the DHT. More...
static struct PeerBucket	k_buckets [sizeof(struct GNUNET_HashCode) *8]
	The buckets. More...
static struct GNUNET_CONTAINER_MultiPeerMap *	all_connected_peers
	Hash map of all CORE-connected peers, for easy removal from k_buckets on disconnect. More...
static struct GNUNET_CONTAINER_MultiPeerMap *	all_desired_peers
	Hash map of all peers we would like to be connected to. More...
static unsigned int	bucket_size = 8
	Maximum size for each bucket. More...
static struct GNUNET_SCHEDULER_Task *	find_peer_task
	Task that sends FIND PEER requests. More...
static struct GNUNET_PeerIdentity	my_identity
	Identity of this peer. More...
struct GNUNET_HashCode	my_identity_hash
	Hash of the identity of this peer. More...
static struct GNUNET_CORE_Handle *	core_api
	Handle to CORE. More...
static struct GNUNET_ATS_ConnectivityHandle *	ats_ch
	Handle to ATS connectivity. More...

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,
			...
	)		GNUNET_log_from(kind, "dht-traffic", __VA_ARGS__)

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

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

SANITY_CHECKS

#define SANITY_CHECKS   1

Enable slow sanity checks to debug issues.

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

MAX_BUCKETS

#define MAX_BUCKETS   sizeof(struct GNUNET_HashCode) * 8

How many buckets will we allow total.

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

Referenced by find_bucket(), and handle_core_connect().

DEFAULT_BUCKET_SIZE

#define DEFAULT_BUCKET_SIZE   8

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

Definition at line 64 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 69 of file gnunet-service-dht_neighbours.c.

Referenced by send_find_peer_message().

MAXIMUM_REPLICATION_LEVEL

#define MAXIMUM_REPLICATION_LEVEL   16

Maximum allowed replication level for all requests.

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

Referenced by get_forward_count().

MAXIMUM_PENDING_PER_PEER

#define MAXIMUM_PENDING_PER_PEER   64

Maximum allowed number of pending messages per peer.

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

Referenced by GDS_NEIGHBOURS_handle_get(), GDS_NEIGHBOURS_handle_put(), and GDS_NEIGHBOURS_handle_reply().

DHT_MINIMUM_FIND_PEER_INTERVAL

#define DHT_MINIMUM_FIND_PEER_INTERVAL   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30)

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

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

Referenced by send_find_peer_message().

DHT_MAXIMUM_FIND_PEER_INTERVAL

#define DHT_MAXIMUM_FIND_PEER_INTERVAL   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 10)

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

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

Referenced by send_find_peer_message().

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 94 of file gnunet-service-dht_neighbours.c.

Function Documentation

find_bucket()

static int find_bucket ( const struct GNUNET_HashCode *  hc )

static

Find the optimal bucket for this key.

Parameters

hc	the hashcode to compare our identity to

Returns

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

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

References GNUNET_break, GNUNET_CRYPTO_hash_matching_bits(), GNUNET_SYSERR, MAX_BUCKETS, and my_identity_hash.

Referenced by GDS_am_closest_peer(), handle_core_connect(), handle_find_peer(), and try_connect().

{
  unsigned int bits;

  bits = GNUNET_CRYPTO_hash_matching_bits(&my_identity_hash, hc);
  if (bits == MAX_BUCKETS)
    {
      /* How can all bits match? Got my own ID? */
      GNUNET_break(0);
      return GNUNET_SYSERR;
    }
  return MAX_BUCKETS - bits - 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

offer_hello_done()

static void offer_hello_done ( void *  cls )

static

Function called when GNUNET_TRANSPORT_offer_hello() is done.

Clean up the "oh" field in the cls

Parameters

cls	a struct ConnectInfo

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

References ConnectInfo::oh.

Referenced by try_connect().

{
  struct ConnectInfo *ci = cls;

  ci->oh = NULL;
}

Here is the caller graph for this function:

free_connect_info()

static int free_connect_info ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  value  )

static

Function called for all entries in all_desired_peers to clean up.

Parameters

cls	NULL
peer	peer the entry is for
value	the value to remove

Returns

GNUNET_YES

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

References GNUNET_assert, GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_TRANSPORT_offer_hello_cancel(), GNUNET_YES, ConnectInfo::oh, ConnectInfo::sh, and value.

Referenced by GDS_NEIGHBOURS_done(), and try_connect().

{
  struct ConnectInfo *ci = value;

  (void)cls;
  GNUNET_assert(GNUNET_YES ==
                GNUNET_CONTAINER_multipeermap_remove(all_desired_peers,
                                                     peer,
                                                     ci));
  if (NULL != ci->sh)
    {
      GNUNET_ATS_connectivity_suggest_cancel(ci->sh);
      ci->sh = NULL;
    }
  if (NULL != ci->oh)
    {
      GNUNET_TRANSPORT_offer_hello_cancel(ci->oh);
      ci->oh = NULL;
    }
  GNUNET_free(ci);
  return GNUNET_YES;
}

Here is the call graph for this function:

Here is the caller graph for this function:

try_connect()

static void try_connect ( const struct GNUNET_PeerIdentity *  pid, const struct GNUNET_MessageHeader *  h  )

static

Consider if we want to connect to a given peer, and if so let ATS know.

If applicable, the HELLO is offered to the TRANSPORT service.

Parameters

pid	peer to consider connectivity requirements for
h	a HELLO message, or NULL

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

References bucket_size, find_bucket(), free_connect_info(), GDS_cfg, GNUNET_assert, GNUNET_ATS_connectivity_suggest(), GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CRYPTO_hash(), GNUNET_new, GNUNET_OK, GNUNET_TRANSPORT_offer_hello(), GNUNET_TRANSPORT_offer_hello_cancel(), GNUNET_YES, k_buckets, offer_hello_done(), ConnectInfo::oh, PeerBucket::peers_size, ConnectInfo::sh, and ConnectInfo::strength.

Referenced by handle_dht_p2p_result(), and update_desire_strength().

{
  int bucket;
  struct GNUNET_HashCode pid_hash;
  struct ConnectInfo *ci;
  uint32_t strength;

  GNUNET_CRYPTO_hash(pid,
                     sizeof(struct GNUNET_PeerIdentity),
                     &pid_hash);
  bucket = find_bucket(&pid_hash);
  if (bucket < 0)
    return; /* self? */
  ci = GNUNET_CONTAINER_multipeermap_get(all_desired_peers,
                                         pid);

  if (k_buckets[bucket].peers_size < bucket_size)
    strength = (bucket_size - k_buckets[bucket].peers_size) * bucket;
  else
    strength = bucket; /* minimum value of connectivity */
  if (GNUNET_YES ==
      GNUNET_CONTAINER_multipeermap_contains(all_connected_peers,
                                             pid))
    strength *= 2; /* double for connected peers */
  else if (k_buckets[bucket].peers_size > bucket_size)
    strength = 0; /* bucket full, we really do not care about more */

  if ((0 == strength) &&
      (NULL != ci))
    {
      /* release request */
      GNUNET_assert(GNUNET_YES ==
                    free_connect_info(NULL,
                                      pid,
                                      ci));
      return;
    }
  if (NULL == ci)
    {
      ci = GNUNET_new(struct ConnectInfo);
      GNUNET_assert(GNUNET_OK ==
                    GNUNET_CONTAINER_multipeermap_put(all_desired_peers,
                                                      pid,
                                                      ci,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    }
  if ((NULL != ci->oh) &&
      (NULL != h))
    GNUNET_TRANSPORT_offer_hello_cancel(ci->oh);
  if (NULL != h)
    ci->oh = GNUNET_TRANSPORT_offer_hello(GDS_cfg,
                                          h,
                                          &offer_hello_done,
                                          ci);
  if ((NULL != ci->sh) &&
      (ci->strength != strength))
    GNUNET_ATS_connectivity_suggest_cancel(ci->sh);
  if (ci->strength != strength)
    ci->sh = GNUNET_ATS_connectivity_suggest(ats_ch,
                                             pid,
                                             strength);
  ci->strength = strength;
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_desire_strength()

static int update_desire_strength ( void *  cls, const struct GNUNET_PeerIdentity *  pid, void *  value  )

static

Function called for each peer in all_desired_peers during update_connect_preferences() if we have reason to adjust the strength of our desire to keep connections to certain peers.

Calls try_connect() to update the calculations for the given pid.

Parameters

cls	NULL
pid	peer to update
value	unused

Returns

GNUNET_YES (continue to iterate)

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

References GNUNET_YES, and try_connect().

Referenced by update_connect_preferences().

{
  (void)cls;
  (void)value;
  try_connect(pid,
              NULL);
  return GNUNET_YES;
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_connect_preferences()

static void update_connect_preferences ( )

static

Update our preferences for connectivity as given to ATS.

Parameters

cls	the struct PeerInfo of the peer
tc	scheduler context.

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

References GNUNET_CONTAINER_multipeermap_iterate(), and update_desire_strength().

Referenced by handle_core_connect(), and handle_core_disconnect().

{
  GNUNET_CONTAINER_multipeermap_iterate(all_desired_peers,
                                        &update_desire_strength,
                                        NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

add_known_to_bloom()

static int 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	value the peer information (unused)

Returns

GNUNET_YES (we should continue to iterate)

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

References GNUNET_BLOCK_group_set_seen(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, and GNUNET_YES.

Referenced by send_find_peer_message().

{
  struct GNUNET_BLOCK_Group *bg = cls;
  struct GNUNET_HashCode key_hash;

  (void)cls;
  (void)value;
  GNUNET_CRYPTO_hash(key,
                     sizeof(struct GNUNET_PeerIdentity),
                     &key_hash);
  GNUNET_BLOCK_group_set_seen(bg,
                              &key_hash,
                              1);
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Adding known peer (%s) to bloomfilter for FIND PEER\n",
             GNUNET_i2s(key));
  return GNUNET_YES;
}

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

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

References add_known_to_bloom(), bucket_size, DHT_BLOOM_SIZE, DHT_MAXIMUM_FIND_PEER_INTERVAL, DHT_MINIMUM_FIND_PEER_INTERVAL, FIND_PEER_REPLICATION_LEVEL, GDS_block_context, GDS_NEIGHBOURS_handle_get(), GDS_stats, gettext_noop, 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_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_CRYPTO_random_u64(), GNUNET_DHT_RO_FIND_PEER, GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_MINUTES, my_identity_hash, newly_found_peers, and GNUNET_TIME_Relative::rel_value_us.

Referenced by handle_core_connect().

{
  struct GNUNET_TIME_Relative next_send_time;
  struct GNUNET_BLOCK_Group *bg;
  struct GNUNET_CONTAINER_BloomFilter *peer_bf;

  (void)cls;
  find_peer_task = NULL;
  if (newly_found_peers > bucket_size)
    {
      /* If we are finding many peers already, no need to send out our request right now! */
      find_peer_task =
        GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES,
                                     &send_find_peer_message,
                                     NULL);
      newly_found_peers = 0;
      return;
    }
  bg = GNUNET_BLOCK_group_create(GDS_block_context,
                                 GNUNET_BLOCK_TYPE_DHT_HELLO,
                                 GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
                                                          UINT32_MAX),
                                 NULL,
                                 0,
                                 "filter-size",
                                 DHT_BLOOM_SIZE,
                                 NULL);
  GNUNET_CONTAINER_multipeermap_iterate(all_connected_peers,
                                        &add_known_to_bloom,
                                        bg);
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# FIND PEER messages initiated"),
                           1,
                           GNUNET_NO);
  peer_bf
    = GNUNET_CONTAINER_bloomfilter_init(NULL,
                                        DHT_BLOOM_SIZE,
                                        GNUNET_CONSTANTS_BLOOMFILTER_K);
  // FIXME: pass priority!?
  GDS_NEIGHBOURS_handle_get(GNUNET_BLOCK_TYPE_DHT_HELLO,
                            GNUNET_DHT_RO_FIND_PEER | GNUNET_DHT_RO_RECORD_ROUTE,
                            FIND_PEER_REPLICATION_LEVEL,
                            0,
                            &my_identity_hash,
                            NULL,
                            0,
                            bg,
                            peer_bf);
  GNUNET_CONTAINER_bloomfilter_free(peer_bf);
  GNUNET_BLOCK_group_destroy(bg);
  /* schedule next round */
  next_send_time.rel_value_us =
    DHT_MINIMUM_FIND_PEER_INTERVAL.rel_value_us +
    GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK,
                             DHT_MAXIMUM_FIND_PEER_INTERVAL.rel_value_us /
                             (newly_found_peers + 1));
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

handle_core_connect()

static void* handle_core_connect ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_MQ_Handle *  mq  )

static

Method called whenever a peer connects.

Parameters

cls	closure
peer	peer identity this notification is about
mq	message queue for sending messages to peer

Returns

our struct PeerInfo for peer

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

References bucket_size, closest_bucket, disable_try_connect, find_bucket(), GDS_stats, gettext_noop, GNUNET_assert, 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_SCHEDULER_add_now(), GNUNET_STATISTICS_update(), GNUNET_YES, PeerBucket::head, PeerInfo::id, k_buckets, MAX_BUCKETS, mq, PeerInfo::mq, my_identity, newly_found_peers, peer, PeerInfo::peer_bucket, PeerBucket::peers_size, PeerInfo::phash, pi, send_find_peer_message(), PeerBucket::tail, and update_connect_preferences().

Referenced by GDS_NEIGHBOURS_init().

{
  struct PeerInfo *pi;

  (void)cls;
  /* Check for connect to self message */
  if (0 == GNUNET_memcmp(&my_identity,
                         peer))
    return NULL;
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Connected to %s\n",
             GNUNET_i2s(peer));
  GNUNET_assert(GNUNET_NO ==
                GNUNET_CONTAINER_multipeermap_get(all_connected_peers,
                                                  peer));
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# peers connected"),
                           1,
                           GNUNET_NO);
  pi = GNUNET_new(struct PeerInfo);
  pi->id = peer;
  pi->mq = mq;
  GNUNET_CRYPTO_hash(peer,
                     sizeof(struct GNUNET_PeerIdentity),
                     &pi->phash);
  pi->peer_bucket = find_bucket(&pi->phash);
  GNUNET_assert((pi->peer_bucket >= 0) &&
                ((unsigned int)pi->peer_bucket < MAX_BUCKETS));
  GNUNET_CONTAINER_DLL_insert_tail(k_buckets[pi->peer_bucket].head,
                                   k_buckets[pi->peer_bucket].tail,
                                   pi);
  k_buckets[pi->peer_bucket].peers_size++;
  closest_bucket = GNUNET_MAX(closest_bucket,
                              (unsigned int)pi->peer_bucket);
  GNUNET_assert(GNUNET_OK ==
                GNUNET_CONTAINER_multipeermap_put(all_connected_peers,
                                                  pi->id,
                                                  pi,
                                                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  if ((pi->peer_bucket > 0) &&
      (k_buckets[pi->peer_bucket].peers_size <= bucket_size))
    {
      update_connect_preferences();
      newly_found_peers++;
    }
  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);
    }
  return pi;
}

Here is the call graph for this function:

Here is the caller graph for this function:

handle_core_disconnect()

static void handle_core_disconnect ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  internal_cls  )

static

Method called whenever a peer disconnects.

Parameters

cls	closure
peer	peer identity this notification is about
internal_cls	our struct PeerInfo for peer

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

References bucket_size, closest_bucket, disable_try_connect, GDS_stats, gettext_noop, 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, k_buckets, PeerInfo::peer_bucket, PeerBucket::peers_size, PeerBucket::tail, and update_connect_preferences().

Referenced by GDS_NEIGHBOURS_init().

{
  struct PeerInfo *to_remove = internal_cls;

  (void)cls;
  /* Check for disconnect from self message */
  if (NULL == to_remove)
    return;
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Disconnected %s\n",
             GNUNET_i2s(peer));
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# peers connected"),
                           -1,
                           GNUNET_NO);
  GNUNET_assert(GNUNET_YES ==
                GNUNET_CONTAINER_multipeermap_remove(all_connected_peers,
                                                     peer,
                                                     to_remove));
  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(to_remove->peer_bucket >= 0);
  GNUNET_CONTAINER_DLL_remove(k_buckets[to_remove->peer_bucket].head,
                              k_buckets[to_remove->peer_bucket].tail,
                              to_remove);
  GNUNET_assert(k_buckets[to_remove->peer_bucket].peers_size > 0);
  k_buckets[to_remove->peer_bucket].peers_size--;
  while ((closest_bucket > 0) &&
         (0 == k_buckets[to_remove->peer_bucket].peers_size))
    closest_bucket--;
  if (k_buckets[to_remove->peer_bucket].peers_size < bucket_size)
    update_connect_preferences();
  GNUNET_free(to_remove);
}

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 ( uint32_t  hop_count, uint32_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 829 of file gnunet-service-dht_neighbours.c.

References GDS_NSE_get(), GDS_stats, gettext_noop, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_MIN, GNUNET_NO, GNUNET_STATISTICS_update(), PeerPutMessage::hop_count, and MAXIMUM_REPLICATION_LEVEL.

Referenced by get_target_peers().

{
  uint32_t random_value;
  uint32_t forward_count;
  float target_value;

  if (hop_count > GDS_NSE_get() * 4.0)
    {
      /* forcefully terminate */
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop("# requests TTL-dropped"),
                               1, GNUNET_NO);
      return 0;
    }
  if (hop_count > GDS_NSE_get() * 2.0)
    {
      /* Once we have reached our ideal number of hops, only forward to 1 peer */
      return 1;
    }
  /* bound by system-wide maximum */
  target_replication =
    GNUNET_MIN(MAXIMUM_REPLICATION_LEVEL, target_replication);
  target_value =
    1 + (target_replication - 1.0) / (GDS_NSE_get() +
                                      ((float)(target_replication - 1.0) *
                                       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(GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX);
  if (random_value < (target_value * UINT32_MAX))
    forward_count++;
  return forward_count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_distance()

static unsigned int get_distance ( const struct GNUNET_HashCode *  target, const struct GNUNET_HashCode *  have  )

static

Compute the distance between have and target as a 32-bit value.

Differences in the lower bits must count stronger than differences in the higher bits.

Parameters

target
have

Returns

0 if have==target, otherwise a number that is larger as the distance between the two hash codes increases

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

References GNUNET_CRYPTO_hash_get_bit(), and GNUNET_CRYPTO_hash_matching_bits().

Referenced by select_peer().

{
  unsigned int bucket;
  unsigned int msb;
  unsigned int lsb;
  unsigned int i;

  /* We have to represent the distance between two 2^9 (=512)-bit
   * numbers as a 2^5 (=32)-bit number with "0" being used for the
   * two numbers being identical; furthermore, we need to
   * guarantee that a difference in the number of matching
   * bits is always represented in the result.
   *
   * We use 2^32/2^9 numerical values to distinguish between
   * hash codes that have the same LSB bit distance and
   * use the highest 2^9 bits of the result to signify the
   * number of (mis)matching LSB bits; if we have 0 matching
   * and hence 512 mismatching LSB bits we return -1 (since
   * 512 itself cannot be represented with 9 bits) */

  /* first, calculate the most significant 9 bits of our
   * result, aka the number of LSBs */
  bucket = GNUNET_CRYPTO_hash_matching_bits(target,
                                            have);
  /* bucket is now a value between 0 and 512 */
  if (bucket == 512)
    return 0;                   /* perfect match */
  if (bucket == 0)
    return (unsigned int)-1;    /* LSB differs; use max (if we did the bit-shifting
                                 * below, we'd end up with max+1 (overflow)) */

  /* calculate the most significant bits of the final result */
  msb = (512 - bucket) << (32 - 9);
  /* calculate the 32-9 least significant bits of the final result by
   * looking at the differences in the 32-9 bits following the
   * mismatching bit at 'bucket' */
  lsb = 0;
  for (i = bucket + 1;
       (i < sizeof(struct GNUNET_HashCode) * 8) && (i < bucket + 1 + 32 - 9); i++)
    {
      if (GNUNET_CRYPTO_hash_get_bit(target, i) !=
          GNUNET_CRYPTO_hash_get_bit(have, i))
        lsb |= (1 << (bucket + 32 - 9 - i));    /* first bit set will be 10,
                                                 * last bit set will be 31 -- if
                                                 * i does not reach 512 first... */
    }
  return msb | lsb;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_am_closest_peer()

int 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 942 of file gnunet-service-dht_neighbours.c.

References GNUNET_HashCode::bits, find_bucket(), GNUNET_assert, GNUNET_CONTAINER_bloomfilter_test(), GNUNET_CRYPTO_hash_matching_bits(), GNUNET_memcmp, GNUNET_NO, GNUNET_YES, PeerBucket::head, k_buckets, my_identity_hash, PeerInfo::next, and PeerInfo::phash.

Referenced by handle_dht_p2p_get(), and handle_dht_p2p_put().

{
  int bits;
  int other_bits;
  int bucket_num;
  struct PeerInfo *pos;

  if (0 == GNUNET_memcmp(&my_identity_hash,
                         key))
    return GNUNET_YES;
  bucket_num = find_bucket(key);
  GNUNET_assert(bucket_num >= 0);
  bits = GNUNET_CRYPTO_hash_matching_bits(&my_identity_hash,
                                          key);
  pos = k_buckets[bucket_num].head;
  while (NULL != pos)
    {
      if ((NULL != bloom) &&
          (GNUNET_YES ==
           GNUNET_CONTAINER_bloomfilter_test(bloom,
                                             &pos->phash)))
        {
          pos = pos->next;
          continue;             /* Skip already checked entries */
        }
      other_bits = GNUNET_CRYPTO_hash_matching_bits(&pos->phash,
                                                    key);
      if (other_bits > bits)
        return GNUNET_NO;
      if (other_bits == bits)   /* We match the same number of bits */
        return GNUNET_YES;
      pos = pos->next;
    }
  /* No peers closer, we are the closest! */
  return GNUNET_YES;
}

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 blocked peers.

Note that we should not ALWAYS select the closest peer to the target, peers further away from the target should be chosen with exponentially declining probability.

FIXME: double-check that this is fine

Parameters

key	the key we are selecting a peer to route to
bloom	a bloomfilter 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 999 of file gnunet-service-dht_neighbours.c.

References bucket_size, closest_bucket, GDS_NSE_get(), GDS_stats, get_distance(), gettext_noop, GNUNET_break, GNUNET_CONTAINER_bloomfilter_test(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, head, PeerBucket::head, PeerInfo::id, k_buckets, PeerInfo::next, and PeerInfo::phash.

Referenced by get_target_peers().

{
  unsigned int bc;
  unsigned int count;
  unsigned int selected;
  struct PeerInfo *pos;
  unsigned int dist;
  unsigned int smallest_distance;
  struct PeerInfo *chosen;

  if (hops >= GDS_NSE_get())
    {
      /* greedy selection (closest peer that is not in bloomfilter) */
      smallest_distance = UINT_MAX;
      chosen = NULL;
      for (bc = 0; bc <= closest_bucket; bc++)
        {
          pos = k_buckets[bc].head;
          count = 0;
          while ((pos != NULL) && (count < bucket_size))
            {
              if ((NULL == bloom) ||
                  (GNUNET_NO ==
                   GNUNET_CONTAINER_bloomfilter_test(bloom,
                                                     &pos->phash)))
                {
                  dist = get_distance(key,
                                      &pos->phash);
                  if (dist < smallest_distance)
                    {
                      chosen = pos;
                      smallest_distance = dist;
                    }
                }
              else
                {
                  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));
                  GNUNET_STATISTICS_update(GDS_stats,
                                           gettext_noop("# Peers excluded from routing due to Bloomfilter"),
                                           1,
                                           GNUNET_NO);
                  dist = get_distance(key,
                                      &pos->phash);
                  if (dist < smallest_distance)
                    {
                      chosen = NULL;
                      smallest_distance = dist;
                    }
                }
              count++;
              pos = pos->next;
            }
        }
      if (NULL == chosen)
        GNUNET_STATISTICS_update(GDS_stats,
                                 gettext_noop("# Peer selection failed"),
                                 1,
                                 GNUNET_NO);
      else
        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
                   "Selected peer `%s' in greedy routing for %s\n",
                   GNUNET_i2s(chosen->id),
                   GNUNET_h2s(key));
      return chosen;
    }

  /* select "random" peer */
  /* count number of peers that are available and not filtered */
  count = 0;
  for (bc = 0; bc <= closest_bucket; bc++)
    {
      pos = k_buckets[bc].head;
      while ((NULL != pos) && (count < bucket_size))
        {
          if ((NULL != bloom) &&
              (GNUNET_YES ==
               GNUNET_CONTAINER_bloomfilter_test(bloom,
                                                 &pos->phash)))
            {
              GNUNET_STATISTICS_update(GDS_stats,
                                       gettext_noop
                                         ("# Peers excluded from routing due to Bloomfilter"),
                                       1, GNUNET_NO);
              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));
              pos = pos->next;
              continue;         /* Ignore bloomfiltered peers */
            }
          count++;
          pos = pos->next;
        }
    }
  if (0 == count)               /* No peers to select from! */
    {
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop("# Peer selection failed"), 1,
                               GNUNET_NO);
      return NULL;
    }
  /* Now actually choose a peer */
  selected = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
                                      count);
  count = 0;
  for (bc = 0; bc <= closest_bucket; bc++)
    {
      for (pos = k_buckets[bc].head; ((pos != NULL) && (count < bucket_size)); pos = pos->next)
        {
          if ((bloom != NULL) &&
              (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;
            }
        }
    }
  GNUNET_break(0);
  return NULL;
}

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, uint32_t  hop_count, uint32_t  target_replication, struct PeerInfo ***  targets  )

static

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

Parameters

key	routing key
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
targets	where to store an array of target peers (to be free'd by the caller)

Returns

number of peers returned in 'targets'.

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

References 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, PeerInfo::phash, ret, and select_peer().

Referenced by GDS_NEIGHBOURS_handle_get(), and GDS_NEIGHBOURS_handle_put().

{
  unsigned int ret;
  unsigned int off;
  struct PeerInfo **rtargets;
  struct PeerInfo *nxt;

  GNUNET_assert(NULL != bloom);
  ret = get_forward_count(hop_count,
                          target_replication);
  if (0 == ret)
    {
      *targets = NULL;
      return 0;
    }
  rtargets = GNUNET_new_array(ret,
                              struct PeerInfo *);
  for (off = 0; off < ret; off++)
    {
      nxt = select_peer(key,
                        bloom,
                        hop_count);
      if (NULL == nxt)
        break;
      rtargets[off] = nxt;
      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),
             ret);
  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,
             ret);
  return off;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_NEIGHBOURS_handle_put()

int GDS_NEIGHBOURS_handle_put	(	enum GNUNET_BLOCK_Type	type,
		enum GNUNET_DHT_RouteOption	options,
		uint32_t	desired_replication_level,
		struct GNUNET_TIME_Absolute	expiration_time,
		uint32_t	hop_count,
		struct GNUNET_CONTAINER_BloomFilter *	bf,
		const struct GNUNET_HashCode *	key,
		unsigned int	put_path_length,
		struct GNUNET_PeerIdentity *	put_path,
		const void *	data,
		size_t	data_size
	)

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

type	type of the block
options	routing options
desired_replication_level	desired replication count
expiration_time	when does the content expire
hop_count	how many hops has this message traversed so far
bf	Bloom filter of peers this PUT has already traversed
key	key for the content
put_path_length	number of entries in put_path
put_path	peers this request has traversed so far (if tracked)
data	payload to store
data_size	number of bytes in data

Returns

GNUNET_OK if the request was forwarded, GNUNET_NO if not

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

References PeerPutMessage::bloomfilter, data_size, PeerPutMessage::desired_replication_level, DHT_BLOOM_SIZE, env, PeerPutMessage::expiration_time, GDS_stats, get_target_peers(), gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE, GNUNET_CONTAINER_bloomfilter_add(), GNUNET_CONTAINER_bloomfilter_get_raw_data(), GNUNET_CONTAINER_bloomfilter_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_P2P_PUT, GNUNET_MQ_get_length(), GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_hton(), GNUNET_YES, PeerPutMessage::hop_count, PeerInfo::id, PeerPutMessage::key, MAXIMUM_PENDING_PER_PEER, PeerInfo::mq, my_identity, my_identity_hash, PeerPutMessage::options, PeerInfo::phash, PeerPutMessage::put_path_length, and PeerPutMessage::type.

Referenced by handle_dht_local_put(), and handle_dht_p2p_put().

{
  unsigned int target_count;
  unsigned int i;
  struct PeerInfo **targets;
  struct PeerInfo *target;
  size_t msize;
  struct GNUNET_MQ_Envelope *env;
  struct PeerPutMessage *ppm;
  struct GNUNET_PeerIdentity *pp;
  unsigned int skip_count;

  GNUNET_assert(NULL != bf);
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Adding myself (%s) to PUT bloomfilter for %s\n",
             GNUNET_i2s(&my_identity),
             GNUNET_h2s(key));
  GNUNET_CONTAINER_bloomfilter_add(bf,
                                   &my_identity_hash);
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# PUT requests routed"),
                           1,
                           GNUNET_NO);
  target_count
    = get_target_peers(key,
                       bf,
                       hop_count,
                       desired_replication_level,
                       &targets);
  if (0 == target_count)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
                 "Routing PUT for %s terminates after %u hops at %s\n",
                 GNUNET_h2s(key),
                 (unsigned int)hop_count,
                 GNUNET_i2s(&my_identity));
      return GNUNET_NO;
    }
  msize = put_path_length * sizeof(struct GNUNET_PeerIdentity) + data_size;
  if (msize + sizeof(struct PeerPutMessage)
      >= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
    {
      put_path_length = 0;
      msize = data_size;
    }
  if (msize + sizeof(struct PeerPutMessage)
      >= GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE)
    {
      GNUNET_break(0);
      GNUNET_free(targets);
      return GNUNET_NO;
    }
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# PUT messages queued for transmission"),
                           target_count,
                           GNUNET_NO);
  skip_count = 0;
  for (i = 0; i < target_count; i++)
    {
      target = targets[i];
      if (GNUNET_MQ_get_length(target->mq) >= MAXIMUM_PENDING_PER_PEER)
        {
          /* skip */
          GNUNET_STATISTICS_update(GDS_stats,
                                   gettext_noop("# P2P messages dropped due to full queue"),
                                   1,
                                   GNUNET_NO);
          skip_count++;
          continue;
        }
      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
                 "Routing PUT for %s after %u hops to %s\n",
                 GNUNET_h2s(key),
                 (unsigned int)hop_count,
                 GNUNET_i2s(target->id));
      env = GNUNET_MQ_msg_extra(ppm,
                                msize,
                                GNUNET_MESSAGE_TYPE_DHT_P2P_PUT);
      ppm->options = htonl(options);
      ppm->type = htonl(type);
      ppm->hop_count = htonl(hop_count + 1);
      ppm->desired_replication_level = htonl(desired_replication_level);
      ppm->put_path_length = htonl(put_path_length);
      ppm->expiration_time = GNUNET_TIME_absolute_hton(expiration_time);
      GNUNET_break(GNUNET_YES ==
                   GNUNET_CONTAINER_bloomfilter_test(bf,
                                                     &target->phash));
      GNUNET_assert(GNUNET_OK ==
                    GNUNET_CONTAINER_bloomfilter_get_raw_data(bf,
                                                              ppm->bloomfilter,
                                                              DHT_BLOOM_SIZE));
      ppm->key = *key;
      pp = (struct GNUNET_PeerIdentity *)&ppm[1];
      GNUNET_memcpy(pp,
                    put_path,
                    sizeof(struct GNUNET_PeerIdentity) * put_path_length);
      GNUNET_memcpy(&pp[put_path_length],
                    data,
                    data_size);
      GNUNET_MQ_send(target->mq,
                     env);
    }
  GNUNET_free(targets);
  return (skip_count < target_count) ? GNUNET_OK : GNUNET_NO;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_NEIGHBOURS_handle_get()

int GDS_NEIGHBOURS_handle_get	(	enum GNUNET_BLOCK_Type	type,
		enum GNUNET_DHT_RouteOption	options,
		uint32_t	desired_replication_level,
		uint32_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	group to use for filtering replies
peer_bf	filter for peers not to select (again)

Returns

GNUNET_OK if the request was forwarded, GNUNET_NO if not

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

References PeerGetMessage::bf_mutator, PeerGetMessage::bloomfilter, PeerGetMessage::desired_replication_level, DHT_BLOOM_SIZE, env, GDS_stats, get_target_peers(), gettext_noop, GNUNET_assert, GNUNET_BLOCK_group_serialize(), GNUNET_break, GNUNET_CONTAINER_bloomfilter_add(), GNUNET_CONTAINER_bloomfilter_get_raw_data(), GNUNET_CONTAINER_bloomfilter_test(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_free_non_null, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_P2P_GET, GNUNET_MQ_get_length(), GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_YES, PeerGetMessage::hop_count, PeerInfo::id, PeerPutMessage::key, PeerGetMessage::key, MAXIMUM_PENDING_PER_PEER, PeerInfo::mq, my_identity, my_identity_hash, PeerGetMessage::options, PeerInfo::phash, PeerGetMessage::type, and PeerGetMessage::xquery_size.

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

{
  unsigned int target_count;
  struct PeerInfo **targets;
  struct PeerInfo *target;
  struct GNUNET_MQ_Envelope *env;
  size_t msize;
  struct PeerGetMessage *pgm;
  char *xq;
  size_t reply_bf_size;
  void *reply_bf;
  unsigned int skip_count;
  uint32_t bf_nonce;

  GNUNET_assert(NULL != peer_bf);
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# 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\n",
             GNUNET_i2s(&my_identity),
             GNUNET_h2s(key));
  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,
                                   &bf_nonce,
                                   &reply_bf,
                                   &reply_bf_size))
    {
      reply_bf = NULL;
      reply_bf_size = 0;
      bf_nonce = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
                                          UINT32_MAX);
    }
  msize = xquery_size + reply_bf_size;
  if (msize + sizeof(struct PeerGetMessage) >= GNUNET_MAX_MESSAGE_SIZE)
    {
      GNUNET_break(0);
      GNUNET_free_non_null(reply_bf);
      GNUNET_free(targets);
      return GNUNET_NO;
    }
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# GET messages queued for transmission"),
                           target_count,
                           GNUNET_NO);
  /* forward request */
  skip_count = 0;
  for (unsigned int i = 0; i < target_count; i++)
    {
      target = targets[i];
      if (GNUNET_MQ_get_length(target->mq) >= MAXIMUM_PENDING_PER_PEER)
        {
          /* skip */
          GNUNET_STATISTICS_update(GDS_stats,
                                   gettext_noop("# P2P messages dropped due to full queue"),
                                   1, GNUNET_NO);
          skip_count++;
          continue;
        }
      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));
      env = GNUNET_MQ_msg_extra(pgm,
                                msize,
                                GNUNET_MESSAGE_TYPE_DHT_P2P_GET);
      pgm->options = htonl(options);
      pgm->type = htonl(type);
      pgm->hop_count = htonl(hop_count + 1);
      pgm->desired_replication_level = htonl(desired_replication_level);
      pgm->xquery_size = htonl(xquery_size);
      pgm->bf_mutator = bf_nonce;
      GNUNET_break(GNUNET_YES ==
                   GNUNET_CONTAINER_bloomfilter_test(peer_bf,
                                                     &target->phash));
      GNUNET_assert(GNUNET_OK ==
                    GNUNET_CONTAINER_bloomfilter_get_raw_data(peer_bf,
                                                              pgm->bloomfilter,
                                                              DHT_BLOOM_SIZE));
      pgm->key = *key;
      xq = (char *)&pgm[1];
      GNUNET_memcpy(xq,
                    xquery,
                    xquery_size);
      GNUNET_memcpy(&xq[xquery_size],
                    reply_bf,
                    reply_bf_size);
      GNUNET_MQ_send(target->mq,
                     env);
    }
  GNUNET_free(targets);
  GNUNET_free_non_null(reply_bf);
  return (skip_count < target_count) ? GNUNET_OK : GNUNET_NO;
}

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	(	const struct GNUNET_PeerIdentity *	target,
		enum GNUNET_BLOCK_Type	type,
		struct GNUNET_TIME_Absolute	expiration_time,
		const struct GNUNET_HashCode *	key,
		unsigned int	put_path_length,
		const struct GNUNET_PeerIdentity *	put_path,
		unsigned int	get_path_length,
		const struct GNUNET_PeerIdentity *	get_path,
		const void *	data,
		size_t	data_size
	)

Handle a reply (route to origin).

Only forwards the reply back to the given peer. Does not do local caching or forwarding to local clients.

Parameters

target	neighbour that should receive the block (if still connected)
type	type of the block
expiration_time	when does the content expire
key	key for the content
put_path_length	number of entries in put_path
put_path	peers the original PUT traversed (if tracked)
get_path_length	number of entries in get_path
get_path	peers this reply has traversed so far (if tracked)
data	payload of the reply
data_size	number of bytes in data

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

References env, PeerResultMessage::expiration_time, GDS_stats, PeerResultMessage::get_path_length, gettext_noop, GNUNET_break, GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT, GNUNET_MQ_get_length(), GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_hton(), PeerPutMessage::key, PeerResultMessage::key, MAXIMUM_PENDING_PER_PEER, PeerInfo::mq, pi, PeerPutMessage::put_path_length, PeerResultMessage::put_path_length, and PeerResultMessage::type.

Referenced by handle_find_peer(), handle_local_result(), and process().

{
  struct PeerInfo *pi;
  struct GNUNET_MQ_Envelope *env;
  size_t msize;
  struct PeerResultMessage *prm;
  struct GNUNET_PeerIdentity *paths;

  msize = data_size + (get_path_length + put_path_length) *
          sizeof(struct GNUNET_PeerIdentity);
  if ((msize + sizeof(struct PeerResultMessage) >= GNUNET_MAX_MESSAGE_SIZE) ||
      (get_path_length >
       GNUNET_MAX_MESSAGE_SIZE / sizeof(struct GNUNET_PeerIdentity)) ||
      (put_path_length >
       GNUNET_MAX_MESSAGE_SIZE / sizeof(struct GNUNET_PeerIdentity)) ||
      (data_size > GNUNET_MAX_MESSAGE_SIZE))
    {
      GNUNET_break(0);
      return;
    }
  pi = GNUNET_CONTAINER_multipeermap_get(all_connected_peers,
                                         target);
  if (NULL == pi)
    {
      /* peer disconnected in the meantime, drop reply */
      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
                 "No matching peer for reply for key %s\n",
                 GNUNET_h2s(key));
      return;
    }
  if (GNUNET_MQ_get_length(pi->mq) >= MAXIMUM_PENDING_PER_PEER)
    {
      /* skip */
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop("# P2P messages dropped due to full queue"),
                               1,
                               GNUNET_NO);
      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
                 "Peer queue full, ignoring reply for key %s\n",
                 GNUNET_h2s(key));
      return;
    }

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Forwarding reply for key %s to peer %s\n",
             GNUNET_h2s(key),
             GNUNET_i2s(target));
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop
                             ("# RESULT messages queued for transmission"), 1,
                           GNUNET_NO);
  env = GNUNET_MQ_msg_extra(prm,
                            msize,
                            GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT);
  prm->type = htonl(type);
  prm->put_path_length = htonl(put_path_length);
  prm->get_path_length = htonl(get_path_length);
  prm->expiration_time = GNUNET_TIME_absolute_hton(expiration_time);
  prm->key = *key;
  paths = (struct GNUNET_PeerIdentity *)&prm[1];
  GNUNET_memcpy(paths,
                put_path,
                put_path_length * sizeof(struct GNUNET_PeerIdentity));
  GNUNET_memcpy(&paths[put_path_length],
                get_path,
                get_path_length * sizeof(struct GNUNET_PeerIdentity));
  GNUNET_memcpy(&paths[put_path_length + get_path_length],
                data,
                data_size);
  GNUNET_MQ_send(pi->mq,
                 env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

core_init()

static void core_init ( void *  cls, const struct GNUNET_PeerIdentity *  identity  )

static

To be called on core init/fail.

Parameters

cls	service closure
identity	the public identity of this peer

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

References GDS_service, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_SERVICE_resume(), identity, my_identity, and my_identity_hash.

Referenced by GDS_NEIGHBOURS_init().

{
  (void)cls;
  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
             "CORE called, I am %s\n",
             GNUNET_i2s(identity));
  my_identity = *identity;
  GNUNET_CRYPTO_hash(identity,
                     sizeof(struct GNUNET_PeerIdentity),
                     &my_identity_hash);
  GNUNET_SERVICE_resume(GDS_service);
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_dht_p2p_put()

static int 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
message	message

Returns

GNUNET_OK if the message is valid

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

References GNUNET_break_op, GNUNET_MAX_MESSAGE_SIZE, GNUNET_OK, GNUNET_SYSERR, PeerPutMessage::header, PeerPutMessage::put_path_length, and GNUNET_MessageHeader::size.

{
  uint32_t putlen;
  uint16_t msize;

  (void)cls;
  msize = ntohs(put->header.size);
  putlen = ntohl(put->put_path_length);
  if ((msize <
       sizeof(struct PeerPutMessage) +
       putlen * sizeof(struct GNUNET_PeerIdentity)) ||
      (putlen >
       GNUNET_MAX_MESSAGE_SIZE / sizeof(struct GNUNET_PeerIdentity)))
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

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 PeerInfo of the sender
message	message

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

References PeerPutMessage::bloomfilter, PeerPutMessage::desired_replication_level, DHT_BLOOM_SIZE, PeerPutMessage::expiration_time, GDS_am_closest_peer(), GDS_block_context, GDS_CLIENTS_handle_reply(), GDS_CLIENTS_process_put(), GDS_DATACACHE_handle_put(), GDS_NEIGHBOURS_handle_put(), GDS_stats, gettext_noop, GNUNET_BLOCK_EO_NONE, GNUNET_BLOCK_evaluate(), GNUNET_BLOCK_EVALUATION_OK_DUPLICATE, GNUNET_BLOCK_EVALUATION_OK_LAST, GNUNET_BLOCK_EVALUATION_OK_MORE, GNUNET_BLOCK_EVALUATION_REQUEST_INVALID, GNUNET_BLOCK_EVALUATION_REQUEST_VALID, GNUNET_BLOCK_EVALUATION_RESULT_INVALID, GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT, GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED, GNUNET_BLOCK_get_key(), GNUNET_BLOCK_TYPE_REGEX, GNUNET_break, GNUNET_break_op, GNUNET_CONSTANTS_BLOOMFILTER_K, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_CONTAINER_bloomfilter_test(), GNUNET_CRYPTO_hash_matching_bits(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_DHT_RO_LAST_HOP, GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_h2s(), GNUNET_h2s_full(), GNUNET_i2s(), GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_strdup, GNUNET_STRINGS_pp2s(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_ntoh(), GNUNET_YES, PeerPutMessage::header, PeerPutMessage::hop_count, PeerInfo::id, PeerPutMessage::key, log_route_details_stderr, LOG_TRAFFIC, my_identity, my_identity_hash, PeerPutMessage::options, payload, peer, PeerInfo::phash, PeerPutMessage::put_path_length, GNUNET_MessageHeader::size, and PeerPutMessage::type.

{
  struct PeerInfo *peer = cls;
  const struct GNUNET_PeerIdentity *put_path;
  const void *payload;
  uint32_t putlen;
  uint16_t msize;
  size_t payload_size;
  enum GNUNET_DHT_RouteOption options;
  struct GNUNET_CONTAINER_BloomFilter *bf;
  struct GNUNET_HashCode test_key;
  int forwarded;
  struct GNUNET_TIME_Absolute exp_time;

  exp_time = GNUNET_TIME_absolute_ntoh(put->expiration_time);
  if (0 == GNUNET_TIME_absolute_get_remaining(exp_time).rel_value_us)
    {
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop("# Expired PUTs discarded"),
                               1,
                               GNUNET_NO);
      return;
    }
  msize = ntohs(put->header.size);
  putlen = ntohl(put->put_path_length);
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# P2P PUT requests received"),
                           1,
                           GNUNET_NO);
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# P2P PUT bytes received"),
                           msize,
                           GNUNET_NO);
  put_path = (const struct GNUNET_PeerIdentity *)&put[1];
  payload = &put_path[putlen];
  options = ntohl(put->options);
  payload_size = msize - (sizeof(struct PeerPutMessage) +
                          putlen * sizeof(struct GNUNET_PeerIdentity));

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "PUT for `%s' from %s\n",
             GNUNET_h2s(&put->key),
             GNUNET_i2s(peer->id));
  if (GNUNET_YES == log_route_details_stderr)
    {
      char *tmp;
      char *pp;

      pp = GNUNET_STRINGS_pp2s(put_path,
                               putlen);
      tmp = GNUNET_strdup(GNUNET_i2s(&my_identity));
      LOG_TRAFFIC(GNUNET_ERROR_TYPE_DEBUG,
                  "R5N PUT %s: %s->%s (%u, %u=>%u, PP: %s)\n",
                  GNUNET_h2s(&put->key),
                  GNUNET_i2s(peer->id),
                  tmp,
                  ntohl(put->hop_count),
                  GNUNET_CRYPTO_hash_matching_bits(&peer->phash,
                                                   &put->key),
                  GNUNET_CRYPTO_hash_matching_bits(&my_identity_hash,
                                                   &put->key),
                  pp);
      GNUNET_free(pp);
      GNUNET_free(tmp);
    }
  switch (GNUNET_BLOCK_get_key
            (GDS_block_context,
            ntohl(put->type),
            payload,
            payload_size,
            &test_key))
    {
    case GNUNET_YES:
      if (0 != memcmp(&test_key,
                      &put->key,
                      sizeof(struct GNUNET_HashCode)))
        {
          char *put_s = GNUNET_strdup(GNUNET_h2s_full(&put->key));

          GNUNET_break_op(0);
          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                     "PUT with key `%s' for block with key %s\n",
                     put_s,
                     GNUNET_h2s_full(&test_key));
          GNUNET_free(put_s);
          return;
        }
      break;

    case GNUNET_NO:
      GNUNET_break_op(0);
      return;

    case GNUNET_SYSERR:
      /* cannot verify, good luck */
      break;
    }
  if (ntohl(put->type) == GNUNET_BLOCK_TYPE_REGEX)  /* FIXME: do for all tpyes */
    {
      switch (GNUNET_BLOCK_evaluate(GDS_block_context,
                                    ntohl(put->type),
                                    NULL, /* query group */
                                    GNUNET_BLOCK_EO_NONE,
                                    NULL,   /* query */
                                    NULL, 0, /* xquery */
                                    payload,
                                    payload_size))
        {
        case GNUNET_BLOCK_EVALUATION_OK_MORE:
        case GNUNET_BLOCK_EVALUATION_OK_LAST:
          break;

        case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE:
        case GNUNET_BLOCK_EVALUATION_RESULT_INVALID:
        case GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT:
        case GNUNET_BLOCK_EVALUATION_REQUEST_VALID:
        case GNUNET_BLOCK_EVALUATION_REQUEST_INVALID:
        case GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED:
        default:
          GNUNET_break_op(0);
          return;
        }
    }

  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));
  {
    struct GNUNET_PeerIdentity pp[putlen + 1];

    /* extend 'put path' by sender */
    if (0 != (options & GNUNET_DHT_RO_RECORD_ROUTE))
      {
#if SANITY_CHECKS
        for (unsigned int i = 0; i <= putlen; i++)
          {
            for (unsigned int j = 0; j < i; j++)
              {
                GNUNET_break(0 != memcmp(&pp[i],
                                         &pp[j],
                                         sizeof(struct GNUNET_PeerIdentity)));
              }
            GNUNET_break(0 != memcmp(&pp[i],
                                     peer->id,
                                     sizeof(struct GNUNET_PeerIdentity)));
          }
#endif
        GNUNET_memcpy(pp,
                      put_path,
                      putlen * sizeof(struct GNUNET_PeerIdentity));
        pp[putlen] = *peer->id;
        putlen++;
      }
    else
      putlen = 0;

    /* give to local clients */
    GDS_CLIENTS_handle_reply(exp_time,
                             &put->key,
                             0,
                             NULL,
                             putlen,
                             pp,
                             ntohl(put->type),
                             payload_size,
                             payload);
    /* store locally */
    if ((0 != (options & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE)) ||
        (GDS_am_closest_peer(&put->key, bf)))
      GDS_DATACACHE_handle_put(exp_time,
                               &put->key,
                               putlen,
                               pp,
                               ntohl(put->type),
                               payload_size,
                               payload);
    /* route to other peers */
    forwarded = GDS_NEIGHBOURS_handle_put(ntohl(put->type),
                                          options,
                                          ntohl(put->desired_replication_level),
                                          exp_time,
                                          ntohl(put->hop_count),
                                          bf,
                                          &put->key,
                                          putlen,
                                          pp,
                                          payload,
                                          payload_size);
    /* notify monitoring clients */
    GDS_CLIENTS_process_put(options
                            | ((GNUNET_OK == forwarded)
                               ? GNUNET_DHT_RO_LAST_HOP
                               : 0),
                            ntohl(put->type),
                            ntohl(put->hop_count),
                            ntohl(put->desired_replication_level),
                            putlen, pp,
                            exp_time,
                            &put->key,
                            payload,
                            payload_size);
  }
  GNUNET_CONTAINER_bloomfilter_free(bf);
}

Here is the call graph for this function:

handle_find_peer()

static void handle_find_peer ( const struct GNUNET_PeerIdentity *  sender, const struct GNUNET_HashCode *  key, struct GNUNET_BLOCK_Group *  bg  )

static

We have received a FIND PEER request.

Send matching HELLOs back.

Parameters

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

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

References closest_bucket, find_bucket(), GDS_block_context, GDS_HELLO_get(), GDS_my_hello, GDS_NEIGHBOURS_handle_reply(), GDS_stats, gettext_noop, GNUNET_assert, GNUNET_BLOCK_EO_LOCAL_SKIP_CRYPTO, GNUNET_BLOCK_evaluate(), GNUNET_BLOCK_EVALUATION_OK_MORE, GNUNET_BLOCK_TYPE_DHT_HELLO, GNUNET_break, GNUNET_CONSTANTS_HELLO_ADDRESS_EXPIRATION, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_HELLO_size(), GNUNET_MIN, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_relative_to_absolute(), PeerBucket::head, hello_expiration, PeerInfo::id, k_buckets, my_identity_hash, PeerInfo::next, peer, PeerBucket::peers_size, and PeerInfo::phash.

Referenced by handle_dht_p2p_get().

{
  int bucket_idx;
  struct PeerBucket *bucket;
  struct PeerInfo *peer;
  unsigned int choice;
  const struct GNUNET_HELLO_Message *hello;
  size_t hello_size;

  /* first, check about our own HELLO */
  if (NULL != GDS_my_hello)
    {
      hello_size = GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)GDS_my_hello);
      GNUNET_break(hello_size >= sizeof(struct GNUNET_MessageHeader));
      if (GNUNET_BLOCK_EVALUATION_OK_MORE ==
          GNUNET_BLOCK_evaluate(GDS_block_context,
                                GNUNET_BLOCK_TYPE_DHT_HELLO,
                                bg,
                                GNUNET_BLOCK_EO_LOCAL_SKIP_CRYPTO,
                                &my_identity_hash,
                                NULL, 0,
                                GDS_my_hello,
                                hello_size))
        {
          GDS_NEIGHBOURS_handle_reply(sender,
                                      GNUNET_BLOCK_TYPE_DHT_HELLO,
                                      GNUNET_TIME_relative_to_absolute(hello_expiration),
                                      key,
                                      0,
                                      NULL,
                                      0,
                                      NULL,
                                      GDS_my_hello,
                                      hello_size);
        }
      else
        {
          GNUNET_STATISTICS_update(GDS_stats,
                                   gettext_noop("# FIND PEER requests ignored due to Bloomfilter"),
                                   1,
                                   GNUNET_NO);
        }
    }
  else
    {
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop("# FIND PEER requests ignored due to lack of HELLO"),
                               1,
                               GNUNET_NO);
    }

  /* then, also consider sending a random HELLO from the closest bucket */
  if (0 == memcmp(&my_identity_hash,
                  key,
                  sizeof(struct GNUNET_HashCode)))
    bucket_idx = closest_bucket;
  else
    bucket_idx = GNUNET_MIN((int)closest_bucket,
                            find_bucket(key));
  if (bucket_idx < 0)
    return;
  bucket = &k_buckets[bucket_idx];
  if (bucket->peers_size == 0)
    return;
  choice = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
                                    bucket->peers_size);
  peer = bucket->head;
  while (choice > 0)
    {
      GNUNET_assert(NULL != peer);
      peer = peer->next;
      choice--;
    }
  choice = bucket->peers_size;
  do
    {
      peer = peer->next;
      if (0 == choice--)
        return;                 /* no non-masked peer available */
      if (NULL == peer)
        peer = bucket->head;
      hello = GDS_HELLO_get(peer->id);
    }
  while ((NULL == hello) ||
         (GNUNET_BLOCK_EVALUATION_OK_MORE !=
          GNUNET_BLOCK_evaluate(GDS_block_context,
                                GNUNET_BLOCK_TYPE_DHT_HELLO,
                                bg,
                                GNUNET_BLOCK_EO_LOCAL_SKIP_CRYPTO,
                                &peer->phash,
                                NULL, 0,
                                hello,
                                (hello_size = GNUNET_HELLO_size(hello)))));
  GDS_NEIGHBOURS_handle_reply(sender,
                              GNUNET_BLOCK_TYPE_DHT_HELLO,
                              GNUNET_TIME_relative_to_absolute
                                (GNUNET_CONSTANTS_HELLO_ADDRESS_EXPIRATION),
                              key,
                              0,
                              NULL,
                              0,
                              NULL,
                              hello,
                              hello_size);
}

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, enum GNUNET_BLOCK_Type  type, struct GNUNET_TIME_Absolute  expiration_time, const struct GNUNET_HashCode *  key, unsigned int  put_path_length, const struct GNUNET_PeerIdentity *  put_path, unsigned int  get_path_length, const struct GNUNET_PeerIdentity *  get_path, const void *  data, size_t  data_size  )

static

Handle a result from local datacache for a GET operation.

Parameters

cls	the struct PeerInfo for which this is a reply
type	type of the block
expiration_time	when does the content expire
key	key for the content
put_path_length	number of entries in put_path
put_path	peers the original PUT traversed (if tracked)
get_path_length	number of entries in get_path
get_path	peers this reply has traversed so far (if tracked)
data	payload of the reply
data_size	number of bytes in data

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

References GDS_NEIGHBOURS_handle_reply(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_STRINGS_pp2s(), PeerInfo::id, and peer.

Referenced by handle_dht_p2p_get().

{
  struct PeerInfo *peer = cls;
  char *pp;

  pp = GNUNET_STRINGS_pp2s(put_path,
                           put_path_length);
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Found local result for %s (PP: %s)\n",
             GNUNET_h2s(key),
             pp);
  GNUNET_free(pp);
  GDS_NEIGHBOURS_handle_reply(peer->id,
                              type,
                              expiration_time,
                              key,
                              put_path_length, put_path,
                              get_path_length, get_path,
                              data, data_size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_dht_p2p_get()

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

static

Check validity of p2p get request.

Parameters

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

Returns

GNUNET_OK if the message is well-formed

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

References GNUNET_break_op, GNUNET_OK, and GNUNET_SYSERR.

{
  uint32_t xquery_size;
  uint16_t msize;

  (void)cls;
  msize = ntohs(get->header.size);
  xquery_size = ntohl(get->xquery_size);
  if (msize < sizeof(struct PeerGetMessage) + xquery_size)
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

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 PeerInfo of the sender
get	the message

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

References DHT_BLOOM_SIZE, GDS_am_closest_peer(), GDS_block_context, GDS_CLIENTS_process_get(), GDS_DATACACHE_handle_get(), GDS_NEIGHBOURS_handle_get(), GDS_ROUTING_add(), GDS_stats, gettext_noop, GNUNET_BLOCK_EO_NONE, GNUNET_BLOCK_evaluate(), GNUNET_BLOCK_EVALUATION_OK_LAST, GNUNET_BLOCK_EVALUATION_REQUEST_VALID, GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED, GNUNET_BLOCK_group_create(), GNUNET_break_op, GNUNET_CONSTANTS_BLOOMFILTER_K, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_CONTAINER_bloomfilter_test(), GNUNET_CRYPTO_hash_matching_bits(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_DHT_RO_FIND_PEER, GNUNET_DHT_RO_LAST_HOP, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_strdup, GNUNET_YES, handle_find_peer(), handle_local_result(), PeerInfo::id, log_route_details_stderr, LOG_TRAFFIC, my_identity, my_identity_hash, PeerPutMessage::options, peer, PeerInfo::phash, and PeerPutMessage::type.

{
  struct PeerInfo *peer = cls;
  uint32_t xquery_size;
  size_t reply_bf_size;
  uint16_t msize;
  enum GNUNET_BLOCK_Type type;
  enum GNUNET_DHT_RouteOption options;
  enum GNUNET_BLOCK_EvaluationResult eval;
  struct GNUNET_BLOCK_Group *bg;
  struct GNUNET_CONTAINER_BloomFilter *peer_bf;
  const char *xquery;
  int forwarded;

  /* parse and validate message */
  msize = ntohs(get->header.size);
  xquery_size = ntohl(get->xquery_size);
  reply_bf_size = msize - (sizeof(struct PeerGetMessage) + xquery_size);
  type = ntohl(get->type);
  options = ntohl(get->options);
  xquery = (const char *)&get[1];
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# P2P GET requests received"),
                           1,
                           GNUNET_NO);
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# P2P GET bytes received"),
                           msize,
                           GNUNET_NO);
  if (GNUNET_YES == log_route_details_stderr)
    {
      char *tmp;

      tmp = GNUNET_strdup(GNUNET_i2s(&my_identity));
      LOG_TRAFFIC(GNUNET_ERROR_TYPE_DEBUG,
                  "R5N GET %s: %s->%s (%u, %u=>%u) xq: %.*s\n",
                  GNUNET_h2s(&get->key),
                  GNUNET_i2s(peer->id),
                  tmp,
                  ntohl(get->hop_count),
                  GNUNET_CRYPTO_hash_matching_bits(&peer->phash,
                                                   &get->key),
                  GNUNET_CRYPTO_hash_matching_bits(&my_identity_hash,
                                                   &get->key),
                  ntohl(get->xquery_size),
                  xquery);
      GNUNET_free(tmp);
    }
  eval
    = GNUNET_BLOCK_evaluate(GDS_block_context,
                            type,
                            NULL,
                            GNUNET_BLOCK_EO_NONE,
                            &get->key,
                            xquery,
                            xquery_size,
                            NULL,
                            0);
  if (eval != GNUNET_BLOCK_EVALUATION_REQUEST_VALID)
    {
      /* request invalid or block type not supported */
      GNUNET_break_op(eval == GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED);
      return;
    }
  peer_bf = GNUNET_CONTAINER_bloomfilter_init(get->bloomfilter,
                                              DHT_BLOOM_SIZE,
                                              GNUNET_CONSTANTS_BLOOMFILTER_K);
  GNUNET_break_op(GNUNET_YES ==
                  GNUNET_CONTAINER_bloomfilter_test(peer_bf,
                                                    &peer->phash));
  bg = GNUNET_BLOCK_group_create(GDS_block_context,
                                 type,
                                 get->bf_mutator,
                                 &xquery[xquery_size],
                                 reply_bf_size,
                                 "filter-size",
                                 reply_bf_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)ntohl(get->hop_count));
  /* local lookup (this may update the reply_bf) */
  if ((0 != (options & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE)) ||
      (GDS_am_closest_peer(&get->key,
                           peer_bf)))
    {
      if ((0 != (options & GNUNET_DHT_RO_FIND_PEER)))
        {
          GNUNET_STATISTICS_update(GDS_stats,
                                   gettext_noop("# P2P FIND PEER requests processed"),
                                   1,
                                   GNUNET_NO);
          handle_find_peer(peer->id,
                           &get->key,
                           bg);
        }
      else
        {
          eval = GDS_DATACACHE_handle_get(&get->key,
                                          type,
                                          xquery,
                                          xquery_size,
                                          bg,
                                          &handle_local_result,
                                          peer);
        }
    }
  else
    {
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop("# P2P GET requests ONLY routed"),
                               1,
                               GNUNET_NO);
    }

  /* remember request for routing replies */
  GDS_ROUTING_add(peer->id,
                  type,
                  bg,       /* bg now owned by routing, but valid at least until end of this function! */
                  options,
                  &get->key,
                  xquery,
                  xquery_size);

  /* P2P forwarding */
  forwarded = GNUNET_NO;
  if (eval != GNUNET_BLOCK_EVALUATION_OK_LAST)
    forwarded = GDS_NEIGHBOURS_handle_get(type,
                                          options,
                                          ntohl(get->desired_replication_level),
                                          ntohl(get->hop_count),
                                          &get->key,
                                          xquery,
                                          xquery_size,
                                          bg,
                                          peer_bf);
  GDS_CLIENTS_process_get(options
                          | (GNUNET_OK == forwarded)
                          ? GNUNET_DHT_RO_LAST_HOP : 0,
                          type,
                          ntohl(get->hop_count),
                          ntohl(get->desired_replication_level),
                          0,
                          NULL,
                          &get->key);

  /* clean up; note that 'bg' is owned by routing now! */
  GNUNET_CONTAINER_bloomfilter_free(peer_bf);
}

Here is the call graph for this function:

check_dht_p2p_result()

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

static

Check validity of p2p result message.

Parameters

cls	closure
message	message

Returns

GNUNET_YES if the message is well-formed

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

References PeerResultMessage::get_path_length, GNUNET_break_op, GNUNET_MAX_MESSAGE_SIZE, GNUNET_OK, GNUNET_SYSERR, PeerResultMessage::header, PeerPutMessage::put_path_length, PeerResultMessage::put_path_length, and GNUNET_MessageHeader::size.

{
  uint32_t get_path_length;
  uint32_t put_path_length;
  uint16_t msize;

  (void)cls;
  msize = ntohs(prm->header.size);
  put_path_length = ntohl(prm->put_path_length);
  get_path_length = ntohl(prm->get_path_length);
  if ((msize <
       sizeof(struct PeerResultMessage) + (get_path_length +
                                           put_path_length) *
       sizeof(struct GNUNET_PeerIdentity)) ||
      (get_path_length >
       GNUNET_MAX_MESSAGE_SIZE / sizeof(struct GNUNET_PeerIdentity)) ||
      (put_path_length >
       GNUNET_MAX_MESSAGE_SIZE / sizeof(struct GNUNET_PeerIdentity)))
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

process_reply_with_path()

static void process_reply_with_path ( struct GNUNET_TIME_Absolute  expiration_time, const struct GNUNET_HashCode *  key, unsigned int  get_path_length, const struct GNUNET_PeerIdentity *  get_path, unsigned int  put_path_length, const struct GNUNET_PeerIdentity *  put_path, enum GNUNET_BLOCK_Type  type, size_t  data_size, const void *  data  )

static

Process a reply, after the get_path has been updated.

Parameters

expiration_time	when does the reply expire
key	key matching the query
get_path_length	number of entries in get_path
get_path	path the reply has taken
put_path_length	number of entries in put_path
put_path	path the PUT has taken
type	type of the block
data_size	number of bytes in data
data	payload of the reply

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

References cache_results, GDS_CLIENTS_handle_reply(), GDS_CLIENTS_process_get_resp(), GDS_DATACACHE_handle_put(), GDS_ROUTING_process(), GNUNET_memcpy, and GNUNET_YES.

Referenced by handle_dht_p2p_result().

{
  /* forward to local clients */
  GDS_CLIENTS_handle_reply(expiration_time,
                           key,
                           get_path_length,
                           get_path,
                           put_path_length,
                           put_path,
                           type,
                           data_size,
                           data);
  GDS_CLIENTS_process_get_resp(type,
                               get_path,
                               get_path_length,
                               put_path,
                               put_path_length,
                               expiration_time,
                               key,
                               data,
                               data_size);
  if (GNUNET_YES == cache_results)
    {
      struct GNUNET_PeerIdentity xput_path[get_path_length + 1 + put_path_length];

      GNUNET_memcpy(xput_path,
                    put_path,
                    put_path_length * sizeof(struct GNUNET_PeerIdentity));
      GNUNET_memcpy(&xput_path[put_path_length],
                    get_path,
                    get_path_length * sizeof(struct GNUNET_PeerIdentity));

      GDS_DATACACHE_handle_put(expiration_time,
                               key,
                               get_path_length + put_path_length,
                               xput_path,
                               type,
                               data_size,
                               data);
    }
  /* forward to other peers */
  GDS_ROUTING_process(type,
                      expiration_time,
                      key,
                      put_path_length,
                      put_path,
                      get_path_length,
                      get_path,
                      data,
                      data_size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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
message	message

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

References data, data_size, disable_try_connect, PeerResultMessage::expiration_time, GDS_stats, PeerResultMessage::get_path_length, gettext_noop, GNUNET_BLOCK_TYPE_DHT_HELLO, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_HELLO_get_id(), GNUNET_i2s(), GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_strdup, GNUNET_STRINGS_pp2s(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_ntoh(), GNUNET_YES, h, PeerResultMessage::header, PeerInfo::id, PeerResultMessage::key, log_route_details_stderr, LOG_TRAFFIC, my_identity, peer, process_reply_with_path(), PeerPutMessage::put_path_length, PeerResultMessage::put_path_length, GNUNET_MessageHeader::size, try_connect(), PeerPutMessage::type, and PeerResultMessage::type.

{
  struct PeerInfo *peer = cls;
  const struct GNUNET_PeerIdentity *put_path;
  const struct GNUNET_PeerIdentity *get_path;
  const void *data;
  uint32_t get_path_length;
  uint32_t put_path_length;
  uint16_t msize;
  size_t data_size;
  enum GNUNET_BLOCK_Type type;
  struct GNUNET_TIME_Absolute exp_time;

  /* parse and validate message */
  exp_time = GNUNET_TIME_absolute_ntoh(prm->expiration_time);
  if (0 == GNUNET_TIME_absolute_get_remaining(exp_time).rel_value_us)
    {
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop("# Expired results discarded"),
                               1,
                               GNUNET_NO);
      return;
    }
  msize = ntohs(prm->header.size);
  put_path_length = ntohl(prm->put_path_length);
  get_path_length = ntohl(prm->get_path_length);
  put_path = (const struct GNUNET_PeerIdentity *)&prm[1];
  get_path = &put_path[put_path_length];
  type = ntohl(prm->type);
  data = (const void *)&get_path[get_path_length];
  data_size = msize - (sizeof(struct PeerResultMessage) +
                       (get_path_length +
                        put_path_length) * sizeof(struct GNUNET_PeerIdentity));
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# P2P RESULTS received"),
                           1,
                           GNUNET_NO);
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# P2P RESULT bytes received"),
                           msize,
                           GNUNET_NO);
  if (GNUNET_YES == log_route_details_stderr)
    {
      char *tmp;
      char *pp;
      char *gp;

      gp = GNUNET_STRINGS_pp2s(get_path,
                               get_path_length);
      pp = GNUNET_STRINGS_pp2s(put_path,
                               put_path_length);
      tmp = GNUNET_strdup(GNUNET_i2s(&my_identity));
      LOG_TRAFFIC(GNUNET_ERROR_TYPE_DEBUG,
                  "R5N RESULT %s: %s->%s (GP: %s, PP: %s)\n",
                  GNUNET_h2s(&prm->key),
                  GNUNET_i2s(peer->id),
                  tmp,
                  gp,
                  pp);
      GNUNET_free(gp);
      GNUNET_free(pp);
      GNUNET_free(tmp);
    }
  /* if we got a HELLO, consider it for our own routing table */
  if (GNUNET_BLOCK_TYPE_DHT_HELLO == type)
    {
      const struct GNUNET_MessageHeader *h;
      struct GNUNET_PeerIdentity pid;

      /* Should be a HELLO, validate and consider using it! */
      if (data_size < sizeof(struct GNUNET_HELLO_Message))
        {
          GNUNET_break_op(0);
          return;
        }
      h = data;
      if (data_size != ntohs(h->size))
        {
          GNUNET_break_op(0);
          return;
        }
      if (GNUNET_OK !=
          GNUNET_HELLO_get_id((const struct GNUNET_HELLO_Message *)h,
                              &pid))
        {
          GNUNET_break_op(0);
          return;
        }
      if ((GNUNET_YES != disable_try_connect) &&
          (0 != memcmp(&my_identity,
                       &pid,
                       sizeof(struct GNUNET_PeerIdentity))))
        try_connect(&pid,
                    h);
    }

  /* First, check if 'peer' is already on the path, and if
     so, truncate it instead of expanding. */
  for (unsigned int i = 0; i <= get_path_length; i++)
    if (0 == memcmp(&get_path[i],
                    peer->id,
                    sizeof(struct GNUNET_PeerIdentity)))
      {
        process_reply_with_path(exp_time,
                                &prm->key,
                                i,
                                get_path,
                                put_path_length,
                                put_path,
                                type,
                                data_size,
                                data);
        return;
      }

  /* Need to append 'peer' to 'get_path' (normal case) */
  {
    struct GNUNET_PeerIdentity xget_path[get_path_length + 1];

    GNUNET_memcpy(xget_path,
                  get_path,
                  get_path_length * sizeof(struct GNUNET_PeerIdentity));
    xget_path[get_path_length] = *peer->id;

    process_reply_with_path(exp_time,
                            &prm->key,
                            get_path_length + 1,
                            xget_path,
                            put_path_length,
                            put_path,
                            type,
                            data_size,
                            data);
  }
}

Here is the call graph for this function:

GDS_NEIGHBOURS_init()

int GDS_NEIGHBOURS_init

(

void

)

Initialize neighbours subsystem.

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

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

References bucket_size, cache_results, core_init(), disable_try_connect, GDS_cfg, getenv(), GNUNET_ATS_connectivity_init(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CORE_connect(), GNUNET_MESSAGE_TYPE_DHT_P2P_GET, GNUNET_MESSAGE_TYPE_DHT_P2P_PUT, GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, handle_core_connect(), handle_core_disconnect(), and log_route_details_stderr.

Referenced by run().

{
  struct GNUNET_MQ_MessageHandler core_handlers[] = {
    GNUNET_MQ_hd_var_size(dht_p2p_get,
                          GNUNET_MESSAGE_TYPE_DHT_P2P_GET,
                          struct PeerGetMessage,
                          NULL),
    GNUNET_MQ_hd_var_size(dht_p2p_put,
                          GNUNET_MESSAGE_TYPE_DHT_P2P_PUT,
                          struct PeerPutMessage,
                          NULL),
    GNUNET_MQ_hd_var_size(dht_p2p_result,
                          GNUNET_MESSAGE_TYPE_DHT_P2P_RESULT,
                          struct PeerResultMessage,
                          NULL),
    GNUNET_MQ_handler_end()
  };
  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");

  log_route_details_stderr =
    (NULL != getenv("GNUNET_DHT_ROUTE_DEBUG")) ? GNUNET_YES : GNUNET_NO;
  ats_ch = GNUNET_ATS_connectivity_init(GDS_cfg);
  core_api = GNUNET_CORE_connect(GDS_cfg,
                                 NULL,
                                 &core_init,
                                 &handle_core_connect,
                                 &handle_core_disconnect,
                                 core_handlers);
  if (NULL == core_api)
    return GNUNET_SYSERR;
  all_connected_peers = GNUNET_CONTAINER_multipeermap_create(256,
                                                             GNUNET_YES);
  all_desired_peers = GNUNET_CONTAINER_multipeermap_create(256,
                                                           GNUNET_NO);
  return GNUNET_OK;
}

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 2523 of file gnunet-service-dht_neighbours.c.

References free_connect_info(), GNUNET_assert, GNUNET_ATS_connectivity_done(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CONTAINER_multipeermap_size(), and GNUNET_CORE_disconnect().

Referenced by shutdown_task().

{
  if (NULL == core_api)
    return;
  GNUNET_CORE_disconnect(core_api);
  core_api = NULL;
  GNUNET_assert(0 ==
                GNUNET_CONTAINER_multipeermap_size(all_connected_peers));
  GNUNET_CONTAINER_multipeermap_destroy(all_connected_peers);
  all_connected_peers = NULL;
  GNUNET_CONTAINER_multipeermap_iterate(all_desired_peers,
                                        &free_connect_info,
                                        NULL);
  GNUNET_CONTAINER_multipeermap_destroy(all_desired_peers);
  all_desired_peers = NULL;
  GNUNET_ATS_connectivity_done(ats_ch);
  ats_ch = NULL;
  GNUNET_assert(NULL == find_peer_task);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_NEIGHBOURS_get_id()

struct GNUNET_PeerIdentity* GDS_NEIGHBOURS_get_id

(

void

)

Get the ID of the local node.

Returns

identity of the local node

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

References my_identity.

Referenced by handle_dht_local_get(), and handle_dht_local_put().

{
  return &my_identity;
}

Here is the caller graph for this function:

Variable Documentation

hello_expiration

struct GNUNET_TIME_Relative hello_expiration

Hello address expiration.

Definition at line 55 of file gnunet-service-dht.c.

Referenced by handle_find_peer().

cache_results

int cache_results

static

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

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

Referenced by GDS_NEIGHBOURS_init(), and process_reply_with_path().

log_route_details_stderr

int log_route_details_stderr

static

Should routing details be logged to stderr (for debugging)?

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

Referenced by GDS_NEIGHBOURS_init(), handle_dht_p2p_get(), handle_dht_p2p_put(), and handle_dht_p2p_result().

closest_bucket

unsigned int closest_bucket

static

The lowest currently used bucket, initially 0 (for 0-bits matching bucket).

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

Referenced by handle_core_connect(), handle_core_disconnect(), handle_find_peer(), 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 354 of file gnunet-service-dht_neighbours.c.

Referenced by handle_core_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 359 of file gnunet-service-dht_neighbours.c.

Referenced by GDS_NEIGHBOURS_init(), handle_core_connect(), handle_core_disconnect(), and handle_dht_p2p_result().

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 364 of file gnunet-service-dht_neighbours.c.

Referenced by GDS_am_closest_peer(), handle_core_connect(), handle_core_disconnect(), handle_find_peer(), select_peer(), and try_connect().

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 370 of file gnunet-service-dht_neighbours.c.

all_desired_peers

struct GNUNET_CONTAINER_MultiPeerMap* all_desired_peers

static

Hash map of all peers we would like to be connected to.

Values are of type struct ConnectInfo.

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

bucket_size

unsigned int bucket_size = 8

static

Maximum size for each bucket.

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

Referenced by GDS_NEIGHBOURS_init(), handle_core_connect(), handle_core_disconnect(), select_peer(), send_find_peer_message(), and try_connect().

find_peer_task

struct GNUNET_SCHEDULER_Task* find_peer_task

static

Task that sends FIND PEER requests.

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

my_identity

struct GNUNET_PeerIdentity my_identity

static

Identity of this peer.

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

Referenced by core_init(), GDS_NEIGHBOURS_get_id(), GDS_NEIGHBOURS_handle_get(), GDS_NEIGHBOURS_handle_put(), handle_core_connect(), handle_dht_p2p_get(), handle_dht_p2p_put(), and handle_dht_p2p_result().

my_identity_hash

struct GNUNET_HashCode my_identity_hash

Hash of the identity of this peer.

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

Referenced by core_init(), find_bucket(), GDS_am_closest_peer(), GDS_DATACACHE_handle_put(), GDS_NEIGHBOURS_handle_get(), GDS_NEIGHBOURS_handle_put(), handle_dht_p2p_get(), handle_dht_p2p_put(), handle_find_peer(), and send_find_peer_message().

core_api

struct GNUNET_CORE_Handle* core_api

static

Handle to CORE.

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

ats_ch

struct GNUNET_ATS_ConnectivityHandle* ats_ch

static

Handle to ATS connectivity.

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