GNUnet 0.21.1
gnunet-service-nse.c File Reference

network size estimation service More...

#include "platform.h"
#include <math.h>
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "gnunet_statistics_service.h"
#include "gnunet_core_service.h"
#include "gnunet_nse_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. More...
 
#define DEBUG_NSE   GNUNET_NO
 Generate extensive debug-level log messages? More...
 
#define HISTORY_SIZE   64
 Over how many values do we calculate the weighted average? More...
 
#define NSE_PRIORITY
 Message priority to use. More...
 
#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. More...
 
static void handle_start (void *cls, const struct GNUNET_MessageHeader *message)
 Handler for START message from client, triggers an immediate current network estimate notification. More...
 
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? More...
 
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? More...
 
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. More...
 
static struct GNUNET_TIME_Relative get_transmit_delay (int round_offset)
 Get the transmission delay that should be applied for a particular round. More...
 
static void transmit_task_cb (void *cls)
 Task that triggers a NSE P2P transmission. More...
 
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. More...
 
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. More...
 
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. More...
 
static void update_flood_message (void *cls)
 Update our flood message to be sent (and our timestamps). More...
 
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. More...
 
static void write_proof (void)
 Write our current proof to disk. More...
 
static void find_proof (void *cls)
 Find our proof of work. More...
 
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. More...
 
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. More...
 
static void handle_p2p_estimate (void *cls, const struct GNUNET_NSE_FloodMessage *incoming_flood)
 Core handler for size estimate flooding messages. More...
 
static void * handle_core_connect (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
 Method called whenever a peer connects. More...
 
static void handle_core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
 Method called whenever a peer disconnects. More...
 
static void shutdown_task (void *cls)
 Task run during shutdown. More...
 
static void core_init (void *cls, const struct GNUNET_PeerIdentity *identity)
 Called on core init/fail. More...
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
 Handle network size estimate clients. More...
 
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. More...
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *c, void *internal_cls)
 Callback called when a client disconnected from the service. More...
 
 GNUNET_SERVICE_MAIN ("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. More...
 

Variables

static unsigned long long nse_work_required
 Amount of work required (W-bit collisions) for NSE proofs, in collision-bits. More...
 
static struct GNUNET_TIME_Relative gnunet_nse_interval
 Interval for sending network size estimation flood requests. More...
 
static struct GNUNET_TIME_Relative proof_find_delay
 Interval between proof find runs. More...
 
static struct GNUNET_CRYPTO_PowSalt salt = { "gnunet-nse-proof" }
 Salt for PoW calcualations. More...
 
static GNUNET_NETWORK_STRUCT_END const struct GNUNET_CONFIGURATION_Handlecfg
 Handle to our current configuration. More...
 
static struct GNUNET_STATISTICS_Handlestats
 Handle to the statistics service. More...
 
static struct GNUNET_CORE_Handlecore_api
 Handle to the core service. More...
 
static struct GNUNET_CONTAINER_MultiPeerMappeers
 Map of all connected peers. More...
 
static double current_size_estimate
 The current network size estimate. More...
 
static double current_std_dev = NAN
 The standard deviation of the last HISTORY_SIZE network size estimates. More...
 
static uint32_t hop_count_max
 Current hop counter estimate (estimate for network diameter). More...
 
static struct GNUNET_NSE_FloodMessage next_message
 Message for the next round, if we got any. More...
 
static struct GNUNET_NSE_FloodMessage size_estimate_messages [64]
 Array of recent size estimate messages. More...
 
static unsigned int estimate_index
 Index of most recent estimate. More...
 
static unsigned int estimate_count
 Number of valid entries in the history. More...
 
static struct GNUNET_SCHEDULER_Taskflood_task
 Task scheduled to update our flood message for the next round. More...
 
static struct GNUNET_SCHEDULER_Taskproof_task
 Task scheduled to compute our proof. More...
 
static struct GNUNET_NotificationContextnc
 Notification context, simplifies client broadcasts. More...
 
static struct GNUNET_TIME_Absolute next_timestamp
 The next major time. More...
 
static struct GNUNET_TIME_Absolute current_timestamp
 The current major time. More...
 
static struct GNUNET_CRYPTO_EddsaPrivateKeymy_private_key
 The private key of this peer. More...
 
static struct GNUNET_PeerIdentity my_identity
 The peer identity of this peer. More...
 
static uint64_t my_proof
 Proof of work for this peer. More...
 

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 58 of file gnunet-service-nse.c.

◆ DEBUG_NSE

#define DEBUG_NSE   GNUNET_NO

Generate extensive debug-level log messages?

Definition at line 63 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 68 of file gnunet-service-nse.c.

◆ NSE_PRIORITY

#define NSE_PRIORITY
Value:
@ GNUNET_MQ_PRIO_BACKGROUND
Lowest priority, i.e.
@ GNUNET_MQ_PREF_CORK_ALLOWED
Flag to indicate that CORKing is acceptable.
@ GNUNET_MQ_PREF_UNRELIABLE
Flag to indicate that unreliable delivery is acceptable.

Message priority to use.

No real rush, reliability not required. Corking OK.

Definition at line 74 of file 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
emmessage to fill in

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

328{
329 double mean;
330 double sum;
331 double std_dev;
332 double variance;
333 double val;
334 double nsize;
335
336#define WEST 1
337 /* Weighted incremental algorithm for stddev according to West (1979) */
338#if WEST
339 double sumweight;
340 double weight;
341 double q;
342 double r;
343 double temp;
344
345 mean = 0.0;
346 sum = 0.0;
347 sumweight = 0.0;
348 variance = 0.0;
349 for (unsigned int i = 0; i < estimate_count; i++)
350 {
351 unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
352
353 val = htonl (size_estimate_messages[j].matching_bits);
354 weight = estimate_count + 1 - i;
355
356 temp = weight + sumweight;
357 q = val - mean;
358 r = q * weight / temp;
359 mean += r;
360 sum += sumweight * q * r;
361 sumweight = temp;
362 }
363 if (estimate_count > 0)
364 variance = (sum / sumweight) * estimate_count / (estimate_count - 1.0);
365#else
366 /* trivial version for debugging */
367 double vsq;
368
369 /* non-weighted trivial version */
370 sum = 0.0;
371 vsq = 0.0;
372 variance = 0.0;
373 mean = 0.0;
374
375 for (unsigned int i = 0; i < estimate_count; i++)
376 {
377 unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
378
379 val = htonl (size_estimate_messages[j].matching_bits);
380 sum += val;
381 vsq += val * val;
382 }
383 if (0 != estimate_count)
384 {
385 mean = sum / estimate_count;
386 variance = (vsq - mean * sum)
387 / (estimate_count - 1.0); // terrible for numerical stability...
388 }
389#endif
390 if (variance >= 0)
391 std_dev = sqrt (variance);
392 else
393 std_dev = variance; /* return NaN (due to estimate_count == 0 causing 0.0/0.0) */
394 current_std_dev = std_dev;
396
397 em->header.size = htons (sizeof(struct GNUNET_NSE_ClientMessage));
399 em->reserved = htonl (0);
401 {
402 double se = mean - 0.332747;
403 unsigned int j = GNUNET_CONTAINER_multipeermap_size (peers);
404 if (0 == j)
405 j = 1; /* Avoid log2(0); can only happen if CORE didn't report
406 connection to self yet */
407 nsize = log2 (j);
408 em->size_estimate = GNUNET_hton_double (GNUNET_MAX (se, nsize));
409 em->std_deviation = GNUNET_hton_double (std_dev);
411 "# nodes in the network (estimate)",
412 (uint64_t) pow (2, GNUNET_MAX (se, nsize)),
413 GNUNET_NO);
414 }
415}
static struct GNUNET_REVOCATION_Query * q
Handle for revocation query.
static unsigned long long matching_bits
Number of matching bits required for revocation.
static struct GNUNET_CONTAINER_MultiPeerMap * peers
Map of all connected peers.
static double current_std_dev
The standard deviation of the last HISTORY_SIZE network size estimates.
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.
#define HISTORY_SIZE
Over how many values do we calculate the weighted average?
static struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
static unsigned int estimate_count
Number of valid entries in the history.
static double current_size_estimate
The current network size estimate.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
#define GNUNET_MAX(a, b)
double GNUNET_hton_double(double d)
Convert double to network byte order.
Definition: common_endian.c:70
@ GNUNET_NO
#define GNUNET_MESSAGE_TYPE_NSE_ESTIMATE
service->client message indicating
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:638
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Network size estimate sent from the service to clients.
Definition: nse.h:43
uint32_t reserved
For alignment.
Definition: nse.h:52
double size_estimate
The current estimated network size.
Definition: nse.h:62
struct GNUNET_TIME_AbsoluteNBO timestamp
Timestamp at which the server received the message.
Definition: nse.h:57
double std_deviation
The standard deviation (rounded down to the nearest integer) of size estimations.
Definition: nse.h:69
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_NSE_ESTIMATE.
Definition: nse.h:47

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, consensus-simulation::sum, 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
clsclient who sent the message
messagethe message received

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

