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_IDENTITY_PrivateKey *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_IDENTITY_PrivateKey *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_IDENTITY_PrivateKey *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_with_filter (struct NamestoreClient *nc, uint32_t request_id, const struct GNUNET_IDENTITY_PrivateKey *zone_key, const char *name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, enum GNUNET_GNSRECORD_Filter filter)
	Generate a struct LookupNameResponseMessage and send it to the given client using the given notification context. More...
static void	send_lookup_response (struct NamestoreClient *nc, uint32_t request_id, const struct GNUNET_IDENTITY_PrivateKey *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, const char *emsg, 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_IDENTITY_PrivateKey *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_IDENTITY_PrivateKey *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	get_block_exp_existing (void *cls, uint64_t seq, const struct GNUNET_IDENTITY_PrivateKey *private_key, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Check if set contains a tombstone, store if necessary. 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_tx_control (void *cls, const struct TxControlMessage *tx_msg)
	Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_TX_CONTROL message. More...
static void	handle_zone_to_name_it (void *cls, uint64_t seq, const struct GNUNET_IDENTITY_PrivateKey *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_IDENTITY_PrivateKey *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_IDENTITY_PrivateKey *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_fixed_size(tx_control, GNUNET_MESSAGE_TYPE_NAMESTORE_TX_CONTROL, struct TxControlMessage, 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_IDENTITY_PrivateKey	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 char *	db_lib_name
	Name of the database plugin. More...
struct GNUNET_NAMESTORE_PluginFunctions *	GSN_database
	Database handle for service. 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 44 of file gnunet-service-namestore.c.

NC_SIZE

#define NC_SIZE   16

Size of the cache used by get_nick_record()

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

Function Documentation

cleanup_task()

static void cleanup_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

unused

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

{
  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;
  }
  if (NULL != monitor_nc)
  {
    GNUNET_notification_context_destroy (monitor_nc);
    monitor_nc = NULL;
  }
  if (NULL != statistics)
  {
    GNUNET_STATISTICS_destroy (statistics, GNUNET_NO);
    statistics = NULL;
  }
  GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name, GSN_database));
  GNUNET_free (db_lib_name);
  db_lib_name = NULL;
}

References cop_head, cop_tail, 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(), GSN_database, monitor_nc, namecache, CacheOperation::qe, and statistics.

Referenced by run().

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 482 of file gnunet-service-namestore.c.

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

References StoreActivity::conv_name, GNUNET_CONTAINER_DLL_remove, GNUNET_free, sa_head, and sa_tail.

Referenced by client_disconnect_cb(), and continue_store_activity().

Here is the caller graph for this function:

lookup_nick_it()

static void lookup_nick_it ( void *  cls, uint64_t  seq, const struct GNUNET_IDENTITY_PrivateKey *  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 503 of file gnunet-service-namestore.c.

{
  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;
}

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().

Here is the caller graph for this function:

cache_nick()

static void cache_nick ( const struct GNUNET_IDENTITY_PrivateKey *  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 545 of file gnunet-service-namestore.c.

{
  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 (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 ();
}

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

Referenced by get_nick_record(), and handle_record_store().

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_IDENTITY_PrivateKey *  zone )

static

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

Parameters

nc	the namestore client
zone	private key for the zone to look for nick

Returns

NULL if no NICK record was found

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

{
  struct GNUNET_IDENTITY_PublicKey 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))
  {
#if ! defined(GNUNET_CULL_LOGGING)
    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_IDENTITY_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));
    }
#endif
    /* update cache */
    cache_nick (zone, NULL);
    return NULL;
  }
 
  /* update cache */
  cache_nick (zone, nick);
  return nick;
}

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

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

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 664 of file gnunet-service-namestore.c.

{
  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;
  /* Mark as supplemental */
  target[rd2_length].flags = nick_rd->flags | GNUNET_GNSRECORD_RF_SUPPLEMENTAL;
  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);
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

send_lookup_response_with_filter()

static void send_lookup_response_with_filter ( struct NamestoreClient *  nc, uint32_t  request_id, const struct GNUNET_IDENTITY_PrivateKey *  zone_key, const char *  name, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd, enum GNUNET_GNSRECORD_Filter  filter  )

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
filter	record set filter

