gnunet-service-nse.c File Reference

network size estimation service More...

#include "gnunet_common.h"
#include "platform.h"
#include <math.h>
#include "gnunet_util_lib.h"
#include "gnunet_hello_uri_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "gnunet_statistics_service.h"
#include "gnunet_core_service.h"
#include "gnunet_pils_service.h"
#include "nse.h"
#include <gcrypt.h>

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

Go to the source code of this file.

Data Structures
struct	NSEPeerEntry
	Per-peer information. More...
struct	GNUNET_NSE_FloodMessage
	Network size estimate reply; sent when "this" peer's timer has run out before receiving a valid reply from another peer. More...

Macros
#define	USE_RANDOM_DELAYS   GNUNET_YES
	Should messages be delayed randomly? This option should be set to GNUNET_NO only for experiments, not in production.
#define	DEBUG_NSE   GNUNET_NO
	Generate extensive debug-level log messages?
#define	HISTORY_SIZE   64
	Over how many values do we calculate the weighted average?
#define	NSE_PRIORITY
	Message priority to use.
#define	WEST   1
#define	ROUND_SIZE   10

Functions
static void	setup_estimate_message (struct GNUNET_NSE_ClientMessage *em)
	Initialize a message to clients with the current network size estimate.
static void	handle_start (void *cls, const struct GNUNET_MessageHeader *message)
	Handler for START message from client, triggers an immediate current network estimate notification.
static double	get_matching_bits_delay (uint32_t matching_bits)
	How long should we delay a message to go the given number of matching bits?
static struct GNUNET_TIME_Relative	get_delay_randomization (uint32_t matching_bits)
	What delay randomization should we apply for a given number of matching bits?
static uint32_t	get_matching_bits (struct GNUNET_TIME_Absolute timestamp, const struct GNUNET_PeerIdentity *id)
	Get the number of matching bits that the given timestamp has to the given peer ID.
static struct GNUNET_TIME_Relative	get_transmit_delay (int round_offset)
	Get the transmission delay that should be applied for a particular round.
static void	sign_message_before_send_cb (void *cls, const struct GNUNET_PeerIdentity *pid, const struct GNUNET_CRYPTO_EddsaSignature *sig)
static void	transmit_task_cb (void *cls)
	Task that triggers a NSE P2P transmission.
static void	update_network_size_estimate ()
	We've sent on our flood message or one that we received which was validated and closer than ours.
static void	setup_flood_message (unsigned int slot, struct GNUNET_TIME_Absolute ts)
	Setup a flood message in our history array at the given slot offset for the given timestamp.
static int	schedule_current_round (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Schedule transmission for the given peer for the current round based on what we know about the desired delay.
static void	update_flood_message (void *cls)
	Update our flood message to be sent (and our timestamps).
static enum GNUNET_GenericReturnValue	check_proof_of_work (const struct GNUNET_CRYPTO_EddsaPublicKey *pkey, uint64_t val)
	Check whether the given public key and integer are a valid proof of work.
static void	write_proof (void)
	Write our current proof to disk.
static void	find_proof (void *cls)
	Find our proof of work.
static int	verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood)
	An incoming flood message has been received which claims to have more bits matching than any we know in this time period.
static int	update_flood_times (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Update transmissions for the given peer for the current round based on updated proximity information.
static void	handle_p2p_estimate (void *cls, const struct GNUNET_NSE_FloodMessage *incoming_flood)
	Core handler for size estimate flooding messages.
static void *	handle_core_connect (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq, enum GNUNET_CORE_PeerClass class)
	Method called whenever a peer connects.
static void	handle_core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
	Method called whenever a peer disconnects.
static void	shutdown_task (void *cls)
	Task run during shutdown.
static void	pils_id_change_cb (void *cls, const struct GNUNET_HELLO_Parser *parser, const struct GNUNET_HashCode *addr_hash)
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
	Handle network size estimate clients.
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *c, struct GNUNET_MQ_Handle *mq)
	Callback called when a client connects to the service.
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *c, void *internal_cls)
	Callback called when a client disconnected from the service.
	GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet(), "nse", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(start, GNUNET_MESSAGE_TYPE_NSE_START, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro.

Variables
static unsigned long long	nse_work_required
	Amount of work required (W-bit collisions) for NSE proofs, in collision-bits.
static struct GNUNET_TIME_Relative	gnunet_nse_interval
	Interval for sending network size estimation flood requests.
static struct GNUNET_TIME_Relative	proof_find_delay
	Interval between proof find runs.
static struct GNUNET_CRYPTO_PowSalt	salt = { "gnunet-nse-proof" }
	Salt for PoW calculations.
static GNUNET_NETWORK_STRUCT_END const struct GNUNET_CONFIGURATION_Handle *	cfg
	Handle to our current configuration.
static struct GNUNET_STATISTICS_Handle *	stats
	Handle to the statistics service.
static struct GNUNET_PILS_Handle *	pils
	Handle to the PILS service.
static struct GNUNET_CORE_Handle *	core_api
	Handle to the core service.
static struct GNUNET_CONTAINER_MultiPeerMap *	peers
	Map of all connected peers.
static double	current_size_estimate
	The current network size estimate.
static double	current_std_dev = NAN
	The standard deviation of the last HISTORY_SIZE network size estimates.
static uint32_t	hop_count_max
	Current hop counter estimate (estimate for network diameter).
static struct GNUNET_NSE_FloodMessage	next_message
	Message for the next round, if we got any.
static struct GNUNET_NSE_FloodMessage	size_estimate_messages [64]
	Array of recent size estimate messages.
static unsigned int	estimate_index
	Index of most recent estimate.
static unsigned int	estimate_count
	Number of valid entries in the history.
static struct GNUNET_SCHEDULER_Task *	flood_task
	Task scheduled to update our flood message for the next round.
static struct GNUNET_SCHEDULER_Task *	proof_task
	Task scheduled to compute our proof.
static struct GNUNET_NotificationContext *	nc
	Notification context, simplifies client broadcasts.
static struct GNUNET_TIME_Absolute	next_timestamp
	The next major time.
static struct GNUNET_TIME_Absolute	current_timestamp
	The current major time.
static uint64_t	my_proof
	Proof of work for this peer.

Detailed Description

network size estimation service

Author

Nathan Evans

Christian Grothoff

The purpose of this service is to estimate the size of the network. Given a specified interval, each peer hashes the most recent timestamp which is evenly divisible by that interval. This hash is compared in distance to the peer identity to choose an offset. The closer the peer identity to the hashed timestamp, the earlier the peer sends out a "nearest peer" message. The closest peer's message should thus be received before any others, which stops those peer from sending their messages at a later duration. So every peer should receive the same nearest peer message, and from this can calculate the expected number of peers in the network.

Definition in file gnunet-service-nse.c.

Macro Definition Documentation

USE_RANDOM_DELAYS

#define USE_RANDOM_DELAYS   GNUNET_YES

Should messages be delayed randomly? This option should be set to GNUNET_NO only for experiments, not in production.

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

DEBUG_NSE

#define DEBUG_NSE   GNUNET_NO

Generate extensive debug-level log messages?

Definition at line 64 of file gnunet-service-nse.c.

HISTORY_SIZE

#define HISTORY_SIZE   64

Over how many values do we calculate the weighted average?

Definition at line 69 of file gnunet-service-nse.c.

NSE_PRIORITY

#define NSE_PRIORITY

Value:

        (GNUNET_MQ_PRIO_BACKGROUND | GNUNET_MQ_PREF_UNRELIABLE   \
         | GNUNET_MQ_PREF_CORK_ALLOWED)

Message priority to use.

No real rush, reliability not required. Corking OK.

Definition at line 75 of file gnunet-service-nse.c.

                                           { "gnunet-nse-proof" };
 
 
struct NSEPeerEntry
{
  struct GNUNET_MQ_Handle *mq;
 
  const struct GNUNET_PeerIdentity *id;
 
  struct GNUNET_SCHEDULER_Task *transmit_task;
 
  uint32_t next_index_to_send;
 
  struct GNUNET_PILS_Operation *pils_op;
 
  int previous_round;
 
#if ENABLE_NSE_HISTOGRAM
  unsigned int received_messages;
 
  unsigned int transmitted_messages;
 
  unsigned int last_transmitted_size;
#endif
};
 
 
GNUNET_NETWORK_STRUCT_BEGIN
 
struct GNUNET_NSE_FloodMessage
{
  struct GNUNET_MessageHeader header;
 
  uint32_t hop_count GNUNET_PACKED;
 
  struct GNUNET_CRYPTO_SignaturePurpose purpose;
 
  struct GNUNET_TIME_AbsoluteNBO timestamp;
 
  uint32_t matching_bits GNUNET_PACKED;
 
  struct GNUNET_PeerIdentity origin;
 
  uint64_t proof_of_work GNUNET_PACKED;
 
  struct GNUNET_CRYPTO_EddsaSignature signature;
};
GNUNET_NETWORK_STRUCT_END
 
static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
static struct GNUNET_STATISTICS_Handle *stats;
 
static struct GNUNET_PILS_Handle *pils;
 
static struct GNUNET_CORE_Handle *core_api;
 
static struct GNUNET_CONTAINER_MultiPeerMap *peers;
 
static double current_size_estimate;
 
static double current_std_dev = NAN;
 
static uint32_t hop_count_max;
 
static struct GNUNET_NSE_FloodMessage next_message;
 
static struct GNUNET_NSE_FloodMessage size_estimate_messages[HISTORY_SIZE];
 
static unsigned int estimate_index;
 
static unsigned int estimate_count;
 
static struct GNUNET_SCHEDULER_Task *flood_task;
 
static struct GNUNET_SCHEDULER_Task *proof_task;
 
static struct GNUNET_NotificationContext *nc;
 
static struct GNUNET_TIME_Absolute next_timestamp;
 
static struct GNUNET_TIME_Absolute current_timestamp;
 
static uint64_t my_proof;
 
 
static void
setup_estimate_message (struct GNUNET_NSE_ClientMessage *em)
{
  double mean;
  double sum;
  double std_dev;
  double variance;
  double val;
  double nsize;
 
#define WEST 1
  /* Weighted incremental algorithm for stddev according to West (1979) */
#if WEST
  double sumweight;
  double weight;
  double q;
  double r;
  double temp;
 
  mean = 0.0;
  sum = 0.0;
  sumweight = 0.0;
  variance = 0.0;
  for (unsigned int i = 0; i < estimate_count; i++)
  {
    unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
 
    val = htonl (size_estimate_messages[j].matching_bits);
    weight = estimate_count + 1 - i;
 
    temp = weight + sumweight;
    q = val - mean;
    r = q * weight / temp;
    mean += r;
    sum += sumweight * q * r;
    sumweight = temp;
  }
  if (estimate_count > 0)
    variance = (sum / sumweight) * estimate_count / (estimate_count - 1.0);
#else
  /* trivial version for debugging */
  double vsq;
 
  /* non-weighted trivial version */
  sum = 0.0;
  vsq = 0.0;
  variance = 0.0;
  mean = 0.0;
 
  for (unsigned int i = 0; i < estimate_count; i++)
  {
    unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
 
    val = htonl (size_estimate_messages[j].matching_bits);
    sum += val;
    vsq += val * val;
  }
  if (0 != estimate_count)
  {
    mean = sum / estimate_count;
    variance = (vsq - mean * sum)
               / (estimate_count - 1.0); // terrible for numerical stability...
  }
#endif
  if (variance >= 0)
    std_dev = sqrt (variance);
  else
    std_dev = variance; /* return NaN (due to estimate_count == 0 causing 0.0/0.0) */
  current_std_dev = std_dev;
  current_size_estimate = mean;
 
  em->header.size = htons (sizeof(struct GNUNET_NSE_ClientMessage));
  em->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_ESTIMATE);
  em->reserved = htonl (0);
  em->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
  {
    double se = mean - 0.332747;
    unsigned int j = GNUNET_CONTAINER_multipeermap_size (peers);
    if (0 == j)
      j = 1; /* Avoid log2(0); can only happen if CORE didn't report
                connection to self yet */
    nsize = log2 (j);
    em->size_estimate = GNUNET_hton_double (GNUNET_MAX (se, nsize));
    em->std_deviation = GNUNET_hton_double (std_dev);
    GNUNET_STATISTICS_set (stats,
                           "# nodes in the network (estimate)",
                           (uint64_t) pow (2, GNUNET_MAX (se, nsize)),
                           GNUNET_NO);
  }
}
 
 
static void
handle_start (void *cls, const struct GNUNET_MessageHeader *message)
{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_MQ_Handle *mq;
  struct GNUNET_NSE_ClientMessage em;
  struct GNUNET_MQ_Envelope *env;
 
  (void) message;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received START message from client\n");
  mq = GNUNET_SERVICE_client_get_mq (client);
  GNUNET_notification_context_add (nc, mq);
  setup_estimate_message (&em);
  env = GNUNET_MQ_msg_copy (&em.header);
  GNUNET_MQ_send (mq, env);
  GNUNET_SERVICE_client_continue (client);
}
 
 
static double
get_matching_bits_delay (uint32_t matching_bits)
{
  /* Calculated as: S + f/2 - (f / pi) * (atan(x - p')) */
  // S is next_timestamp (ignored in return value)
  // f is frequency (gnunet_nse_interval)
  // x is matching_bits
  // p' is current_size_estimate
  return ((double) gnunet_nse_interval.rel_value_us / (double) 2.0)
         - ((gnunet_nse_interval.rel_value_us / M_PI)
            * atan (matching_bits - current_size_estimate));
}
 
 
static struct GNUNET_TIME_Relative
get_delay_randomization (uint32_t matching_bits)
{
#if USE_RANDOM_DELAYS
  struct GNUNET_TIME_Relative ret;
  uint32_t i;
  double d;
 
  d = get_matching_bits_delay (matching_bits);
  i = (uint32_t) (d / (double) (hop_count_max + 1));
  ret.rel_value_us = i;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Randomizing flood using latencies up to %s\n",
              GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
  ret.rel_value_us =
    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, i + 1);
  return ret;