429{
430 struct GNUNET_SERVICE_Client *client = cls;
431 struct GNUNET_MQ_Handle *mq;
432 struct GNUNET_NSE_ClientMessage em;
433 struct GNUNET_MQ_Envelope *env;
434
435 (void) message;
436 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received START message from client\n");
440 env = GNUNET_MQ_msg_copy (&em.header);
443}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static void setup_estimate_message(struct GNUNET_NSE_ClientMessage *em)
Initialize a message to clients with the current network size estimate.
static struct GNUNET_NotificationContext * nc
Notification context, simplifies client broadcasts.
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_DEBUG
struct GNUNET_MQ_Envelope * GNUNET_MQ_msg_copy(const struct GNUNET_MessageHeader *hdr)
Create a new envelope by copying an existing message.
Definition: mq.c:533
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:304
void GNUNET_notification_context_add(struct GNUNET_NotificationContext *nc, struct GNUNET_MQ_Handle *mq)
Add a subscriber to the notification context.
Definition: nc.c:161
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2602
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2408
Handle to a message queue.
Definition: mq.c:87
Handle to a client that is connected to a service.
Definition: service.c:252

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_bitsnumber of matching bits to consider

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

454{
455 /* Calculated as: S + f/2 - (f / pi) * (atan(x - p')) */
456 // S is next_timestamp (ignored in return value)
457 // f is frequency (gnunet_nse_interval)
458 // x is matching_bits
459 // p' is current_size_estimate
460 return ((double) gnunet_nse_interval.rel_value_us / (double) 2.0)
463}
static struct GNUNET_TIME_Relative gnunet_nse_interval
Interval for sending network size estimation flood requests.
uint64_t rel_value_us
The actual value.

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_bitsnumber of matching bits
Returns
random delay to apply

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

