monitor namestore changes and publish them immediately to GNUnet name system More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_dht_service.h"
#include "gnunet_namestore_service.h"
#include "gnunet_statistics_service.h"

Include dependency graph for gnunet-service-zonemaster-monitor.c:

Go to the source code of this file.

Data Structures
struct	DhtPutActivity
	Handle for DHT PUT activity triggered from the namestore monitor. More...

Macros
#define	LOG_STRERROR_FILE(kind, syscall, filename)

#define	PUBLISH_OPS_PER_EXPIRATION 4
	How often should we (re)publish each record before it expires? More...

#define	DHT_QUEUE_LIMIT 2000
	How many pending DHT operations do we allow at most? More...

#define	NAMESTORE_QUEUE_LIMIT 5
	How many events may the namestore give us before it has to wait for us to keep up? More...

#define	DHT_GNS_REPLICATION_LEVEL 5
	What replication level do we use for DHT PUT operations? More...

Functions
static void	shutdown_task (void *cls)
	Task run during shutdown. More...

static void	dht_put_monitor_continuation (void *cls)
	Continuation called from DHT once the PUT operation triggered by a monitor is done. More...

static unsigned int	convert_records_for_export (const struct GNUNET_GNSRECORD_Data rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Data rd_public)
	Convert namestore records from the internal format to that suitable for publication (removes private records, converts to absolute expiration time). More...

static struct GNUNET_DHT_PutHandle *	perform_dht_put (const struct GNUNET_CRYPTO_EcdsaPrivateKey key, const char label, const struct GNUNET_GNSRECORD_Data rd_public, unsigned int rd_public_count, struct DhtPutActivity ma)
	Store GNS records in the DHT. More...

static void	handle_monitor_event (void cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey zone, const char label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data rd)
	Process a record that was stored in the namestore (invoked by the monitor). More...

static void	handle_monitor_error (void *cls)
	The zone monitor encountered an IPC error trying to to get in sync. More...

static void	run (void cls, const struct GNUNET_CONFIGURATION_Handle c, struct GNUNET_SERVICE_Handle *service)
	Performe zonemaster duties: watch namestore, publish records. More...

	GNUNET_SERVICE_MAIN ("zonemaster-monitor", GNUNET_SERVICE_OPTION_NONE, &run, NULL, NULL, NULL, GNUNET_MQ_handler_end())
	Define "main" method using service macro. More...

Variables
static struct GNUNET_STATISTICS_Handle *	statistics
	Handle to the statistics service. More...

static struct GNUNET_DHT_Handle *	dht_handle
	Our handle to the DHT. More...

static struct GNUNET_NAMESTORE_Handle *	namestore_handle
	Our handle to the namestore service. More...

static struct GNUNET_NAMESTORE_ZoneMonitor *	zmon
	Handle to monitor namestore changes to instant propagation. More...

static struct DhtPutActivity *	ma_head
	Head of monitor activities; kept in a DLL. More...

static struct DhtPutActivity *	ma_tail
	Tail of monitor activities; kept in a DLL. More...

static unsigned int	ma_queue_length
	Number of entries in the DHT queue ma_head. More...

static int	cache_keys
	Optimize block insertion by caching map of private keys to public keys in memory? More...

Detailed Description

monitor namestore changes and publish them immediately to GNUnet name system

Author: Christian Grothoff

Definition in file gnunet-service-zonemaster-monitor.c.

Macro Definition Documentation

◆ LOG_STRERROR_FILE

#define LOG_STRERROR_FILE	(	kind,
		syscall,
		filename
	)

Value:

GNUNET_log_from_strerror_file (kind, "util", \
                                                                   syscall, \
                                                                   filename)

Definition at line 33 of file gnunet-service-zonemaster-monitor.c.

◆ PUBLISH_OPS_PER_EXPIRATION

#define PUBLISH_OPS_PER_EXPIRATION 4

How often should we (re)publish each record before it expires?

Definition at line 43 of file gnunet-service-zonemaster-monitor.c.

◆ DHT_QUEUE_LIMIT

#define DHT_QUEUE_LIMIT 2000

How many pending DHT operations do we allow at most?

Definition at line 48 of file gnunet-service-zonemaster-monitor.c.

Referenced by handle_monitor_event().