#else
  return GNUNET_TIME_UNIT_ZERO;
#endif
}
 
 
static uint32_t
get_matching_bits (struct GNUNET_TIME_Absolute timestamp,
                   const struct GNUNET_PeerIdentity *id)
{
  struct GNUNET_HashCode timestamp_hash;
  struct GNUNET_HashCode pid_hash;
  struct GNUNET_HashCode xor;
 
  GNUNET_CRYPTO_hash (&timestamp.abs_value_us,
                      sizeof(timestamp.abs_value_us),
                      &timestamp_hash);
  GNUNET_CRYPTO_hash (id,
                      sizeof(struct GNUNET_PeerIdentity),
                      &pid_hash);
  GNUNET_CRYPTO_hash_xor (&pid_hash,
                          &timestamp_hash,
                          &xor);
  return GNUNET_CRYPTO_hash_count_leading_zeros (&xor);
}
 
 
static struct GNUNET_TIME_Relative
get_transmit_delay (int round_offset)
{
  struct GNUNET_TIME_Relative ret;
  struct GNUNET_TIME_Absolute tgt;
  double dist_delay;
  uint32_t matching_bits;
 
  switch (round_offset)
  {
  case -1:
    /* previous round is randomized between 0 and 50 ms */
#if USE_RANDOM_DELAYS
    ret.rel_value_us =
      GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, 50);
#else
    ret = GNUNET_TIME_UNIT_ZERO;
#endif
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Transmitting previous round behind schedule in %s\n",
                GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
    return ret;
 
  case 0:
    /* current round is based on best-known matching_bits */
    matching_bits =
      ntohl (size_estimate_messages[estimate_index].matching_bits);
    dist_delay = get_matching_bits_delay (matching_bits);
    dist_delay += get_delay_randomization (matching_bits).rel_value_us;
    ret.rel_value_us = (uint64_t) dist_delay;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "For round %s, delay for %u matching bits is %s\n",
                GNUNET_STRINGS_absolute_time_to_string (current_timestamp),
                (unsigned int) matching_bits,
                GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
    /* now consider round start time and add delay to it */
    tgt = GNUNET_TIME_absolute_add (current_timestamp, ret);
    return GNUNET_TIME_absolute_get_remaining (tgt);
  }
  GNUNET_break (0);
  return GNUNET_TIME_UNIT_FOREVER_REL;
}
 
 
static void
sign_message_before_send_cb (void *cls,
                             const struct GNUNET_PeerIdentity *pid,
                             const struct GNUNET_CRYPTO_EddsaSignature *sig)
{
  struct NSEPeerEntry *pe = cls;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_NSE_FloodMessage *fm;
 
  pe->pils_op = NULL;
  fm = &size_estimate_messages[pe->next_index_to_send];
  fm->signature = *sig;
  env = GNUNET_MQ_msg_copy (&fm->header);
  GNUNET_MQ_send (pe->mq, env);
}
 
 
static void
transmit_task_cb (void *cls)
{
  struct NSEPeerEntry *peer_entry = cls;
  unsigned int idx;
 
  peer_entry->transmit_task = NULL;
  idx = estimate_index;
  if (GNUNET_NO == peer_entry->previous_round)
  {
    idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE;
    peer_entry->previous_round = GNUNET_YES;
    peer_entry->transmit_task =
      GNUNET_SCHEDULER_add_delayed (get_transmit_delay (0),
                                    &transmit_task_cb,
                                    peer_entry);
  }
  if ((0 == ntohl (size_estimate_messages[idx].hop_count)) &&
      (NULL != proof_task))
  {
    GNUNET_STATISTICS_update (stats,
                              "# flood messages not generated (no proof yet)",
                              1,
                              GNUNET_NO);
    return;
  }
  if (0 == ntohs (size_estimate_messages[idx].header.size))
  {
    GNUNET_STATISTICS_update (stats,
                              "# flood messages not generated (lack of history)",
                              1,
                              GNUNET_NO);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "In round %s, sending to `%s' estimate with %u bits\n",
              GNUNET_STRINGS_absolute_time_to_string (
                GNUNET_TIME_absolute_ntoh (
                  size_estimate_messages[idx].timestamp)),
              GNUNET_i2s (peer_entry->id),
              (unsigned int) ntohl (size_estimate_messages[idx].matching_bits));
  if (0 == ntohl (size_estimate_messages[idx].hop_count))
    GNUNET_STATISTICS_update (stats, "# flood messages started", 1, GNUNET_NO);
  GNUNET_STATISTICS_update (stats,
                            "# flood messages transmitted",
                            1,
                            GNUNET_NO);
#if ENABLE_NSE_HISTOGRAM
  peer_entry->transmitted_messages++;
  peer_entry->last_transmitted_size =
    ntohl (size_estimate_messages[idx].matching_bits);
#endif
  peer_entry->next_index_to_send = idx;
  peer_entry->pils_op = GNUNET_PILS_sign_by_peer_identity (
    pils,
    &size_estimate_messages[idx].purpose,
    &sign_message_before_send_cb,
    peer_entry);
}
 
 
static void
update_network_size_estimate ()
{
  struct GNUNET_NSE_ClientMessage em;
 
  setup_estimate_message (&em);
  GNUNET_notification_context_broadcast (nc, &em.header, GNUNET_YES);
}
 
 
static void
setup_flood_message (unsigned int slot, struct GNUNET_TIME_Absolute ts)
{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_NSE_FloodMessage *fm;
  uint32_t matching_bits;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  matching_bits = get_matching_bits (ts, my_identity);
  fm = &size_estimate_messages[slot];
  fm->header.size = htons (sizeof(struct GNUNET_NSE_FloodMessage));
  fm->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD);
  fm->hop_count = htonl (0);
  fm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_NSE_SEND);
  fm->purpose.size =
    htonl (sizeof(struct GNUNET_NSE_FloodMessage)
           - sizeof(struct GNUNET_MessageHeader) - sizeof(uint32_t)
           - sizeof(struct GNUNET_CRYPTO_EddsaSignature));
  fm->matching_bits = htonl (matching_bits);
  fm->timestamp = GNUNET_TIME_absolute_hton (ts);
  fm->origin = *my_identity;
  fm->proof_of_work = my_proof;
  memset (&fm->signature, 0, sizeof(fm->signature));
}
 
 
static int
schedule_current_round (void *cls,
                        const struct GNUNET_PeerIdentity *key,
                        void *value)
{
  struct NSEPeerEntry *peer_entry = value;
  struct GNUNET_TIME_Relative delay;
 
  (void) cls;
  (void) key;
  if (NULL != peer_entry->transmit_task)
  {
    GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
    peer_entry->previous_round = GNUNET_NO;
  }
#if ENABLE_NSE_HISTOGRAM
  if (peer_entry->received_messages > 1)
    GNUNET_STATISTICS_update (stats,
                              "# extra messages",
                              peer_entry->received_messages - 1,
                              GNUNET_NO);
  peer_entry->transmitted_messages = 0;
  peer_entry->last_transmitted_size = 0;
  peer_entry->received_messages = 0;
#endif
  delay =
    get_transmit_delay ((GNUNET_NO == peer_entry->previous_round) ? -1 : 0);
  peer_entry->transmit_task =
    GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry);
  return GNUNET_OK;
}
 
 
static void
update_flood_message (void *cls)
{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_TIME_Relative offset;
 
  (void) cls;
  flood_task = NULL;
  my_identity = GNUNET_PILS_get_identity (pils);
  if (! my_identity)
    return;
 
  offset = GNUNET_TIME_absolute_get_remaining (next_timestamp);
  if (0 != offset.rel_value_us)
  {
    /* somehow run early, delay more */
    flood_task =
      GNUNET_SCHEDULER_add_delayed (offset, &update_flood_message, NULL);
    return;
  }
  estimate_index = (estimate_index + 1) % HISTORY_SIZE;
  if (estimate_count < HISTORY_SIZE)
    estimate_count++;
  current_timestamp = next_timestamp;
  next_timestamp =
    GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
  if ((current_timestamp.abs_value_us ==
       GNUNET_TIME_absolute_ntoh (next_message.timestamp).abs_value_us) &&
      (get_matching_bits (current_timestamp, my_identity) <
       ntohl (next_message.matching_bits)))
  {
    /* we received a message for this round way early, use it! */
    size_estimate_messages[estimate_index] = next_message;
    size_estimate_messages[estimate_index].hop_count =
      htonl (1 + ntohl (next_message.hop_count));
  }
  else
    setup_flood_message (estimate_index, current_timestamp);
  next_message.matching_bits = htonl (0);  /* reset for 'next' round */
  hop_count_max = 0;
  for (unsigned int i = 0; i < HISTORY_SIZE; i++)
    hop_count_max =
      GNUNET_MAX (ntohl (size_estimate_messages[i].hop_count), hop_count_max);
  GNUNET_CONTAINER_multipeermap_iterate (peers, &schedule_current_round, NULL);
  flood_task =
    GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL);
}
 
 
static enum GNUNET_GenericReturnValue
check_proof_of_work (const struct GNUNET_CRYPTO_EddsaPublicKey *pkey,
                     uint64_t val)
{
  char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)
           + sizeof(val)] GNUNET_ALIGN;
  struct GNUNET_HashCode result;
 
  GNUNET_memcpy (buf, &val, sizeof(val));
  GNUNET_memcpy (&buf[sizeof(val)],
                 pkey,
                 sizeof(struct GNUNET_CRYPTO_EddsaPublicKey));
  GNUNET_CRYPTO_pow_hash (&salt,
                          buf,
                          sizeof(buf),
                          &result);
  return (GNUNET_CRYPTO_hash_count_leading_zeros (&result) >=
          nse_work_required)
    ? GNUNET_YES
    : GNUNET_NO;
}
 
 
static void
write_proof (void)
{
  char *proof;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg,
                                               "NSE",
                                               "PROOFFILE",
                                               &proof))
    return;
  (void) GNUNET_DISK_directory_remove (proof);
  if (GNUNET_OK !=
      GNUNET_DISK_fn_write (proof,
                            &my_proof,
                            sizeof(my_proof),
                            GNUNET_DISK_PERM_USER_READ
                            | GNUNET_DISK_PERM_USER_WRITE))
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                              "write",
                              proof);
  GNUNET_free (proof);
}
 
 
static void
find_proof (void *cls)
{
#define ROUND_SIZE 10
  uint64_t counter;
  char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)
           + sizeof(uint64_t)] GNUNET_ALIGN;
  struct GNUNET_HashCode result;
  const struct GNUNET_PeerIdentity *my_identity;
  unsigned int i;
 
  (void) cls;
  proof_task = NULL;
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
  GNUNET_memcpy (&buf[sizeof(uint64_t)],
                 my_identity,
                 sizeof(struct GNUNET_PeerIdentity));
  i = 0;
  counter = my_proof;
  while ((counter != UINT64_MAX) && (i < ROUND_SIZE))
  {
    GNUNET_memcpy (buf, &counter, sizeof(uint64_t));
    GNUNET_CRYPTO_pow_hash (&salt,
                            buf,
                            sizeof(buf),
                            &result);
    if (nse_work_required <=
        GNUNET_CRYPTO_hash_count_leading_zeros (&result))
    {
      my_proof = counter;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Proof of work found: %llu!\n",
                  (unsigned long long) GNUNET_ntohll (counter));
      write_proof ();
      setup_flood_message (estimate_index, current_timestamp);
      return;
    }
    counter++;
    i++;
  }
  if (my_proof / (100 * ROUND_SIZE) < counter / (100 * ROUND_SIZE))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Testing proofs currently at %llu\n",
                (unsigned long long) counter);
    /* remember progress every 100 rounds */
    my_proof = counter;
    write_proof ();
  }
  else
  {
    my_proof = counter;
  }
  proof_task =
    GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay,
                                                GNUNET_SCHEDULER_PRIORITY_IDLE,
                                                &find_proof,
                                                NULL);
}
 
 
static int
verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood)
{
  if (GNUNET_YES != check_proof_of_work (&incoming_flood->origin.public_key,
                                         incoming_flood->proof_of_work))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Proof of work invalid: %llu!\n",
                (unsigned long long) GNUNET_ntohll (
                  incoming_flood->proof_of_work));
    GNUNET_break_op (0);
    return GNUNET_NO;
  }
  if ((nse_work_required > 0) &&
      (GNUNET_OK !=
       GNUNET_CRYPTO_eddsa_verify_ (GNUNET_SIGNATURE_PURPOSE_NSE_SEND,
                                    &incoming_flood->purpose,
                                    &incoming_flood->signature,
                                    &incoming_flood->origin.public_key)))
  {
    GNUNET_break_op (0);
    return GNUNET_NO;
  }
  return GNUNET_YES;
}
 
 
static int
update_flood_times (void *cls,
                    const struct GNUNET_PeerIdentity *key,
                    void *value)
{
  struct NSEPeerEntry *exclude = cls;
  struct NSEPeerEntry *peer_entry = value;
  struct GNUNET_TIME_Relative delay;
 
  (void) key;
  if (peer_entry == exclude)
    return GNUNET_OK; /* trigger of the update */
  if (GNUNET_NO == peer_entry->previous_round)
  {
    /* still stuck in previous round, no point to update, check that
     * we are active here though... */
    if (NULL == peer_entry->transmit_task)
    {
      GNUNET_break (0);
    }
    return GNUNET_OK;
  }
  if (NULL != peer_entry->transmit_task)
  {
    GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
    peer_entry->transmit_task = NULL;
  }
  delay = get_transmit_delay (0);
  peer_entry->transmit_task =
    GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry);
  return GNUNET_OK;
}
 
 
static void
handle_p2p_estimate (void *cls,
                     const struct GNUNET_NSE_FloodMessage *incoming_flood)
{
  const struct GNUNET_PeerIdentity *my_identity;
  struct NSEPeerEntry *peer_entry = cls;
  struct GNUNET_TIME_Absolute ts;
  uint32_t matching_bits;
  unsigned int idx;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  if (! my_identity)
    return;
 
#if ENABLE_NSE_HISTOGRAM
  {
    uint64_t t;
 
    t = GNUNET_TIME_absolute_get ().abs_value_us;
    if (NULL != lh)
      GNUNET_TESTBED_LOGGER_write (lh, &t, sizeof(uint64_t));
    if (NULL != histogram)
      GNUNET_BIO_write_int64 (histogram, "histogram-time", t);
  }
#endif
  GNUNET_STATISTICS_update (stats, "# flood messages received", 1, GNUNET_NO);
  matching_bits = ntohl (incoming_flood->matching_bits);
#if DEBUG_NSE
  {
    char origin[5];
    char pred[5];
    struct GNUNET_PeerIdentity os;
 
    GNUNET_snprintf (origin,
                     sizeof(origin),
                     "%s",
                     GNUNET_i2s (&incoming_flood->origin));
    GNUNET_snprintf (pred, sizeof(pred), "%s", GNUNET_i2s (peer_entry->id));
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Flood at %s from `%s' via `%s' at `%s' with bits %u\n",
                GNUNET_STRINGS_absolute_time_to_string (
                  GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp)),
                origin,
                pred,
                GNUNET_i2s (&my_identity),
                (unsigned int) matching_bits);
  }