474{
475#if USE_RANDOM_DELAYS
477 uint32_t i;
478 double d;
479
481 i = (uint32_t) (d / (double) (hop_count_max + 1));
482 ret.rel_value_us = i;
484 "Randomizing flood using latencies up to %s\n",
486 ret.rel_value_us =
488 return ret;
489#else
491#endif
492}
static mp_limb_t d[(((256)+GMP_NUMB_BITS - 1)/GMP_NUMB_BITS)]
static int ret
Final status code.
Definition: gnunet-arm.c:94
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 uint32_t hop_count_max
Current hop counter estimate (estimate for network diameter).
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
@ GNUNET_YES
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:570
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
Time for relative time used by GNUnet, in microseconds.

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
timestamptime to generate key
idpeer identity to compare with
Returns
number of matching bits

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

505{
506 struct GNUNET_HashCode timestamp_hash;
507 struct GNUNET_HashCode pid_hash;
508 struct GNUNET_HashCode xor;
509
511 sizeof(timestamp.abs_value_us),
512 &timestamp_hash);
514 sizeof(struct GNUNET_PeerIdentity),
515 &pid_hash);
516 GNUNET_CRYPTO_hash_xor (&pid_hash,
517 &timestamp_hash,
518 &xor);
520}
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
void GNUNET_CRYPTO_hash_xor(const struct GNUNET_HashCode *a, const struct GNUNET_HashCode *b, struct GNUNET_HashCode *result)
compute result = a ^ b
Definition: crypto_hash.c:135
unsigned int GNUNET_CRYPTO_hash_count_leading_zeros(const struct GNUNET_HashCode *h)
Count the number of leading 0 bits in h.
Definition: crypto_hash.c:177
A 512-bit hashcode.
The identity of the host (wraps the signing key of the peer).
uint64_t abs_value_us
The actual value.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hash_count_leading_zeros(), and GNUNET_CRYPTO_hash_xor().

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 532 of file gnunet-service-nse.c.

533{
535 struct GNUNET_TIME_Absolute tgt;
536 double dist_delay;
537 uint32_t matching_bits;
538
539 switch (round_offset)
540 {
541 case -1:
542 /* previous round is randomized between 0 and 50 ms */
543#if USE_RANDOM_DELAYS
544 ret.rel_value_us =
546#else
548#endif
550 "Transmitting previous round behind schedule in %s\n",
552 return ret;
553
554 case 0:
555 /* current round is based on best-known matching_bits */
560 ret.rel_value_us = (uint64_t) dist_delay;
562 "For round %s, delay for %u matching bits is %s\n",
564 (unsigned int) matching_bits,
566 /* now consider round start time and add delay to it */
569 }
570 GNUNET_break (0);
572}
static struct GNUNET_TIME_Absolute current_timestamp
The current major time.
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?
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Generate a random unsigned 64-bit value.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:405
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition: time.c:450
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:617
Time for absolute times used by GNUnet, in microseconds.

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:

◆ transmit_task_cb()

static void transmit_task_cb ( void *  cls)
static

Task that triggers a NSE P2P transmission.

Parameters
clsthe struct NSEPeerEntry *

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

582{
583 struct NSEPeerEntry *peer_entry = cls;
584 unsigned int idx;
585 struct GNUNET_MQ_Envelope *env;
586
587 peer_entry->transmit_task = NULL;
588 idx = estimate_index;
589 if (GNUNET_NO == peer_entry->previous_round)
590 {
591 idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE;
592 peer_entry->previous_round = GNUNET_YES;
593 peer_entry->transmit_task =
596 peer_entry);
597 }
598 if ((0 == ntohl (size_estimate_messages[idx].hop_count)) &&
599 (NULL != proof_task))
600 {
602 "# flood messages not generated (no proof yet)",
603 1,
604 GNUNET_NO);
605 return;
606 }
607 if (0 == ntohs (size_estimate_messages[idx].header.size))
608 {
610 "# flood messages not generated (lack of history)",
611 1,
612 GNUNET_NO);
613 return;
614 }
616 "In round %s, sending to `%s' estimate with %u bits\n",
619 size_estimate_messages[idx].timestamp)),
620 GNUNET_i2s (peer_entry->id),
621 (unsigned int) ntohl (size_estimate_messages[idx].matching_bits));
622 if (0 == ntohl (size_estimate_messages[idx].hop_count))
623 GNUNET_STATISTICS_update (stats, "# flood messages started", 1, GNUNET_NO);
625 "# flood messages transmitted",
626 1,
627 GNUNET_NO);
628#if ENABLE_NSE_HISTOGRAM
629 peer_entry->transmitted_messages++;
630 peer_entry->last_transmitted_size =
632#endif
634 GNUNET_MQ_send (peer_entry->mq, env);
635}
static void transmit_task_cb(void *cls)
Task that triggers a NSE P2P transmission.
static struct GNUNET_SCHEDULER_Task * proof_task
Task scheduled to compute our proof.
static struct GNUNET_TIME_Relative get_transmit_delay(int round_offset)
Get the transmission delay that should be applied for a particular round.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1278
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:737
Per-peer information.
struct GNUNET_MQ_Handle * mq
Core handle for sending messages to this peer.
struct GNUNET_SCHEDULER_Task * transmit_task
Task scheduled to send message to this peer.
const struct GNUNET_PeerIdentity * id
What is the identity of the peer?
int previous_round
Did we receive or send a message about the previous round to this peer yet? GNUNET_YES if the previou...

References env, estimate_index, get_transmit_delay(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), GNUNET_NO, 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::mq, NSEPeerEntry::previous_round, proof_task, size_estimate_messages, stats, 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 645 of file gnunet-service-nse.c.

646{
647 struct GNUNET_NSE_ClientMessage em;
648
651}
void GNUNET_notification_context_broadcast(struct GNUNET_NotificationContext *nc, const struct GNUNET_MessageHeader *msg, int can_drop)
Send a message to all subscribers of this context.
Definition: nc.c:190

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