FIXME if we ever support GNUNET_NAMESTORE_OMIT_PUBLIC, we need to omit adding this public record here

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

{
  struct GNUNET_MQ_Envelope *env;
  struct RecordResultMessage *zir_msg;
  struct GNUNET_GNSRECORD_Data *nick;
  struct GNUNET_GNSRECORD_Data *res;
  struct GNUNET_GNSRECORD_Data rd_nf[rd_count];
  struct GNUNET_TIME_Absolute block_exp = GNUNET_TIME_UNIT_ZERO_ABS;;
  unsigned int res_count;
  unsigned int rd_nf_count;
  size_t name_len;
  ssize_t rd_ser_len;
  char *name_tmp;
  char *rd_ser;
  char *emsg;
 
  nick = get_nick_record (zone_key);
  GNUNET_assert (-1 != GNUNET_GNSRECORD_records_get_size (rd_count, rd));
 
  if (GNUNET_OK != GNUNET_GNSRECORD_normalize_record_set (name,
                                                          rd,
                                                          rd_count,
                                                          rd_nf,
                                                          &rd_nf_count,
                                                          &block_exp,
                                                          filter,
                                                          &emsg))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s\n", emsg);
    GNUNET_free (emsg);
    GNUNET_assert (0);
  }
 
  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_nf_count, rd_nf, &res_count, &res);
  }
  else
  {
    res_count = rd_nf_count;
    res = (struct GNUNET_GNSRECORD_Data *) rd_nf;
  }
  if (NULL != nick)
    GNUNET_free (nick);
 
  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)
  {
    if (rd_nf != res)
      GNUNET_free (res);
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (nc->client);
    return;
  }
  if (((size_t) rd_ser_len) >= UINT16_MAX - name_len - sizeof(*zir_msg))
  {
    if (rd_nf != res)
      GNUNET_free (res);
    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;
  zir_msg->expire = GNUNET_TIME_absolute_hton (block_exp);
  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_nf != res)
    GNUNET_free (res);
}

References env, RecordResultMessage::expire, filter, GNUNET_GNSRECORD_Data::flags, get_nick_record(), RecordResultMessage::gns_header, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_normalize_record_set(), 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_OK, GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_UNIT_ZERO_ABS, merge_with_nick_records(), GNUNET_PEERINFO_NotifyContext::mq, name, RecordResultMessage::name_len, nc, RecordResultMessage::private_key, GNUNET_NAMESTORE_Header::r_id, RecordResultMessage::rd_count, RecordResultMessage::rd_len, res, statistics, and zone_key.

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

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_IDENTITY_PrivateKey *  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 862 of file gnunet-service-namestore.c.

{
  send_lookup_response_with_filter (nc, request_id, zone_key, name,
                                    rd_count, rd, GNUNET_GNSRECORD_FILTER_NONE);
}

References GNUNET_GNSRECORD_FILTER_NONE, name, nc, send_lookup_response_with_filter(), and zone_key.

Referenced by monitor_iterate_cb().

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, const char *  emsg, 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 882 of file gnunet-service-namestore.c.

{
  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_extra (rcr_msg,
                             (NULL != emsg) ? strlen (emsg) + 1 : 0,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE);
  rcr_msg->gns_header.r_id = htonl (rid);
  rcr_msg->op_result = htonl (res);
  rcr_msg->reserved = htons (0);
  if (NULL != emsg)
  {
    rcr_msg->emsg_len = htons (strlen (emsg) + 1);
    memcpy (&rcr_msg[1], emsg, strlen (emsg) + 1);
  }
  GNUNET_MQ_send (nc->mq, env);
}

References RecordStoreResponseMessage::emsg_len, env, RecordStoreResponseMessage::gns_header, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_PEERINFO_NotifyContext::mq, nc, RecordStoreResponseMessage::op_result, GNUNET_NAMESTORE_Header::r_id, res, RecordStoreResponseMessage::reserved, and statistics.

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

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 917 of file gnunet-service-namestore.c.

{
  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);
}

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().

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 943 of file gnunet-service-namestore.c.

{
  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, emsg, 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);
}

References _, ZoneIteration::cache_ops, cop_head, cop_tail, 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().

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_IDENTITY_PrivateKey *  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