#endif
 
#if ENABLE_NSE_HISTOGRAM
  peer_entry->received_messages++;
  if ((peer_entry->transmitted_messages > 0) &&
      (peer_entry->last_transmitted_size >= matching_bits) )
    GNUNET_STATISTICS_update (stats, "# cross messages", 1, GNUNET_NO);
#endif
 
  ts = GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp);
  if (ts.abs_value_us == current_timestamp.abs_value_us)
    idx = estimate_index;
  else if (ts.abs_value_us ==
           current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us)
    idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
  else if (ts.abs_value_us == next_timestamp.abs_value_us)
  {
    if (matching_bits <= ntohl (next_message.matching_bits))
      return;   /* ignore, simply too early/late */
    if (GNUNET_YES != verify_message_crypto (incoming_flood))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Peer %s is likely ill-configured!\n",
                  GNUNET_i2s (peer_entry->id));
      GNUNET_break_op (0);
      return;
    }
    next_message = *incoming_flood;
    return;
  }
  else
  {
    GNUNET_STATISTICS_update (stats,
                              "# flood messages discarded (clock skew too large)",
                              1,
                              GNUNET_NO);
    return;
  }
  if (0 == (GNUNET_memcmp (peer_entry->id, my_identity)))
  {
    /* send to self, update our own estimate IF this also comes from us! */
    if (0 == GNUNET_memcmp (&incoming_flood->origin, my_identity))
      update_network_size_estimate ();
    return;
  }
  if (matching_bits == ntohl (size_estimate_messages[idx].matching_bits))
  {
    /* Cancel transmission in the other direction, as this peer clearly has
       up-to-date information already. Even if we didn't talk to this peer in
       the previous round, we should no longer send it stale information as it
       told us about the current round! */
    peer_entry->previous_round = GNUNET_YES;
    if (idx != estimate_index)
    {
      /* do not transmit information for the previous round to this peer
         anymore (but allow current round) */
      return;
    }
    /* got up-to-date information for current round, cancel transmission to
     * this peer altogether */
    if (NULL != peer_entry->transmit_task)
    {
      GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
      peer_entry->transmit_task = NULL;
    }
    return;
  }
  if (matching_bits < ntohl (size_estimate_messages[idx].matching_bits))
  {
    if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES))
    {
      peer_entry->previous_round = GNUNET_NO;
    }
    /* push back our result now, that peer is spreading bad information... */
    if (NULL != peer_entry->transmit_task)
      GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
    peer_entry->transmit_task =
      GNUNET_SCHEDULER_add_now (&transmit_task_cb, peer_entry);
    /* Not closer than our most recent message, no need to do work here */
    GNUNET_STATISTICS_update (stats,
                              "# flood messages ignored (had closer already)",
                              1,
                              GNUNET_NO);
    return;
  }
  if (GNUNET_YES != verify_message_crypto (incoming_flood))
  {
    GNUNET_break_op (0);
    return;
  }
  GNUNET_assert (matching_bits >
                 ntohl (size_estimate_messages[idx].matching_bits));
  /* Cancel transmission in the other direction, as this peer clearly has
   * up-to-date information already.
   */
  peer_entry->previous_round = GNUNET_YES;
  if (idx == estimate_index)
  {
    /* cancel any activity for current round */
    if (NULL != peer_entry->transmit_task)
    {
      GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
      peer_entry->transmit_task = NULL;
    }
  }
  size_estimate_messages[idx] = *incoming_flood;
  size_estimate_messages[idx].hop_count =
    htonl (ntohl (incoming_flood->hop_count) + 1);
  hop_count_max =
    GNUNET_MAX (ntohl (incoming_flood->hop_count) + 1, hop_count_max);
  GNUNET_STATISTICS_set (stats,
                         "# estimated network diameter",
                         hop_count_max,
                         GNUNET_NO);
 
  /* have a new, better size estimate, inform clients */
  update_network_size_estimate ();
 
  /* flood to rest */
  GNUNET_CONTAINER_multipeermap_iterate (peers,
                                         &update_flood_times,
                                         peer_entry);
}
 
 
static void *
handle_core_connect (void *cls,
                     const struct GNUNET_PeerIdentity *peer,
                     struct GNUNET_MQ_Handle *mq,
                     enum GNUNET_CORE_PeerClass class)
{
  struct NSEPeerEntry *peer_entry;
 
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Peer `%s' connected to us\n",
              GNUNET_i2s (peer));
  /* set our default transmission options */
  GNUNET_MQ_set_options (mq, NSE_PRIORITY);
  /* create our peer entry for this peer */
  peer_entry = GNUNET_new (struct NSEPeerEntry);
  peer_entry->id = peer;
  peer_entry->mq = mq;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multipeermap_put (
                   peers,
                   peer_entry->id,
                   peer_entry,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  peer_entry->transmit_task =
    GNUNET_SCHEDULER_add_delayed (get_transmit_delay (-1),
                                  &transmit_task_cb,
                                  peer_entry);
  GNUNET_STATISTICS_update (stats, "# peers connected", 1, GNUNET_NO);
  return peer_entry;
}
 
 
static void
handle_core_disconnect (void *cls,
                        const struct GNUNET_PeerIdentity *peer,
                        void *internal_cls)
{
  struct NSEPeerEntry *pos = internal_cls;
 
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Peer `%s' disconnected from us\n",
              GNUNET_i2s (peer));
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (peers, peer, pos));
  if (NULL != pos->transmit_task)
  {
    GNUNET_SCHEDULER_cancel (pos->transmit_task);
    pos->transmit_task = NULL;
  }
  GNUNET_free (pos);
  GNUNET_STATISTICS_update (stats, "# peers connected", -1, GNUNET_NO);
}
 
 
#if ENABLE_NSE_HISTOGRAM
static void
flush_comp_cb (void *cls, size_t size)
{
  (void) cls;
  (void) size;
  GNUNET_TESTBED_LOGGER_disconnect (lh);
  lh = NULL;
}
 
 
#endif
 
 
static void
shutdown_task (void *cls)
{
  (void) cls;
  if (NULL != flood_task)
  {
    GNUNET_SCHEDULER_cancel (flood_task);
    flood_task = NULL;
  }
  if (NULL != proof_task)
  {
    GNUNET_SCHEDULER_cancel (proof_task);
    proof_task = NULL;
    write_proof ();  /* remember progress */
  }
  if (NULL != nc)
  {
    GNUNET_notification_context_destroy (nc);
    nc = NULL;
  }
  if (NULL != core_api)
  {
    GNUNET_CORE_disconnect (core_api);
    core_api = NULL;
  }
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
    stats = NULL;
  }
  if (NULL != peers)
  {
    GNUNET_CONTAINER_multipeermap_destroy (peers);
    peers = NULL;
  }
  if (NULL != pils)
  {
    GNUNET_PILS_disconnect (pils);
    pils = NULL;
  }