Referenced by handle_p2p_estimate().

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
slotindex to use
tstimestamp to use

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

663{
664 struct GNUNET_NSE_FloodMessage *fm;
665 uint32_t matching_bits;
666
668 fm = &size_estimate_messages[slot];
669 fm->header.size = htons (sizeof(struct GNUNET_NSE_FloodMessage));
671 fm->hop_count = htonl (0);
673 fm->purpose.size =
674 htonl (sizeof(struct GNUNET_NSE_FloodMessage)
675 - sizeof(struct GNUNET_MessageHeader) - sizeof(uint32_t)
676 - sizeof(struct GNUNET_CRYPTO_EddsaSignature));
677 fm->matching_bits = htonl (matching_bits);
679 fm->origin = my_identity;
681 if (nse_work_required > 0)
684 &fm->purpose,
685 &fm->signature));
686 else
687 memset (&fm->signature, 0, sizeof(fm->signature));
688}
static struct GNUNET_PeerIdentity my_identity
The peer identity of this peer.
static uint64_t my_proof
Proof of work for this peer.
static unsigned long long nse_work_required
Amount of work required (W-bit collisions) for NSE proofs, in collision-bits.
static struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
The private key of this peer.
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.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_sign_(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EddsaSignature *sig)
EdDSA sign a given block.
Definition: crypto_ecc.c:607
@ GNUNET_OK
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD
P2P message sent from nearest peer.
#define GNUNET_SIGNATURE_PURPOSE_NSE_SEND
Signature of a network size estimate message.
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!...
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
an ECC signature using EdDSA.
Header for all communications.
Network size estimate reply; sent when "this" peer's timer has run out before receiving a valid reply...
uint32_t hop_count
Number of hops this message has taken so far.
uint32_t matching_bits
Number of matching bits between the hash of timestamp and the initiator's public key.
struct GNUNET_TIME_AbsoluteNBO timestamp
The current timestamp value (which all peers should agree on).
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD.
struct GNUNET_PeerIdentity origin
Public key of the originator.
uint64_t proof_of_work
Proof of work, causing leading zeros when hashed with pkey.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose.
struct GNUNET_CRYPTO_EddsaSignature signature
Signature (over range specified in purpose).

References get_matching_bits(), GNUNET_assert, GNUNET_CRYPTO_eddsa_sign_(), GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD, GNUNET_OK, 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_private_key, my_proof, nse_work_required, GNUNET_NSE_FloodMessage::origin, GNUNET_NSE_FloodMessage::proof_of_work, GNUNET_CRYPTO_EccSignaturePurpose::purpose, GNUNET_NSE_FloodMessage::purpose, GNUNET_NSE_FloodMessage::signature, GNUNET_MessageHeader::size, GNUNET_CRYPTO_EccSignaturePurpose::size, size_estimate_messages, GNUNET_NSE_FloodMessage::timestamp, and GNUNET_MessageHeader::type.

Referenced by core_init(), find_proof(), 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
clsunused
keyhash of peer identity
valuethe struct NSEPeerEntry
Returns
GNUNET_OK (continue to iterate)

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

704{
705 struct NSEPeerEntry *peer_entry = value;
706 struct GNUNET_TIME_Relative delay;
707
708 (void) cls;
709 (void) key;
710 if (NULL != peer_entry->transmit_task)
711 {
713 peer_entry->previous_round = GNUNET_NO;
714 }
715#if ENABLE_NSE_HISTOGRAM
716 if (peer_entry->received_messages > 1)
718 "# extra messages",
719 peer_entry->received_messages - 1,
720 GNUNET_NO);
721 peer_entry->transmitted_messages = 0;
722 peer_entry->last_transmitted_size = 0;
723 peer_entry->received_messages = 0;
724#endif
725 delay =
726 get_transmit_delay ((GNUNET_NO == peer_entry->previous_round) ? -1 : 0);
727 peer_entry->transmit_task =
729 return GNUNET_OK;
730}
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:981

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
clsunused

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

740{
741 struct GNUNET_TIME_Relative offset;
742
743 (void) cls;
744 flood_task = NULL;
746 if (0 != offset.rel_value_us)
747 {
748 /* somehow run early, delay more */
749 flood_task =
751 return;
752 }
763 {
764 /* we received a message for this round way early, use it! */
767 htonl (1 + ntohl (next_message.hop_count));
768 }
769 else
771 next_message.matching_bits = htonl (0); /* reset for 'next' round */
772 hop_count_max = 0;
773 for (unsigned int i = 0; i < HISTORY_SIZE; i++)
775 GNUNET_MAX (ntohl (size_estimate_messages[i].hop_count), hop_count_max);
777 flood_task =
779}
static void update_flood_message(void *cls)
Update our flood message to be sent (and our timestamps).
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 desire...
static struct GNUNET_NSE_FloodMessage next_message
Message for the next round, if we got any.
static struct GNUNET_SCHEDULER_Task * flood_task
Task scheduled to update our flood message for the next round.
static struct GNUNET_TIME_Absolute next_timestamp
The next major time.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run at the specified time.
Definition: scheduler.c:1255

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_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, 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 core_init(), 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
pkeythe public key
valthe integer
Returns
GNUNET_YES if valid, GNUNET_NO if not

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