Do not block-cache tombstones

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

{
  struct GNUNET_GNSRECORD_Block *block;
  struct GNUNET_GNSRECORD_Data rd_clean[rd_count];
  struct CacheOperation *cop;
  struct GNUNET_IDENTITY_PublicKey pkey;
  struct GNUNET_GNSRECORD_Data *nick;
  struct GNUNET_GNSRECORD_Data *res;
  unsigned int res_count;
  unsigned int rd_count_clean;
  struct GNUNET_TIME_Absolute exp_time;
 
  rd_count_clean = 0;
  for (int i = 0; i < rd_count; i++)
  {
    if (GNUNET_GNSRECORD_TYPE_TOMBSTONE == rd[i].record_type)
      continue;
    rd_clean[rd_count_clean++] = rd[i];
  }
 
  nick = get_nick_record (zone_key);
  res_count = rd_count_clean;
  res = (struct GNUNET_GNSRECORD_Data *) rd_clean;  /* fixme: a bit unclean... */
  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_clean, rd_clean, &res_count, &res);
  }
  if (NULL != nick)
    GNUNET_free (nick);
  if (0 == res_count)
  {
    if (NULL != nc)
      send_store_response (nc, GNUNET_OK, NULL, rid);
    if (rd_clean != res)
      GNUNET_free (res);
    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, NULL, rid);
    if (rd_clean != res)
      GNUNET_free (res);
    return;
  }
  exp_time = GNUNET_GNSRECORD_record_get_expiration_time (res_count, res,
                                                          GNUNET_TIME_UNIT_ZERO_ABS);
  if (cache_keys)
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_GNSRECORD_block_create2 (zone_key, exp_time, name,
                                                   res, res_count, &block));
  else
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_GNSRECORD_block_create (zone_key, exp_time, name,
                                                  res, res_count, &block));
  GNUNET_assert (NULL != block);
  GNUNET_IDENTITY_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);
  if (rd_clean != res)
    GNUNET_free (res);
}

References cache_keys, ZoneIteration::cache_ops, cop_head, cop_tail, disable_namecache, finish_cache_operation(), GNUNET_GNSRECORD_Data::flags, get_nick_record(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_block_create(), GNUNET_GNSRECORD_block_create2(), GNUNET_GNSRECORD_record_get_expiration_time(), GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_TYPE_TOMBSTONE, GNUNET_GNSRECORD_z2s(), GNUNET_IDENTITY_key_get_public(), GNUNET_log, GNUNET_NAMECACHE_block_cache(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, merge_with_nick_records(), name, namecache, nc, CacheOperation::nc, pkey, CacheOperation::qe, res, CacheOperation::rid, send_store_response(), statistics, CacheOperation::zi, and zone_key.

Referenced by continue_store_activity(), and zone_iterate_proc().

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 1087 of file gnunet-service-namestore.c.

{
  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);
}

References GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_absolute_time_to_string(), MONITOR_STALL_WARN_DELAY, and zm.

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

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 1106 of file gnunet-service-namestore.c.

{
  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_with_filter (zm->nc,
                                        0,
                                        &rp_msg->private_key,
                                        sa->conv_name,
                                        rd_count,
                                        rd,
                                        zm->filter);
      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);
}

References NamestoreClient::client, StoreActivity::conv_name, GNUNET_NAMESTORE_ZoneMonitor::filter, free_store_activity(), RecordStoreMessage::gns_header, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_records_deserialize(), GNUNET_log, GNUNET_memcmp, GNUNET_NZL, 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_with_filter(), warn_monitor_slow(), zero, zm, StoreActivity::zm_pos, and GNUNET_NAMESTORE_ZoneMonitor::zone.

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

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 1186 of file gnunet-service-namestore.c.

{
  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_break (NULL == GNUNET_PLUGIN_unload (nc->db_lib_name, nc->GSN_database));
  GNUNET_free (nc->db_lib_name);
  GNUNET_free (nc);
}

References continue_store_activity(), cop_head, free_store_activity(), GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_PLUGIN_unload(), GNUNET_SCHEDULER_cancel(), monitor_head, monitor_tail, nc, CacheOperation::nc, CacheOperation::next, StoreActivity::next, sa_head, zm, and StoreActivity::zm_pos.