#if ENABLE_NSE_HISTOGRAM
  if (NULL != logger_test)
  {
    GNUNET_CLIENT_service_test_cancel (logger_test);
    logger_test = NULL;
  }
  if (NULL != lh)
  {
    GNUNET_TESTBED_LOGGER_flush (lh, &flush_comp_cb, NULL);
  }
  if (NULL != histogram)
  {
    GNUNET_BIO_write_close (histogram, NULL);
    histogram = NULL;
  }
#endif
}
 
 
static void
pils_id_change_cb (void *cls,
                   const struct GNUNET_HELLO_Parser *parser,
                   const struct GNUNET_HashCode *addr_hash)
{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_TIME_Absolute now;
  struct GNUNET_TIME_Absolute prev_time;
 
  my_identity = GNUNET_PILS_get_identity (pils);
 
  if (NULL != proof_task)
  {
    GNUNET_SCHEDULER_cancel (proof_task);
    proof_task = NULL;
  }
 
  if (NULL == my_identity)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Connection to core FAILED!\n");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  proof_task =
    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
                                        &find_proof,
                                        NULL);
  now = GNUNET_TIME_absolute_get ();
  current_timestamp.abs_value_us =
    (now.abs_value_us / gnunet_nse_interval.rel_value_us)
    * gnunet_nse_interval.rel_value_us;
  next_timestamp =
    GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
  estimate_index = HISTORY_SIZE - 1;
  estimate_count = 0;
  if (GNUNET_YES == check_proof_of_work (&(my_identity->public_key), my_proof))
  {
    int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
    prev_time.abs_value_us =
      current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us;
    setup_flood_message (idx, prev_time);
    setup_flood_message (estimate_index, current_timestamp);
    estimate_count++;
  }
  if (NULL != flood_task)
    GNUNET_SCHEDULER_cancel (flood_task);
  flood_task =
    GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL);
}
 
 
#if ENABLE_NSE_HISTOGRAM
static void
status_cb (void *cls, int status)
{
  (void) cls;
  logger_test = NULL;
  if (GNUNET_YES != status)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Testbed logger not running\n");
    return;
  }
  if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect (cfg)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Cannot connect to the testbed logger.  Exiting.\n");
    GNUNET_SCHEDULER_shutdown ();
  }
}
 
 
#endif
 
 
static void
run (void *cls,
     const struct GNUNET_CONFIGURATION_Handle *c,
     struct GNUNET_SERVICE_Handle *service)
{
  struct GNUNET_MQ_MessageHandler core_handlers[] =
  { GNUNET_MQ_hd_fixed_size (p2p_estimate,
                             GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD,
                             struct GNUNET_NSE_FloodMessage,
                             NULL),
    GNUNET_MQ_handler_end () };
  char *proof;
  const struct GNUNET_CORE_ServiceInfo service_info = {
    .service = GNUNET_CORE_SERVICE_NSE,
    .version = { 1, 0 },
    .version_max = { 1, 0 },
    .version_min = { 1, 0 },
  };
 