793{
794 char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)
795 + sizeof(val)] GNUNET_ALIGN;
796 struct GNUNET_HashCode result;
797
798 GNUNET_memcpy (buf, &val, sizeof(val));
799 GNUNET_memcpy (&buf[sizeof(val)],
800 pkey,
801 sizeof(struct GNUNET_CRYPTO_EddsaPublicKey));
803 buf,
804 sizeof(buf),
805 &result);
808 ? GNUNET_YES
809 : GNUNET_NO;
810}
static char * pkey
Public key of the zone to look in, in ASCII.
static int result
Global testing status.
static struct GNUNET_CRYPTO_PowSalt salt
Salt for PoW calcualations.
void GNUNET_CRYPTO_pow_hash(const struct GNUNET_CRYPTO_PowSalt *salt, const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
Calculate the 'proof-of-work' hash (an expensive hash).
Definition: crypto_pow.c:42
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to 'struct's.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Public ECC key (always for curve Ed25519) encoded in a format suitable for network transmission and E...

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 core_init(), 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 817 of file gnunet-service-nse.c.

818{
819 char *proof;
820
821 if (GNUNET_OK !=
823 "NSE",
824 "PROOFFILE",
825 &proof))
826 return;
828 if (GNUNET_OK !=
830 &my_proof,
831 sizeof(my_proof),
835 "write",
836 proof);
838}
static uint64_t proof
Definition: gnunet-scrypt.c:49
static GNUNET_NETWORK_STRUCT_END const struct GNUNET_CONFIGURATION_Handle * cfg
Handle to our current configuration.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
enum GNUNET_GenericReturnValue GNUNET_DISK_fn_write(const char *fn, const void *buf, size_t buf_size, enum GNUNET_DISK_AccessPermissions mode)
Write a buffer to a file atomically.
Definition: disk.c:725
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1087
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
#define GNUNET_free(ptr)
Wrapper around free.

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
clsclosure (unused)

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

848{
849#define ROUND_SIZE 10
850 uint64_t counter;
851 char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)
852 + sizeof(uint64_t)] GNUNET_ALIGN;
853 struct GNUNET_HashCode result;
854 unsigned int i;
855
856 (void) cls;
857 proof_task = NULL;
858 GNUNET_memcpy (&buf[sizeof(uint64_t)],
860 sizeof(struct GNUNET_PeerIdentity));
861 i = 0;
862 counter = my_proof;
863 while ((counter != UINT64_MAX) && (i < ROUND_SIZE))
864 {
865 GNUNET_memcpy (buf, &counter, sizeof(uint64_t));
867 buf,
868 sizeof(buf),
869 &result);
870 if (nse_work_required <=
872 {
873 my_proof = counter;
875 "Proof of work found: %llu!\n",
876 (unsigned long long) GNUNET_ntohll (counter));
877 write_proof ();
879 return;
880 }
881 counter++;
882 i++;
883 }
884 if (my_proof / (100 * ROUND_SIZE) < counter / (100 * ROUND_SIZE))
885 {
887 "Testing proofs currently at %llu\n",
888 (unsigned long long) counter);
889 /* remember progress every 100 rounds */
890 my_proof = counter;
891 write_proof ();
892 }
893 else
894 {
895 my_proof = counter;
896 }
897 proof_task =
900 &find_proof,
901 NULL);
902}
static void find_proof(void *cls)
Find our proof of work.
static struct GNUNET_TIME_Relative proof_find_delay
Interval between proof find runs.
#define ROUND_SIZE
static void write_proof(void)
Write our current proof to disk.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
@ GNUNET_SCHEDULER_PRIORITY_IDLE
Run when otherwise idle.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, enum GNUNET_SCHEDULER_Priority priority, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1208

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

Referenced by find_proof(), and run().

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_floodthe message to verify
Returns
GNUNET_YES if the message is verified GNUNET_NO if the key/signature don't verify

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