◆ NAMESTORE_QUEUE_LIMIT

#define NAMESTORE_QUEUE_LIMIT 5

How many events may the namestore give us before it has to wait for us to keep up?

Definition at line 54 of file gnunet-service-zonemaster-monitor.c.

Referenced by run().

◆ DHT_GNS_REPLICATION_LEVEL

#define DHT_GNS_REPLICATION_LEVEL 5

What replication level do we use for DHT PUT operations?

Definition at line 59 of file gnunet-service-zonemaster-monitor.c.

Referenced by perform_dht_put().

Function Documentation

◆ shutdown_task()

static void shutdown_task ( void * cls )

static

Task run during shutdown.

Parameters

cls	unused
tc	unused

Definition at line 138 of file gnunet-service-zonemaster-monitor.c.

References GNUNET_CONTAINER_DLL_remove, GNUNET_DHT_disconnect(), GNUNET_DHT_put_cancel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NAMESTORE_disconnect(), GNUNET_NAMESTORE_zone_monitor_stop(), GNUNET_NO, GNUNET_STATISTICS_destroy(), ma_queue_length, and DhtPutActivity::ph.

Referenced by run().

 {
   struct DhtPutActivity *ma;
 
   (void) cls;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Shutting down!\n");
   while (NULL != (ma = ma_head))
   {
     GNUNET_DHT_put_cancel (ma->ph);
     ma_queue_length--;
     GNUNET_CONTAINER_DLL_remove (ma_head,
                                  ma_tail,
                                  ma);
     GNUNET_free (ma);
   }
   if (NULL != statistics)
   {
     GNUNET_STATISTICS_destroy (statistics,
                                GNUNET_NO);
     statistics = NULL;
   }
   if (NULL != zmon)
   {
     GNUNET_NAMESTORE_zone_monitor_stop (zmon);
     zmon = NULL;
   }
   if (NULL != namestore_handle)
   {
     GNUNET_NAMESTORE_disconnect (namestore_handle);
     namestore_handle = NULL;
   }
   if (NULL != dht_handle)
   {
     GNUNET_DHT_disconnect (dht_handle);
     dht_handle = NULL;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dht_put_monitor_continuation()

static void dht_put_monitor_continuation ( void * cls )

static

Continuation called from DHT once the PUT operation triggered by a monitor is done.

Parameters

cls	a `struct DhtPutActivity`

Definition at line 185 of file gnunet-service-zonemaster-monitor.c.

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NAMESTORE_zone_monitor_next(), and ma_queue_length.

Referenced by perform_dht_put().

 {
   struct DhtPutActivity *ma = cls;
 
   GNUNET_NAMESTORE_zone_monitor_next (zmon,
                                       1);
   ma_queue_length--;
   GNUNET_CONTAINER_DLL_remove (ma_head,
                                ma_tail,
                                ma);
   GNUNET_free (ma);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ convert_records_for_export()

static unsigned int convert_records_for_export	(	const struct GNUNET_GNSRECORD_Data *	rd,
		unsigned int	rd_count,
		struct GNUNET_GNSRECORD_Data *	rd_public
	)

static

Convert namestore records from the internal format to that suitable for publication (removes private records, converts to absolute expiration time).

Parameters

rd	input records
rd_count	size of the rd and rd_public arrays
rd_public	where to write the converted records

Returns: number of records written to rd_public

Definition at line 210 of file gnunet-service-zonemaster-monitor.c.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, and GNUNET_TIME_absolute_get().

Referenced by handle_monitor_event().

 {
   struct GNUNET_TIME_Absolute now;
   unsigned int rd_public_count;
 
   rd_public_count = 0;
   now = GNUNET_TIME_absolute_get ();
   for (unsigned int i = 0; i < rd_count; i++)
   {
     if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE))
       continue;
     if ((0 == (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION)) &&
         (rd[i].expiration_time < now.abs_value_us))
       continue;   /* record already expired, skip it */
     rd_public[rd_public_count++] = rd[i];
   }
   return rd_public_count;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ perform_dht_put()

static struct GNUNET_DHT_PutHandle* perform_dht_put	(	const struct GNUNET_CRYPTO_EcdsaPrivateKey *	key,
		const char *	label,
		const struct GNUNET_GNSRECORD_Data *	rd_public,
		unsigned int	rd_public_count,
		struct DhtPutActivity *	ma
	)

static

Store GNS records in the DHT.

Parameters

key	key of the zone
label	label to store under
rd_public	public record data
rd_public_count	number of records in rd_public
ma	handle for the PUT operation

Returns: DHT PUT handle, NULL on error

Definition at line 243 of file gnunet-service-zonemaster-monitor.c.

References cache_keys, DHT_GNS_REPLICATION_LEVEL, dht_put_monitor_continuation(), GNUNET_BLOCK_TYPE_GNS_NAMERECORD, GNUNET_break, GNUNET_DHT_put(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_block_create(), GNUNET_GNSRECORD_block_create2(), GNUNET_GNSRECORD_query_from_private_key(), GNUNET_GNSRECORD_record_get_expiration_time(), GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_GNSRECORD_Block::purpose, ret, and GNUNET_CRYPTO_EccSignaturePurpose::size.

Referenced by handle_monitor_event().

 {
   struct GNUNET_GNSRECORD_Block *block;
   struct GNUNET_HashCode query;
   struct GNUNET_TIME_Absolute expire;
   size_t block_size;
   struct GNUNET_DHT_PutHandle *ret;
 
   expire = GNUNET_GNSRECORD_record_get_expiration_time (rd_public_count,
                                                         rd_public);
   if (cache_keys)
     block = GNUNET_GNSRECORD_block_create2 (key,
                                             expire,
                                             label,
                                             rd_public,
                                             rd_public_count);
   else
     block = GNUNET_GNSRECORD_block_create (key,
                                            expire,
                                            label,
                                            rd_public,
                                            rd_public_count);
   if (NULL == block)
   {
     GNUNET_break (0);
     return NULL;   /* whoops */
   }
   block_size = ntohl (block->purpose.size)
                + sizeof(struct GNUNET_CRYPTO_EcdsaSignature)
                + sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey);
   GNUNET_GNSRECORD_query_from_private_key (key,
                                            label,
                                            &query);
   GNUNET_STATISTICS_update (statistics,
                             "DHT put operations initiated",
                             1,
                             GNUNET_NO);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Storing %u record(s) for label `%s' in DHT with expiration `%s' under key %s\n",
               rd_public_count,
               label,
               GNUNET_STRINGS_absolute_time_to_string (expire),
               GNUNET_h2s (&query));
   ret = GNUNET_DHT_put (dht_handle,
                         &query,
                         DHT_GNS_REPLICATION_LEVEL,
                         GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
                         GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
                         block_size,
                         block,
                         expire,
                         &dht_put_monitor_continuation,
                         ma);
   GNUNET_free (block);
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_monitor_event()

static void handle_monitor_event	(	void *	cls,
		const struct GNUNET_CRYPTO_EcdsaPrivateKey *	zone,
		const char *	label,
		unsigned int	rd_count,
		const struct GNUNET_GNSRECORD_Data *	rd
	)

static

Process a record that was stored in the namestore (invoked by the monitor).

Parameters

cls	closure, NULL
zone	private key of the zone; NULL on disconnect
label	label of the records; NULL on disconnect
rd_count	number of entries in rd array, 0 if label was deleted
rd	array of records with data to store

Definition at line 316 of file gnunet-service-zonemaster-monitor.c.

References convert_records_for_export(), DHT_QUEUE_LIMIT, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_DHT_put_cancel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_NAMESTORE_zone_monitor_next(), GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, ma_head, ma_queue_length, perform_dht_put(), DhtPutActivity::ph, and DhtPutActivity::start_date.

Referenced by run().

 {
   struct GNUNET_GNSRECORD_Data rd_public[rd_count];
   unsigned int rd_public_count;
   struct DhtPutActivity *ma;
 
   (void) cls;
   GNUNET_STATISTICS_update (statistics,
                             "Namestore monitor events received",
                             1,
                             GNUNET_NO);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received %u records for label `%s' via namestore monitor\n",
               rd_count,
               label);
   /* filter out records that are not public, and convert to
      absolute expiration time. */
   rd_public_count = convert_records_for_export (rd,
                                                 rd_count,
                                                 rd_public);
   if (0 == rd_public_count)
   {
     GNUNET_NAMESTORE_zone_monitor_next (zmon,
                                         1);
     return;   /* nothing to do */
   }
   ma = GNUNET_new (struct DhtPutActivity);
   ma->start_date = GNUNET_TIME_absolute_get ();
   ma->ph = perform_dht_put (zone,
                             label,
                             rd,
                             rd_count,
                             ma);
   if (NULL == ma->ph)
   {
     /* PUT failed, do not remember operation */
     GNUNET_free (ma);
     GNUNET_NAMESTORE_zone_monitor_next (zmon,
                                         1);
     return;
   }
   GNUNET_CONTAINER_DLL_insert_tail (ma_head,
                                     ma_tail,
                                     ma);
   ma_queue_length++;
   if (ma_queue_length > DHT_QUEUE_LIMIT)
   {
     ma = ma_head;
     GNUNET_CONTAINER_DLL_remove (ma_head,
                                  ma_tail,
                                  ma);
     GNUNET_DHT_put_cancel (ma->ph);
     ma_queue_length--;
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 "DHT PUT unconfirmed after %s, aborting PUT\n",
                 GNUNET_STRINGS_relative_time_to_string (
                   GNUNET_TIME_absolute_get_duration (ma->start_date),
                   GNUNET_YES));
     GNUNET_free (ma);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_monitor_error()

static void handle_monitor_error ( void * cls )

static

The zone monitor encountered an IPC error trying to to get in sync.

Restart from the beginning.

Parameters

cls NULL

Definition at line 390 of file gnunet-service-zonemaster-monitor.c.

References GNUNET_NO, and GNUNET_STATISTICS_update().

Referenced by run().

 {
   (void) cls;
   GNUNET_STATISTICS_update (statistics,
                             "Namestore monitor errors encountered",
                             1,
                             GNUNET_NO);
 }

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

Performe zonemaster duties: watch namestore, publish records.

Parameters

cls	closure
server	the initialized server
c	configuration to use

Definition at line 408 of file gnunet-service-zonemaster-monitor.c.

References _, cache_keys, GNUNET_break, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_DHT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MQ_handler_end, GNUNET_NAMESTORE_connect(), GNUNET_NAMESTORE_zone_monitor_next(), GNUNET_NAMESTORE_zone_monitor_start(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SERVICE_MAIN(), GNUNET_SERVICE_OPTION_NONE, GNUNET_STATISTICS_create(), handle_monitor_error(), handle_monitor_event(), NAMESTORE_QUEUE_LIMIT, and shutdown_task().

 {
   unsigned long long max_parallel_bg_queries = 128;
 
   (void) cls;
   (void) service;
   namestore_handle = GNUNET_NAMESTORE_connect (c);
   if (NULL == namestore_handle)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Failed to connect to the namestore!\n"));
     GNUNET_SCHEDULER_shutdown ();
     return;
   }
   cache_keys = GNUNET_CONFIGURATION_get_value_yesno (c,
                                                      "namestore",
                                                      "CACHE_KEYS");
   if (GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_number (c,
                                              "zonemaster",
                                              "MAX_PARALLEL_BACKGROUND_QUERIES",
                                              &max_parallel_bg_queries))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Number of allowed parallel background queries: %llu\n",
                 max_parallel_bg_queries);
   }
   if (0 == max_parallel_bg_queries)
     max_parallel_bg_queries = 1;
   dht_handle = GNUNET_DHT_connect (c,
                                    (unsigned int) max_parallel_bg_queries);
   if (NULL == dht_handle)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Could not connect to DHT!\n"));
     GNUNET_SCHEDULER_add_now (&shutdown_task,
                               NULL);
     return;
   }
 
   /* Schedule periodic put for our records. */
   statistics = GNUNET_STATISTICS_create ("zonemaster-mon",
                                          c);
   zmon = GNUNET_NAMESTORE_zone_monitor_start (c,
                                               NULL,
                                               GNUNET_NO,
                                               &handle_monitor_error,
                                               NULL,
                                               &handle_monitor_event,
                                               NULL,
                                               NULL /* sync_cb */,
                                               NULL);
   GNUNET_NAMESTORE_zone_monitor_next (zmon,
                                       NAMESTORE_QUEUE_LIMIT - 1);
   GNUNET_break (NULL != zmon);
   GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                  NULL);
 }