  (void) cls;
  (void) service;
  cfg = c;
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg,
                                                        "NSE",
                                                        "INTERVAL",
                                                        &gnunet_nse_interval))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "INTERVAL");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg,
                                                        "NSE",
                                                        "WORKDELAY",
                                                        &proof_find_delay))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKDELAY");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          "NSE",
                                                          "WORKBITS",
                                                          &nse_work_required))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (nse_work_required >= sizeof(struct GNUNET_HashCode) * 8)
  {
    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                               "NSE",
                               "WORKBITS",
                               _ ("Value is too large.\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
#if ENABLE_NSE_HISTOGRAM
  {
    char *histogram_dir;
    char *histogram_fn;
 
    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                              "NSE",
                                                              "HISTOGRAM_DIR",
                                                              &histogram_dir))
    {
      GNUNET_assert (
        0 < GNUNET_asprintf (&histogram_fn, "%s/timestamps", histogram_dir));
      GNUNET_free (histogram_dir);
      histogram = GNUNET_BIO_write_open_file (histogram_fn);
      if (NULL == histogram)
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Unable to open histogram file `%s'\n",
                    histogram_fn);
      GNUNET_free (histogram_fn);
    }
    logger_test = GNUNET_CLIENT_service_test ("testbed-logger",
                                              cfg,
                                              GNUNET_TIME_UNIT_SECONDS,
                                              &status_cb,
                                              NULL);
  }
#endif
 
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if ((GNUNET_YES != GNUNET_DISK_file_test (proof)) ||
      (sizeof(my_proof) !=
       GNUNET_DISK_fn_read (proof, &my_proof, sizeof(my_proof))))
    my_proof = 0;
  GNUNET_free (proof);
 
  peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
  nc = GNUNET_notification_context_create (1);
  /* Connect to core service and register core handlers */
  core_api =
    GNUNET_CORE_connect (cfg,  /* Main configuration */
                         NULL, /* Closure passed to functions */
                         NULL, /* Call core_init once connected */
                         &handle_core_connect, /* Handle connects */
                         &handle_core_disconnect, /* Handle disconnects */
                         core_handlers, /* Register these handlers */
                         &service_info);
  if (NULL == core_api)
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  pils = GNUNET_PILS_connect (cfg, &pils_id_change_cb, NULL);
  if (NULL == pils)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  stats = GNUNET_STATISTICS_create ("nse", cfg);
}
 
 
static void *
client_connect_cb (void *cls,
                   struct GNUNET_SERVICE_Client *c,
                   struct GNUNET_MQ_Handle *mq)
{
  (void) cls;
  (void) mq;
  return c;
}
 
 
static void
client_disconnect_cb (void *cls,
                      struct GNUNET_SERVICE_Client *c,
                      void *internal_cls)
{
  (void) cls;
  GNUNET_assert (c == internal_cls);
}
 
 
GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet (),
                     "nse",
                     GNUNET_SERVICE_OPTION_NONE,
                     &run,
                     &client_connect_cb,
                     &client_disconnect_cb,
                     NULL,
                     GNUNET_MQ_hd_fixed_size (start,
                                              GNUNET_MESSAGE_TYPE_NSE_START,
                                              struct GNUNET_MessageHeader,
                                              NULL),
                     GNUNET_MQ_handler_end ());
 
 
#if defined(__linux__) && defined(__GLIBC__)
#include <malloc.h>
 
void __attribute__ ((constructor))
GNUNET_NSE_memory_init (void);
 
void __attribute__ ((constructor))
GNUNET_NSE_memory_init (void)
{
  mallopt (M_TRIM_THRESHOLD, 4 * 1024);
  mallopt (M_TOP_PAD, 1 * 1024);
  malloc_trim (0);
}
 
 
#endif
 
 
/* end of gnunet-service-nse.c */

WEST

#define WEST   1

ROUND_SIZE

#define ROUND_SIZE   10

Function Documentation

setup_estimate_message()

static void setup_estimate_message ( struct GNUNET_NSE_ClientMessage *  em )

static

Initialize a message to clients with the current network size estimate.

Parameters

em	message to fill in

Definition at line 333 of file gnunet-service-nse.c.

{
  double mean;
  double sum;
  double std_dev;
  double variance;
  double val;
  double nsize;
 
#define WEST 1
  /* Weighted incremental algorithm for stddev according to West (1979) */
#if WEST
  double sumweight;
  double weight;
  double q;
  double r;
  double temp;
 
  mean = 0.0;
  sum = 0.0;
  sumweight = 0.0;
  variance = 0.0;
  for (unsigned int i = 0; i < estimate_count; i++)
  {
    unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
 
    val = htonl (size_estimate_messages[j].matching_bits);
    weight = estimate_count + 1 - i;
 
    temp = weight + sumweight;
    q = val - mean;
    r = q * weight / temp;
    mean += r;
    sum += sumweight * q * r;
    sumweight = temp;
  }
  if (estimate_count > 0)
    variance = (sum / sumweight) * estimate_count / (estimate_count - 1.0);
#else
  /* trivial version for debugging */
  double vsq;
 
  /* non-weighted trivial version */
  sum = 0.0;
  vsq = 0.0;
  variance = 0.0;
  mean = 0.0;
 
  for (unsigned int i = 0; i < estimate_count; i++)
  {
    unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
 
    val = htonl (size_estimate_messages[j].matching_bits);
    sum += val;
    vsq += val * val;
  }
  if (0 != estimate_count)
  {
    mean = sum / estimate_count;
    variance = (vsq - mean * sum)
               / (estimate_count - 1.0); // terrible for numerical stability...
  }
#endif
  if (variance >= 0)
    std_dev = sqrt (variance);
  else
    std_dev = variance; /* return NaN (due to estimate_count == 0 causing 0.0/0.0) */
  current_std_dev = std_dev;
  current_size_estimate = mean;
 
  em->header.size = htons (sizeof(struct GNUNET_NSE_ClientMessage));
  em->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_ESTIMATE);
  em->reserved = htonl (0);
  em->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
  {
    double se = mean - 0.332747;
    unsigned int j = GNUNET_CONTAINER_multipeermap_size (peers);
    if (0 == j)
      j = 1; /* Avoid log2(0); can only happen if CORE didn't report
                connection to self yet */
    nsize = log2 (j);
    em->size_estimate = GNUNET_hton_double (GNUNET_MAX (se, nsize));
    em->std_deviation = GNUNET_hton_double (std_dev);
    GNUNET_STATISTICS_set (stats,
                           "# nodes in the network (estimate)",
                           (uint64_t) pow (2, GNUNET_MAX (se, nsize)),
                           GNUNET_NO);
  }
}

References current_size_estimate, current_std_dev, estimate_count, estimate_index, GNUNET_CONTAINER_multipeermap_size(), GNUNET_hton_double(), GNUNET_MAX, GNUNET_MESSAGE_TYPE_NSE_ESTIMATE, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_hton(), GNUNET_NSE_ClientMessage::header, HISTORY_SIZE, matching_bits, peers, q, GNUNET_NSE_ClientMessage::reserved, GNUNET_MessageHeader::size, GNUNET_NSE_ClientMessage::size_estimate, size_estimate_messages, stats, GNUNET_NSE_ClientMessage::std_deviation, GNUNET_NSE_ClientMessage::timestamp, and GNUNET_MessageHeader::type.

Referenced by handle_start(), and update_network_size_estimate().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_start()

static void handle_start ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Handler for START message from client, triggers an immediate current network estimate notification.

Also, we remember the client for updates upon future estimate measurements.

Parameters

cls	client who sent the message
message	the message received

Definition at line 434 of file gnunet-service-nse.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_MQ_Handle *mq;
  struct GNUNET_NSE_ClientMessage em;
  struct GNUNET_MQ_Envelope *env;
 
  (void) message;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received START message from client\n");
  mq = GNUNET_SERVICE_client_get_mq (client);
  GNUNET_notification_context_add (nc, mq);
  setup_estimate_message (&em);
  env = GNUNET_MQ_msg_copy (&em.header);
  GNUNET_MQ_send (mq, env);
  GNUNET_SERVICE_client_continue (client);
}

References env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), GNUNET_notification_context_add(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), GNUNET_NSE_ClientMessage::header, mq, nc, and setup_estimate_message().

Here is the call graph for this function:

get_matching_bits_delay()

static double get_matching_bits_delay ( uint32_t  matching_bits )

static

How long should we delay a message to go the given number of matching bits?

Parameters

matching_bits

number of matching bits to consider

Definition at line 459 of file gnunet-service-nse.c.

{
  /* Calculated as: S + f/2 - (f / pi) * (atan(x - p')) */
  // S is next_timestamp (ignored in return value)
  // f is frequency (gnunet_nse_interval)
  // x is matching_bits
  // p' is current_size_estimate
  return ((double) gnunet_nse_interval.rel_value_us / (double) 2.0)
         - ((gnunet_nse_interval.rel_value_us / M_PI)
            * atan (matching_bits - current_size_estimate));
}

References current_size_estimate, gnunet_nse_interval, matching_bits, and GNUNET_TIME_Relative::rel_value_us.

Referenced by get_delay_randomization(), and get_transmit_delay().

Here is the caller graph for this function:

get_delay_randomization()

static struct GNUNET_TIME_Relative get_delay_randomization ( uint32_t  matching_bits )

static

What delay randomization should we apply for a given number of matching bits?

Parameters

matching_bits

number of matching bits

Returns

random delay to apply

Definition at line 479 of file gnunet-service-nse.c.

{
#if USE_RANDOM_DELAYS
  struct GNUNET_TIME_Relative ret;
  uint32_t i;
  double d;
 
  d = get_matching_bits_delay (matching_bits);
  i = (uint32_t) (d / (double) (hop_count_max + 1));
  ret.rel_value_us = i;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Randomizing flood using latencies up to %s\n",
              GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
  ret.rel_value_us =
    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, i + 1);
  return ret;
#else
  return GNUNET_TIME_UNIT_ZERO;
#endif
}

References d, get_matching_bits_delay(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_UNIT_ZERO, GNUNET_YES, hop_count_max, matching_bits, and ret.

Referenced by get_transmit_delay().

Here is the call graph for this function:

Here is the caller graph for this function:

get_matching_bits()

static uint32_t get_matching_bits ( struct GNUNET_TIME_Absolute  timestamp, const struct GNUNET_PeerIdentity *  id  )

static

Get the number of matching bits that the given timestamp has to the given peer ID.

Parameters

timestamp	time to generate key
id	peer identity to compare with

Returns

number of matching bits

Definition at line 509 of file gnunet-service-nse.c.

{
  struct GNUNET_HashCode timestamp_hash;
  struct GNUNET_HashCode pid_hash;
  struct GNUNET_HashCode xor;
 
  GNUNET_CRYPTO_hash (&timestamp.abs_value_us,
                      sizeof(timestamp.abs_value_us),
                      &timestamp_hash);
  GNUNET_CRYPTO_hash (id,
                      sizeof(struct GNUNET_PeerIdentity),
                      &pid_hash);
  GNUNET_CRYPTO_hash_xor (&pid_hash,
                          &timestamp_hash,
                          &xor);
  return GNUNET_CRYPTO_hash_count_leading_zeros (&xor);
}

References GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hash_count_leading_zeros(), GNUNET_CRYPTO_hash_xor(), and timestamp().

Referenced by setup_flood_message(), and update_flood_message().

Here is the call graph for this function:

Here is the caller graph for this function:

get_transmit_delay()

static struct GNUNET_TIME_Relative get_transmit_delay ( int  round_offset )

static

Get the transmission delay that should be applied for a particular round.

Parameters

round_offset

-1 for the previous round (random delay between 0 and 50ms) 0 for the current round (based on our proximity to time key)

Returns

delay that should be applied

Definition at line 538 of file gnunet-service-nse.c.

{
  struct GNUNET_TIME_Relative ret;
  struct GNUNET_TIME_Absolute tgt;
  double dist_delay;
  uint32_t matching_bits;
 
  switch (round_offset)
  {
  case -1:
    /* previous round is randomized between 0 and 50 ms */
#if USE_RANDOM_DELAYS
    ret.rel_value_us =
      GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, 50);
#else
    ret = GNUNET_TIME_UNIT_ZERO;
#endif
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Transmitting previous round behind schedule in %s\n",
                GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
    return ret;
 
  case 0:
    /* current round is based on best-known matching_bits */
    matching_bits =
      ntohl (size_estimate_messages[estimate_index].matching_bits);
    dist_delay = get_matching_bits_delay (matching_bits);
    dist_delay += get_delay_randomization (matching_bits).rel_value_us;
    ret.rel_value_us = (uint64_t) dist_delay;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "For round %s, delay for %u matching bits is %s\n",
                GNUNET_STRINGS_absolute_time_to_string (current_timestamp),
                (unsigned int) matching_bits,
                GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES));
    /* now consider round start time and add delay to it */
    tgt = GNUNET_TIME_absolute_add (current_timestamp, ret);
    return GNUNET_TIME_absolute_get_remaining (tgt);
  }
  GNUNET_break (0);
  return GNUNET_TIME_UNIT_FOREVER_REL;
}

References current_timestamp, estimate_index, get_delay_randomization(), get_matching_bits_delay(), GNUNET_break, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_ZERO, GNUNET_YES, matching_bits, GNUNET_TIME_Relative::rel_value_us, ret, and size_estimate_messages.

Referenced by handle_core_connect(), schedule_current_round(), transmit_task_cb(), and update_flood_times().

Here is the call graph for this function:

Here is the caller graph for this function:

sign_message_before_send_cb()

static void sign_message_before_send_cb ( void *  cls, const struct GNUNET_PeerIdentity *  pid, const struct GNUNET_CRYPTO_EddsaSignature *  sig  )

static

Definition at line 582 of file gnunet-service-nse.c.

{
  struct NSEPeerEntry *pe = cls;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_NSE_FloodMessage *fm;
 
  pe->pils_op = NULL;
  fm = &size_estimate_messages[pe->next_index_to_send];
  fm->signature = *sig;
  env = GNUNET_MQ_msg_copy (&fm->header);
  GNUNET_MQ_send (pe->mq, env);
}

References env, GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), GNUNET_NSE_FloodMessage::header, NSEPeerEntry::mq, NSEPeerEntry::next_index_to_send, NSEPeerEntry::pils_op, GNUNET_NSE_FloodMessage::signature, and size_estimate_messages.

Referenced by transmit_task_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_task_cb()

static void transmit_task_cb ( void *  cls )

static

Task that triggers a NSE P2P transmission.

Parameters

cls	the struct NSEPeerEntry *

Definition at line 604 of file gnunet-service-nse.c.

{
  struct NSEPeerEntry *peer_entry = cls;
  unsigned int idx;
 
  peer_entry->transmit_task = NULL;
  idx = estimate_index;
  if (GNUNET_NO == peer_entry->previous_round)
  {
    idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE;
    peer_entry->previous_round = GNUNET_YES;
    peer_entry->transmit_task =
      GNUNET_SCHEDULER_add_delayed (get_transmit_delay (0),
                                    &transmit_task_cb,
                                    peer_entry);
  }
  if ((0 == ntohl (size_estimate_messages[idx].hop_count)) &&
      (NULL != proof_task))
  {
    GNUNET_STATISTICS_update (stats,
                              "# flood messages not generated (no proof yet)",
                              1,
                              GNUNET_NO);
    return;
  }
  if (0 == ntohs (size_estimate_messages[idx].header.size))
  {
    GNUNET_STATISTICS_update (stats,
                              "# flood messages not generated (lack of history)",
                              1,
                              GNUNET_NO);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "In round %s, sending to `%s' estimate with %u bits\n",
              GNUNET_STRINGS_absolute_time_to_string (
                GNUNET_TIME_absolute_ntoh (
                  size_estimate_messages[idx].timestamp)),
              GNUNET_i2s (peer_entry->id),
              (unsigned int) ntohl (size_estimate_messages[idx].matching_bits));
  if (0 == ntohl (size_estimate_messages[idx].hop_count))
    GNUNET_STATISTICS_update (stats, "# flood messages started", 1, GNUNET_NO);
  GNUNET_STATISTICS_update (stats,
                            "# flood messages transmitted",
                            1,
                            GNUNET_NO);
#if ENABLE_NSE_HISTOGRAM
  peer_entry->transmitted_messages++;
  peer_entry->last_transmitted_size =
    ntohl (size_estimate_messages[idx].matching_bits);
#endif
  peer_entry->next_index_to_send = idx;
  peer_entry->pils_op = GNUNET_PILS_sign_by_peer_identity (
    pils,
    &size_estimate_messages[idx].purpose,
    &sign_message_before_send_cb,
    peer_entry);
}

References estimate_index, get_transmit_delay(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_PILS_sign_by_peer_identity(), GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_ntoh(), GNUNET_YES, HISTORY_SIZE, NSEPeerEntry::id, matching_bits, NSEPeerEntry::next_index_to_send, pils, NSEPeerEntry::pils_op, NSEPeerEntry::previous_round, proof_task, sign_message_before_send_cb(), size_estimate_messages, stats, timestamp(), NSEPeerEntry::transmit_task, and transmit_task_cb().

Referenced by handle_core_connect(), handle_p2p_estimate(), schedule_current_round(), transmit_task_cb(), and update_flood_times().

Here is the call graph for this function:

Here is the caller graph for this function:

update_network_size_estimate()

static void update_network_size_estimate ( )

static

We've sent on our flood message or one that we received which was validated and closer than ours.

Update the global list of recent messages and the average. Also re-broadcast the message to any clients.

Definition at line 671 of file gnunet-service-nse.c.

{
  struct GNUNET_NSE_ClientMessage em;
 
  setup_estimate_message (&em);
  GNUNET_notification_context_broadcast (nc, &em.header, GNUNET_YES);
}

References GNUNET_notification_context_broadcast(), GNUNET_YES, GNUNET_NSE_ClientMessage::header, nc, and setup_estimate_message().

Referenced by handle_p2p_estimate(), and load_underlay().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_flood_message()

static void setup_flood_message ( unsigned int  slot, struct GNUNET_TIME_Absolute  ts  )

static

Setup a flood message in our history array at the given slot offset for the given timestamp.

Parameters

slot	index to use
ts	timestamp to use

Definition at line 688 of file gnunet-service-nse.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_NSE_FloodMessage *fm;
  uint32_t matching_bits;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  matching_bits = get_matching_bits (ts, my_identity);
  fm = &size_estimate_messages[slot];
  fm->header.size = htons (sizeof(struct GNUNET_NSE_FloodMessage));
  fm->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD);
  fm->hop_count = htonl (0);
  fm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_NSE_SEND);
  fm->purpose.size =
    htonl (sizeof(struct GNUNET_NSE_FloodMessage)
           - sizeof(struct GNUNET_MessageHeader) - sizeof(uint32_t)
           - sizeof(struct GNUNET_CRYPTO_EddsaSignature));
  fm->matching_bits = htonl (matching_bits);
  fm->timestamp = GNUNET_TIME_absolute_hton (ts);
  fm->origin = *my_identity;
  fm->proof_of_work = my_proof;
  memset (&fm->signature, 0, sizeof(fm->signature));
}

References get_matching_bits(), GNUNET_assert, GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD, GNUNET_PILS_get_identity(), GNUNET_SIGNATURE_PURPOSE_NSE_SEND, GNUNET_TIME_absolute_hton(), GNUNET_NSE_FloodMessage::header, GNUNET_NSE_FloodMessage::hop_count, matching_bits, GNUNET_NSE_FloodMessage::matching_bits, my_identity, my_proof, GNUNET_NSE_FloodMessage::origin, pils, GNUNET_NSE_FloodMessage::proof_of_work, GNUNET_CRYPTO_SignaturePurpose::purpose, GNUNET_NSE_FloodMessage::purpose, GNUNET_NSE_FloodMessage::signature, GNUNET_MessageHeader::size, GNUNET_CRYPTO_SignaturePurpose::size, size_estimate_messages, GNUNET_NSE_FloodMessage::timestamp, and GNUNET_MessageHeader::type.