916{
917 if (GNUNET_YES != check_proof_of_work (&incoming_flood->origin.public_key,
918 incoming_flood->proof_of_work))
919 {
921 "Proof of work invalid: %llu!\n",
922 (unsigned long long) GNUNET_ntohll (
923 incoming_flood->proof_of_work));
924 GNUNET_break_op (0);
925 return GNUNET_NO;
926 }
927 if ((nse_work_required > 0) &&
928 (GNUNET_OK !=
930 &incoming_flood->purpose,
931 &incoming_flood->signature,
932 &incoming_flood->origin.public_key)))
933 {
934 GNUNET_break_op (0);
935 return GNUNET_NO;
936 }
937 return GNUNET_YES;
938}
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.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_verify_(uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_CRYPTO_EddsaSignature *sig, const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Verify EdDSA signature.
Definition: crypto_ecc.c:690
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_CRYPTO_EddsaPublicKey public_key

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
clspeer entry to exclude from updates
keyhash of peer identity
valuethe struct NSEPeerEntry * of a peer to transmit to
Returns
GNUNET_OK (continue to iterate)

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

954{
955 struct NSEPeerEntry *exclude = cls;
956 struct NSEPeerEntry *peer_entry = value;
957 struct GNUNET_TIME_Relative delay;
958
959 (void) key;
960 if (peer_entry == exclude)
961 return GNUNET_OK; /* trigger of the update */
962 if (GNUNET_NO == peer_entry->previous_round)
963 {
964 /* still stuck in previous round, no point to update, check that
965 * we are active here though... */
966 if (NULL == peer_entry->transmit_task)
967 {
968 GNUNET_break (0);
969 }
970 return GNUNET_OK;
971 }
972 if (NULL != peer_entry->transmit_task)
973 {
975 peer_entry->transmit_task = NULL;
976 }
977 delay = get_transmit_delay (0);
978 peer_entry->transmit_task =
980 return GNUNET_OK;
981}

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
clspeer this message is from
incoming_floodreceived message

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

993{
994 struct NSEPeerEntry *peer_entry = cls;
995 struct GNUNET_TIME_Absolute ts;
996 uint32_t matching_bits;
997 unsigned int idx;
998
999#if ENABLE_NSE_HISTOGRAM
1000 {
1001 uint64_t t;
1002
1004 if (NULL != lh)
1005 GNUNET_TESTBED_LOGGER_write (lh, &t, sizeof(uint64_t));
1006 if (NULL != histogram)
1007 GNUNET_BIO_write_int64 (histogram, "histogram-time", t);
1008 }
1009#endif
1010 GNUNET_STATISTICS_update (stats, "# flood messages received", 1, GNUNET_NO);
1011 matching_bits = ntohl (incoming_flood->matching_bits);
1012#if DEBUG_NSE
1013 {
1014 char origin[5];
1015 char pred[5];
1016 struct GNUNET_PeerIdentity os;
1017
1019 sizeof(origin),
1020 "%s",
1021 GNUNET_i2s (&incoming_flood->origin));
1022 GNUNET_snprintf (pred, sizeof(pred), "%s", GNUNET_i2s (peer_entry->id));
1024 "Flood at %s from `%s' via `%s' at `%s' with bits %u\n",
1026 GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp)),
1027 origin,
1028 pred,
1030 (unsigned int) matching_bits);
1031 }
1032#endif
1033
1034#if ENABLE_NSE_HISTOGRAM
1035 peer_entry->received_messages++;
1036 if ((peer_entry->transmitted_messages > 0) &&
1037 (peer_entry->last_transmitted_size >= matching_bits) )
1038 GNUNET_STATISTICS_update (stats, "# cross messages", 1, GNUNET_NO);
1039#endif
1040
1041 ts = GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp);
1042 if (ts.abs_value_us == current_timestamp.abs_value_us)
1043 idx = estimate_index;
1044 else if (ts.abs_value_us ==
1047 else if (ts.abs_value_us == next_timestamp.abs_value_us)
1048 {
1050 return; /* ignore, simply too early/late */
1051 if (GNUNET_YES != verify_message_crypto (incoming_flood))
1052 {
1054 "Peer %s is likely ill-configured!\n",
1055 GNUNET_i2s (peer_entry->id));
1056 GNUNET_break_op (0);
1057 return;
1058 }
1059 next_message = *incoming_flood;
1060 return;
1061 }
1062 else
1063 {
1065 "# flood messages discarded (clock skew too large)",
1066 1,
1067 GNUNET_NO);
1068 return;
1069 }
1070 if (0 == (GNUNET_memcmp (peer_entry->id, &my_identity)))
1071 {
1072 /* send to self, update our own estimate IF this also comes from us! */
1073 if (0 == GNUNET_memcmp (&incoming_flood->origin, &my_identity))
1075 return;
1076 }
1078 {
1079 /* Cancel transmission in the other direction, as this peer clearly has
1080 up-to-date information already. Even if we didn't talk to this peer in
1081 the previous round, we should no longer send it stale information as it
1082 told us about the current round! */
1083 peer_entry->previous_round = GNUNET_YES;
1084 if (idx != estimate_index)
1085 {
1086 /* do not transmit information for the previous round to this peer
1087 anymore (but allow current round) */
1088 return;
1089 }
1090 /* got up-to-date information for current round, cancel transmission to
1091 * this peer altogether */
1092 if (NULL != peer_entry->transmit_task)
1093 {
1095 peer_entry->transmit_task = NULL;
1096 }
1097 return;
1098 }
1100 {
1101 if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES))
1102 {
1103 peer_entry->previous_round = GNUNET_NO;
1104 }
1105 /* push back our result now, that peer is spreading bad information... */
1106 if (NULL != peer_entry->transmit_task)
1108 peer_entry->transmit_task =
1110 /* Not closer than our most recent message, no need to do work here */
1112 "# flood messages ignored (had closer already)",
1113 1,
1114 GNUNET_NO);
1115 return;
1116 }
1117 if (GNUNET_YES != verify_message_crypto (incoming_flood))
1118 {
1119 GNUNET_break_op (0);
1120 return;
1121 }
1124 /* Cancel transmission in the other direction, as this peer clearly has
1125 * up-to-date information already.
1126 */
1127 peer_entry->previous_round = GNUNET_YES;
1128 if (idx == estimate_index)
1129 {
1130 /* cancel any activity for current round */
1131 if (NULL != peer_entry->transmit_task)
1132 {
1134 peer_entry->transmit_task = NULL;
1135 }
1136 }
1137 size_estimate_messages[idx] = *incoming_flood;
1139 htonl (ntohl (incoming_flood->hop_count) + 1);
1141 GNUNET_MAX (ntohl (incoming_flood->hop_count) + 1, hop_count_max);
1143 "# estimated network diameter",
1145 GNUNET_NO);
1146
1147 /* have a new, better size estimate, inform clients */
1149
1150 /* flood to rest */
1153 peer_entry);
1154}
static ogg_stream_state os
Ogg stream state.
static char origin[GNUNET_DNSPARSER_MAX_NAME_LENGTH]
Current origin.
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 update_network_size_estimate()
We've sent on our flood message or one that we received which was validated and closer than ours.
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 ...
static struct GNUNET_SCHEDULER_Task * t
Main task.
enum GNUNET_GenericReturnValue GNUNET_BIO_write_int64(struct GNUNET_BIO_WriteHandle *h, const char *what, int64_t i)
Write an (u)int64_t.
Definition: bio.c:867
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
@ GNUNET_ERROR_TYPE_ERROR
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1305

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_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, os, peers, 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 
)
static

Method called whenever a peer connects.

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

Parameters
clsclosure
peerpeer identity this notification is about

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

