gnunet-service-namestore.c File Reference

namestore for the GNUnet naming system More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_dnsparser_lib.h"
#include "gnunet_gns_service.h"
#include "gnunet_namecache_service.h"
#include "gnunet_namestore_service.h"
#include "gnunet_namestore_plugin.h"
#include "gnunet_statistics_service.h"
#include "gnunet_signatures.h"
#include "namestore.h"

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

Go to the source code of this file.

Data Structures
struct	ZoneIteration
	A namestore iteration operation. More...
struct	NamestoreClient
	A namestore client. More...
struct	ZoneMonitor
	A namestore monitor. More...
struct	CacheOperation
	Pending operation on the namecache. More...
struct	StoreActivity
	Information for an ongoing handle_record_store() operation. More...
struct	NickCache
	Entry in list of cached nick resolutions. More...
struct	RecordLookupContext
	Closure for lookup_it(). More...
struct	ZoneToNameCtx
	Context for record remove operations passed from handle_zone_to_name to handle_zone_to_name_it as closure. More...
struct	ZoneIterationProcResult
	Context for record remove operations passed from run_zone_iteration_round to zone_iterate_proc as closure. More...

Macros
#define	LOG_STRERROR_FILE(kind, syscall, filename)   GNUNET_log_from_strerror_file (kind, "util", syscall, filename)
#define	MONITOR_STALL_WARN_DELAY   GNUNET_TIME_UNIT_MINUTES
	If a monitor takes more than 1 minute to process an event, print a warning. More...
#define	NC_SIZE   16
	Size of the cache used by get_nick_record() More...

Functions
static void	cleanup_task (void *cls)
	Task run during shutdown. More...
static void	free_store_activity (struct StoreActivity *sa)
	Release memory used by sa. More...