Here is the call 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 1258 of file gnunet-service-namestore.c.

{
  struct NamestoreClient *nc;
  char *database;
 
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
  nc = GNUNET_new (struct NamestoreClient);
  nc->client = client;
  nc->mq = mq;
  /* Loading database plugin */
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (GSN_cfg,
                                                          "namestore",
                                                          "database",
                                                          &database))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No database backend configured\n");
    GNUNET_free (nc);
    return NULL;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Loading %s\n", db_lib_name);
  nc->GSN_database = GNUNET_PLUGIN_load (db_lib_name, (void *) GSN_cfg);
  GNUNET_free (database);
  if (NULL == nc->GSN_database)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Could not load database backend `%s'\n",
                db_lib_name);
    GNUNET_free (nc);
    return NULL;
  }
  nc->db_lib_name = GNUNET_strdup (db_lib_name);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Loaded %s\n", db_lib_name);
  return nc;
}

References NamestoreClient::client, db_lib_name, GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_PLUGIN_load(), GNUNET_strdup, GSN_cfg, mq, GNUNET_PEERINFO_NotifyContext::mq, and nc.

Here is the call graph for this function:

lookup_it()

static void lookup_it ( void *  cls, uint64_t  seq, const struct GNUNET_IDENTITY_PrivateKey *  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 1347 of file gnunet-service-namestore.c.

{
  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;
    }
  }
}

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().

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 1445 of file gnunet-service-namestore.c.

{
  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;
}

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.

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 1470 of file gnunet-service-namestore.c.

{
  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_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_normalize (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;
  }
  name_len = strlen (conv_name) + 1;
  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);
  if (GNUNET_YES != ntohl (ll_msg->is_edit_request))
    res = nc->GSN_database->lookup_records (nc->GSN_database->cls,
                                            &ll_msg->zone,
                                            conv_name,
                                            &lookup_it,
                                            &rlc);
  else
    res = nc->GSN_database->edit_records (nc->GSN_database->cls,
                                          &ll_msg->zone,
                                          conv_name,
                                          &lookup_it,
                                          &rlc);
 
  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)
    llr_msg->found = htons (GNUNET_YES);
  else if (GNUNET_SYSERR == res)
    llr_msg->found = htons (GNUNET_SYSERR);
  else
    llr_msg->found = htons (GNUNET_NO);
  GNUNET_memcpy (&llr_msg[1], conv_name, name_len);
  GNUNET_memcpy (&res_name[name_len], rlc.res_rd, rlc.rd_ser_len);
  GNUNET_MQ_send (nc->mq, env);
  GNUNET_free (rlc.res_rd);
  GNUNET_free (conv_name);
}

References env, RecordLookupContext::found, LabelLookupResponseMessage::found, get_nick_record(), LabelLookupMessage::gns_header, LabelLookupResponseMessage::gns_header, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNSRECORD_string_normalize(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, GNUNET_YES, LabelLookupMessage::is_edit_request, RecordLookupContext::label, lookup_it(), GNUNET_PEERINFO_NotifyContext::mq, LabelLookupResponseMessage::name_len, 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.

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 1550 of file gnunet-service-namestore.c.

{
  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;
}

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.

get_block_exp_existing()

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

static

Check if set contains a tombstone, store if necessary.

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 1594 of file gnunet-service-namestore.c.

{
  struct GNUNET_TIME_Absolute *exp = cls;
  struct GNUNET_GNSRECORD_Data rd_pub[rd_count];
  unsigned int rd_pub_count;
  char *emsg;
 
  if (GNUNET_OK !=
      GNUNET_GNSRECORD_normalize_record_set (label,
                                             rd,
                                             rd_count,
                                             rd_pub,
                                             &rd_pub_count,
                                             exp,
                                             GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE,
                                             &emsg))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "%s\n", emsg);
    GNUNET_free (emsg);
  }
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE, GNUNET_GNSRECORD_normalize_record_set(), GNUNET_log, and GNUNET_OK.

Referenced by handle_record_store().

Here is the call graph for this function:

Here is the caller graph for this function:

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 1631 of file gnunet-service-namestore.c.

{
  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;
  struct GNUNET_TIME_Absolute existing_block_exp;
  struct GNUNET_TIME_Absolute new_block_exp;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received NAMESTORE_RECORD_STORE message\n");
  existing_block_exp = GNUNET_TIME_UNIT_ZERO_ABS;
  new_block_exp = GNUNET_TIME_UNIT_ZERO_ABS;
  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)];
    char *emsg;
 
    /* Extracting and converting private key */
    conv_name = GNUNET_GNSRECORD_string_normalize (name_tmp);
    if (NULL == conv_name)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Error normalizing name `%s'\n",
                  name_tmp);
      send_store_response (nc, GNUNET_SYSERR, _ ("Error normalizing name."),
                           rid);
      GNUNET_SERVICE_client_continue (nc->client);
      return;
    }
 
    /* Check name for validity */
    if (GNUNET_OK != GNUNET_GNSRECORD_label_check (conv_name, &emsg))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Label invalid: `%s'\n",
                  emsg);
      send_store_response (nc, GNUNET_SYSERR, emsg, rid);
      GNUNET_free (emsg);
      GNUNET_free (conv_name);
      GNUNET_SERVICE_client_continue (nc->client);
      return;
    }
 
    if (GNUNET_OK !=
        GNUNET_GNSRECORD_records_deserialize (rd_ser_len, rd_ser, rd_count, rd))
    {
      send_store_response (nc, GNUNET_SYSERR,
                           _ ("Error deserializing records."), rid);
      GNUNET_free (conv_name);
      GNUNET_SERVICE_client_continue (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 ((GNUNET_NO == nc->GSN_database->lookup_records (nc->GSN_database->cls,
                                                        &rp_msg->private_key,
                                                        conv_name,
                                                        &get_block_exp_existing,
                                                        &existing_block_exp)) &&
        (rd_count == 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
       We may need one additional record later for tombstone.
       FIXME: Since we must normalize the record set (check for
       consistency etc) we have to iterate the set twice.
       May be inefficient.
       We cannot really move the nick caching into GNSRECORD.
       */
      struct GNUNET_GNSRECORD_Data rd_clean[GNUNET_NZL (rd_count)];
      struct GNUNET_GNSRECORD_Data rd_nf[GNUNET_NZL (rd_count) + 1];
      unsigned int rd_clean_off;
      unsigned int rd_nf_count;
      char *emsg;
      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 (GNUNET_OK !=
          GNUNET_GNSRECORD_normalize_record_set (conv_name,
                                                 rd_clean,
                                                 rd_clean_off,
                                                 rd_nf,
                                                 &rd_nf_count,
                                                 &new_block_exp,
                                                 GNUNET_GNSRECORD_FILTER_NONE,
                                                 &emsg))
      {
        send_store_response (nc, GNUNET_SYSERR, emsg, rid);
        GNUNET_free (emsg);
        GNUNET_SERVICE_client_continue (nc->client);
        GNUNET_free (conv_name);
        return;
      }
      /*
       * If existing_block_exp is 0, then there was not record set
       * and no tombstone.
       * Otherwise, if the existing block expiration is after the
       * new block expiration would be, we need to add a tombstone
       * or update it.
       */
      if (GNUNET_TIME_absolute_cmp (new_block_exp, <=, existing_block_exp))
      {
        rd_nf[rd_nf_count].record_type = GNUNET_GNSRECORD_TYPE_TOMBSTONE;
        rd_nf[rd_nf_count].expiration_time =
          existing_block_exp.abs_value_us;
        rd_nf[rd_nf_count].data = NULL;
        rd_nf[rd_nf_count].data_size = 0;
        rd_nf[rd_nf_count].flags = GNUNET_GNSRECORD_RF_PRIVATE;
        rd_nf_count++;
      }
      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 = nc->GSN_database->store_records (nc->GSN_database->cls,
                                             &rp_msg->private_key,
                                             conv_name,
                                             rd_nf_count,
                                             rd_nf);
    }
 
    if (GNUNET_OK != res)
    {
      /* store not successful, no need to tell monitors */
      send_store_response (nc, res, _ ("Store failed"), 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);
  }
}

References _, GNUNET_TIME_Absolute::abs_value_us, cache_nick(), continue_store_activity(), StoreActivity::conv_name, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, get_block_exp_existing(), RecordStoreMessage::gns_header, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_FILTER_NONE, GNUNET_GNSRECORD_label_check(), GNUNET_GNSRECORD_normalize_record_set(), GNUNET_GNSRECORD_records_deserialize(), GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_string_normalize(), GNUNET_GNSRECORD_TYPE_NICK, GNUNET_GNSRECORD_TYPE_TOMBSTONE, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_NZL, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_absolute_cmp, GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, GNUNET_NAMESTORE_Header::header, monitor_head, RecordStoreMessage::name_len, nc, StoreActivity::nc, RecordStoreMessage::private_key, GNUNET_NAMESTORE_Header::r_id, RecordStoreMessage::rd_count, RecordStoreMessage::rd_len, GNUNET_GNSRECORD_Data::record_type, res, StoreActivity::rsm, sa_head, sa_tail, send_store_response(), GNUNET_MessageHeader::size, statistics, and StoreActivity::zm_pos.

Here is the call graph for this function:

handle_tx_control()

static void handle_tx_control ( void *  cls, const struct TxControlMessage *  tx_msg  )

static

Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_TX_CONTROL message.

Parameters

cls	client sending the message
tx_msg	message of type struct TxControlMessage

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

{
  struct NamestoreClient *nc = cls;
  struct TxControlResultMessage *txr_msg;
  struct GNUNET_MQ_Envelope *env;
  enum GNUNET_GenericReturnValue ret;
  char *emsg = NULL;
  char *err_tmp;
  size_t err_len;
 
  switch (ntohs (tx_msg->control))
  {
  case GNUNET_NAMESTORE_TX_BEGIN:
    ret = nc->GSN_database->transaction_begin (nc->GSN_database->cls,
                                               &emsg);
    break;
  case GNUNET_NAMESTORE_TX_COMMIT:
    ret = nc->GSN_database->transaction_commit (nc->GSN_database->cls,
                                                &emsg);
    break;
  case GNUNET_NAMESTORE_TX_ROLLBACK:
    ret = nc->GSN_database->transaction_rollback (nc->GSN_database->cls,
                                                  &emsg);
    break;
  default:
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Unknown control type %u\n", ntohs (tx_msg->control));
    GNUNET_break (0);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "TX status is %u\n", ret);
  err_len = (NULL == emsg) ? 0 : strlen (emsg) + 1;
  env =
    GNUNET_MQ_msg_extra (txr_msg,
                         err_len,
                         GNUNET_MESSAGE_TYPE_NAMESTORE_TX_CONTROL_RESULT);
  txr_msg->gns_header.header.size = htons (sizeof (struct
                                                   TxControlResultMessage)
                                           + err_len);
  txr_msg->gns_header.r_id = tx_msg->gns_header.r_id;
  txr_msg->success = htons (ret);
  err_tmp = (char *) &txr_msg[1];
  GNUNET_memcpy (err_tmp, emsg, err_len);
  GNUNET_MQ_send (nc->mq, env);
  GNUNET_SERVICE_client_continue (nc->client);
}

References TxControlMessage::control, env, TxControlMessage::gns_header, TxControlResultMessage::gns_header, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_NAMESTORE_TX_CONTROL_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NAMESTORE_TX_BEGIN, GNUNET_NAMESTORE_TX_COMMIT, GNUNET_NAMESTORE_TX_ROLLBACK, GNUNET_SERVICE_client_continue(), GNUNET_NAMESTORE_Header::header, GNUNET_PEERINFO_NotifyContext::mq, nc, GNUNET_NAMESTORE_Header::r_id, ret, GNUNET_MessageHeader::size, and TxControlResultMessage::success.

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_IDENTITY_PrivateKey *  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 1907 of file gnunet-service-namestore.c.

{
  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);
}

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, ZoneToNameResponseMessage::zone, and zone_key.

Referenced by handle_zone_to_name().

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 1973 of file gnunet-service-namestore.c.

{
  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 == nc->GSN_database->zone_to_name (nc->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);
}

References 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(), GNUNET_PEERINFO_NotifyContext::mq, nc, ZoneToNameCtx::nc, GNUNET_NAMESTORE_Header::r_id, ZoneToNameResponseMessage::res, ZoneToNameCtx::rid, ZoneToNameCtx::success, ZoneToNameMessage::value_zone, and ZoneToNameMessage::zone.

Here is the call graph for this function:

zone_iterate_proc()

static void zone_iterate_proc ( void *  cls, uint64_t  seq, const struct GNUNET_IDENTITY_PrivateKey *  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 2040 of file gnunet-service-namestore.c.

{
  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_with_filter (proc->zi->nc,
                                    proc->zi->request_id,
                                    zone_key,
                                    name,
                                    rd_count,
                                    rd,
                                    proc->zi->filter);
 
 
  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);
}

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

Referenced by run_zone_iteration_round().

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 2098 of file gnunet-service-namestore.c.

{
  struct ZoneIterationProcResult proc;
  struct GNUNET_TIME_Absolute start;
  struct GNUNET_TIME_Relative duration;
  struct NamestoreClient *nc = zi->nc;
 
  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 !=
                nc->GSN_database->iterate_records (nc->GSN_database->cls,
                                                   (GNUNET_YES ==
                                                    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);
}

References ZoneIteration::cache_ops, duration, 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_YES, ZoneIterationProcResult::limit, nc, ZoneIteration::nc, GNUNET_TIME_Relative::rel_value_us, ZoneIteration::send_end, ZoneIteration::seq, start, statistics, ZoneIterationProcResult::zi, ZoneIteration::zone, zone_iterate_proc(), and zone_iteration_done_client_continue().

Referenced by handle_iteration_next(), and handle_iteration_start().

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 2147 of file gnunet-service-namestore.c.

{
  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->filter = ntohs (zis_msg->filter);
  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);
}

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

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 2174 of file gnunet-service-namestore.c.

{
  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);
}

References 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(), nc, ZoneIteration::next, GNUNET_NAMESTORE_Header::r_id, and ZoneIteration::request_id.

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 2206 of file gnunet-service-namestore.c.

{
  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);
}

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

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 2241 of file gnunet-service-namestore.c.

{
  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);
  }
}

References continue_store_activity(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get(), GNUNET_YES, MONITOR_STALL_WARN_DELAY, StoreActivity::next, sa_head, warn_monitor_slow(), zm, and StoreActivity::zm_pos.

Referenced by handle_monitor_next(), and monitor_sync().

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 2281 of file gnunet-service-namestore.c.

{
  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);
}

References env, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, monitor_unblock(), GNUNET_NAMESTORE_ZoneMonitor::mq, and zm.

Referenced by handle_monitor_start(), and monitor_iteration_next().

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 2381 of file gnunet-service-namestore.c.

{
  struct ZoneMonitor *zm = cls;
  struct NamestoreClient *nc = zm->nc;
  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 = nc->GSN_database->iterate_records (nc->GSN_database->cls,
                                           (GNUNET_YES == 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;
  }
}

References GNUNET_assert, GNUNET_is_zero, GNUNET_NO, GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, GNUNET_YES, monitor_iterate_cb(), monitor_sync(), nc, ret, zm, and GNUNET_NAMESTORE_ZoneMonitor::zone.

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

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_IDENTITY_PrivateKey *  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 2316 of file gnunet-service-namestore.c.

{
  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);
  }
}

References GNUNET_assert, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_update(), monitor_iteration_next(), name, send_lookup_response(), ZoneMonitor::seq, statistics, zm, and zone_key.

Referenced by monitor_iteration_next().

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 2352 of file gnunet-service-namestore.c.

{
  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->filter = ntohs (zis_msg->filter);
  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);
}

References ZoneMonitorStartMessage::filter, GNUNET_NAMESTORE_ZoneMonitor::filter, 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, ZoneMonitorStartMessage::iterate_first, monitor_head, monitor_iteration_next(), monitor_nc, monitor_sync(), monitor_tail, GNUNET_PEERINFO_NotifyContext::mq, nc, zm, ZoneMonitorStartMessage::zone, and GNUNET_NAMESTORE_ZoneMonitor::zone.

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 2421 of file gnunet-service-namestore.c.

{
  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);
  }
}

References 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::limit, ZoneMonitorNextMessage::limit, monitor_head, monitor_iteration_next(), MONITOR_STALL_WARN_DELAY, monitor_unblock(), nc, warn_monitor_slow(), and 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 2481 of file gnunet-service-namestore.c.

{
  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);
  }
  statistics = GNUNET_STATISTICS_create ("namestore", cfg);
  /* 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_SCHEDULER_add_now (&cleanup_task, NULL);
    return;
  }
  GNUNET_asprintf (&db_lib_name, "libgnunet_plugin_namestore_%s", database);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Loading %s\n", db_lib_name);
  GSN_database = GNUNET_PLUGIN_load (db_lib_name, (void *) cfg);
  GNUNET_free (database);
  if (NULL == GSN_database)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Could not load database backend `%s'\n",
                db_lib_name);
    GNUNET_free (db_lib_name);
    GNUNET_SCHEDULER_add_now (&cleanup_task, NULL);
    return;
  }
  GNUNET_SCHEDULER_add_shutdown (&cleanup_task, NULL);
}