1168{
1169 struct NSEPeerEntry *peer_entry;
1170
1171 (void) cls;
1173 "Peer `%s' connected to us\n",
1174 GNUNET_i2s (peer));
1175 /* set our default transmission options */
1177 /* create our peer entry for this peer */
1178 peer_entry = GNUNET_new (struct NSEPeerEntry);
1179 peer_entry->id = peer;
1180 peer_entry->mq = mq;
1183 peers,
1184 peer_entry->id,
1185 peer_entry,
1187 peer_entry->transmit_task =
1190 peer_entry);
1191 GNUNET_STATISTICS_update (stats, "# peers connected", 1, GNUNET_NO);
1192 return peer_entry;
1193}
#define NSE_PRIORITY
Message priority to use.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GNUNET_MQ_set_options(struct GNUNET_MQ_Handle *mq, enum GNUNET_MQ_PriorityPreferences pp)
Set application-specific options for this queue.
Definition: mq.c:871

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
clsclosure
peerpeer identity this notification is about
internal_clsthe struct NSEPeerEntry for the peer

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

1208{
1209 struct NSEPeerEntry *pos = internal_cls;
1210
1211 (void) cls;
1213 "Peer `%s' disconnected from us\n",
1214 GNUNET_i2s (peer));
1217 if (NULL != pos->transmit_task)
1218 {
1220 pos->transmit_task = NULL;
1221 }
1222 GNUNET_free (pos);
1223 GNUNET_STATISTICS_update (stats, "# peers connected", -1, GNUNET_NO);
1224}
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.

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
clsunused

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

1255{
1256 (void) cls;
1257 if (NULL != flood_task)
1258 {
1260 flood_task = NULL;
1261 }
1262 if (NULL != proof_task)
1263 {
1265 proof_task = NULL;
1266 write_proof (); /* remember progress */
1267 }
1268 if (NULL != nc)
1269 {
1271 nc = NULL;
1272 }
1273 if (NULL != core_api)
1274 {
1276 core_api = NULL;
1277 }
1278 if (NULL != stats)
1279 {
1281 stats = NULL;
1282 }
1283 if (NULL != peers)
1284 {
1286 peers = NULL;
1287 }
1288 if (NULL != my_private_key)
1289 {
1291 my_private_key = NULL;
1292 }
1293#if ENABLE_NSE_HISTOGRAM
1294 if (NULL != logger_test)
1295 {
1296 GNUNET_CLIENT_service_test_cancel (logger_test);
1297 logger_test = NULL;
1298 }
1299 if (NULL != lh)
1300 {
1301 GNUNET_TESTBED_LOGGER_flush (lh, &flush_comp_cb, NULL);
1302 }
1303 if (NULL != histogram)
1304 {
1305 GNUNET_BIO_write_close (histogram, NULL);
1306 histogram = NULL;
1307 }
1308#endif
1309}
static struct GNUNET_CORE_Handle * core_api
Handle to the core service.
enum GNUNET_GenericReturnValue GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h, char **emsg)
Close an IO handle.
Definition: bio.c:556
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:729
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
void GNUNET_notification_context_destroy(struct GNUNET_NotificationContext *nc)
Destroy the context, force disconnect for all subscribers.
Definition: nc.c:138
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).

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

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ core_init()

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

Called on core init/fail.

Parameters
clsservice closure
identitythe public identity of this peer

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

1320{
1321 struct GNUNET_TIME_Absolute now;
1322 struct GNUNET_TIME_Absolute prev_time;
1323
1324 (void) cls;
1325 if (NULL == identity)
1326 {
1327 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Connection to core FAILED!\n");
1329 return;
1330 }
1332 now = GNUNET_TIME_absolute_get ();
1334 (now.abs_value_us / gnunet_nse_interval.rel_value_us)
1339 estimate_count = 0;
1341 {
1342 int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
1343 prev_time.abs_value_us =
1345 setup_flood_message (idx, prev_time);
1348 }
1349 flood_task =
1351}
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:567

References GNUNET_TIME_Absolute::abs_value_us, check_proof_of_work(), current_timestamp, estimate_count, estimate_index, flood_task, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_memcmp, gnunet_nse_interval, GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_YES, HISTORY_SIZE, identity, my_identity, my_proof, next_timestamp, 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
clsclosure
cconfiguration to use
servicethe initialized service

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

