gnunet-service-dht_neighbours.h File Reference

GNUnet DHT routing code. More...

#include "gnunet_util_lib.h"
#include "gnunet_block_lib.h"
#include "gnunet_dht_service.h"

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

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
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...
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...
int	GDS_NEIGHBOURS_init (void)
	Initialize neighbours subsystem. More...
void	GDS_NEIGHBOURS_done (void)
	Shutdown neighbours subsystem. More...
struct GNUNET_PeerIdentity *	GDS_NEIGHBOURS_get_id (void)
	Get the ID of the local node. More...

Variables
struct GNUNET_HashCode	my_identity_hash
	Hash of the identity of this peer. More...

Detailed Description

GNUnet DHT routing code.

Author

Christian Grothoff

Nathan Evans

Definition in file gnunet-service-dht_neighbours.h.

Function Documentation

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

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	block group to filter replies
peer_bf	filter for peers not to select (again, updated)

Returns

GNUNET_OK if the request was forwarded, GNUNET_NO if not

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 other peers waiting for it. 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 put_path
get_path	peers this reply has traversed so far (if tracked)
data	payload of the reply
data_size	number of bytes in data

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:

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:

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

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().