Referenced by find_proof(), pils_id_change_cb(), and update_flood_message().

Here is the call graph for this function:

Here is the caller graph for this function:

schedule_current_round()

static int schedule_current_round ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Schedule transmission for the given peer for the current round based on what we know about the desired delay.

Parameters

cls	unused
key	hash of peer identity
value	the struct NSEPeerEntry

Returns

GNUNET_OK (continue to iterate)

Definition at line 725 of file gnunet-service-nse.c.

{
  struct NSEPeerEntry *peer_entry = value;
  struct GNUNET_TIME_Relative delay;
 
  (void) cls;
  (void) key;
  if (NULL != peer_entry->transmit_task)
  {
    GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
    peer_entry->previous_round = GNUNET_NO;
  }
#if ENABLE_NSE_HISTOGRAM
  if (peer_entry->received_messages > 1)
    GNUNET_STATISTICS_update (stats,
                              "# extra messages",
                              peer_entry->received_messages - 1,
                              GNUNET_NO);
  peer_entry->transmitted_messages = 0;
  peer_entry->last_transmitted_size = 0;
  peer_entry->received_messages = 0;
#endif
  delay =
    get_transmit_delay ((GNUNET_NO == peer_entry->previous_round) ? -1 : 0);
  peer_entry->transmit_task =
    GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry);
  return GNUNET_OK;
}

References get_transmit_delay(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), key, NSEPeerEntry::previous_round, stats, NSEPeerEntry::transmit_task, transmit_task_cb(), and value.

Referenced by update_flood_message().

Here is the call graph for this function:

Here is the caller graph for this function:

update_flood_message()

static void update_flood_message ( void *  cls )

static

Update our flood message to be sent (and our timestamps).

Parameters

cls

unused

Definition at line 763 of file gnunet-service-nse.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_TIME_Relative offset;
 
  (void) cls;
  flood_task = NULL;
  my_identity = GNUNET_PILS_get_identity (pils);
  if (! my_identity)
    return;
 
  offset = GNUNET_TIME_absolute_get_remaining (next_timestamp);
  if (0 != offset.rel_value_us)
  {
    /* somehow run early, delay more */
    flood_task =
      GNUNET_SCHEDULER_add_delayed (offset, &update_flood_message, NULL);
    return;
  }
  estimate_index = (estimate_index + 1) % HISTORY_SIZE;
  if (estimate_count < HISTORY_SIZE)
    estimate_count++;
  current_timestamp = next_timestamp;
  next_timestamp =
    GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
  if ((current_timestamp.abs_value_us ==
       GNUNET_TIME_absolute_ntoh (next_message.timestamp).abs_value_us) &&
      (get_matching_bits (current_timestamp, my_identity) <
       ntohl (next_message.matching_bits)))
  {
    /* we received a message for this round way early, use it! */
    size_estimate_messages[estimate_index] = next_message;
    size_estimate_messages[estimate_index].hop_count =
      htonl (1 + ntohl (next_message.hop_count));
  }
  else
    setup_flood_message (estimate_index, current_timestamp);
  next_message.matching_bits = htonl (0);  /* reset for 'next' round */
  hop_count_max = 0;
  for (unsigned int i = 0; i < HISTORY_SIZE; i++)
    hop_count_max =
      GNUNET_MAX (ntohl (size_estimate_messages[i].hop_count), hop_count_max);
  GNUNET_CONTAINER_multipeermap_iterate (peers, &schedule_current_round, NULL);
  flood_task =
    GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL);
}

References GNUNET_TIME_Absolute::abs_value_us, current_timestamp, estimate_count, estimate_index, flood_task, get_matching_bits(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_MAX, gnunet_nse_interval, GNUNET_PILS_get_identity(), GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_ntoh(), HISTORY_SIZE, GNUNET_NSE_FloodMessage::hop_count, hop_count_max, GNUNET_NSE_FloodMessage::matching_bits, my_identity, next_message, next_timestamp, peers, pils, GNUNET_TIME_Relative::rel_value_us, schedule_current_round(), setup_flood_message(), size_estimate_messages, GNUNET_NSE_FloodMessage::timestamp, and update_flood_message().

Referenced by pils_id_change_cb(), and update_flood_message().

Here is the call graph for this function:

Here is the caller graph for this function:

check_proof_of_work()

static enum GNUNET_GenericReturnValue check_proof_of_work ( const struct GNUNET_CRYPTO_EddsaPublicKey *  pkey, uint64_t  val  )

static

Check whether the given public key and integer are a valid proof of work.

Parameters

pkey	the public key
val	the integer

Returns

GNUNET_YES if valid, GNUNET_NO if not

Definition at line 820 of file gnunet-service-nse.c.

{
  char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)
           + sizeof(val)] GNUNET_ALIGN;
  struct GNUNET_HashCode result;
 
  GNUNET_memcpy (buf, &val, sizeof(val));
  GNUNET_memcpy (&buf[sizeof(val)],
                 pkey,
                 sizeof(struct GNUNET_CRYPTO_EddsaPublicKey));
  GNUNET_CRYPTO_pow_hash (&salt,
                          buf,
                          sizeof(buf),
                          &result);
  return (GNUNET_CRYPTO_hash_count_leading_zeros (&result) >=
          nse_work_required)
    ? GNUNET_YES
    : GNUNET_NO;
}

References GNUNET_ALIGN, GNUNET_CRYPTO_hash_count_leading_zeros(), GNUNET_CRYPTO_pow_hash(), GNUNET_memcpy, GNUNET_NO, GNUNET_YES, nse_work_required, pkey, result, and salt.

Referenced by pils_id_change_cb(), and verify_message_crypto().

Here is the call graph for this function:

Here is the caller graph for this function:

write_proof()

static void write_proof ( void  )

static

Write our current proof to disk.

Definition at line 846 of file gnunet-service-nse.c.

{
  char *proof;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg,
                                               "NSE",
                                               "PROOFFILE",
                                               &proof))
    return;
  (void) GNUNET_DISK_directory_remove (proof);
  if (GNUNET_OK !=
      GNUNET_DISK_fn_write (proof,
                            &my_proof,
                            sizeof(my_proof),
                            GNUNET_DISK_PERM_USER_READ
                            | GNUNET_DISK_PERM_USER_WRITE))
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                              "write",
                              proof);
  GNUNET_free (proof);
}

References cfg, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_DISK_directory_remove(), GNUNET_DISK_fn_write(), GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_strerror_file, GNUNET_OK, my_proof, and proof.

Referenced by find_proof(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

find_proof()

static void find_proof ( void *  cls )

static

Find our proof of work.

Parameters

cls	closure (unused)

Definition at line 876 of file gnunet-service-nse.c.

{
#define ROUND_SIZE 10
  uint64_t counter;
  char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)
           + sizeof(uint64_t)] GNUNET_ALIGN;
  struct GNUNET_HashCode result;
  const struct GNUNET_PeerIdentity *my_identity;
  unsigned int i;
 
  (void) cls;
  proof_task = NULL;
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
  GNUNET_memcpy (&buf[sizeof(uint64_t)],
                 my_identity,
                 sizeof(struct GNUNET_PeerIdentity));
  i = 0;
  counter = my_proof;
  while ((counter != UINT64_MAX) && (i < ROUND_SIZE))
  {
    GNUNET_memcpy (buf, &counter, sizeof(uint64_t));
    GNUNET_CRYPTO_pow_hash (&salt,
                            buf,
                            sizeof(buf),
                            &result);
    if (nse_work_required <=
        GNUNET_CRYPTO_hash_count_leading_zeros (&result))
    {
      my_proof = counter;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Proof of work found: %llu!\n",
                  (unsigned long long) GNUNET_ntohll (counter));
      write_proof ();
      setup_flood_message (estimate_index, current_timestamp);
      return;
    }
    counter++;
    i++;
  }
  if (my_proof / (100 * ROUND_SIZE) < counter / (100 * ROUND_SIZE))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Testing proofs currently at %llu\n",
                (unsigned long long) counter);
    /* remember progress every 100 rounds */
    my_proof = counter;
    write_proof ();
  }
  else
  {
    my_proof = counter;
  }
  proof_task =
    GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay,
                                                GNUNET_SCHEDULER_PRIORITY_IDLE,
                                                &find_proof,
                                                NULL);
}

References current_timestamp, estimate_index, find_proof(), GNUNET_ALIGN, GNUNET_assert, GNUNET_CRYPTO_hash_count_leading_zeros(), GNUNET_CRYPTO_pow_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_ntohll(), GNUNET_PILS_get_identity(), GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_PRIORITY_IDLE, my_identity, my_proof, nse_work_required, pils, proof_find_delay, proof_task, result, ROUND_SIZE, salt, setup_flood_message(), and write_proof().

Referenced by find_proof(), and pils_id_change_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

verify_message_crypto()

static int verify_message_crypto ( const struct GNUNET_NSE_FloodMessage *  incoming_flood )

static

An incoming flood message has been received which claims to have more bits matching than any we know in this time period.

Verify the signature and/or proof of work.

Parameters

incoming_flood

the message to verify

Returns

GNUNET_YES if the message is verified GNUNET_NO if the key/signature don't verify

Definition at line 947 of file gnunet-service-nse.c.

{
  if (GNUNET_YES != check_proof_of_work (&incoming_flood->origin.public_key,
                                         incoming_flood->proof_of_work))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Proof of work invalid: %llu!\n",
                (unsigned long long) GNUNET_ntohll (
                  incoming_flood->proof_of_work));
    GNUNET_break_op (0);
    return GNUNET_NO;
  }
  if ((nse_work_required > 0) &&
      (GNUNET_OK !=
       GNUNET_CRYPTO_eddsa_verify_ (GNUNET_SIGNATURE_PURPOSE_NSE_SEND,
                                    &incoming_flood->purpose,
                                    &incoming_flood->signature,
                                    &incoming_flood->origin.public_key)))
  {
    GNUNET_break_op (0);
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

References check_proof_of_work(), GNUNET_break_op, GNUNET_CRYPTO_eddsa_verify_(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_NSE_SEND, GNUNET_YES, nse_work_required, GNUNET_NSE_FloodMessage::origin, GNUNET_NSE_FloodMessage::proof_of_work, GNUNET_PeerIdentity::public_key, GNUNET_NSE_FloodMessage::purpose, and GNUNET_NSE_FloodMessage::signature.

Referenced by handle_p2p_estimate().

Here is the call graph for this function:

Here is the caller graph for this function:

update_flood_times()

static int update_flood_times ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Update transmissions for the given peer for the current round based on updated proximity information.

Parameters

cls	peer entry to exclude from updates
key	hash of peer identity
value	the struct NSEPeerEntry * of a peer to transmit to

Returns

GNUNET_OK (continue to iterate)

Definition at line 983 of file gnunet-service-nse.c.

{
  struct NSEPeerEntry *exclude = cls;
  struct NSEPeerEntry *peer_entry = value;
  struct GNUNET_TIME_Relative delay;
 
  (void) key;
  if (peer_entry == exclude)
    return GNUNET_OK; /* trigger of the update */
  if (GNUNET_NO == peer_entry->previous_round)
  {
    /* still stuck in previous round, no point to update, check that
     * we are active here though... */
    if (NULL == peer_entry->transmit_task)
    {
      GNUNET_break (0);
    }
    return GNUNET_OK;
  }
  if (NULL != peer_entry->transmit_task)
  {
    GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
    peer_entry->transmit_task = NULL;
  }
  delay = get_transmit_delay (0);
  peer_entry->transmit_task =
    GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry);
  return GNUNET_OK;
}

References get_transmit_delay(), GNUNET_break, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), key, NSEPeerEntry::previous_round, NSEPeerEntry::transmit_task, transmit_task_cb(), and value.