static void	lookup_nick_it (void *cls, uint64_t seq, const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Function called with the records for the GNUNET_GNS_EMPTY_LABEL_AT label in the zone. More...
static void	cache_nick (const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const struct GNUNET_GNSRECORD_Data *nick)
	Add entry to the cache for zone and nick. More...
static struct GNUNET_GNSRECORD_Data *	get_nick_record (const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone)
	Return the NICK record for the zone (if it exists). More...
static void	merge_with_nick_records (const struct GNUNET_GNSRECORD_Data *nick_rd, unsigned int rd2_length, const struct GNUNET_GNSRECORD_Data *rd2, unsigned int *rdc_res, struct GNUNET_GNSRECORD_Data **rd_res)
	Merge the nick record nick_rd with the rest of the record set given in rd2. More...
static void	send_lookup_response (struct NamestoreClient *nc, uint32_t request_id, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Generate a struct LookupNameResponseMessage and send it to the given client using the given notification context. More...
static void	send_store_response (struct NamestoreClient *nc, int res, uint32_t rid)
	Send response to the store request to the client. More...
static void	zone_iteration_done_client_continue (struct ZoneIteration *zi)
	Function called once we are done with the zone iteration and allow the zone iteration client to send us more messages. More...
static void	finish_cache_operation (void *cls, int32_t success, const char *emsg)
	Cache operation complete, clean up. More...
static void	refresh_block (struct NamestoreClient *nc, struct ZoneIteration *zi, uint32_t rid, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	We just touched the plaintext information about a name in our zone; refresh the corresponding (encrypted) block in the namecache. More...
static void	warn_monitor_slow (void *cls)
	Print a warning that one of our monitors is no longer reacting. More...
static void	continue_store_activity (struct StoreActivity *sa)
	Continue processing the sa. More...
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
	Called whenever a client is disconnected. More...
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
	Add a client to our list of active clients. More...
static void	lookup_it (void *cls, uint64_t seq, const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Function called by the namestore plugin when we are trying to lookup a record as part of handle_record_lookup(). More...
static int	check_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg)
	Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP message. More...
static void	handle_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg)
	Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP message. More...
static int	check_record_store (void *cls, const struct RecordStoreMessage *rp_msg)
	Checks a GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE message. More...
static void	handle_record_store (void *cls, const struct RecordStoreMessage *rp_msg)
	Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE message. More...
static void	handle_zone_to_name_it (void *cls, uint64_t seq, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Zone to name iterator. More...
static void	handle_zone_to_name (void *cls, const struct ZoneToNameMessage *ztn_msg)
	Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME message. More...
static void	zone_iterate_proc (void *cls, uint64_t seq, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Process results for zone iteration from database. More...
static void	run_zone_iteration_round (struct ZoneIteration *zi, uint64_t limit)
	Perform the next round of the zone iteration. More...
static void	handle_iteration_start (void *cls, const struct ZoneIterationStartMessage *zis_msg)
	Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START message. More...
static void	handle_iteration_stop (void *cls, const struct ZoneIterationStopMessage *zis_msg)
	Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP message. More...
static void	handle_iteration_next (void *cls, const struct ZoneIterationNextMessage *zis_msg)
	Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT message. More...
static void	monitor_unblock (struct ZoneMonitor *zm)
	Function called when the monitor is ready for more data, and we should thus unblock PUT operations that were blocked on the monitor not being ready. More...
static void	monitor_sync (struct ZoneMonitor *zm)
	Send 'sync' message to zone monitor, we're now in sync. More...
static void	monitor_iteration_next (void *cls)
	Obtain the next datum during the zone monitor's zone initial iteration. More...
static void	monitor_iterate_cb (void *cls, uint64_t seq, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	A GNUNET_NAMESTORE_RecordIterator for monitors. More...
static void	handle_monitor_start (void *cls, const struct ZoneMonitorStartMessage *zis_msg)
	Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START message. More...
static void	handle_monitor_next (void *cls, const struct ZoneMonitorNextMessage *nm)
	Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT message. More...
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *service)
	Process namestore requests. More...
	GNUNET_SERVICE_MAIN ("namestore", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(record_store, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE, struct RecordStoreMessage, NULL), GNUNET_MQ_hd_var_size(record_lookup, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP, struct LabelLookupMessage, NULL), GNUNET_MQ_hd_fixed_size(zone_to_name, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME, struct ZoneToNameMessage, NULL), GNUNET_MQ_hd_fixed_size(iteration_start, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START, struct ZoneIterationStartMessage, NULL), GNUNET_MQ_hd_fixed_size(iteration_next, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT, struct ZoneIterationNextMessage, NULL), GNUNET_MQ_hd_fixed_size(iteration_stop, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP, struct ZoneIterationStopMessage, NULL), GNUNET_MQ_hd_fixed_size(monitor_start, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START, struct ZoneMonitorStartMessage, NULL), GNUNET_MQ_hd_fixed_size(monitor_next, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT, struct ZoneMonitorNextMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro. More...

Variables
static struct NickCache	nick_cache [16]
	We cache nick records to reduce DB load. More...
static const struct GNUNET_CRYPTO_EcdsaPrivateKey	zero
	Public key of all zeros. More...
static const struct GNUNET_CONFIGURATION_Handle *	GSN_cfg
	Configuration handle. More...
static struct GNUNET_STATISTICS_Handle *	statistics
	Handle to the statistics service. More...
static struct GNUNET_NAMECACHE_Handle *	namecache
	Namecache handle. More...
static struct GNUNET_NAMESTORE_PluginFunctions *	GSN_database
	Database handle. More...
static char *	db_lib_name
	Name of the database plugin. More...
static struct CacheOperation *	cop_head
	Head of cop DLL. More...
static struct CacheOperation *	cop_tail
	Tail of cop DLL. More...
static struct ZoneMonitor *	monitor_head
	First active zone monitor. More...
static struct ZoneMonitor *	monitor_tail
	Last active zone monitor. More...
static struct StoreActivity *	sa_head
	Head of DLL of monitor-blocked store activities. More...
static struct StoreActivity *	sa_tail
	Tail of DLL of monitor-blocked store activities. More...
static struct GNUNET_NotificationContext *	monitor_nc
	Notification context shared by all monitors. More...
static int	cache_keys
	Optimize block insertion by caching map of private keys to public keys in memory? More...
static int	disable_namecache
	Use the namecache? Doing so creates additional cryptographic operations whenever we touch a record. More...

Detailed Description

namestore for the GNUnet naming system

Author

Matthias Wachs

Christian Grothoff

Definition in file gnunet-service-namestore.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 38 of file gnunet-service-namestore.c.

MONITOR_STALL_WARN_DELAY

#define MONITOR_STALL_WARN_DELAY   GNUNET_TIME_UNIT_MINUTES

If a monitor takes more than 1 minute to process an event, print a warning.

Definition at line 43 of file gnunet-service-namestore.c.

Referenced by continue_store_activity(), handle_monitor_next(), monitor_unblock(), and warn_monitor_slow().

NC_SIZE

#define NC_SIZE   16

Size of the cache used by get_nick_record()

Definition at line 48 of file gnunet-service-namestore.c.

Referenced by cache_nick(), and get_nick_record().

Function Documentation

cleanup_task()

static void cleanup_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

unused

Definition at line 424 of file gnunet-service-namestore.c.

References db_lib_name, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_NAMECACHE_cancel(), GNUNET_NAMECACHE_disconnect(), GNUNET_NO, GNUNET_notification_context_destroy(), GNUNET_PLUGIN_unload(), GNUNET_STATISTICS_destroy(), and CacheOperation::qe.

Referenced by run().

{
  struct CacheOperation *cop;

  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Stopping namestore service\n");
  while (NULL != (cop = cop_head))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Aborting incomplete namecache operation\n");
    GNUNET_NAMECACHE_cancel (cop->qe);
    GNUNET_CONTAINER_DLL_remove (cop_head,
                                 cop_tail,
                                 cop);
    GNUNET_free (cop);
  }
  if (NULL != namecache)
  {
    GNUNET_NAMECACHE_disconnect (namecache);
    namecache = NULL;
  }
  GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name,
                                              GSN_database));
  GNUNET_free (db_lib_name);
  db_lib_name = NULL;
  if (NULL != monitor_nc)
  {
    GNUNET_notification_context_destroy (monitor_nc);
    monitor_nc = NULL;
  }
  if (NULL != statistics)
  {
    GNUNET_STATISTICS_destroy (statistics,
                               GNUNET_NO);
    statistics = NULL;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

free_store_activity()

static void free_store_activity ( struct StoreActivity *  sa )

static

Release memory used by sa.

Parameters

sa	activity to free

Definition at line 470 of file gnunet-service-namestore.c.

References StoreActivity::conv_name, GNUNET_CONTAINER_DLL_remove, and GNUNET_free.

Referenced by client_disconnect_cb(), and continue_store_activity().

{
  GNUNET_CONTAINER_DLL_remove (sa_head,
                               sa_tail,
                               sa);
  GNUNET_free (sa->conv_name);
  GNUNET_free (sa);
}

Here is the caller graph for this function:

lookup_nick_it()

static void lookup_nick_it ( void *  cls, uint64_t  seq, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  private_key, const char *  label, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Function called with the records for the GNUNET_GNS_EMPTY_LABEL_AT label in the zone.

Used to locate the GNUNET_GNSRECORD_TYPE_NICK record, which (if found) is then copied to cls for future use.

Parameters

cls	a struct GNUNET_GNSRECORD_Data ** for storing the nick (if found)
seq	sequence number of the record, MUST NOT BE ZERO
private_key	the private key of the zone (unused)
label	should be GNUNET_GNS_EMPTY_LABEL_AT
rd_count	number of records in rd
rd	records stored under label in the zone

Definition at line 493 of file gnunet-service-namestore.c.

References GNUNET_GNSRECORD_Data::data, data_size, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_assert, GNUNET_break, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_TYPE_NICK, GNUNET_malloc, GNUNET_memcpy, GNUNET_GNSRECORD_Data::record_type, and res.

Referenced by get_nick_record().

{
  struct GNUNET_GNSRECORD_Data **res = cls;

  (void) private_key;
  GNUNET_assert (0 != seq);
  if (0 != strcmp (label, GNUNET_GNS_EMPTY_LABEL_AT))
  {
    GNUNET_break (0);
    return;
  }
  for (unsigned int c = 0; c < rd_count; c++)
  {
    if (GNUNET_GNSRECORD_TYPE_NICK == rd[c].record_type)
    {
      (*res) = GNUNET_malloc (rd[c].data_size + sizeof (struct GNUNET_GNSRECORD_Data));
      (*res)->data = &(*res)[1];
      GNUNET_memcpy ((void *) (*res)->data,
                     rd[c].data,
                     rd[c].data_size);
      (*res)->data_size = rd[c].data_size;
      (*res)->expiration_time = rd[c].expiration_time;
      (*res)->flags = rd[c].flags;
      (*res)->record_type = GNUNET_GNSRECORD_TYPE_NICK;
      return;
    }
  }
  (*res) = NULL;
}

Here is the caller graph for this function:

cache_nick()

static void cache_nick ( const struct GNUNET_CRYPTO_EcdsaPrivateKey *  zone, const struct GNUNET_GNSRECORD_Data *  nick  )

static

Add entry to the cache for zone and nick.

Parameters

zone	zone key to cache under
nick	nick entry to cache

Definition at line 536 of file gnunet-service-namestore.c.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, GNUNET_free_non_null, GNUNET_malloc, GNUNET_memcmp, GNUNET_TIME_absolute_get(), NickCache::last_used, NC_SIZE, ZoneIteration::nick, nick_cache, NickCache::rd, ZoneIteration::zone, and NickCache::zone.

Referenced by get_nick_record(), and handle_record_store().

{
  struct NickCache *oldest;

  oldest = NULL;
  for (unsigned int i=0;i<NC_SIZE;i++)
  {
    struct NickCache *pos = &nick_cache[i];

    if ( (NULL == oldest) ||
         (oldest->last_used.abs_value_us >
          pos->last_used.abs_value_us) )
      oldest = pos;
    if (0 == GNUNET_memcmp (zone,
                     &pos->zone))
    {
      oldest = pos;
      break;
    }
  }
  GNUNET_free_non_null (oldest->rd);
  oldest->zone = *zone;
  if (NULL != nick)
  {
    oldest->rd = GNUNET_malloc (sizeof (*nick) +
                                nick->data_size);
    *oldest->rd = *nick;
    oldest->rd->data = &oldest->rd[1];
    memcpy (&oldest->rd[1],
            nick->data,
            nick->data_size);
  }
  else
  {
    oldest->rd = NULL;
  }
  oldest->last_used = GNUNET_TIME_absolute_get ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_nick_record()

static struct GNUNET_GNSRECORD_Data* get_nick_record ( const struct GNUNET_CRYPTO_EcdsaPrivateKey *  zone )

static

Return the NICK record for the zone (if it exists).

Parameters

zone	private key for the zone to look for nick

Returns

NULL if no NICK record was found

Definition at line 584 of file gnunet-service-namestore.c.

References cache_nick(), GNUNET_NAMESTORE_PluginFunctions::cls, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_get_log_call_status(), GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_z2s(), GNUNET_log, GNUNET_LOG_CALL_STATUS, GNUNET_malloc, GNUNET_memcmp, GNUNET_OK, GNUNET_TIME_absolute_get(), NickCache::last_used, lookup_nick_it(), GNUNET_NAMESTORE_PluginFunctions::lookup_records, NC_SIZE, ZoneIteration::nick, nick_cache, NickCache::rd, res, and NickCache::zone.

Referenced by handle_record_lookup(), refresh_block(), and send_lookup_response().

{
  struct GNUNET_CRYPTO_EcdsaPublicKey pub;
  struct GNUNET_GNSRECORD_Data *nick;
  int res;

  /* check cache first */
  for (unsigned int i=0;i<NC_SIZE;i++)
  {
    struct NickCache *pos = &nick_cache[i];
    if ( (NULL != pos->rd) &&
         (0 == GNUNET_memcmp (zone,
                              &pos->zone)) )
    {
      if (NULL == pos->rd)
        return NULL;
      nick = GNUNET_malloc (sizeof (*nick) +
                            pos->rd->data_size);
      *nick = *pos->rd;
      nick->data = &nick[1];
      memcpy (&nick[1],
              pos->rd->data,
              pos->rd->data_size);
      pos->last_used = GNUNET_TIME_absolute_get ();
      return nick;
    }
  }

  nick = NULL;
  res = GSN_database->lookup_records (GSN_database->cls,
                                      zone,
                                      GNUNET_GNS_EMPTY_LABEL_AT,
                                      &lookup_nick_it,
                                      &nick);
  if ( (GNUNET_OK != res) ||
       (NULL == nick) )
  {
    static int do_log = GNUNET_LOG_CALL_STATUS;

    if (0 == do_log)
      do_log
        = GNUNET_get_log_call_status (GNUNET_ERROR_TYPE_DEBUG,
                                      "namestore",
                                      __FILE__,
                                      __FUNCTION__,
                                      __LINE__);
    if (1 == do_log)
    {
      GNUNET_CRYPTO_ecdsa_key_get_public (zone, &pub);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
                  "No nick name set for zone `%s'\n",
                  GNUNET_GNSRECORD_z2s (&pub));
    }
    /* update cache */
    cache_nick (zone,
                NULL);
    return NULL;
  }

  /* update cache */
  cache_nick (zone,
              nick);
  return nick;
}

Here is the call graph for this function:

Here is the caller graph for this function:

merge_with_nick_records()

static void merge_with_nick_records ( const struct GNUNET_GNSRECORD_Data *  nick_rd, unsigned int  rd2_length, const struct GNUNET_GNSRECORD_Data *  rd2, unsigned int *  rdc_res, struct GNUNET_GNSRECORD_Data **  rd_res  )

static

Merge the nick record nick_rd with the rest of the record set given in rd2.

Store the result in rdc_res and rd_res. The nick_rd's expiration time is set to the maximum expiration time of all of the records in rd2.

Parameters

nick_rd	the nick record to integrate
rd2_length	length of the rd2 array
rd2	array of records
rdc_res[out]	length of the resulting rd_res array
rd_res[out]	set to an array of records, including nick_rd and rd2; all of the variable-size 'data' fields in rd2 are allocated in the same chunk of memory!

Definition at line 666 of file gnunet-service-namestore.c.

References data, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_assert, GNUNET_break, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_malloc, GNUNET_memcpy, and GNUNET_TIME_absolute_get().

Referenced by lookup_it(), refresh_block(), and send_lookup_response().

{
  uint64_t latest_expiration;
  size_t req;
  char *data;
  size_t data_offset;
  struct GNUNET_GNSRECORD_Data *target;

  (*rdc_res) = 1 + rd2_length;
  if (0 == 1 + rd2_length)
  {
    GNUNET_break (0);
    (*rd_res) = NULL;
    return;
  }
  req = sizeof (struct GNUNET_GNSRECORD_Data) + nick_rd->data_size;
  for (unsigned int i=0; i<rd2_length; i++)
  {
    const struct GNUNET_GNSRECORD_Data *orig = &rd2[i];

    if (req + sizeof (struct GNUNET_GNSRECORD_Data) + orig->data_size < req)
    {
      GNUNET_break (0);
      (*rd_res) = NULL;
      return;
    }
    req += sizeof (struct GNUNET_GNSRECORD_Data) + orig->data_size;
  }
  target = GNUNET_malloc (req);
  (*rd_res) = target;
  data = (char *) &target[1 + rd2_length];
  data_offset = 0;
  latest_expiration = 0;
  for (unsigned int i=0;i<rd2_length;i++)
  {
    const struct GNUNET_GNSRECORD_Data *orig = &rd2[i];

    if (0 != (orig->flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
    {
      if ((GNUNET_TIME_absolute_get().abs_value_us + orig->expiration_time) >
          latest_expiration)
        latest_expiration = orig->expiration_time;
    }
    else if (orig->expiration_time > latest_expiration)
      latest_expiration = orig->expiration_time;
    target[i] = *orig;
    target[i].data = (void *) &data[data_offset];
    GNUNET_memcpy (&data[data_offset],
                   orig->data,
                   orig->data_size);
    data_offset += orig->data_size;
  }
  /* append nick */
  target[rd2_length] = *nick_rd;
  target[rd2_length].expiration_time = latest_expiration;
  target[rd2_length].data = (void *) &data[data_offset];
  GNUNET_memcpy (&data[data_offset],
                 nick_rd->data,
                 nick_rd->data_size);
  data_offset += nick_rd->data_size;
  GNUNET_assert (req ==
                 (sizeof (struct GNUNET_GNSRECORD_Data)) * (*rdc_res) + data_offset);
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_lookup_response()

static void send_lookup_response ( struct NamestoreClient *  nc, uint32_t  request_id, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  zone_key, const char *  name, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Generate a struct LookupNameResponseMessage and send it to the given client using the given notification context.

Parameters

nc	client to unicast to
request_id	request ID to use
zone_key	zone key of the zone
name	name
rd_count	number of records in rd
rd	array of records

Definition at line 747 of file gnunet-service-namestore.c.

References NamestoreClient::client, env, GNUNET_GNSRECORD_Data::flags, get_nick_record(), RecordResultMessage::gns_header, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), merge_with_nick_records(), NamestoreClient::mq, RecordResultMessage::name_len, ZoneIteration::nick, RecordResultMessage::private_key, GNUNET_NAMESTORE_Header::r_id, RecordResultMessage::rd_count, RecordResultMessage::rd_len, and res.

Referenced by continue_store_activity(), monitor_iterate_cb(), and zone_iterate_proc().

{
  struct GNUNET_MQ_Envelope *env;
  struct RecordResultMessage *zir_msg;
  struct GNUNET_GNSRECORD_Data *nick;
  struct GNUNET_GNSRECORD_Data *res;
  unsigned int res_count;
  size_t name_len;
  ssize_t rd_ser_len;
  char *name_tmp;
  char *rd_ser;

  nick = get_nick_record (zone_key);
  GNUNET_assert (-1 !=
                 GNUNET_GNSRECORD_records_get_size (rd_count,
                                                    rd));

  if ( (NULL != nick) &&
       (0 != strcmp (name,
                     GNUNET_GNS_EMPTY_LABEL_AT)))
  {
    nick->flags = (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE;
    merge_with_nick_records (nick,
                             rd_count,
                             rd,
                             &res_count,
                             &res);
    GNUNET_free (nick);
  }
  else
  {
    res_count = rd_count;
    res = (struct GNUNET_GNSRECORD_Data *) rd;
  }

  GNUNET_assert (-1 !=
                 GNUNET_GNSRECORD_records_get_size (res_count,
                                                    res));


  name_len = strlen (name) + 1;
  rd_ser_len = GNUNET_GNSRECORD_records_get_size (res_count,
                                                  res);
  if (rd_ser_len < 0)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (nc->client);
    return;
  }
  if (((size_t) rd_ser_len) >= UINT16_MAX - name_len - sizeof (*zir_msg))
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (nc->client);
    return;
  }
  env = GNUNET_MQ_msg_extra (zir_msg,
                             name_len + rd_ser_len,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT);
  zir_msg->gns_header.r_id = htonl (request_id);
  zir_msg->name_len = htons (name_len);
  zir_msg->rd_count = htons (res_count);
  zir_msg->rd_len = htons ((uint16_t) rd_ser_len);
  zir_msg->private_key = *zone_key;
  name_tmp = (char *) &zir_msg[1];
  GNUNET_memcpy (name_tmp,
                 name,
                 name_len);
  rd_ser = &name_tmp[name_len];
  GNUNET_assert (rd_ser_len ==
                 GNUNET_GNSRECORD_records_serialize (res_count,
                                                     res,
                                                     rd_ser_len,
                                                     rd_ser));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending RECORD_RESULT message with %u records\n",
              res_count);
  GNUNET_STATISTICS_update (statistics,
                            "Record sets sent to clients",
                            1,
                            GNUNET_NO);
  GNUNET_MQ_send (nc->mq,
                  env);
  if (rd != res)
    GNUNET_free (res);
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_store_response()

static void send_store_response ( struct NamestoreClient *  nc, int  res, uint32_t  rid  )

static

Send response to the store request to the client.

Parameters

client	client to talk to
res	status of the operation
rid	client's request ID

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

References env, RecordStoreResponseMessage::gns_header, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_STATISTICS_update(), NamestoreClient::mq, RecordStoreResponseMessage::op_result, and GNUNET_NAMESTORE_Header::r_id.

Referenced by finish_cache_operation(), handle_record_store(), and refresh_block().

{
  struct GNUNET_MQ_Envelope *env;
  struct RecordStoreResponseMessage *rcr_msg;

  GNUNET_assert (NULL != nc);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending RECORD_STORE_RESPONSE message\n");
  GNUNET_STATISTICS_update (statistics,
                            "Store requests completed",
                            1,
                            GNUNET_NO);
  env = GNUNET_MQ_msg (rcr_msg,
                       GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE);
  rcr_msg->gns_header.r_id = htonl (rid);
  rcr_msg->op_result = htonl (res);
  GNUNET_MQ_send (nc->mq,
                  env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

zone_iteration_done_client_continue()

static void zone_iteration_done_client_continue ( struct ZoneIteration *  zi )

static

Function called once we are done with the zone iteration and allow the zone iteration client to send us more messages.

Parameters

zi	zone iteration we are processing

Definition at line 877 of file gnunet-service-namestore.c.

References NamestoreClient::client, env, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), NamestoreClient::mq, ZoneIteration::nc, NamestoreClient::op_head, NamestoreClient::op_tail, GNUNET_NAMESTORE_Header::r_id, ZoneIteration::request_id, and ZoneIteration::send_end.

Referenced by finish_cache_operation(), and run_zone_iteration_round().

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_NAMESTORE_Header *em;

  GNUNET_SERVICE_client_continue (zi->nc->client);
  if (! zi->send_end)
    return;
  /* send empty response to indicate end of list */
  env = GNUNET_MQ_msg (em,
                       GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END);
  em->r_id = htonl (zi->request_id);
  GNUNET_MQ_send (zi->nc->mq,
                  env);

  GNUNET_CONTAINER_DLL_remove (zi->nc->op_head,
                               zi->nc->op_tail,
                               zi);
  GNUNET_free (zi);
}

Here is the call graph for this function:

Here is the caller graph for this function:

finish_cache_operation()

static void finish_cache_operation ( void *  cls, int32_t  success, const char *  emsg  )

static

Cache operation complete, clean up.

Parameters

cls	the struct CacheOperation
success	success
emsg	error messages

Definition at line 907 of file gnunet-service-namestore.c.

References _, ZoneIteration::cache_ops, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, CacheOperation::nc, CacheOperation::rid, send_store_response(), CacheOperation::zi, and zone_iteration_done_client_continue().

Referenced by refresh_block().

{
  struct CacheOperation *cop = cls;
  struct ZoneIteration *zi;

  if (NULL != emsg)
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _("Failed to replicate block in namecache: %s\n"),
                emsg);
  else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "CACHE operation completed\n");
  GNUNET_CONTAINER_DLL_remove (cop_head,
                               cop_tail,
                               cop);
  if (NULL != cop->nc)
    send_store_response (cop->nc,
                         success,
                         cop->rid);
  if (NULL != (zi = cop->zi))
    {
      zi->cache_ops--;
      if (0 == zi->cache_ops)
      {
        /* unchoke zone iteration, cache has caught up */
        zone_iteration_done_client_continue (zi);
      }
    }
  GNUNET_free (cop);
}

Here is the call graph for this function:

Here is the caller graph for this function:

refresh_block()

static void refresh_block ( struct NamestoreClient *  nc, struct ZoneIteration *  zi, uint32_t  rid, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  zone_key, const char *  name, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

We just touched the plaintext information about a name in our zone; refresh the corresponding (encrypted) block in the namecache.

Parameters

nc	client responsible for the request, can be NULL
zi	zone iteration response for the request, can be NULL
rid	request ID of the client
zone_key	private key of the zone
name	label for the records
rd_count	number of records
rd	records stored under the given name

Definition at line 954 of file gnunet-service-namestore.c.

References cache_keys, ZoneIteration::cache_ops, disable_namecache, finish_cache_operation(), GNUNET_GNSRECORD_Data::flags, get_nick_record(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_block_create(), GNUNET_GNSRECORD_block_create2(), GNUNET_GNSRECORD_record_get_expiration_time(), GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_z2s(), GNUNET_log, GNUNET_NAMECACHE_block_cache(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_YES, merge_with_nick_records(), ZoneIteration::nc, CacheOperation::nc, ZoneIteration::nick, CacheOperation::qe, res, CacheOperation::rid, send_store_response(), and CacheOperation::zi.

Referenced by continue_store_activity(), and zone_iterate_proc().

{
  struct GNUNET_GNSRECORD_Block *block;
  struct CacheOperation *cop;
  struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
  struct GNUNET_GNSRECORD_Data *nick;
  struct GNUNET_GNSRECORD_Data *res;
  unsigned int res_count;
  struct GNUNET_TIME_Absolute exp_time;

  nick = get_nick_record (zone_key);
  res_count = rd_count;
  res = (struct GNUNET_GNSRECORD_Data *) rd; /* fixme: a bit unclean... */
  if (NULL != nick)
  {
    nick->flags = (nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE;
    merge_with_nick_records (nick,
                             rd_count,rd,
                             &res_count,
                             &res);
    GNUNET_free (nick);
  }
  if (0 == res_count)
  {
    if (NULL != nc)
      send_store_response (nc,
                           GNUNET_OK,
                           rid);
    return; /* no data, no need to update cache */
  }
  if (GNUNET_YES == disable_namecache)
  {
    GNUNET_STATISTICS_update (statistics,
                              "Namecache updates skipped (NC disabled)",
                              1,
                              GNUNET_NO);
    if (NULL != nc)
      send_store_response (nc,
                           GNUNET_OK,
                           rid);
    return;
  }
  exp_time = GNUNET_GNSRECORD_record_get_expiration_time (res_count,
                                                          res);
  if (cache_keys)
    block = GNUNET_GNSRECORD_block_create2 (zone_key,
                                            exp_time,
                                            name,
                                            res,
                                            res_count);
  else
    block = GNUNET_GNSRECORD_block_create (zone_key,
                                           exp_time,
                                           name,
                                           res,
                                           res_count);
  GNUNET_assert (NULL != block);
  GNUNET_CRYPTO_ecdsa_key_get_public (zone_key,
                                      &pkey);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Caching block for label `%s' with %u records and expiration %s in zone `%s' in namecache\n",
              name,
              res_count,
              GNUNET_STRINGS_absolute_time_to_string (exp_time),
              GNUNET_GNSRECORD_z2s (&pkey));
  GNUNET_STATISTICS_update (statistics,
                            "Namecache updates pushed",
                            1,
                            GNUNET_NO);
  cop = GNUNET_new (struct CacheOperation);
  cop->nc = nc;
  cop->zi = zi;
  if (NULL != zi)
    zi->cache_ops++;
  cop->rid = rid;
  GNUNET_CONTAINER_DLL_insert (cop_head,
                               cop_tail,
                               cop);
  cop->qe = GNUNET_NAMECACHE_block_cache (namecache,
                                          block,
                                          &finish_cache_operation,
                                          cop);
  GNUNET_free (block);
}

Here is the call graph for this function:

Here is the caller graph for this function:

warn_monitor_slow()

static void warn_monitor_slow ( void *  cls )

static

Print a warning that one of our monitors is no longer reacting.

Parameters

cls	a struct ZoneMonitor to warn about

Definition at line 1052 of file gnunet-service-namestore.c.

References GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_absolute_time_to_string(), MONITOR_STALL_WARN_DELAY, ZoneMonitor::sa_wait_warning, ZoneMonitor::sa_waiting_start, and zm.

Referenced by continue_store_activity(), handle_monitor_next(), and monitor_unblock().

{
  struct ZoneMonitor *zm = cls;

  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "No response from monitor since %s\n",
              GNUNET_STRINGS_absolute_time_to_string (zm->sa_waiting_start));
  zm->sa_wait_warning = GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY,
                                                      &warn_monitor_slow,
                                                      zm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

continue_store_activity()

static void continue_store_activity ( struct StoreActivity *  sa )

static

Continue processing the sa.

Parameters

sa	store activity to process

Definition at line 1071 of file gnunet-service-namestore.c.

References NamestoreClient::client, StoreActivity::conv_name, free_store_activity(), RecordStoreMessage::gns_header, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_records_deserialize(), GNUNET_log, GNUNET_memcmp, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_SERVICE_client_continue(), GNUNET_TIME_absolute_get(), GNUNET_YES, MONITOR_STALL_WARN_DELAY, RecordStoreMessage::name_len, StoreActivity::nc, RecordStoreMessage::private_key, GNUNET_NAMESTORE_Header::r_id, RecordStoreMessage::rd_count, RecordStoreMessage::rd_len, refresh_block(), StoreActivity::rsm, send_lookup_response(), warn_monitor_slow(), zero, zm, StoreActivity::zm_pos, and GNUNET_NAMESTORE_ZoneMonitor::zone.

Referenced by client_disconnect_cb(), handle_record_store(), and monitor_unblock().

{
  const struct RecordStoreMessage *rp_msg = sa->rsm;
  unsigned int rd_count;
  size_t name_len;
  size_t rd_ser_len;
  uint32_t rid;
  const char *name_tmp;
  const char *rd_ser;

  rid = ntohl (rp_msg->gns_header.r_id);
  name_len = ntohs (rp_msg->name_len);
  rd_count = ntohs (rp_msg->rd_count);
  rd_ser_len = ntohs (rp_msg->rd_len);
  name_tmp = (const char *) &rp_msg[1];
  rd_ser = &name_tmp[name_len];
  {
    struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL(rd_count)];

    /* We did this before, must succeed again */
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_GNSRECORD_records_deserialize (rd_ser_len,
                                                         rd_ser,
                                                         rd_count,
                                                         rd));

    for (struct ZoneMonitor *zm = sa->zm_pos;
         NULL != zm;
         zm = sa->zm_pos)
    {
      if ( (0 != GNUNET_memcmp (&rp_msg->private_key,
                         &zm->zone)) &&
           (0 != GNUNET_memcmp (&zm->zone,
                         &zero)) )
        {
          sa->zm_pos = zm->next; /* not interesting to this monitor */
          continue;
        }
      if (zm->limit == zm->iteration_cnt)
      {
        zm->sa_waiting = GNUNET_YES;
        zm->sa_waiting_start = GNUNET_TIME_absolute_get ();
        if (NULL != zm->sa_wait_warning)
          GNUNET_SCHEDULER_cancel (zm->sa_wait_warning);
        zm->sa_wait_warning = GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY,
                                                            &warn_monitor_slow,
                                                            zm);
        return; /* blocked on zone monitor */
      }
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Notifying monitor about changes under label `%s'\n",
                  sa->conv_name);
      zm->limit--;
      send_lookup_response (zm->nc,
                            0,
                            &rp_msg->private_key,
                            sa->conv_name,
                            rd_count,
                            rd);
      sa->zm_pos = zm->next;
    }
    /* great, done with the monitors, unpack (again) for refresh_block operation */
    refresh_block (sa->nc,
                   NULL,
                   rid,
                   &rp_msg->private_key,
                   sa->conv_name,
                   rd_count,
                   rd);
  }
  GNUNET_SERVICE_client_continue (sa->nc->client);
  free_store_activity (sa);
}

Here is the call graph for this function:

Here is the caller graph for this function:

client_disconnect_cb()

static void client_disconnect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, void *  app_ctx  )

static

Called whenever a client is disconnected.

Frees our resources associated with that client.

Parameters

cls	closure
client	identification of the client
app_ctx	the struct NamestoreClient of client

Definition at line 1155 of file gnunet-service-namestore.c.

References continue_store_activity(), free_store_activity(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_cancel(), ZoneIteration::nc, CacheOperation::nc, CacheOperation::next, StoreActivity::next, NamestoreClient::op_head, NamestoreClient::op_tail, zm, and StoreActivity::zm_pos.

Referenced by run().

{
  struct NamestoreClient *nc = app_ctx;
  struct ZoneIteration *no;
  struct CacheOperation *cop;

  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client %p disconnected\n",
              client);
  for (struct ZoneMonitor *zm = monitor_head; NULL != zm; zm = zm->next)
  {
    struct StoreActivity *san;

    if (nc != zm->nc)
      continue;
    GNUNET_CONTAINER_DLL_remove (monitor_head,
                                 monitor_tail,
                                 zm);
    if (NULL != zm->task)
    {
      GNUNET_SCHEDULER_cancel (zm->task);
      zm->task = NULL;
    }
    if (NULL != zm->sa_wait_warning)
    {
      GNUNET_SCHEDULER_cancel (zm->sa_wait_warning);
      zm->sa_wait_warning = NULL;
    }
    for (struct StoreActivity *sa = sa_head; NULL != sa; sa = san)
    {
      san = sa->next;
      if (zm == sa->zm_pos)
      {
        sa->zm_pos = zm->next;
        /* this may free sa */
        continue_store_activity (sa);
      }
    }
    GNUNET_free (zm);
    break;
  }
  for (struct StoreActivity *sa = sa_head; NULL != sa; sa = sa->next)
  {
    if (sa->nc == nc)
    {
      /* this may free sa */
      free_store_activity (sa);
      break; /* there can only be one per nc */
    }
  }
  while (NULL != (no = nc->op_head))
  {
    GNUNET_CONTAINER_DLL_remove (nc->op_head,
                                 nc->op_tail,
                                 no);
    GNUNET_free (no);
  }
  for (cop = cop_head; NULL != cop; cop = cop->next)
    if (nc == cop->nc)
      cop->nc = NULL;
  GNUNET_free (nc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

client_connect_cb()

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

static

Add a client to our list of active clients.

Parameters

cls	NULL
client	client to add
mq	message queue for client

Returns

internal namestore client structure for this client

Definition at line 1231 of file gnunet-service-namestore.c.

References NamestoreClient::client, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, mq, NamestoreClient::mq, and ZoneIteration::nc.

Referenced by run().

{
  struct NamestoreClient *nc;

  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client %p connected\n",
              client);
  nc = GNUNET_new (struct NamestoreClient);
  nc->client = client;
  nc->mq = mq;
  return nc;
}

Here is the caller graph for this function:

lookup_it()

static void lookup_it ( void *  cls, uint64_t  seq, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  private_key, const char *  label, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Function called by the namestore plugin when we are trying to lookup a record as part of handle_record_lookup().

Merges all results into the context.

Parameters

cls	closure with a struct RecordLookupContext
seq	unique serial number of the record, MUST NOT BE ZERO
zone_key	private key of the zone
label	name that is being mapped (at most 255 characters long)
rd_count	number of entries in rd array
rd	array of records with data to store

Definition at line 1299 of file gnunet-service-namestore.c.

References GNUNET_GNSRECORD_Data::flags, RecordLookupContext::found, GNUNET_assert, GNUNET_break, GNUNET_free, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_malloc, GNUNET_NO, GNUNET_YES, RecordLookupContext::label, merge_with_nick_records(), RecordLookupContext::nick, RecordLookupContext::rd_ser_len, RecordLookupContext::res_rd, and RecordLookupContext::res_rd_count.

Referenced by handle_record_lookup().

{
  struct RecordLookupContext *rlc = cls;

  (void) private_key;
  GNUNET_assert (0 != seq);
  if (0 != strcmp (label,
                   rlc->label))
    return;
  rlc->found = GNUNET_YES;
  if (0 == rd_count)
  {
    rlc->rd_ser_len = 0;
    rlc->res_rd_count = 0;
    rlc->res_rd = NULL;
    return;
  }
  if ( (NULL != rlc->nick) &&
       (0 != strcmp (label,
                     GNUNET_GNS_EMPTY_LABEL_AT)) )
  {
    /* Merge */
    struct GNUNET_GNSRECORD_Data *rd_res;
    unsigned int rdc_res;

    rd_res = NULL;
    rdc_res = 0;
    rlc->nick->flags = (rlc->nick->flags | GNUNET_GNSRECORD_RF_PRIVATE) ^ GNUNET_GNSRECORD_RF_PRIVATE;
    merge_with_nick_records (rlc->nick,
                             rd_count,
                             rd,
                             &rdc_res,
                             &rd_res);
    rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rdc_res,
                                                         rd_res);
    if (rlc->rd_ser_len < 0)
    {
      GNUNET_break (0);
      GNUNET_free  (rd_res);
      rlc->found = GNUNET_NO;
      rlc->rd_ser_len = 0;
      return;
    }
    rlc->res_rd_count = rdc_res;
    rlc->res_rd = GNUNET_malloc (rlc->rd_ser_len);
    if (rlc->rd_ser_len !=
        GNUNET_GNSRECORD_records_serialize (rdc_res,
                                            rd_res,
                                            rlc->rd_ser_len,
                                            rlc->res_rd))
    {
      GNUNET_break (0);
      GNUNET_free  (rlc->res_rd);
      rlc->res_rd = NULL;
      rlc->res_rd_count = 0;
      rlc->rd_ser_len = 0;
      GNUNET_free  (rd_res);
      rlc->found = GNUNET_NO;
      return;
    }
    GNUNET_free (rd_res);
    GNUNET_free (rlc->nick);
    rlc->nick = NULL;
  }
  else
  {
    rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count,
                                                         rd);
    if (rlc->rd_ser_len < 0)
    {
      GNUNET_break (0);
      rlc->found = GNUNET_NO;
      rlc->rd_ser_len = 0;
      return;
    }
    rlc->res_rd_count = rd_count;
    rlc->res_rd = GNUNET_malloc (rlc->rd_ser_len);
    if (rlc->rd_ser_len !=
        GNUNET_GNSRECORD_records_serialize (rd_count,
                                            rd,
                                            rlc->rd_ser_len,
                                            rlc->res_rd))
    {
      GNUNET_break (0);
      GNUNET_free  (rlc->res_rd);
      rlc->res_rd = NULL;
      rlc->res_rd_count = 0;
      rlc->rd_ser_len = 0;
      rlc->found = GNUNET_NO;
      return;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_record_lookup()

static int check_record_lookup ( void *  cls, const struct LabelLookupMessage *  ll_msg  )

static

Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP message.

Parameters

cls	client sending the message
ll_msg	message of type struct LabelLookupMessage

Returns

GNUNET_OK if ll_msg is well-formed

Definition at line 1407 of file gnunet-service-namestore.c.

References LabelLookupMessage::gns_header, GNUNET_break, GNUNET_MQ_check_zero_termination, GNUNET_OK, GNUNET_SYSERR, GNUNET_NAMESTORE_Header::header, LabelLookupMessage::label_len, and GNUNET_MessageHeader::size.

{
  uint32_t name_len;
  size_t src_size;

  (void) cls;
  name_len = ntohl (ll_msg->label_len);
  src_size = ntohs (ll_msg->gns_header.header.size);
  if (name_len != src_size - sizeof (struct LabelLookupMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  GNUNET_MQ_check_zero_termination (ll_msg);
  return GNUNET_OK;
}

handle_record_lookup()

static void handle_record_lookup ( void *  cls, const struct LabelLookupMessage *  ll_msg  )

static

Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP message.

Parameters

cls	client sending the message
ll_msg	message of type struct LabelLookupMessage

Definition at line 1433 of file gnunet-service-namestore.c.

References NamestoreClient::client, GNUNET_NAMESTORE_PluginFunctions::cls, env, LabelLookupResponseMessage::found, RecordLookupContext::found, get_nick_record(), LabelLookupMessage::gns_header, LabelLookupResponseMessage::gns_header, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_free_non_null, GNUNET_GNSRECORD_string_to_lowercase(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_YES, RecordLookupContext::label, LabelLookupMessage::label_len, lookup_it(), GNUNET_NAMESTORE_PluginFunctions::lookup_records, NamestoreClient::mq, LabelLookupResponseMessage::name_len, ZoneIteration::nc, RecordLookupContext::nick, LabelLookupResponseMessage::private_key, GNUNET_NAMESTORE_Header::r_id, LabelLookupResponseMessage::rd_count, LabelLookupResponseMessage::rd_len, RecordLookupContext::rd_ser_len, res, RecordLookupContext::res_rd, RecordLookupContext::res_rd_count, and LabelLookupMessage::zone.

{
  struct NamestoreClient *nc = cls;
  struct GNUNET_MQ_Envelope *env;
  struct LabelLookupResponseMessage *llr_msg;
  struct RecordLookupContext rlc;
  const char *name_tmp;
  char *res_name;
  char *conv_name;
  uint32_t name_len;
  int res;

  name_len = ntohl (ll_msg->label_len);
  name_tmp = (const char *) &ll_msg[1];
  GNUNET_SERVICE_client_continue (nc->client);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received NAMESTORE_RECORD_LOOKUP message for name `%s'\n",
              name_tmp);

  conv_name = GNUNET_GNSRECORD_string_to_lowercase (name_tmp);
  if (NULL == conv_name)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Error converting name `%s'\n",
                name_tmp);
    GNUNET_SERVICE_client_drop (nc->client);
    return;
  }
  rlc.label = conv_name;
  rlc.found = GNUNET_NO;
  rlc.res_rd_count = 0;
  rlc.res_rd = NULL;
  rlc.rd_ser_len = 0;
  rlc.nick = get_nick_record (&ll_msg->zone);
  res = GSN_database->lookup_records (GSN_database->cls,
                                      &ll_msg->zone,
                                      conv_name,
                                      &lookup_it,
                                      &rlc);
  GNUNET_free (conv_name);
  env = GNUNET_MQ_msg_extra (llr_msg,
                             name_len + rlc.rd_ser_len,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE);
  llr_msg->gns_header.r_id = ll_msg->gns_header.r_id;
  llr_msg->private_key = ll_msg->zone;
  llr_msg->name_len = htons (name_len);
  llr_msg->rd_count = htons (rlc.res_rd_count);
  llr_msg->rd_len = htons (rlc.rd_ser_len);
  res_name = (char *) &llr_msg[1];
  if  ((GNUNET_YES == rlc.found) && (GNUNET_OK == res))
    llr_msg->found = ntohs (GNUNET_YES);
  else
    llr_msg->found = ntohs (GNUNET_NO);
  GNUNET_memcpy (&llr_msg[1],
                 name_tmp,
                 name_len);
  GNUNET_memcpy (&res_name[name_len],
                 rlc.res_rd,
                 rlc.rd_ser_len);
  GNUNET_MQ_send (nc->mq,
                  env);
  GNUNET_free_non_null (rlc.res_rd);
}

Here is the call graph for this function:

check_record_store()

static int check_record_store ( void *  cls, const struct RecordStoreMessage *  rp_msg  )

static

Checks a GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE message.

Parameters

cls	client sending the message
rp_msg	message of type struct RecordStoreMessage

Returns

GNUNET_OK if rp_msg is well-formed

Definition at line 1507 of file gnunet-service-namestore.c.

References RecordStoreMessage::gns_header, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, GNUNET_NAMESTORE_Header::header, MAX_NAME_LEN, RecordStoreMessage::name_len, RecordStoreMessage::rd_len, RecordLookupContext::rd_ser_len, and GNUNET_MessageHeader::size.

{
  size_t name_len;
  size_t msg_size;
  size_t msg_size_exp;
  size_t rd_ser_len;
  const char *name_tmp;

  (void) cls;
  name_len = ntohs (rp_msg->name_len);
  msg_size = ntohs (rp_msg->gns_header.header.size);
  rd_ser_len = ntohs (rp_msg->rd_len);
  msg_size_exp = sizeof (struct RecordStoreMessage) + name_len + rd_ser_len;
  if (msg_size != msg_size_exp)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if ( (0 == name_len) ||
       (name_len > MAX_NAME_LEN) )
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  name_tmp = (const char *) &rp_msg[1];
  if ('\0' != name_tmp[name_len -1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

handle_record_store()

static void handle_record_store ( void *  cls, const struct RecordStoreMessage *  rp_msg  )

static

Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE message.

Parameters

cls	client sending the message
rp_msg	message of type struct RecordStoreMessage

Definition at line 1549 of file gnunet-service-namestore.c.

References cache_nick(), NamestoreClient::client, GNUNET_NAMESTORE_PluginFunctions::cls, continue_store_activity(), StoreActivity::conv_name, RecordStoreMessage::gns_header, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_records_deserialize(), GNUNET_GNSRECORD_string_to_lowercase(), GNUNET_GNSRECORD_TYPE_NICK, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), GNUNET_YES, GNUNET_NAMESTORE_Header::header, GNUNET_NAMESTORE_PluginFunctions::lookup_records, monitor_head, RecordStoreMessage::name_len, ZoneIteration::nc, StoreActivity::nc, RecordStoreMessage::private_key, GNUNET_NAMESTORE_Header::r_id, RecordStoreMessage::rd_count, RecordStoreMessage::rd_len, GNUNET_GNSRECORD_Data::record_type, res, RecordStoreMessage::reserved, StoreActivity::rsm, send_store_response(), GNUNET_MessageHeader::size, GNUNET_NAMESTORE_PluginFunctions::store_records, and StoreActivity::zm_pos.

{
  struct NamestoreClient *nc = cls;
  size_t name_len;
  size_t rd_ser_len;
  uint32_t rid;
  const char *name_tmp;
  char *conv_name;
  const char *rd_ser;
  unsigned int rd_count;
  int res;
  struct StoreActivity *sa;

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received NAMESTORE_RECORD_STORE message\n");
  rid = ntohl (rp_msg->gns_header.r_id);
  name_len = ntohs (rp_msg->name_len);
  rd_count = ntohs (rp_msg->rd_count);
  rd_ser_len = ntohs (rp_msg->rd_len);
  GNUNET_break (0 == ntohs (rp_msg->reserved));
  name_tmp = (const char *) &rp_msg[1];
  rd_ser = &name_tmp[name_len];
  {
    struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL(rd_count)];

    if (GNUNET_OK !=
        GNUNET_GNSRECORD_records_deserialize (rd_ser_len,
                                              rd_ser,
                                              rd_count,
                                              rd))
    {
      GNUNET_break (0);
      GNUNET_SERVICE_client_drop (nc->client);
      return;
    }

    /* Extracting and converting private key */
    conv_name = GNUNET_GNSRECORD_string_to_lowercase (name_tmp);
    if (NULL == conv_name)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Error converting name `%s'\n",
                  name_tmp);
      GNUNET_SERVICE_client_drop (nc->client);
      return;
    }
    GNUNET_STATISTICS_update (statistics,
                              "Well-formed store requests received",
                              1,
                              GNUNET_NO);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Creating %u records for name `%s'\n",
                (unsigned int) rd_count,
                conv_name);
    if ( (0 == rd_count) &&
         (GNUNET_NO ==
          GSN_database->lookup_records (GSN_database->cls,
                                        &rp_msg->private_key,
                                        conv_name,
                                        NULL,
                                        0)) )
    {
      /* This name does not exist, so cannot be removed */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Name `%s' does not exist, no deletion required\n",
                  conv_name);
      res = GNUNET_NO;
    }
    else
    {
      /* remove "NICK" records, unless this is for the
         #GNUNET_GNS_EMPTY_LABEL_AT label */
      struct GNUNET_GNSRECORD_Data rd_clean[GNUNET_NZL(rd_count)];
      unsigned int rd_clean_off;
      int have_nick;

      rd_clean_off = 0;
      have_nick = GNUNET_NO;
      for (unsigned int i=0;i<rd_count;i++)
      {
        rd_clean[rd_clean_off] = rd[i];
        if ( (0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT,
                           conv_name)) ||
             (GNUNET_GNSRECORD_TYPE_NICK != rd[i].record_type) )
          rd_clean_off++;

        if ( (0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT,
                           conv_name)) &&
             (GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) )
        {
          cache_nick (&rp_msg->private_key,
                      &rd[i]);
          have_nick = GNUNET_YES;
        }
      }
      if ( (0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT,
                         conv_name)) &&
           (GNUNET_NO == have_nick) )
      {
        /* remove nick record from cache, in case we have one there */
        cache_nick (&rp_msg->private_key,
                    NULL);
      }
      res = GSN_database->store_records (GSN_database->cls,
                                         &rp_msg->private_key,
                                         conv_name,
                                         rd_clean_off,
                                         rd_clean);
    }

    if (GNUNET_OK != res)
    {
      /* store not successful, not need to tell monitors */
      send_store_response (nc,
                           res,
                           rid);
      GNUNET_SERVICE_client_continue (nc->client);
      GNUNET_free (conv_name);
      return;
    }

    sa = GNUNET_malloc (sizeof (struct StoreActivity) +
                        ntohs (rp_msg->gns_header.header.size));
    GNUNET_CONTAINER_DLL_insert (sa_head,
                                 sa_tail,
                                 sa);
    sa->nc = nc;
    sa->rsm = (const struct RecordStoreMessage *) &sa[1];
    GNUNET_memcpy (&sa[1],
                   rp_msg,
                   ntohs (rp_msg->gns_header.header.size));
    sa->zm_pos = monitor_head;
    sa->conv_name = conv_name;
    continue_store_activity (sa);
  }
}