References cache_keys, cfg, cleanup_task(), 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_NAMECACHE_connect(), GNUNET_notification_context_create(), GNUNET_OK, GNUNET_PLUGIN_load(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_STATISTICS_create(), GNUNET_YES, GSN_cfg, GSN_database, monitor_nc, namecache, service, and statistics.

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_fixed_size(tx_control, GNUNET_MESSAGE_TYPE_NAMESTORE_TX_CONTROL, struct TxControlMessage, 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.

Variable Documentation

nick_cache

struct NickCache nick_cache[16]

static

We cache nick records to reduce DB load.

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

Referenced by cache_nick(), and get_nick_record().

zero

const struct GNUNET_IDENTITY_PrivateKey zero

static

Public key of all zeros.

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

Referenced by check_ipv6_listed(), continue_store_activity(), create_message_request(), GNUNET_CRYPTO_edx25519_private_key_derive(), GNUNET_DHT_verify_path(), GNUNET_TUN_ipv6policy2regex(), and GST_manipulation_set_metric().

GSN_cfg

const struct GNUNET_CONFIGURATION_Handle* GSN_cfg

static

Configuration handle.

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

Referenced by client_connect_cb(), and run().

statistics

struct GNUNET_STATISTICS_Handle* statistics

static

Handle to the statistics service.

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

Referenced by cleanup_task(), handle_iteration_next(), handle_record_store(), monitor_iterate_cb(), refresh_block(), run(), run_zone_iteration_round(), send_lookup_response_with_filter(), and send_store_response().

namecache

struct GNUNET_NAMECACHE_Handle* namecache

static

Namecache handle.

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

Referenced by cleanup_task(), refresh_block(), and run().

db_lib_name

char* db_lib_name

static

Name of the database plugin.

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

Referenced by cleanup_task(), client_connect_cb(), and run().

GSN_database

struct GNUNET_NAMESTORE_PluginFunctions* GSN_database

Database handle for service.

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

Referenced by cleanup_task(), get_nick_record(), and run().

cop_head

struct CacheOperation* cop_head

static

Head of cop DLL.

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

Referenced by cleanup_task(), client_disconnect_cb(), finish_cache_operation(), and refresh_block().

cop_tail

struct CacheOperation* cop_tail

static

Tail of cop DLL.

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

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

monitor_head

struct ZoneMonitor* monitor_head

static

First active zone monitor.

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

Referenced by client_disconnect_cb(), handle_monitor_next(), handle_monitor_start(), and handle_record_store().

monitor_tail

struct ZoneMonitor* monitor_tail

static

Last active zone monitor.

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

Referenced by client_disconnect_cb(), and handle_monitor_start().

sa_head

struct StoreActivity* sa_head

static

Head of DLL of monitor-blocked store activities.

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

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

sa_tail

struct StoreActivity* sa_tail

static

Tail of DLL of monitor-blocked store activities.

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

Referenced by free_store_activity(), and handle_record_store().

monitor_nc

struct GNUNET_NotificationContext* monitor_nc

static

Notification context shared by all monitors.

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

Referenced by cleanup_task(), handle_monitor_start(), and run().

cache_keys

int cache_keys

static

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

Definition at line 425 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 431 of file gnunet-service-namestore.c.

Referenced by refresh_block(), and run().