Referenced by handle_p2p_estimate().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_p2p_estimate()

static void handle_p2p_estimate ( void *  cls, const struct GNUNET_NSE_FloodMessage *  incoming_flood  )

static

Core handler for size estimate flooding messages.

Parameters

cls	peer this message is from
incoming_flood	received message

Definition at line 1023 of file gnunet-service-nse.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct NSEPeerEntry *peer_entry = cls;
  struct GNUNET_TIME_Absolute ts;
  uint32_t matching_bits;
  unsigned int idx;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  if (! my_identity)
    return;
 
#if ENABLE_NSE_HISTOGRAM
  {
    uint64_t t;
 
    t = GNUNET_TIME_absolute_get ().abs_value_us;
    if (NULL != lh)
      GNUNET_TESTBED_LOGGER_write (lh, &t, sizeof(uint64_t));
    if (NULL != histogram)
      GNUNET_BIO_write_int64 (histogram, "histogram-time", t);
  }
#endif
  GNUNET_STATISTICS_update (stats, "# flood messages received", 1, GNUNET_NO);
  matching_bits = ntohl (incoming_flood->matching_bits);
#if DEBUG_NSE
  {
    char origin[5];
    char pred[5];
    struct GNUNET_PeerIdentity os;
 
    GNUNET_snprintf (origin,
                     sizeof(origin),
                     "%s",
                     GNUNET_i2s (&incoming_flood->origin));
    GNUNET_snprintf (pred, sizeof(pred), "%s", GNUNET_i2s (peer_entry->id));
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Flood at %s from `%s' via `%s' at `%s' with bits %u\n",
                GNUNET_STRINGS_absolute_time_to_string (
                  GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp)),
                origin,
                pred,
                GNUNET_i2s (&my_identity),
                (unsigned int) matching_bits);
  }
#endif
 
#if ENABLE_NSE_HISTOGRAM
  peer_entry->received_messages++;
  if ((peer_entry->transmitted_messages > 0) &&
      (peer_entry->last_transmitted_size >= matching_bits) )
    GNUNET_STATISTICS_update (stats, "# cross messages", 1, GNUNET_NO);
#endif
 
  ts = GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp);
  if (ts.abs_value_us == current_timestamp.abs_value_us)
    idx = estimate_index;
  else if (ts.abs_value_us ==
           current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us)
    idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
  else if (ts.abs_value_us == next_timestamp.abs_value_us)
  {
    if (matching_bits <= ntohl (next_message.matching_bits))
      return;   /* ignore, simply too early/late */
    if (GNUNET_YES != verify_message_crypto (incoming_flood))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Peer %s is likely ill-configured!\n",
                  GNUNET_i2s (peer_entry->id));
      GNUNET_break_op (0);
      return;
    }
    next_message = *incoming_flood;
    return;
  }
  else
  {
    GNUNET_STATISTICS_update (stats,
                              "# flood messages discarded (clock skew too large)",
                              1,
                              GNUNET_NO);
    return;
  }
  if (0 == (GNUNET_memcmp (peer_entry->id, my_identity)))
  {
    /* send to self, update our own estimate IF this also comes from us! */
    if (0 == GNUNET_memcmp (&incoming_flood->origin, my_identity))
      update_network_size_estimate ();
    return;
  }
  if (matching_bits == ntohl (size_estimate_messages[idx].matching_bits))
  {
    /* Cancel transmission in the other direction, as this peer clearly has
       up-to-date information already. Even if we didn't talk to this peer in
       the previous round, we should no longer send it stale information as it
       told us about the current round! */
    peer_entry->previous_round = GNUNET_YES;
    if (idx != estimate_index)
    {
      /* do not transmit information for the previous round to this peer
         anymore (but allow current round) */
      return;
    }
    /* got up-to-date information for current round, cancel transmission to
     * this peer altogether */
    if (NULL != peer_entry->transmit_task)
    {
      GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
      peer_entry->transmit_task = NULL;
    }
    return;
  }
  if (matching_bits < ntohl (size_estimate_messages[idx].matching_bits))
  {
    if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES))
    {
      peer_entry->previous_round = GNUNET_NO;
    }
    /* push back our result now, that peer is spreading bad information... */
    if (NULL != peer_entry->transmit_task)
      GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
    peer_entry->transmit_task =
      GNUNET_SCHEDULER_add_now (&transmit_task_cb, peer_entry);
    /* Not closer than our most recent message, no need to do work here */
    GNUNET_STATISTICS_update (stats,
                              "# flood messages ignored (had closer already)",
                              1,
                              GNUNET_NO);
    return;
  }
  if (GNUNET_YES != verify_message_crypto (incoming_flood))
  {
    GNUNET_break_op (0);
    return;
  }
  GNUNET_assert (matching_bits >
                 ntohl (size_estimate_messages[idx].matching_bits));
  /* Cancel transmission in the other direction, as this peer clearly has
   * up-to-date information already.
   */
  peer_entry->previous_round = GNUNET_YES;
  if (idx == estimate_index)
  {
    /* cancel any activity for current round */
    if (NULL != peer_entry->transmit_task)
    {
      GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
      peer_entry->transmit_task = NULL;
    }
  }
  size_estimate_messages[idx] = *incoming_flood;
  size_estimate_messages[idx].hop_count =
    htonl (ntohl (incoming_flood->hop_count) + 1);
  hop_count_max =
    GNUNET_MAX (ntohl (incoming_flood->hop_count) + 1, hop_count_max);
  GNUNET_STATISTICS_set (stats,
                         "# estimated network diameter",
                         hop_count_max,
                         GNUNET_NO);
 
  /* have a new, better size estimate, inform clients */
  update_network_size_estimate ();
 
  /* flood to rest */
  GNUNET_CONTAINER_multipeermap_iterate (peers,
                                         &update_flood_times,
                                         peer_entry);
}

References GNUNET_TIME_Absolute::abs_value_us, current_timestamp, estimate_index, GNUNET_assert, GNUNET_BIO_write_int64(), GNUNET_break_op, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_i2s(), GNUNET_log, GNUNET_MAX, GNUNET_memcmp, GNUNET_NO, gnunet_nse_interval, GNUNET_PILS_get_identity(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_snprintf(), GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_ntoh(), GNUNET_YES, HISTORY_SIZE, GNUNET_NSE_FloodMessage::hop_count, hop_count_max, NSEPeerEntry::id, matching_bits, GNUNET_NSE_FloodMessage::matching_bits, my_identity, next_message, next_timestamp, origin, GNUNET_NSE_FloodMessage::origin, peers, pils, NSEPeerEntry::previous_round, GNUNET_TIME_Relative::rel_value_us, size_estimate_messages, stats, t, GNUNET_NSE_FloodMessage::timestamp, NSEPeerEntry::transmit_task, transmit_task_cb(), update_flood_times(), update_network_size_estimate(), and verify_message_crypto().

Here is the call graph for this function:

handle_core_connect()

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

static

Method called whenever a peer connects.

Sets up the PeerEntry and schedules the initial size info transmission to this peer.

Parameters

cls	closure
peer	peer identity this notification is about
class	class of the connecting peer

Definition at line 1203 of file gnunet-service-nse.c.

{
  struct NSEPeerEntry *peer_entry;
 
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Peer `%s' connected to us\n",
              GNUNET_i2s (peer));
  /* set our default transmission options */
  GNUNET_MQ_set_options (mq, NSE_PRIORITY);
  /* create our peer entry for this peer */
  peer_entry = GNUNET_new (struct NSEPeerEntry);
  peer_entry->id = peer;
  peer_entry->mq = mq;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multipeermap_put (
                   peers,
                   peer_entry->id,
                   peer_entry,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  peer_entry->transmit_task =
    GNUNET_SCHEDULER_add_delayed (get_transmit_delay (-1),
                                  &transmit_task_cb,
                                  peer_entry);
  GNUNET_STATISTICS_update (stats, "# peers connected", 1, GNUNET_NO);
  return peer_entry;
}

References get_transmit_delay(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MQ_set_options(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), NSEPeerEntry::id, mq, NSEPeerEntry::mq, NSE_PRIORITY, peers, stats, NSEPeerEntry::transmit_task, and transmit_task_cb().

Referenced by run().

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.

Deletes the PeerEntry and cancels any pending transmission requests to that peer.

Parameters

cls	closure
peer	peer identity this notification is about
internal_cls	the struct NSEPeerEntry for the peer

Definition at line 1244 of file gnunet-service-nse.c.

{
  struct NSEPeerEntry *pos = internal_cls;
 
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Peer `%s' disconnected from us\n",
              GNUNET_i2s (peer));
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (peers, peer, pos));
  if (NULL != pos->transmit_task)
  {
    GNUNET_SCHEDULER_cancel (pos->transmit_task);
    pos->transmit_task = NULL;
  }
  GNUNET_free (pos);
  GNUNET_STATISTICS_update (stats, "# peers connected", -1, GNUNET_NO);
}

References GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), GNUNET_YES, peers, stats, and NSEPeerEntry::transmit_task.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

unused

Definition at line 1293 of file gnunet-service-nse.c.

{
  (void) cls;
  if (NULL != flood_task)
  {
    GNUNET_SCHEDULER_cancel (flood_task);
    flood_task = NULL;
  }
  if (NULL != proof_task)
  {
    GNUNET_SCHEDULER_cancel (proof_task);
    proof_task = NULL;
    write_proof ();  /* remember progress */
  }
  if (NULL != nc)
  {
    GNUNET_notification_context_destroy (nc);
    nc = NULL;
  }
  if (NULL != core_api)
  {
    GNUNET_CORE_disconnect (core_api);
    core_api = NULL;
  }
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
    stats = NULL;
  }
  if (NULL != peers)
  {
    GNUNET_CONTAINER_multipeermap_destroy (peers);
    peers = NULL;
  }
  if (NULL != pils)
  {
    GNUNET_PILS_disconnect (pils);
    pils = NULL;
  }
#if ENABLE_NSE_HISTOGRAM
  if (NULL != logger_test)
  {
    GNUNET_CLIENT_service_test_cancel (logger_test);
    logger_test = NULL;
  }
  if (NULL != lh)
  {
    GNUNET_TESTBED_LOGGER_flush (lh, &flush_comp_cb, NULL);
  }
  if (NULL != histogram)
  {
    GNUNET_BIO_write_close (histogram, NULL);
    histogram = NULL;
  }
#endif
}

References core_api, flood_task, GNUNET_BIO_write_close(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CORE_disconnect(), GNUNET_NO, GNUNET_notification_context_destroy(), GNUNET_PILS_disconnect(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), nc, peers, pils, proof_task, stats, and write_proof().

Here is the call graph for this function:

pils_id_change_cb()

static void pils_id_change_cb ( void *  cls, const struct GNUNET_HELLO_Parser *  parser, const struct GNUNET_HashCode *  addr_hash  )

static

Definition at line 1352 of file gnunet-service-nse.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_TIME_Absolute now;
  struct GNUNET_TIME_Absolute prev_time;
 
  my_identity = GNUNET_PILS_get_identity (pils);
 
  if (NULL != proof_task)
  {
    GNUNET_SCHEDULER_cancel (proof_task);
    proof_task = NULL;
  }
 
  if (NULL == my_identity)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Connection to core FAILED!\n");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  proof_task =
    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
                                        &find_proof,
                                        NULL);
  now = GNUNET_TIME_absolute_get ();
  current_timestamp.abs_value_us =
    (now.abs_value_us / gnunet_nse_interval.rel_value_us)
    * gnunet_nse_interval.rel_value_us;
  next_timestamp =
    GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
  estimate_index = HISTORY_SIZE - 1;
  estimate_count = 0;
  if (GNUNET_YES == check_proof_of_work (&(my_identity->public_key), my_proof))
  {
    int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
    prev_time.abs_value_us =
      current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us;
    setup_flood_message (idx, prev_time);
    setup_flood_message (estimate_index, current_timestamp);
    estimate_count++;
  }
  if (NULL != flood_task)
    GNUNET_SCHEDULER_cancel (flood_task);
  flood_task =
    GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL);
}

