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) GNUNET_log_from_strerror_file(kind, "util", 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
	)	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 40 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 45 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 51 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 56 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 134 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 181 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 206 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 239 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 312 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 385 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 403 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);
 }