1396{
1397 struct GNUNET_MQ_MessageHandler core_handlers[] =
1398 { GNUNET_MQ_hd_fixed_size (p2p_estimate,
1401 NULL),
1403 char *proof;
1405
1406 (void) cls;
1407 (void) service;
1408 cfg = c;
1410 "NSE",
1411 "INTERVAL",
1413 {
1416 return;
1417 }
1419 "NSE",
1420 "WORKDELAY",
1422 {
1425 return;
1426 }
1428 "NSE",
1429 "WORKBITS",
1431 {
1434 return;
1435 }
1436 if (nse_work_required >= sizeof(struct GNUNET_HashCode) * 8)
1437 {
1439 "NSE",
1440 "WORKBITS",
1441 _ ("Value is too large.\n"));
1443 return;
1444 }
1445
1446#if ENABLE_NSE_HISTOGRAM
1447 {
1448 char *histogram_dir;
1449 char *histogram_fn;
1450
1452 "NSE",
1453 "HISTOGRAM_DIR",
1454 &histogram_dir))
1455 {
1457 0 < GNUNET_asprintf (&histogram_fn, "%s/timestamps", histogram_dir));
1458 GNUNET_free (histogram_dir);
1459 histogram = GNUNET_BIO_write_open_file (histogram_fn);
1460 if (NULL == histogram)
1462 "Unable to open histogram file `%s'\n",
1463 histogram_fn);
1464 GNUNET_free (histogram_fn);
1465 }
1466 logger_test = GNUNET_CLIENT_service_test ("testbed-logger",
1467 cfg,
1469 &status_cb,
1470 NULL);
1471 }
1472#endif
1473
1476 GNUNET_assert (NULL != pk);
1479 if (GNUNET_OK !=
1480 GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof))
1481 {
1484 my_private_key = NULL;
1486 return;
1487 }
1489 (sizeof(my_proof) !=
1491 my_proof = 0;
1493 proof_task =
1495 &find_proof,
1496 NULL);
1497
1500 /* Connect to core service and register core handlers */
1501 core_api =
1502 GNUNET_CORE_connect (cfg, /* Main configuration */
1503 NULL, /* Closure passed to functions */
1504 &core_init, /* Call core_init once connected */
1505 &handle_core_connect, /* Handle connects */
1506 &handle_core_disconnect, /* Handle disconnects */
1507 core_handlers); /* Register these handlers */
1508 if (NULL == core_api)
1509 {
1511 return;
1512 }
1514}
struct GNUNET_CRYPTO_PrivateKey pk
Private key from command line option, or NULL.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static void core_init(void *cls, const struct GNUNET_PeerIdentity *identity)
Called on core init/fail.
static void * handle_core_connect(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a peer connects.
static void shutdown_task(void *cls)
Task run during shutdown.
static void handle_core_disconnect(void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
Method called whenever a peer disconnects.
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open_file(const char *fn)
Open a file for writing.
Definition: bio.c:508
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
struct GNUNET_CORE_Handle * GNUNET_CORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls, GNUNET_CORE_StartupCallback init, GNUNET_CORE_ConnectEventHandler connects, GNUNET_CORE_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Connect to the core service.
Definition: core_api.c:691
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:198
struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_CRYPTO_eddsa_key_create_from_configuration(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a new private key by reading our peer's key from the file specified in the configuration.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:482
ssize_t GNUNET_DISK_fn_read(const char *fn, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:664
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
void GNUNET_log_config_invalid(enum GNUNET_ErrorType kind, const char *section, const char *option, const char *required)
Log error message about invalid configuration option value.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
struct GNUNET_NotificationContext * GNUNET_notification_context_create(unsigned int queue_length)
Create a new notification context.
Definition: nc.c:122
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1340
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified priority.
Definition: scheduler.c:1232
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
#define GNUNET_TIME_UNIT_SECONDS
One second.
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
Private ECC key encoded for transmission.
Message handler for a specific message type.

References _, cfg, core_api, core_init(), find_proof(), GNUNET_asprintf(), GNUNET_assert, GNUNET_BIO_write_open_file(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CORE_connect(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_CRYPTO_eddsa_key_get_public(), 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_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_add_with_priority(), GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, handle_core_connect(), handle_core_disconnect(), my_identity, my_private_key, my_proof, nc, nse_work_required, peers, pk, proof, proof_find_delay, proof_task, GNUNET_PeerIdentity::public_key, 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
clsclosure for the service
cthe new client that connected to the service
mqthe message queue used to send messages to the client
Returns
c

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

1529{
1530 (void) cls;
1531 (void) mq;
1532 return c;
1533}

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
clsclosure for the service
cthe client that disconnected
internal_clsshould be equal to c

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

1547{
1548 (void) cls;
1549 GNUNET_assert (c == internal_cls);
1550}

References GNUNET_assert.

◆ GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN ( "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 85 of file gnunet-service-nse.c.

Referenced by check_proof_of_work(), find_proof(), run(), setup_flood_message(), 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 90 of file gnunet-service-nse.c.

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

◆ proof_find_delay

struct GNUNET_TIME_Relative proof_find_delay
static

Interval between proof find runs.

Definition at line 95 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 calcualations.

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

Referenced by check_proof_of_work(), and find_proof().

◆ cfg

Handle to our current configuration.

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

Referenced by run(), and write_proof().

◆ stats

◆ core_api

struct GNUNET_CORE_Handle* core_api
static

Handle to the core service.

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

Referenced by run(), and shutdown_task().

◆ peers

◆ current_size_estimate

double current_size_estimate
static

The current network size estimate.

Number of bits matching on average thus far.

Definition at line 246 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 252 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 257 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 262 of file gnunet-service-nse.c.

Referenced by 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 267 of file gnunet-service-nse.c.

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

◆ estimate_index

unsigned int estimate_index
static

◆ estimate_count

unsigned int estimate_count
static

Number of valid entries in the history.

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

Referenced by core_init(), 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 282 of file gnunet-service-nse.c.

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

◆ proof_task

struct GNUNET_SCHEDULER_Task* proof_task
static

Task scheduled to compute our proof.

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

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

◆ nc

struct GNUNET_NotificationContext* nc
static

Notification context, simplifies client broadcasts.

Definition at line 292 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 297 of file gnunet-service-nse.c.

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

◆ current_timestamp

struct GNUNET_TIME_Absolute current_timestamp
static

The current major time.

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

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

◆ my_private_key

struct GNUNET_CRYPTO_EddsaPrivateKey* my_private_key
static

The private key of this peer.

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

Referenced by run(), setup_flood_message(), and shutdown_task().

◆ my_identity

struct GNUNET_PeerIdentity my_identity
static

The peer identity of this peer.

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

Referenced by core_init(), find_proof(), handle_p2p_estimate(), run(), setup_flood_message(), and update_flood_message().

◆ my_proof

uint64_t my_proof
static

Proof of work for this peer.

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

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