References GNUNET_TIME_Absolute::abs_value_us, check_proof_of_work(), current_timestamp, estimate_count, estimate_index, find_proof(), flood_task, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, gnunet_nse_interval, GNUNET_PILS_get_identity(), GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_add_with_priority(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_YES, HISTORY_SIZE, my_identity, my_proof, next_timestamp, pils, proof_task, GNUNET_PeerIdentity::public_key, GNUNET_TIME_Relative::rel_value_us, setup_flood_message(), and update_flood_message().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  c, struct GNUNET_SERVICE_Handle *  service  )

static

Handle network size estimate clients.

Parameters

cls	closure
c	configuration to use
service	the initialized service

Definition at line 1442 of file gnunet-service-nse.c.

{
  struct GNUNET_MQ_MessageHandler core_handlers[] =
  { GNUNET_MQ_hd_fixed_size (p2p_estimate,
                             GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD,
                             struct GNUNET_NSE_FloodMessage,
                             NULL),
    GNUNET_MQ_handler_end () };
  char *proof;
  const struct GNUNET_CORE_ServiceInfo service_info = {
    .service = GNUNET_CORE_SERVICE_NSE,
    .version = { 1, 0 },
    .version_max = { 1, 0 },
    .version_min = { 1, 0 },
  };
 
  (void) cls;
  (void) service;
  cfg = c;
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg,
                                                        "NSE",
                                                        "INTERVAL",
                                                        &gnunet_nse_interval))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "INTERVAL");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg,
                                                        "NSE",
                                                        "WORKDELAY",
                                                        &proof_find_delay))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKDELAY");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          "NSE",
                                                          "WORKBITS",
                                                          &nse_work_required))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (nse_work_required >= sizeof(struct GNUNET_HashCode) * 8)
  {
    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                               "NSE",
                               "WORKBITS",
                               _ ("Value is too large.\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
#if ENABLE_NSE_HISTOGRAM
  {
    char *histogram_dir;
    char *histogram_fn;
 
    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                              "NSE",
                                                              "HISTOGRAM_DIR",
                                                              &histogram_dir))
    {
      GNUNET_assert (
        0 < GNUNET_asprintf (&histogram_fn, "%s/timestamps", histogram_dir));
      GNUNET_free (histogram_dir);
      histogram = GNUNET_BIO_write_open_file (histogram_fn);
      if (NULL == histogram)
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Unable to open histogram file `%s'\n",
                    histogram_fn);
      GNUNET_free (histogram_fn);
    }
    logger_test = GNUNET_CLIENT_service_test ("testbed-logger",
                                              cfg,
                                              GNUNET_TIME_UNIT_SECONDS,
                                              &status_cb,
                                              NULL);
  }
#endif
 
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if ((GNUNET_YES != GNUNET_DISK_file_test (proof)) ||
      (sizeof(my_proof) !=
       GNUNET_DISK_fn_read (proof, &my_proof, sizeof(my_proof))))
    my_proof = 0;
  GNUNET_free (proof);
 
  peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
  nc = GNUNET_notification_context_create (1);
  /* Connect to core service and register core handlers */
  core_api =
    GNUNET_CORE_connect (cfg,  /* Main configuration */
                         NULL, /* Closure passed to functions */
                         NULL, /* Call core_init once connected */
                         &handle_core_connect, /* Handle connects */
                         &handle_core_disconnect, /* Handle disconnects */
                         core_handlers, /* Register these handlers */
                         &service_info);
  if (NULL == core_api)
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  pils = GNUNET_PILS_connect (cfg, &pils_id_change_cb, NULL);
  if (NULL == pils)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  stats = GNUNET_STATISTICS_create ("nse", cfg);
}

References _, cfg, core_api, GNUNET_asprintf(), GNUNET_assert, GNUNET_BIO_write_open_file(), GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CORE_connect(), GNUNET_CORE_SERVICE_NSE, GNUNET_DISK_file_test(), GNUNET_DISK_fn_read(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_config_invalid(), GNUNET_log_config_missing(), GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_notification_context_create(), gnunet_nse_interval, GNUNET_OK, GNUNET_PILS_connect(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, handle_core_connect(), handle_core_disconnect(), my_proof, nc, nse_work_required, peers, pils, pils_id_change_cb(), proof, proof_find_delay, GNUNET_CORE_ServiceInfo::service, service, shutdown_task, and stats.

Here is the call graph for this function:

client_connect_cb()

static void * client_connect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  c, struct GNUNET_MQ_Handle *  mq  )

static

Callback called when a client connects to the service.

Parameters

cls	closure for the service
c	the new client that connected to the service
mq	the message queue used to send messages to the client

Returns

c

Definition at line 1578 of file gnunet-service-nse.c.

{
  (void) cls;
  (void) mq;
  return c;
}

References mq.

client_disconnect_cb()

static void client_disconnect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  c, void *  internal_cls  )

static

Callback called when a client disconnected from the service.

Parameters

cls	closure for the service
c	the client that disconnected
internal_cls	should be equal to c

Definition at line 1596 of file gnunet-service-nse.c.

{
  (void) cls;
  GNUNET_assert (c == internal_cls);
}

References GNUNET_assert.

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	GNUNET_OS_project_data_gnunet()	,
		"nse"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_fixed_size(start, GNUNET_MESSAGE_TYPE_NSE_START, struct GNUNET_MessageHeader, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

nse_work_required

unsigned long long nse_work_required

static

Amount of work required (W-bit collisions) for NSE proofs, in collision-bits.

Definition at line 86 of file gnunet-service-nse.c.

Referenced by check_proof_of_work(), find_proof(), run(), and verify_message_crypto().

gnunet_nse_interval

struct GNUNET_TIME_Relative gnunet_nse_interval

static

Interval for sending network size estimation flood requests.

Definition at line 91 of file gnunet-service-nse.c.

Referenced by get_matching_bits_delay(), handle_p2p_estimate(), pils_id_change_cb(), run(), and update_flood_message().

proof_find_delay

struct GNUNET_TIME_Relative proof_find_delay

static

Interval between proof find runs.

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

Referenced by find_proof(), and run().

salt

struct GNUNET_CRYPTO_PowSalt salt = { "gnunet-nse-proof" }

static

Salt for PoW calculations.

Definition at line 120 of file gnunet-service-nse.c.

{ "gnunet-nse-proof" };

Referenced by check_proof_of_work(), and find_proof().

cfg

GNUNET_NETWORK_STRUCT_END const struct GNUNET_CONFIGURATION_Handle* cfg

static

Handle to our current configuration.

Definition at line 236 of file gnunet-service-nse.c.

Referenced by run(), and write_proof().

stats

struct GNUNET_STATISTICS_Handle* stats

static

Handle to the statistics service.

Definition at line 241 of file gnunet-service-nse.c.

Referenced by handle_core_connect(), handle_core_disconnect(), handle_p2p_estimate(), run(), schedule_current_round(), setup_estimate_message(), shutdown_task(), and transmit_task_cb().

pils

struct GNUNET_PILS_Handle* pils

static

Handle to the PILS service.

Definition at line 246 of file gnunet-service-nse.c.

Referenced by find_proof(), handle_p2p_estimate(), pils_id_change_cb(), run(), setup_flood_message(), shutdown_task(), transmit_task_cb(), and update_flood_message().

core_api

struct GNUNET_CORE_Handle* core_api

static

Handle to the core service.

Definition at line 251 of file gnunet-service-nse.c.

Referenced by run(), and shutdown_task().

peers

struct GNUNET_CONTAINER_MultiPeerMap* peers

static

Map of all connected peers.

Definition at line 256 of file gnunet-service-nse.c.

Referenced by handle_core_connect(), handle_core_disconnect(), handle_p2p_estimate(), run(), setup_estimate_message(), shutdown_task(), and update_flood_message().

current_size_estimate

double current_size_estimate

static

The current network size estimate.

Number of bits matching on average thus far.

Definition at line 262 of file gnunet-service-nse.c.

Referenced by get_matching_bits_delay(), and setup_estimate_message().

current_std_dev

double current_std_dev = NAN

static

The standard deviation of the last HISTORY_SIZE network size estimates.

Definition at line 268 of file gnunet-service-nse.c.

Referenced by setup_estimate_message().

hop_count_max

uint32_t hop_count_max

static

Current hop counter estimate (estimate for network diameter).

Definition at line 273 of file gnunet-service-nse.c.

Referenced by get_delay_randomization(), handle_p2p_estimate(), and update_flood_message().

next_message

struct GNUNET_NSE_FloodMessage next_message

static

Message for the next round, if we got any.

Definition at line 278 of file gnunet-service-nse.c.

Referenced by dequeue_message_from_room(), handle_p2p_estimate(), and update_flood_message().

size_estimate_messages

struct GNUNET_NSE_FloodMessage size_estimate_messages[64]

static

Array of recent size estimate messages.

Definition at line 283 of file gnunet-service-nse.c.

Referenced by get_transmit_delay(), handle_p2p_estimate(), setup_estimate_message(), setup_flood_message(), sign_message_before_send_cb(), transmit_task_cb(), and update_flood_message().

estimate_index

unsigned int estimate_index

static

Index of most recent estimate.

Definition at line 288 of file gnunet-service-nse.c.

Referenced by find_proof(), get_transmit_delay(), handle_p2p_estimate(), pils_id_change_cb(), setup_estimate_message(), transmit_task_cb(), and update_flood_message().

estimate_count

unsigned int estimate_count

static

Number of valid entries in the history.

Definition at line 293 of file gnunet-service-nse.c.

Referenced by pils_id_change_cb(), setup_estimate_message(), and update_flood_message().

flood_task

struct GNUNET_SCHEDULER_Task* flood_task

static

Task scheduled to update our flood message for the next round.

Definition at line 298 of file gnunet-service-nse.c.

Referenced by pils_id_change_cb(), shutdown_task(), and update_flood_message().

proof_task

struct GNUNET_SCHEDULER_Task* proof_task

static

Task scheduled to compute our proof.

Definition at line 303 of file gnunet-service-nse.c.

Referenced by find_proof(), pils_id_change_cb(), shutdown_task(), and transmit_task_cb().

nc

struct GNUNET_NotificationContext* nc

static

Notification context, simplifies client broadcasts.

Definition at line 308 of file gnunet-service-nse.c.

Referenced by handle_start(), run(), shutdown_task(), and update_network_size_estimate().

next_timestamp

struct GNUNET_TIME_Absolute next_timestamp

static

The next major time.

Definition at line 313 of file gnunet-service-nse.c.

Referenced by handle_p2p_estimate(), pils_id_change_cb(), and update_flood_message().

current_timestamp

struct GNUNET_TIME_Absolute current_timestamp

static

The current major time.

Definition at line 318 of file gnunet-service-nse.c.

Referenced by find_proof(), get_transmit_delay(), handle_p2p_estimate(), pils_id_change_cb(), and update_flood_message().

my_proof

uint64_t my_proof

static

Proof of work for this peer.

Definition at line 323 of file gnunet-service-nse.c.

Referenced by find_proof(), pils_id_change_cb(), run(), setup_flood_message(), and write_proof().