Here is the call graph for this function:

handle_zone_to_name_it()

static void handle_zone_to_name_it ( void *  cls, uint64_t  seq, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  zone_key, const char *  name, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Zone to name iterator.

Parameters

cls	struct ZoneToNameCtx *
seq	sequence number of the record, MUST NOT BE ZERO
zone_key	the zone key
name	name
rd_count	number of records in rd
rd	record data

Definition at line 1724 of file gnunet-service-namestore.c.

References env, ZoneToNameResponseMessage::gns_header, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_NAMESTORE_Header::header, NamestoreClient::mq, name, ZoneToNameResponseMessage::name_len, ZoneToNameCtx::nc, GNUNET_NAMESTORE_Header::r_id, ZoneToNameResponseMessage::rd_count, ZoneToNameResponseMessage::rd_len, res, ZoneToNameResponseMessage::res, ZoneToNameCtx::rid, GNUNET_MessageHeader::size, ZoneToNameCtx::success, and ZoneToNameResponseMessage::zone.

Referenced by handle_zone_to_name().

{
  struct ZoneToNameCtx *ztn_ctx = cls;
  struct GNUNET_MQ_Envelope *env;
  struct ZoneToNameResponseMessage *ztnr_msg;
  int16_t res;
  size_t name_len;
  ssize_t rd_ser_len;
  size_t msg_size;
  char *name_tmp;
  char *rd_tmp;

  GNUNET_assert (0 != seq);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Found result for zone-to-name lookup: `%s'\n",
              name);
  res = GNUNET_YES;
  name_len = (NULL == name) ? 0 : strlen (name) + 1;
  rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count,
                                                  rd);
  if (rd_ser_len < 0)
  {
    GNUNET_break (0);
    ztn_ctx->success = GNUNET_SYSERR;
    return;
  }
  msg_size = sizeof (struct ZoneToNameResponseMessage) + name_len + rd_ser_len;
  if (msg_size >= GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    ztn_ctx->success = GNUNET_SYSERR;
    return;
  }
  env = GNUNET_MQ_msg_extra (ztnr_msg,
                             name_len + rd_ser_len,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE);
  ztnr_msg->gns_header.header.size = htons (msg_size);
  ztnr_msg->gns_header.r_id = htonl (ztn_ctx->rid);
  ztnr_msg->res = htons (res);
  ztnr_msg->rd_len = htons (rd_ser_len);
  ztnr_msg->rd_count = htons (rd_count);
  ztnr_msg->name_len = htons (name_len);
  ztnr_msg->zone = *zone_key;
  name_tmp = (char *) &ztnr_msg[1];
  GNUNET_memcpy (name_tmp,
                 name,
                 name_len);
  rd_tmp = &name_tmp[name_len];
  GNUNET_assert (rd_ser_len ==
                 GNUNET_GNSRECORD_records_serialize (rd_count,
                                                     rd,
                                                     rd_ser_len,
                                                     rd_tmp));
  ztn_ctx->success = GNUNET_OK;
  GNUNET_MQ_send (ztn_ctx->nc->mq,
                  env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

handle_zone_to_name()

static void handle_zone_to_name ( void *  cls, const struct ZoneToNameMessage *  ztn_msg  )

static

Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME message.

Parameters

cls	client client sending the message
ztn_msg	message of type 'struct ZoneToNameMessage'

Definition at line 1795 of file gnunet-service-namestore.c.

References NamestoreClient::client, GNUNET_NAMESTORE_PluginFunctions::cls, env, ZoneToNameResponseMessage::gns_header, ZoneToNameMessage::gns_header, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, handle_zone_to_name_it(), NamestoreClient::mq, ZoneIteration::nc, ZoneToNameCtx::nc, GNUNET_NAMESTORE_Header::r_id, ZoneToNameResponseMessage::res, ZoneToNameCtx::rid, ZoneToNameCtx::success, ZoneToNameMessage::value_zone, ZoneToNameMessage::zone, and GNUNET_NAMESTORE_PluginFunctions::zone_to_name.

{
  struct NamestoreClient *nc = cls;
  struct ZoneToNameCtx ztn_ctx;
  struct GNUNET_MQ_Envelope *env;
  struct ZoneToNameResponseMessage *ztnr_msg;

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received ZONE_TO_NAME message\n");
  ztn_ctx.rid = ntohl (ztn_msg->gns_header.r_id);
  ztn_ctx.nc = nc;
  ztn_ctx.success = GNUNET_NO;
  if (GNUNET_SYSERR ==
      GSN_database->zone_to_name (GSN_database->cls,
                                  &ztn_msg->zone,
                                  &ztn_msg->value_zone,
                                  &handle_zone_to_name_it, &ztn_ctx))
  {
    /* internal error, hang up instead of signalling something
       that might be wrong */
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (nc->client);
    return;
  }
  if (GNUNET_NO == ztn_ctx.success)
  {
    /* no result found, send empty response */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Found no result for zone-to-name lookup.\n");
    env = GNUNET_MQ_msg (ztnr_msg,
                         GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE);
    ztnr_msg->gns_header.r_id = ztn_msg->gns_header.r_id;
    ztnr_msg->res = htons (GNUNET_NO);
    GNUNET_MQ_send (nc->mq,
                    env);
  }
  GNUNET_SERVICE_client_continue (nc->client);
}

Here is the call graph for this function:

zone_iterate_proc()

static void zone_iterate_proc ( void *  cls, uint64_t  seq, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  zone_key, const char *  name, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Process results for zone iteration from database.

Parameters

cls	struct ZoneIterationProcResult
seq	sequence number of the record, MUST NOT BE ZERO
zone_key	the zone key
name	name
rd_count	number of records for this name
rd	record data

Definition at line 1866 of file gnunet-service-namestore.c.

References GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_log, GNUNET_NO, GNUNET_YES, ZoneIterationProcResult::limit, ZoneIteration::nc, refresh_block(), ZoneIteration::request_id, send_lookup_response(), ZoneIteration::seq, and ZoneIterationProcResult::zi.

Referenced by run_zone_iteration_round().

{
  struct ZoneIterationProcResult *proc = cls;
  int do_refresh_block;

  GNUNET_assert (0 != seq);
  if ( (NULL == zone_key) &&
       (NULL == name) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Iteration done\n");
    return;
  }
  if ( (NULL == zone_key) ||
       (NULL == name) )
  {
    /* what is this!? should never happen */
    GNUNET_break (0);
    return;
  }
  if (0 == proc->limit)
  {
    /* what is this!? should never happen */
    GNUNET_break (0);
    return;
  }
  proc->limit--;
  proc->zi->seq = seq;
  send_lookup_response (proc->zi->nc,
                        proc->zi->request_id,
                        zone_key,
                        name,
                        rd_count,
                        rd);


  do_refresh_block = GNUNET_NO;
  for (unsigned int i=0;i<rd_count;i++)
    if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
    {
      do_refresh_block = GNUNET_YES;
      break;
    }
  if (GNUNET_YES == do_refresh_block)
    refresh_block (NULL,
                   proc->zi,
                   0,
                   zone_key,
                   name,
                   rd_count,
                   rd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

run_zone_iteration_round()

static void run_zone_iteration_round ( struct ZoneIteration *  zi, uint64_t  limit  )

static

Perform the next round of the zone iteration.

Parameters

zi	zone iterator to process
limit	number of results to return in one pass

Definition at line 1932 of file gnunet-service-namestore.c.

References ZoneIteration::cache_ops, GNUNET_NAMESTORE_PluginFunctions::cls, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_is_zero, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_divide(), GNUNET_NAMESTORE_PluginFunctions::iterate_records, ZoneIterationProcResult::limit, ZoneIteration::send_end, ZoneIteration::seq, ZoneIterationProcResult::zi, ZoneIteration::zone, zone_iterate_proc(), and zone_iteration_done_client_continue().

Referenced by handle_iteration_next(), and handle_iteration_start().

{
  struct ZoneIterationProcResult proc;
  struct GNUNET_TIME_Absolute start;
  struct GNUNET_TIME_Relative duration;

  memset (&proc,
          0,
          sizeof (proc));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Asked to return up to %llu records at position %llu\n",
              (unsigned long long) limit,
              (unsigned long long) zi->seq);
  proc.zi = zi;
  proc.limit = limit;
  start = GNUNET_TIME_absolute_get ();
  GNUNET_break (GNUNET_SYSERR !=
                GSN_database->iterate_records (GSN_database->cls,
                                               (0 == GNUNET_is_zero (&zi->zone))
                                               ? NULL
                                               : &zi->zone,
                                               zi->seq,
                                               limit,
                                               &zone_iterate_proc,
                                               &proc));
  duration = GNUNET_TIME_absolute_get_duration (start);
  duration = GNUNET_TIME_relative_divide (duration,
                                          limit - proc.limit);
  GNUNET_STATISTICS_set (statistics,
                         "NAMESTORE iteration delay (μs/record)",
                         duration.rel_value_us,
                         GNUNET_NO);
  if (0 == proc.limit)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Returned %llu results, more results available\n",
                (unsigned long long) limit);
  zi->send_end = (0 != proc.limit);
  if (0 == zi->cache_ops)
    zone_iteration_done_client_continue (zi);
}

Here is the call graph for this function:

Here is the caller graph for this function:

handle_iteration_start()

static void handle_iteration_start ( void *  cls, const struct ZoneIterationStartMessage *  zis_msg  )

static

Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START message.

Parameters

cls	the client sending the message
zis_msg	message from the client

Definition at line 1982 of file gnunet-service-namestore.c.

References ZoneIterationStartMessage::gns_header, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, ZoneIteration::nc, ZoneIteration::offset, NamestoreClient::op_head, NamestoreClient::op_tail, GNUNET_NAMESTORE_Header::r_id, ZoneIteration::request_id, run_zone_iteration_round(), ZoneIteration::zone, and ZoneIterationStartMessage::zone.

{
  struct NamestoreClient *nc = cls;
  struct ZoneIteration *zi;

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received ZONE_ITERATION_START message\n");
  zi = GNUNET_new (struct ZoneIteration);
  zi->request_id = ntohl (zis_msg->gns_header.r_id);
  zi->offset = 0;
  zi->nc = nc;
  zi->zone = zis_msg->zone;

  GNUNET_CONTAINER_DLL_insert (nc->op_head,
                               nc->op_tail,
                               zi);
  run_zone_iteration_round (zi,
                            1);
}

Here is the call graph for this function:

handle_iteration_stop()

static void handle_iteration_stop ( void *  cls, const struct ZoneIterationStopMessage *  zis_msg  )

static

Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP message.

Parameters

cls	the client sending the message
zis_msg	message from the client

Definition at line 2011 of file gnunet-service-namestore.c.

References NamestoreClient::client, ZoneIterationStopMessage::gns_header, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), ZoneIteration::nc, ZoneIteration::next, NamestoreClient::op_head, NamestoreClient::op_tail, GNUNET_NAMESTORE_Header::r_id, and ZoneIteration::request_id.

{
  struct NamestoreClient *nc = cls;
  struct ZoneIteration *zi;
  uint32_t rid;

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received ZONE_ITERATION_STOP message\n");
  rid = ntohl (zis_msg->gns_header.r_id);
  for (zi = nc->op_head; NULL != zi; zi = zi->next)
    if (zi->request_id == rid)
      break;
  if (NULL == zi)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (nc->client);
    return;
  }
  GNUNET_CONTAINER_DLL_remove (nc->op_head,
                               nc->op_tail,
                               zi);
  GNUNET_free (zi);
  GNUNET_SERVICE_client_continue (nc->client);
}

Here is the call graph for this function:

handle_iteration_next()

static void handle_iteration_next ( void *  cls, const struct ZoneIterationNextMessage *  zis_msg  )

static

Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT message.

Parameters

cls	the client sending the message
message	message from the client

Definition at line 2045 of file gnunet-service-namestore.c.

References NamestoreClient::client, ZoneIterationNextMessage::gns_header, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_ntohll(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), ZoneIterationNextMessage::limit, ZoneIteration::nc, ZoneIteration::next, NamestoreClient::op_head, GNUNET_NAMESTORE_Header::r_id, ZoneIteration::request_id, and run_zone_iteration_round().

{
  struct NamestoreClient *nc = cls;
  struct ZoneIteration *zi;
  uint32_t rid;
  uint64_t limit;

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received ZONE_ITERATION_NEXT message\n");
  GNUNET_STATISTICS_update (statistics,
                            "Iteration NEXT messages received",
                            1,
                            GNUNET_NO);
  rid = ntohl (zis_msg->gns_header.r_id);
  limit = GNUNET_ntohll (zis_msg->limit);
  for (zi = nc->op_head; NULL != zi; zi = zi->next)
    if (zi->request_id == rid)
      break;
  if (NULL == zi)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (nc->client);
    return;
  }
  run_zone_iteration_round (zi,
                            limit);
}

Here is the call graph for this function:

monitor_unblock()

static void monitor_unblock ( struct ZoneMonitor *  zm )

static

Function called when the monitor is ready for more data, and we should thus unblock PUT operations that were blocked on the monitor not being ready.

Definition at line 2081 of file gnunet-service-namestore.c.

References continue_store_activity(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get(), GNUNET_YES, ZoneMonitor::iteration_cnt, ZoneMonitor::limit, MONITOR_STALL_WARN_DELAY, StoreActivity::next, sa_head, ZoneMonitor::sa_wait_warning, ZoneMonitor::sa_waiting, ZoneMonitor::sa_waiting_start, warn_monitor_slow(), and StoreActivity::zm_pos.

Referenced by handle_monitor_next(), and monitor_sync().

{
  struct StoreActivity *sa = sa_head;

  while ( (NULL != sa) &&
          (zm->limit > zm->iteration_cnt) )
  {
    struct StoreActivity *sn = sa->next;

    if (sa->zm_pos == zm)
      continue_store_activity (sa);
    sa = sn;
  }
  if (zm->limit > zm->iteration_cnt)
  {
    zm->sa_waiting = GNUNET_NO;
    if (NULL != zm->sa_wait_warning)
    {
      GNUNET_SCHEDULER_cancel (zm->sa_wait_warning);
      zm->sa_wait_warning = NULL;
    }
  }
  else if (GNUNET_YES == zm->sa_waiting)
  {
    zm->sa_waiting_start = GNUNET_TIME_absolute_get ();
    if (NULL != zm->sa_wait_warning)
      GNUNET_SCHEDULER_cancel (zm->sa_wait_warning);
    zm->sa_wait_warning = GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY,
                                                        &warn_monitor_slow,
                                                        zm);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

monitor_sync()

static void monitor_sync ( struct ZoneMonitor *  zm )

static

Send 'sync' message to zone monitor, we're now in sync.

Parameters

zm	monitor that is now in sync

Definition at line 2121 of file gnunet-service-namestore.c.

References env, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, ZoneMonitor::in_first_iteration, ZoneMonitor::iteration_cnt, ZoneMonitor::limit, monitor_iteration_next(), monitor_unblock(), NamestoreClient::mq, ZoneMonitor::nc, and ZoneMonitor::sa_waiting.

Referenced by handle_monitor_start(), and monitor_iteration_next().

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *sync;

  env = GNUNET_MQ_msg (sync,
                       GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC);
  GNUNET_MQ_send (zm->nc->mq,
                  env);
  /* mark iteration done */
  zm->in_first_iteration = GNUNET_NO;
  zm->iteration_cnt = 0;
  if ( (zm->limit > 0) &&
       (zm->sa_waiting) )
    monitor_unblock (zm);
}

Here is the call graph for this function:

Here is the caller graph for this function:

monitor_iteration_next()

static void monitor_iteration_next ( void *  cls )

static

Obtain the next datum during the zone monitor's zone initial iteration.

Parameters

cls	zone monitor that does its initial iteration

Definition at line 2236 of file gnunet-service-namestore.c.

References NamestoreClient::client, GNUNET_NAMESTORE_PluginFunctions::cls, GNUNET_assert, GNUNET_is_zero, GNUNET_NO, GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, GNUNET_NAMESTORE_PluginFunctions::iterate_records, ZoneMonitor::iteration_cnt, ZoneMonitor::limit, monitor_iterate_cb(), monitor_sync(), ZoneMonitor::nc, ret, ZoneMonitor::seq, ZoneMonitor::task, zm, and ZoneMonitor::zone.

Referenced by handle_monitor_next(), handle_monitor_start(), monitor_iterate_cb(), and monitor_sync().

{
  struct ZoneMonitor *zm = cls;
  int ret;

  zm->task = NULL;
  GNUNET_assert (0 == zm->iteration_cnt);
  if (zm->limit > 16)
    zm->iteration_cnt = zm->limit / 2; /* leave half for monitor events */
  else
    zm->iteration_cnt = zm->limit; /* use it all */
  ret = GSN_database->iterate_records (GSN_database->cls,
                                       (0 == GNUNET_is_zero (&zm->zone))
                                       ? NULL
                                       : &zm->zone,
                                       zm->seq,
                                       zm->iteration_cnt,
                                       &monitor_iterate_cb,
                                       zm);
  if (GNUNET_SYSERR == ret)
  {
    GNUNET_SERVICE_client_drop (zm->nc->client);
    return;
  }
  if (GNUNET_NO == ret)
  {
    /* empty zone */
    monitor_sync (zm);
    return;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

monitor_iterate_cb()

static void monitor_iterate_cb ( void *  cls, uint64_t  seq, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  zone_key, const char *  name, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

A GNUNET_NAMESTORE_RecordIterator for monitors.

Parameters

cls	a 'struct ZoneMonitor *' with information about the monitor
seq	sequence number of the record, MUST NOT BE ZERO
zone_key	zone key of the zone
name	name
rd_count	number of records in rd
rd	array of records

Definition at line 2159 of file gnunet-service-namestore.c.

References GNUNET_assert, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_update(), ZoneMonitor::iteration_cnt, ZoneMonitor::limit, monitor_iteration_next(), ZoneMonitor::nc, send_lookup_response(), ZoneIteration::seq, ZoneMonitor::seq, ZoneMonitor::task, and zm.

Referenced by monitor_iteration_next().

{
  struct ZoneMonitor *zm = cls;

  GNUNET_assert (0 != seq);
  zm->seq = seq;
  GNUNET_assert (NULL != name);
  GNUNET_STATISTICS_update (statistics,
                            "Monitor notifications sent",
                            1,
                            GNUNET_NO);
  zm->limit--;
  zm->iteration_cnt--;
  send_lookup_response (zm->nc,
                        0,
                        zone_key,
                        name,
                        rd_count,
                        rd);
  if ( (0 == zm->iteration_cnt) &&
       (0 != zm->limit) )
  {
    /* We are done with the current iteration batch, AND the
       client would right now accept more, so go again! */
    GNUNET_assert (NULL == zm->task);
    zm->task = GNUNET_SCHEDULER_add_now (&monitor_iteration_next,
                                         zm);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

handle_monitor_start()

static void handle_monitor_start ( void *  cls, const struct ZoneMonitorStartMessage *  zis_msg  )

static

Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START message.

Parameters

cls	the client sending the message
zis_msg	message from the client

Definition at line 2202 of file gnunet-service-namestore.c.

References NamestoreClient::client, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_notification_context_add(), GNUNET_SCHEDULER_add_now(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_mark_monitor(), GNUNET_YES, ZoneMonitor::in_first_iteration, ZoneMonitorStartMessage::iterate_first, ZoneMonitor::limit, monitor_iteration_next(), monitor_sync(), NamestoreClient::mq, ZoneIteration::nc, ZoneMonitor::nc, ZoneMonitor::task, zm, ZoneMonitor::zone, and ZoneMonitorStartMessage::zone.

{
  struct NamestoreClient *nc = cls;
  struct ZoneMonitor *zm;

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received ZONE_MONITOR_START message\n");
  zm = GNUNET_new (struct ZoneMonitor);
  zm->nc = nc;
  zm->zone = zis_msg->zone;
  zm->limit = 1;
  zm->in_first_iteration = (GNUNET_YES == ntohl (zis_msg->iterate_first));
  GNUNET_CONTAINER_DLL_insert (monitor_head,
                               monitor_tail,
                               zm);
  GNUNET_SERVICE_client_mark_monitor (nc->client);
  GNUNET_SERVICE_client_continue (nc->client);
  GNUNET_notification_context_add (monitor_nc,
                                   nc->mq);
  if (zm->in_first_iteration)
    zm->task = GNUNET_SCHEDULER_add_now (&monitor_iteration_next,
                                         zm);
  else
    monitor_sync (zm);
}

Here is the call graph for this function:

handle_monitor_next()

static void handle_monitor_next ( void *  cls, const struct ZoneMonitorNextMessage *  nm  )

static

Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT message.

Parameters

cls	the client sending the message
nm	message from the client

Definition at line 2276 of file gnunet-service-namestore.c.

References NamestoreClient::client, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_ntohll(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_TIME_absolute_get(), GNUNET_YES, ZoneMonitor::in_first_iteration, ZoneMonitor::iteration_cnt, ZoneMonitor::limit, ZoneMonitorNextMessage::limit, monitor_iteration_next(), MONITOR_STALL_WARN_DELAY, monitor_unblock(), ZoneIteration::nc, ZoneMonitor::nc, ZoneMonitor::next, ZoneMonitor::sa_wait_warning, ZoneMonitor::sa_waiting, ZoneMonitor::sa_waiting_start, ZoneMonitor::task, warn_monitor_slow(), and zm.

{
  struct NamestoreClient *nc = cls;
  struct ZoneMonitor *zm;
  uint64_t inc;

  inc = GNUNET_ntohll (nm->limit);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received ZONE_MONITOR_NEXT message with limit %llu\n",
              (unsigned long long) inc);
  for (zm = monitor_head; NULL != zm; zm = zm->next)
    if (zm->nc == nc)
      break;
  if (NULL == zm)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (nc->client);
    return;
  }
  GNUNET_SERVICE_client_continue (nc->client);
  if (zm->limit + inc < zm->limit)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (nc->client);
    return;
  }
  zm->limit += inc;
  if ( (zm->in_first_iteration) &&
       (zm->limit == inc) )
  {
    /* We are still iterating, and the previous iteration must
       have stopped due to the client's limit, so continue it! */
    GNUNET_assert (NULL == zm->task);
    zm->task = GNUNET_SCHEDULER_add_now (&monitor_iteration_next,
                                         zm);
  }
  GNUNET_assert (zm->iteration_cnt <= zm->limit);
  if ( (zm->limit > zm->iteration_cnt) &&
       (zm->sa_waiting) )
  {
    monitor_unblock (zm);
  }
  else if (GNUNET_YES == zm->sa_waiting)
  {
    if (NULL != zm->sa_wait_warning)
      GNUNET_SCHEDULER_cancel (zm->sa_wait_warning);
    zm->sa_waiting_start = GNUNET_TIME_absolute_get ();
    zm->sa_wait_warning = GNUNET_SCHEDULER_add_delayed (MONITOR_STALL_WARN_DELAY,
                                                        &warn_monitor_slow,
                                                        zm);
  }
}

Here is the call graph for this function:

run()

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

static

Process namestore requests.

Parameters

cls	closure
cfg	configuration to use
service	the initialized service

Definition at line 2339 of file gnunet-service-namestore.c.

References cache_keys, cfg, cleanup_task(), client_connect_cb(), client_disconnect_cb(), db_lib_name, disable_namecache, GNUNET_asprintf(), GNUNET_assert, GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_NAMECACHE_connect(), GNUNET_notification_context_create(), GNUNET_OK, GNUNET_PLUGIN_load(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SERVICE_MAIN(), GNUNET_SERVICE_OPTION_NONE, GNUNET_STATISTICS_create(), GNUNET_YES, iteration_start(), and zone_to_name().

{
  char *database;

  (void) cls;
  (void) service;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting namestore service\n");
  cache_keys = GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                                     "namestore",
                                                     "CACHE_KEYS");
  disable_namecache = GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                                            "namecache",
                                                            "DISABLE");
  GSN_cfg = cfg;
  monitor_nc = GNUNET_notification_context_create (1);
  if (GNUNET_YES != disable_namecache)
  {
    namecache = GNUNET_NAMECACHE_connect (cfg);
    GNUNET_assert (NULL != namecache);
  }
  /* Loading database plugin */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             "namestore",
                                             "database",
                                             &database))
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "No database backend configured\n");

  GNUNET_asprintf (&db_lib_name,
                   "libgnunet_plugin_namestore_%s",
                   database);
  GSN_database = GNUNET_PLUGIN_load (db_lib_name,
                                     (void *) GSN_cfg);
  GNUNET_free (database);
  statistics = GNUNET_STATISTICS_create ("namestore",
                                         cfg);
  GNUNET_SCHEDULER_add_shutdown (&cleanup_task,
                                 NULL);
  if (NULL == GSN_database)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Could not load database backend `%s'\n",
                db_lib_name);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	"namestore"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_var_size(record_store, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE, struct RecordStoreMessage, NULL)	,
		GNUNET_MQ_hd_var_size(record_lookup, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP, struct LabelLookupMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(zone_to_name, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME, struct ZoneToNameMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(iteration_start, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START, struct ZoneIterationStartMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(iteration_next, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT, struct ZoneIterationNextMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(iteration_stop, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP, struct ZoneIterationStopMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(monitor_start, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START, struct ZoneMonitorStartMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(monitor_next, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT, struct ZoneMonitorNextMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Referenced by run().

Here is the caller graph for this function:

Variable Documentation

nick_cache

struct NickCache nick_cache[16]

static

We cache nick records to reduce DB load.

Definition at line 338 of file gnunet-service-namestore.c.

Referenced by cache_nick(), and get_nick_record().

zero

const struct GNUNET_CRYPTO_EcdsaPrivateKey zero

static

Public key of all zeros.

Definition at line 343 of file gnunet-service-namestore.c.

Referenced by continue_store_activity(), GAS_ril_address_add(), GNUNET_OS_init(), GNUNET_TIME_absolute_get_zero_(), and GNUNET_TIME_relative_get_zero_().

GSN_cfg

const struct GNUNET_CONFIGURATION_Handle* GSN_cfg

static

Configuration handle.

Definition at line 348 of file gnunet-service-namestore.c.

statistics

struct GNUNET_STATISTICS_Handle* statistics

static

Handle to the statistics service.

Definition at line 353 of file gnunet-service-namestore.c.

namecache

struct GNUNET_NAMECACHE_Handle* namecache

static

Namecache handle.

Definition at line 358 of file gnunet-service-namestore.c.

GSN_database

struct GNUNET_NAMESTORE_PluginFunctions* GSN_database

static

Database handle.

Definition at line 363 of file gnunet-service-namestore.c.

db_lib_name

char* db_lib_name

static

Name of the database plugin.

Definition at line 368 of file gnunet-service-namestore.c.

Referenced by cleanup_task(), and run().

cop_head

struct CacheOperation* cop_head

static

Head of cop DLL.

Definition at line 373 of file gnunet-service-namestore.c.

cop_tail

struct CacheOperation* cop_tail

static

Tail of cop DLL.

Definition at line 378 of file gnunet-service-namestore.c.

monitor_head

struct ZoneMonitor* monitor_head

static

First active zone monitor.

Definition at line 383 of file gnunet-service-namestore.c.

Referenced by handle_record_store().

monitor_tail

struct ZoneMonitor* monitor_tail

static

Last active zone monitor.

Definition at line 388 of file gnunet-service-namestore.c.

sa_head

struct StoreActivity* sa_head

static

Head of DLL of monitor-blocked store activities.

Definition at line 393 of file gnunet-service-namestore.c.

Referenced by monitor_unblock().

sa_tail

struct StoreActivity* sa_tail

static

Tail of DLL of monitor-blocked store activities.

Definition at line 398 of file gnunet-service-namestore.c.

monitor_nc

struct GNUNET_NotificationContext* monitor_nc

static

Notification context shared by all monitors.

Definition at line 403 of file gnunet-service-namestore.c.

cache_keys

int cache_keys

static

Optimize block insertion by caching map of private keys to public keys in memory?

Definition at line 409 of file gnunet-service-namestore.c.

Referenced by refresh_block(), and run().

disable_namecache

int disable_namecache

static

Use the namecache? Doing so creates additional cryptographic operations whenever we touch a record.

Definition at line 415 of file gnunet-service-namestore.c.

Referenced by refresh_block(), and run().