GNUnet  0.11.x
Data Structures | Macros | Functions | Variables
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_Dataget_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 (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, 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 handle_record_store (void *cls, const struct RecordStoreMessage *rp_msg)
 Handles a GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE message. More...
 
static void handle_zone_to_name_it (void *cls, uint64_t seq, const struct GNUNET_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_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_HandleGSN_cfg
 Configuration handle. More...
 
static struct GNUNET_STATISTICS_Handlestatistics
 Handle to the statistics service. More...
 
static struct GNUNET_NAMECACHE_Handlenamecache
 Namecache handle. More...
 
static struct GNUNET_NAMESTORE_PluginFunctionsGSN_database
 Database handle. More...
 
static char * db_lib_name
 Name of the database plugin. More...
 
static struct CacheOperationcop_head
 Head of cop DLL. More...
 
static struct CacheOperationcop_tail
 Tail of cop DLL. More...
 
static struct ZoneMonitormonitor_head
 First active zone monitor. More...
 
static struct ZoneMonitormonitor_tail
 Last active zone monitor. More...
 
static struct StoreActivitysa_head
 Head of DLL of monitor-blocked store activities. More...
 
static struct StoreActivitysa_tail
 Tail of DLL of monitor-blocked store activities. More...
 
static struct GNUNET_NotificationContextmonitor_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.

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

◆ NC_SIZE

#define NC_SIZE   16

Size of the cache used by get_nick_record()

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

Referenced by cache_nick(), and get_nick_record().

Function Documentation

◆ cleanup_task()

static void cleanup_task ( void *  cls)
static

Task run during shutdown.

Parameters
clsunused

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

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

Referenced by run().

421 {
422  struct CacheOperation *cop;
423 
424  (void) cls;
425  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping namestore service\n");
426  while (NULL != (cop = cop_head))
427  {
429  "Aborting incomplete namecache operation\n");
432  GNUNET_free (cop);
433  }
434  if (NULL != namecache)
435  {
437  namecache = NULL;
438  }
441  db_lib_name = NULL;
442  if (NULL != monitor_nc)
443  {
445  monitor_nc = NULL;
446  }
447  if (NULL != statistics)
448  {
450  statistics = NULL;
451  }
452 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static char * db_lib_name
Name of the database plugin.
static struct GNUNET_NotificationContext * monitor_nc
Notification context shared by all monitors.
struct GNUNET_NAMECACHE_QueueEntry * qe
Handle to namecache queue.
static struct CacheOperation * cop_head
Head of cop DLL.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void * GNUNET_PLUGIN_unload(const char *library_name, void *arg)
Unload plugin (runs the "done" callback and returns whatever "done" returned).
Definition: plugin.c:256
void GNUNET_NAMECACHE_cancel(struct GNUNET_NAMECACHE_QueueEntry *qe)
Cancel a namecache operation.
static struct GNUNET_STATISTICS_Handle * statistics
Handle to the statistics service.
static struct GNUNET_NAMESTORE_PluginFunctions * GSN_database
Database handle.
Pending operation on the namecache.
#define GNUNET_log(kind,...)
void GNUNET_NAMECACHE_disconnect(struct GNUNET_NAMECACHE_Handle *h)
Disconnect from the namecache service (and free associated resources).
void GNUNET_notification_context_destroy(struct GNUNET_NotificationContext *nc)
Destroy the context, force disconnect for all subscribers.
Definition: nc.c:137
static struct GNUNET_NAMECACHE_Handle * namecache
Namecache handle.
static struct CacheOperation * cop_tail
Tail of cop DLL.
#define GNUNET_free(ptr)
Wrapper around free.
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
saactivity to free

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

References StoreActivity::conv_name, GNUNET_CONTAINER_DLL_remove, and GNUNET_free.

Referenced by client_disconnect_cb(), and continue_store_activity().

462 {
464  GNUNET_free (sa->conv_name);
465  GNUNET_free (sa);
466 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
char * conv_name
Label nicely canonicalized (lower case).
static struct StoreActivity * sa_tail
Tail of DLL of monitor-blocked store activities.
static struct StoreActivity * sa_head
Head of DLL of monitor-blocked store activities.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsa struct GNUNET_GNSRECORD_Data ** for storing the nick (if found)
seqsequence number of the record, MUST NOT BE ZERO
private_keythe private key of the zone (unused)
labelshould be GNUNET_GNS_EMPTY_LABEL_AT
rd_countnumber of records in rd
rdrecords stored under label in the zone

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

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

Referenced by get_nick_record().

488 {
489  struct GNUNET_GNSRECORD_Data **res = cls;
490 
491  (void) private_key;
492  GNUNET_assert (0 != seq);
493  if (0 != strcmp (label, GNUNET_GNS_EMPTY_LABEL_AT))
494  {
495  GNUNET_break (0);
496  return;
497  }
498  for (unsigned int c = 0; c < rd_count; c++)
499  {
501  {
502  (*res) =
503  GNUNET_malloc (rd[c].data_size + sizeof(struct GNUNET_GNSRECORD_Data));
504  (*res)->data = &(*res)[1];
505  GNUNET_memcpy ((void *) (*res)->data, rd[c].data, rd[c].data_size);
506  (*res)->data_size = rd[c].data_size;
507  (*res)->expiration_time = rd[c].expiration_time;
508  (*res)->flags = rd[c].flags;
509  (*res)->record_type = GNUNET_GNSRECORD_TYPE_NICK;
510  return;
511  }
512  }
513  (*res) = NULL;
514 }
#define GNUNET_GNS_EMPTY_LABEL_AT
String we use to indicate an empty label (top-level entry in the zone).
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
size_t data_size
Number of bytes in data.
#define GNUNET_GNSRECORD_TYPE_NICK
Record type for GNS nick names ("NICK").
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
const void * data
Binary value stored in the DNS record.
uint64_t expiration_time
Expiration time for the DNS record.
static int res
uint32_t record_type
Type of the GNS/DNS record.
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
#define GNUNET_malloc(size)
Wrapper around malloc.
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
zonezone key to cache under
nicknick entry to cache

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

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, ZoneIteration::nick, nick_cache, NickCache::rd, ZoneIteration::zone, and NickCache::zone.

Referenced by get_nick_record(), and handle_record_store().

526 {
527  struct NickCache *oldest;
528 
529  oldest = NULL;
530  for (unsigned int i = 0; i < NC_SIZE; i++)
531  {
532  struct NickCache *pos = &nick_cache[i];
533 
534  if ((NULL == oldest) ||
535  (oldest->last_used.abs_value_us > pos->last_used.abs_value_us))
536  oldest = pos;
537  if (0 == GNUNET_memcmp (zone, &pos->zone))
538  {
539  oldest = pos;
540  break;
541  }
542  }
543  GNUNET_free (oldest->rd);
544  oldest->zone = *zone;
545  if (NULL != nick)
546  {
547  oldest->rd = GNUNET_malloc (sizeof(*nick) + nick->data_size);
548  *oldest->rd = *nick;
549  oldest->rd->data = &oldest->rd[1];
550  memcpy (&oldest->rd[1], nick->data, nick->data_size);
551  }
552  else
553  {
554  oldest->rd = NULL;
555  }
556  oldest->last_used = GNUNET_TIME_absolute_get ();
557 }
struct GNUNET_IDENTITY_PrivateKey zone
Zone the cache entry is for.
size_t data_size
Number of bytes in data.
static struct NickCache nick_cache[16]
We cache nick records to reduce DB load.
uint64_t abs_value_us
The actual value.
Entry in list of cached nick resolutions.
#define NC_SIZE
Size of the cache used by get_nick_record()
static char * zone
Name of the zone we manage.
const void * data
Binary value stored in the DNS record.
struct GNUNET_TIME_Absolute last_used
Timestamp when this cache entry was used last.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_GNSRECORD_Data * rd
Cached record data.
#define GNUNET_free(ptr)
Wrapper around free.
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
zoneprivate key for the zone to look for nick
Returns
NULL if no NICK record was found

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

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(), NickCache::last_used, lookup_nick_it(), GNUNET_NAMESTORE_PluginFunctions::lookup_records, NC_SIZE, ZoneIteration::nick, nick_cache, NickCache::rd, res, and NickCache::zone.

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

568 {
570  struct GNUNET_GNSRECORD_Data *nick;
571  int res;
572 
573  /* check cache first */
574  for (unsigned int i = 0; i < NC_SIZE; i++)
575  {
576  struct NickCache *pos = &nick_cache[i];
577  if ((NULL != pos->rd) && (0 == GNUNET_memcmp (zone, &pos->zone)))
578  {
579  if (NULL == pos->rd)
580  return NULL;
581  nick = GNUNET_malloc (sizeof(*nick) + pos->rd->data_size);
582  *nick = *pos->rd;
583  nick->data = &nick[1];
584  memcpy (&nick[1], pos->rd->data, pos->rd->data_size);
586  return nick;
587  }
588  }
589 
590  nick = NULL;
592  zone,
595  &nick);
596  if ((GNUNET_OK != res) || (NULL == nick))
597  {
598 #if ! defined(GNUNET_CULL_LOGGING)
599  static int do_log = GNUNET_LOG_CALL_STATUS;
600 
601  if (0 == do_log)
603  "namestore",
604  __FILE__,
605  __FUNCTION__,
606  __LINE__);
607  if (1 == do_log)
608  {
611  "No nick name set for zone `%s'\n",
613  }
614 #endif
615  /* update cache */
616  cache_nick (zone, NULL);
617  return NULL;
618  }
619 
620  /* update cache */
621  cache_nick (zone, nick);
622  return nick;
623 }
struct GNUNET_IDENTITY_PrivateKey zone
Zone the cache entry is for.
#define GNUNET_GNS_EMPTY_LABEL_AT
String we use to indicate an empty label (top-level entry in the zone).
size_t data_size
Number of bytes in data.
static struct NickCache nick_cache[16]
We cache nick records to reduce DB load.
Entry in list of cached nick resolutions.
#define NC_SIZE
Size of the cache used by get_nick_record()
void * cls
Closure to pass to all plugin functions.
const void * data
Binary value stored in the DNS record.
struct GNUNET_TIME_Absolute last_used
Timestamp when this cache entry was used last.
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_key_get_public(const struct GNUNET_IDENTITY_PrivateKey *privkey, struct GNUNET_IDENTITY_PublicKey *key)
Retrieves the public key representation of a private key.
Definition: identity_api.c:175
static int res
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
int GNUNET_get_log_call_status(int caller_level, const char *comp, const char *file, const char *function, int line)
Decides whether a particular logging call should or should not be allowed to be made.
int(* lookup_records)(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
Lookup records in the datastore for which we are the authority.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_LOG_CALL_STATUS
An identity key as per LSD0001.
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.
static struct GNUNET_NAMESTORE_PluginFunctions * GSN_database
Database handle.
static struct GNUNET_CRYPTO_EddsaPublicKey pub
Definition: gnunet-scrypt.c:46
#define GNUNET_log(kind,...)
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.
const char * GNUNET_GNSRECORD_z2s(const struct GNUNET_IDENTITY_PublicKey *z)
Convert a zone key to a string (for printing debug messages).
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_GNSRECORD_Data * rd
Cached record data.
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_rdthe nick record to integrate
rd2_lengthlength of the rd2 array
rd2array 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 642 of file gnunet-service-namestore.c.

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

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

647 {
648  uint64_t latest_expiration;
649  size_t req;
650  char *data;
651  size_t data_offset;
652  struct GNUNET_GNSRECORD_Data *target;
653 
654  (*rdc_res) = 1 + rd2_length;
655  if (0 == 1 + rd2_length)
656  {
657  GNUNET_break (0);
658  (*rd_res) = NULL;
659  return;
660  }
661  req = sizeof(struct GNUNET_GNSRECORD_Data) + nick_rd->data_size;
662  for (unsigned int i = 0; i < rd2_length; i++)
663  {
664  const struct GNUNET_GNSRECORD_Data *orig = &rd2[i];
665 
666  if (req + sizeof(struct GNUNET_GNSRECORD_Data) + orig->data_size < req)
667  {
668  GNUNET_break (0);
669  (*rd_res) = NULL;
670  return;
671  }
672  req += sizeof(struct GNUNET_GNSRECORD_Data) + orig->data_size;
673  }
674  target = GNUNET_malloc (req);
675  (*rd_res) = target;
676  data = (char *) &target[1 + rd2_length];
677  data_offset = 0;
678  latest_expiration = 0;
679  for (unsigned int i = 0; i < rd2_length; i++)
680  {
681  const struct GNUNET_GNSRECORD_Data *orig = &rd2[i];
682 
684  {
685  if ((GNUNET_TIME_absolute_get ().abs_value_us + orig->expiration_time) >
686  latest_expiration)
687  latest_expiration = orig->expiration_time;
688  }
689  else if (orig->expiration_time > latest_expiration)
690  latest_expiration = orig->expiration_time;
691  target[i] = *orig;
692  target[i].data = (void *) &data[data_offset];
693  GNUNET_memcpy (&data[data_offset], orig->data, orig->data_size);
694  data_offset += orig->data_size;
695  }
696  /* append nick */
697  target[rd2_length] = *nick_rd;
698  /* Mark as supplemental */
699  target[rd2_length].flags = nick_rd->flags | GNUNET_GNSRECORD_RF_SUPPLEMENTAL;
700  target[rd2_length].expiration_time = latest_expiration;
701  target[rd2_length].data = (void *) &data[data_offset];
702  GNUNET_memcpy (&data[data_offset], nick_rd->data, nick_rd->data_size);
703  data_offset += nick_rd->data_size;
704  GNUNET_assert (req == (sizeof(struct GNUNET_GNSRECORD_Data)) * (*rdc_res)
705  + data_offset);
706 }
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
This is a supplemental record.
size_t data_size
Number of bytes in data.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
const void * data
Binary value stored in the DNS record.
uint64_t expiration_time
Expiration time for the DNS record.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
This expiration time of the record is a relative time (not an absolute time).
uint32_t data
The data value.
#define GNUNET_malloc(size)
Wrapper around malloc.
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
ncclient to unicast to
request_idrequest ID to use
zone_keyzone key of the zone
namename
rd_countnumber of records in rd
rdarray of records

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

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

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

727 {
728  struct GNUNET_MQ_Envelope *env;
729  struct RecordResultMessage *zir_msg;
730  struct GNUNET_GNSRECORD_Data *nick;
731  struct GNUNET_GNSRECORD_Data *res;
732  unsigned int res_count;
733  size_t name_len;
734  ssize_t rd_ser_len;
735  char *name_tmp;
736  char *rd_ser;
737 
738  nick = get_nick_record (zone_key);
739  GNUNET_assert (-1 != GNUNET_GNSRECORD_records_get_size (rd_count, rd));
740 
741  if ((NULL != nick) && (0 != strcmp (name, GNUNET_GNS_EMPTY_LABEL_AT)))
742  {
743  nick->flags =
745  merge_with_nick_records (nick, rd_count, rd, &res_count, &res);
746  GNUNET_free (nick);
747  }
748  else
749  {
750  res_count = rd_count;
751  res = (struct GNUNET_GNSRECORD_Data *) rd;
752  }
753 
754  GNUNET_assert (-1 != GNUNET_GNSRECORD_records_get_size (res_count, res));
755 
756 
757  name_len = strlen (name) + 1;
758  rd_ser_len = GNUNET_GNSRECORD_records_get_size (res_count, res);
759  if (rd_ser_len < 0)
760  {
761  GNUNET_break (0);
763  return;
764  }
765  if (((size_t) rd_ser_len) >= UINT16_MAX - name_len - sizeof(*zir_msg))
766  {
767  GNUNET_break (0);
769  return;
770  }
771  env = GNUNET_MQ_msg_extra (zir_msg,
772  name_len + rd_ser_len,
774  zir_msg->gns_header.r_id = htonl (request_id);
775  zir_msg->name_len = htons (name_len);
776  zir_msg->rd_count = htons (res_count);
777  zir_msg->rd_len = htons ((uint16_t) rd_ser_len);
778  zir_msg->private_key = *zone_key;
779  name_tmp = (char *) &zir_msg[1];
780  GNUNET_memcpy (name_tmp, name, name_len);
781  rd_ser = &name_tmp[name_len];
782  GNUNET_assert (
783  rd_ser_len ==
784  GNUNET_GNSRECORD_records_serialize (res_count, res, rd_ser_len, rd_ser));
786  "Sending RECORD_RESULT message with %u records\n",
787  res_count);
789  "Record sets sent to clients",
790  1,
791  GNUNET_NO);
792  GNUNET_MQ_send (nc->mq, env);
793  if (rd != res)
794  GNUNET_free (res);
795 }
GNUNET_NETWORK_STRUCT_END ssize_t GNUNET_GNSRECORD_records_get_size(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Calculate how many bytes we will need to serialize the given records.
struct GNUNET_MQ_Handle * mq
Message queue for transmission to client.
#define GNUNET_GNS_EMPTY_LABEL_AT
String we use to indicate an empty label (top-level entry in the zone).
ssize_t GNUNET_GNSRECORD_records_serialize(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, size_t dest_size, char *dest)
Serialize the given records to the given destination buffer.
uint32_t r_id
Request ID in NBO.
Definition: namestore.h:51
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_IDENTITY_PrivateKey private_key
The private key of the authority.
Definition: namestore.h:286
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint16_t name_len
Name length.
Definition: namestore.h:266
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
uint16_t rd_count
Number of records contained.
Definition: namestore.h:276
This is a private record of this peer and it should thus not be handed out to other peers...
struct GNUNET_SERVICE_Client * client
The client.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2325
static int res
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static struct GNUNET_STATISTICS_Handle * statistics
Handle to the statistics service.
uint16_t rd_len
Length of serialized record data.
Definition: namestore.h:271
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT.
Definition: namestore.h:261
static struct GNUNET_GNSRECORD_Data * get_nick_record(const struct GNUNET_IDENTITY_PrivateKey *zone)
Return the NICK record for the zone (if it exists).
const char * name
#define GNUNET_log(kind,...)
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
#define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT
Service to client: here is a (plaintext) record you requested.
Record is returned from the namestore (as authority).
Definition: namestore.h:256
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
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.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ send_store_response()

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

Send response to the store request to the client.

Parameters
clientclient to talk to
resstatus of the operation
ridclient's request ID

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

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

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

807 {
808  struct GNUNET_MQ_Envelope *env;
809  struct RecordStoreResponseMessage *rcr_msg;
810 
811  GNUNET_assert (NULL != nc);
813  "Sending RECORD_STORE_RESPONSE message\n");
815  "Store requests completed",
816  1,
817  GNUNET_NO);
818  env = GNUNET_MQ_msg (rcr_msg,
820  rcr_msg->gns_header.r_id = htonl (rid);
821  rcr_msg->op_result = htonl (res);
822  GNUNET_MQ_send (nc->mq, env);
823 }
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE.
Definition: namestore.h:110
struct GNUNET_MQ_Handle * mq
Message queue for transmission to client.
uint32_t r_id
Request ID in NBO.
Definition: namestore.h:51
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
int32_t op_result
GNUNET_SYSERR on failure, GNUNET_OK on success
Definition: namestore.h:115
static int res
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static struct GNUNET_STATISTICS_Handle * statistics
Handle to the statistics service.
Response to a record storage request.
Definition: namestore.h:105
#define GNUNET_log(kind,...)
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
#define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE
Service to client: result of store operation.
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
zizone iteration we are processing

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

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

Referenced by finish_cache_operation(), and run_zone_iteration_round().

834 {
835  struct GNUNET_MQ_Envelope *env;
836  struct GNUNET_NAMESTORE_Header *em;
837 
839  if (! zi->send_end)
840  return;
841  /* send empty response to indicate end of list */
843  em->r_id = htonl (zi->request_id);
844  GNUNET_MQ_send (zi->nc->mq, env);
845 
847  GNUNET_free (zi);
848 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
int send_end
Set to GNUNET_YES if the last iteration exhausted the limit set by the client and we should send the ...
struct GNUNET_MQ_Handle * mq
Message queue for transmission to client.
uint32_t r_id
Request ID in NBO.
Definition: namestore.h:51
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END
Service to client: end of list of results.
struct ZoneIteration * op_head
Head of the DLL of Zone iteration operations in progress initiated by this client.
struct GNUNET_SERVICE_Client * client
The client.
uint32_t request_id
The operation id fot the zone iteration in the response for the client.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct ZoneIteration * op_tail
Tail of the DLL of Zone iteration operations in progress initiated by this client.
Generic namestore message with op id.
Definition: namestore.h:40
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
struct NamestoreClient * nc
Namestore client which intiated this zone iteration.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2244
#define GNUNET_free(ptr)
Wrapper around free.
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
clsthe struct CacheOperation
successsuccess
emsgerror messages

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

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

Referenced by refresh_block().

860 {
861  struct CacheOperation *cop = cls;
862  struct ZoneIteration *zi;
863 
864  if (NULL != emsg)
866  _ ("Failed to replicate block in namecache: %s\n"),
867  emsg);
868  else
869  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CACHE operation completed\n");
871  if (NULL != cop->nc)
872  send_store_response (cop->nc, success, cop->rid);
873  if (NULL != (zi = cop->zi))
874  {
875  zi->cache_ops--;
876  if (0 == zi->cache_ops)
877  {
878  /* unchoke zone iteration, cache has caught up */
880  }
881  }
882  GNUNET_free (cop);
883 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct CacheOperation * cop_head
Head of cop DLL.
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
uint32_t rid
Client&#39;s request ID.
unsigned int cache_ops
Number of pending cache operations triggered by this zone iteration which we need to wait for before ...
struct ZoneIteration * zi
Zone iteration to call zone_iteration_done_client_continue() for if applicable, can be NULL...
static void send_store_response(struct NamestoreClient *nc, int res, uint32_t rid)
Send response to the store request to the client.
A namestore iteration operation.
Pending operation on the namecache.
#define GNUNET_log(kind,...)
struct NamestoreClient * nc
Client to notify about the result, can be NULL.
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 ...
static struct CacheOperation * cop_tail
Tail of cop DLL.
#define GNUNET_free(ptr)
Wrapper around free.
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
ncclient responsible for the request, can be NULL
zizone iteration response for the request, can be NULL
ridrequest ID of the client
zone_keyprivate key of the zone
namelabel for the records
rd_countnumber of records
rdrecords stored under the given name

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

References cache_keys, ZoneIteration::cache_ops, disable_namecache, finish_cache_operation(), GNUNET_GNSRECORD_Data::flags, get_nick_record(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_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_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_YES, merge_with_nick_records(), ZoneIteration::nc, CacheOperation::nc, ZoneIteration::nick, CacheOperation::qe, res, CacheOperation::rid, send_store_response(), and CacheOperation::zi.

Referenced by continue_store_activity(), and zone_iterate_proc().

906 {
907  struct GNUNET_GNSRECORD_Block *block;
908  struct CacheOperation *cop;
910  struct GNUNET_GNSRECORD_Data *nick;
911  struct GNUNET_GNSRECORD_Data *res;
912  unsigned int res_count;
913  struct GNUNET_TIME_Absolute exp_time;
914 
915  nick = get_nick_record (zone_key);
916  res_count = rd_count;
917  res = (struct GNUNET_GNSRECORD_Data *) rd; /* fixme: a bit unclean... */
918  if ((NULL != nick) && (0 != strcmp (name, GNUNET_GNS_EMPTY_LABEL_AT)))
919  {
920  nick->flags =
922  merge_with_nick_records (nick, rd_count, rd, &res_count, &res);
923  GNUNET_free (nick);
924  }
925  if (0 == res_count)
926  {
927  if (NULL != nc)
928  send_store_response (nc, GNUNET_OK, rid);
929  return; /* no data, no need to update cache */
930  }
932  {
934  "Namecache updates skipped (NC disabled)",
935  1,
936  GNUNET_NO);
937  if (NULL != nc)
938  send_store_response (nc, GNUNET_OK, rid);
939  return;
940  }
941  exp_time = GNUNET_GNSRECORD_record_get_expiration_time (res_count, res);
942  if (cache_keys)
943  block =
944  GNUNET_GNSRECORD_block_create2 (zone_key, exp_time, name, res, res_count);
945  else
946  block =
947  GNUNET_GNSRECORD_block_create (zone_key, exp_time, name, res, res_count);
948  GNUNET_assert (NULL != block);
950  GNUNET_log (
952  "Caching block for label `%s' with %u records and expiration %s in zone `%s' in namecache\n",
953  name,
954  res_count,
958  "Namecache updates pushed",
959  1,
960  GNUNET_NO);
961  cop = GNUNET_new (struct CacheOperation);
962  cop->nc = nc;
963  cop->zi = zi;
964  if (NULL != zi)
965  zi->cache_ops++;
966  cop->rid = rid;
969  block,
971  cop);
972  GNUNET_free (block);
973 }
static char * pkey
Public key of the zone to look in, in ASCII.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_GNS_EMPTY_LABEL_AT
String we use to indicate an empty label (top-level entry in the zone).
struct GNUNET_NAMECACHE_QueueEntry * qe
Handle to namecache queue.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct CacheOperation * cop_head
Head of cop DLL.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_GNSRECORD_Block * GNUNET_GNSRECORD_block_create(const struct GNUNET_IDENTITY_PrivateKey *key, struct GNUNET_TIME_Absolute expire, const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count)
Sign name and records.
static int disable_namecache
Use the namecache? Doing so creates additional cryptographic operations whenever we touch a record...
uint32_t rid
Client&#39;s request ID.
struct GNUNET_GNSRECORD_Block * GNUNET_GNSRECORD_block_create2(const struct GNUNET_IDENTITY_PrivateKey *pkey, struct GNUNET_TIME_Absolute expire, const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count)
Sign name and records, cache derived public key (also keeps the private key in static memory...
static void finish_cache_operation(void *cls, int32_t success, const char *emsg)
Cache operation complete, clean up.
unsigned int cache_ops
Number of pending cache operations triggered by this zone iteration which we need to wait for before ...
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_key_get_public(const struct GNUNET_IDENTITY_PrivateKey *privkey, struct GNUNET_IDENTITY_PublicKey *key)
Retrieves the public key representation of a private key.
Definition: identity_api.c:175
This is a private record of this peer and it should thus not be handed out to other peers...
struct GNUNET_NAMECACHE_QueueEntry * GNUNET_NAMECACHE_block_cache(struct GNUNET_NAMECACHE_Handle *h, const struct GNUNET_GNSRECORD_Block *block, GNUNET_NAMECACHE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the namecache.
static int res
struct GNUNET_TIME_Absolute GNUNET_GNSRECORD_record_get_expiration_time(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Returns the expiration time of the given block of records.
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
struct ZoneIteration * zi
Zone iteration to call zone_iteration_done_client_continue() for if applicable, can be NULL...
static struct GNUNET_STATISTICS_Handle * statistics
Handle to the statistics service.
static struct GNUNET_GNSRECORD_Data * get_nick_record(const struct GNUNET_IDENTITY_PrivateKey *zone)
Return the NICK record for the zone (if it exists).
An identity key as per LSD0001.
static void send_store_response(struct NamestoreClient *nc, int res, uint32_t rid)
Send response to the store request to the client.
const char * name
Pending operation on the namecache.
#define GNUNET_log(kind,...)
struct NamestoreClient * nc
Client to notify about the result, can be NULL.
Time for absolute times used by GNUnet, in microseconds.
static struct GNUNET_NAMECACHE_Handle * namecache
Namecache handle.
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:758
static int cache_keys
Optimize block insertion by caching map of private keys to public keys in memory? ...
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.
const char * GNUNET_GNSRECORD_z2s(const struct GNUNET_IDENTITY_PublicKey *z)
Convert a zone key to a string (for printing debug messages).
static struct CacheOperation * cop_tail
Tail of cop DLL.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsa struct ZoneMonitor to warn about

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

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

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

983 {
984  struct ZoneMonitor *zm = cls;
985 
987  "No response from monitor since %s\n",
991  zm);
992 }
struct GNUNET_TIME_Absolute sa_waiting_start
Since when are we blocked on this monitor?
static struct GNUNET_NAMESTORE_ZoneMonitor * zm
Monitor handle.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
#define MONITOR_STALL_WARN_DELAY
If a monitor takes more than 1 minute to process an event, print a warning.
#define GNUNET_log(kind,...)
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:758
struct GNUNET_SCHEDULER_Task * sa_wait_warning
Task to warn about slow monitors.
static void warn_monitor_slow(void *cls)
Print a warning that one of our monitors is no longer reacting.
A namestore monitor.
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
sastore activity to process

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

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

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

1002 {
1003  const struct RecordStoreMessage *rp_msg = sa->rsm;
1004  unsigned int rd_count;
1005  size_t name_len;
1006  size_t rd_ser_len;
1007  uint32_t rid;
1008  const char *name_tmp;
1009  const char *rd_ser;
1010 
1011  rid = ntohl (rp_msg->gns_header.r_id);
1012  name_len = ntohs (rp_msg->name_len);
1013  rd_count = ntohs (rp_msg->rd_count);
1014  rd_ser_len = ntohs (rp_msg->rd_len);
1015  name_tmp = (const char *) &rp_msg[1];
1016  rd_ser = &name_tmp[name_len];
1017  {
1018  struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)];
1019 
1020  /* We did this before, must succeed again */
1021  GNUNET_assert (
1022  GNUNET_OK ==
1023  GNUNET_GNSRECORD_records_deserialize (rd_ser_len, rd_ser, rd_count, rd));
1024 
1025  for (struct ZoneMonitor *zm = sa->zm_pos; NULL != zm; zm = sa->zm_pos)
1026  {
1027  if ((0 != GNUNET_memcmp (&rp_msg->private_key, &zm->zone)) &&
1028  (0 != GNUNET_memcmp (&zm->zone, &zero)))
1029  {
1030  sa->zm_pos = zm->next; /* not interesting to this monitor */
1031  continue;
1032  }
1033  if (zm->limit == zm->iteration_cnt)
1034  {
1035  zm->sa_waiting = GNUNET_YES;
1036  zm->sa_waiting_start = GNUNET_TIME_absolute_get ();
1037  if (NULL != zm->sa_wait_warning)
1038  GNUNET_SCHEDULER_cancel (zm->sa_wait_warning);
1039  zm->sa_wait_warning =
1042  zm);
1043  return; /* blocked on zone monitor */
1044  }
1046  "Notifying monitor about changes under label `%s'\n",
1047  sa->conv_name);
1048  zm->limit--;
1049  send_lookup_response (zm->nc,
1050  0,
1051  &rp_msg->private_key,
1052  sa->conv_name,
1053  rd_count,
1054  rd);
1055  sa->zm_pos = zm->next;
1056  }
1057  /* great, done with the monitors, unpack (again) for refresh_block operation */
1058  refresh_block (sa->nc,
1059  NULL,
1060  rid,
1061  &rp_msg->private_key,
1062  sa->conv_name,
1063  rd_count,
1064  rd);
1065  }
1067  free_store_activity (sa);
1068 }
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE.
Definition: namestore.h:63
uint32_t r_id
Request ID in NBO.
Definition: namestore.h:51
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_IDENTITY_PrivateKey zone
Monitored zone.
struct ZoneMonitor * zm_pos
Next zone monitor that still needs to be notified about this PUT.
static struct GNUNET_NAMESTORE_ZoneMonitor * zm
Monitor handle.
int GNUNET_GNSRECORD_records_deserialize(size_t len, const char *src, unsigned int rd_count, struct GNUNET_GNSRECORD_Data *dest)
Deserialize the given records to the given destination.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
uint16_t rd_len
Length of serialized record data.
Definition: namestore.h:78
#define MONITOR_STALL_WARN_DELAY
If a monitor takes more than 1 minute to process an event, print a warning.
struct NamestoreClient * nc
Which client triggered the store activity?
uint16_t name_len
Name length.
Definition: namestore.h:73
struct GNUNET_SERVICE_Client * client
The client.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
uint16_t rd_count
Number of records contained.
Definition: namestore.h:83
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 notificat...
char * conv_name
Label nicely canonicalized (lower case).
struct GNUNET_IDENTITY_PrivateKey private_key
The private key of the authority.
Definition: namestore.h:93
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_NZL(l)
Macro used to avoid using 0 for the length of a variable-size array (Non-Zero-Length).
Store a record to the namestore (as authority).
Definition: namestore.h:58
static const struct GNUNET_IDENTITY_PrivateKey zero
Public key of all zeros.
static void free_store_activity(struct StoreActivity *sa)
Release memory used by sa.
#define GNUNET_log(kind,...)
const struct RecordStoreMessage * rsm
Copy of the original store message (as data fields in rd will point into it!).
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 (encryp...
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2244
static void warn_monitor_slow(void *cls)
Print a warning that one of our monitors is no longer reacting.
A namestore monitor.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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
clsclosure
clientidentification of the client
app_ctxthe struct NamestoreClient of client

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

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

Referenced by run().

1083 {
1084  struct NamestoreClient *nc = app_ctx;
1085  struct ZoneIteration *no;
1086  struct CacheOperation *cop;
1087 
1088  (void) cls;
1089  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p disconnected\n", client);
1090  for (struct ZoneMonitor *zm = monitor_head; NULL != zm; zm = zm->next)
1091  {
1092  struct StoreActivity *san;
1093 
1094  if (nc != zm->nc)
1095  continue;
1097  if (NULL != zm->task)
1098  {
1099  GNUNET_SCHEDULER_cancel (zm->task);
1100  zm->task = NULL;
1101  }
1102  if (NULL != zm->sa_wait_warning)
1103  {
1104  GNUNET_SCHEDULER_cancel (zm->sa_wait_warning);
1105  zm->sa_wait_warning = NULL;
1106  }
1107  for (struct StoreActivity *sa = sa_head; NULL != sa; sa = san)
1108  {
1109  san = sa->next;
1110  if (zm == sa->zm_pos)
1111  {
1112  sa->zm_pos = zm->next;
1113  /* this may free sa */
1115  }
1116  }
1117  GNUNET_free (zm);
1118  break;
1119  }
1120  for (struct StoreActivity *sa = sa_head; NULL != sa; sa = sa->next)
1121  {
1122  if (sa->nc == nc)
1123  {
1124  /* this may free sa */
1125  free_store_activity (sa);
1126  break; /* there can only be one per nc */
1127  }
1128  }
1129  while (NULL != (no = nc->op_head))
1130  {
1132  GNUNET_free (no);
1133  }
1134  for (cop = cop_head; NULL != cop; cop = cop->next)
1135  if (nc == cop->nc)
1136  cop->nc = NULL;
1137  GNUNET_free (nc);
1138 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct CacheOperation * next
Kept in a DLL.
static struct ZoneMonitor * monitor_head
First active zone monitor.
struct ZoneMonitor * zm_pos
Next zone monitor that still needs to be notified about this PUT.
static struct GNUNET_NAMESTORE_ZoneMonitor * zm
Monitor handle.
struct StoreActivity * next
Kept in a DLL.
static struct CacheOperation * cop_head
Head of cop DLL.
struct ZoneIteration * op_head
Head of the DLL of Zone iteration operations in progress initiated by this client.
static struct ZoneMonitor * monitor_tail
Last active zone monitor.
A namestore client.
static void continue_store_activity(struct StoreActivity *sa)
Continue processing the sa.
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
Information for an ongoing handle_record_store() operation.
static void free_store_activity(struct StoreActivity *sa)
Release memory used by sa.
struct ZoneIteration * op_tail
Tail of the DLL of Zone iteration operations in progress initiated by this client.
static struct StoreActivity * sa_head
Head of DLL of monitor-blocked store activities.
A namestore iteration operation.
Pending operation on the namecache.
#define GNUNET_log(kind,...)
struct NamestoreClient * nc
Client to notify about the result, can be NULL.
A namestore monitor.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
Here is the call graph for this function:
Here is the caller graph for this function:

◆ client_connect_cb()

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

Add a client to our list of active clients.

Parameters
clsNULL
clientclient to add
mqmessage queue for client
Returns
internal namestore client structure for this client

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

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

Referenced by run().

1153 {
1154  struct NamestoreClient *nc;
1155 
1156  (void) cls;
1157  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
1158  nc = GNUNET_new (struct NamestoreClient);
1159  nc->client = client;
1160  nc->mq = mq;
1161  return nc;
1162 }
struct GNUNET_MQ_Handle * mq
Message queue for transmission to client.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
A namestore client.
struct GNUNET_SERVICE_Client * client
The client.
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
Here is the caller 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
clsclosure with a struct RecordLookupContext
sequnique serial number of the record, MUST NOT BE ZERO
zone_keyprivate key of the zone
labelname that is being mapped (at most 255 characters long)
rd_countnumber of entries in rd array
rdarray of records with data to store

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

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

Referenced by handle_record_lookup().

1221 {
1222  struct RecordLookupContext *rlc = cls;
1223 
1224  (void) private_key;
1225  GNUNET_assert (0 != seq);
1226  if (0 != strcmp (label, rlc->label))
1227  return;
1228  rlc->found = GNUNET_YES;
1229  if (0 == rd_count)
1230  {
1231  rlc->rd_ser_len = 0;
1232  rlc->res_rd_count = 0;
1233  rlc->res_rd = NULL;
1234  return;
1235  }
1236  if ((NULL != rlc->nick) && (0 != strcmp (label, GNUNET_GNS_EMPTY_LABEL_AT)))
1237  {
1238  /* Merge */
1239  struct GNUNET_GNSRECORD_Data *rd_res;
1240  unsigned int rdc_res;
1241 
1242  rd_res = NULL;
1243  rdc_res = 0;
1244  rlc->nick->flags = (rlc->nick->flags | GNUNET_GNSRECORD_RF_PRIVATE)
1246  merge_with_nick_records (rlc->nick, rd_count, rd, &rdc_res, &rd_res);
1247  rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rdc_res, rd_res);
1248  if (rlc->rd_ser_len < 0)
1249  {
1250  GNUNET_break (0);
1251  GNUNET_free (rd_res);
1252  rlc->found = GNUNET_NO;
1253  rlc->rd_ser_len = 0;
1254  return;
1255  }
1256  rlc->res_rd_count = rdc_res;
1257  rlc->res_rd = GNUNET_malloc (rlc->rd_ser_len);
1258  if (rlc->rd_ser_len != GNUNET_GNSRECORD_records_serialize (rdc_res,
1259  rd_res,
1260  rlc->rd_ser_len,
1261  rlc->res_rd))
1262  {
1263  GNUNET_break (0);
1264  GNUNET_free (rlc->res_rd);
1265  rlc->res_rd = NULL;
1266  rlc->res_rd_count = 0;
1267  rlc->rd_ser_len = 0;
1268  GNUNET_free (rd_res);
1269  rlc->found = GNUNET_NO;
1270  return;
1271  }
1272  GNUNET_free (rd_res);
1273  GNUNET_free (rlc->nick);
1274  rlc->nick = NULL;
1275  }
1276  else
1277  {
1278  rlc->rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
1279  if (rlc->rd_ser_len < 0)
1280  {
1281  GNUNET_break (0);
1282  rlc->found = GNUNET_NO;
1283  rlc->rd_ser_len = 0;
1284  return;
1285  }
1286  rlc->res_rd_count = rd_count;
1287  rlc->res_rd = GNUNET_malloc (rlc->rd_ser_len);
1288  if (rlc->rd_ser_len != GNUNET_GNSRECORD_records_serialize (rd_count,
1289  rd,
1290  rlc->rd_ser_len,
1291  rlc->res_rd))
1292  {
1293  GNUNET_break (0);
1294  GNUNET_free (rlc->res_rd);
1295  rlc->res_rd = NULL;
1296  rlc->res_rd_count = 0;
1297  rlc->rd_ser_len = 0;
1298  rlc->found = GNUNET_NO;
1299  return;
1300  }
1301  }
1302 }
GNUNET_NETWORK_STRUCT_END ssize_t GNUNET_GNSRECORD_records_get_size(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Calculate how many bytes we will need to serialize the given records.
#define GNUNET_GNS_EMPTY_LABEL_AT
String we use to indicate an empty label (top-level entry in the zone).
ssize_t GNUNET_GNSRECORD_records_serialize(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, size_t dest_size, char *dest)
Serialize the given records to the given destination buffer.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Closure for lookup_it().
This is a private record of this peer and it should thus not be handed out to other peers...
unsigned int res_rd_count
FIXME.
struct GNUNET_GNSRECORD_Data * nick
FIXME.
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
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.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsclient sending the message
ll_msgmessage of type struct LabelLookupMessage
Returns
GNUNET_OK if ll_msg is well-formed

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

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

1314 {
1315  uint32_t name_len;
1316  size_t src_size;
1317 
1318  (void) cls;
1319  name_len = ntohl (ll_msg->label_len);
1320  src_size = ntohs (ll_msg->gns_header.header.size);
1321  if (name_len != src_size - sizeof(struct LabelLookupMessage))
1322  {
1323  GNUNET_break (0);
1324  return GNUNET_SYSERR;
1325  }
1327  return GNUNET_OK;
1328 }
uint32_t label_len
Length of the name.
Definition: namestore.h:132
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_MessageHeader header
header.type will be GNUNET_MESSAGE_TYPE_NAMESTORE_* header.size will be message size ...
Definition: namestore.h:46
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP.
Definition: namestore.h:127
Lookup a label.
Definition: namestore.h:122

◆ 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
clsclient sending the message
ll_msgmessage of type struct LabelLookupMessage

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

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

1339 {
1340  struct NamestoreClient *nc = cls;
1341  struct GNUNET_MQ_Envelope *env;
1342  struct LabelLookupResponseMessage *llr_msg;
1343  struct RecordLookupContext rlc;
1344  const char *name_tmp;
1345  char *res_name;
1346  char *conv_name;
1347  uint32_t name_len;
1348  int res;
1349 
1350  name_len = ntohl (ll_msg->label_len);
1351  name_tmp = (const char *) &ll_msg[1];
1354  "Received NAMESTORE_RECORD_LOOKUP message for name `%s'\n",
1355  name_tmp);
1356 
1357  conv_name = GNUNET_GNSRECORD_string_to_lowercase (name_tmp);
1358  if (NULL == conv_name)
1359  {
1361  "Error converting name `%s'\n",
1362  name_tmp);
1364  return;
1365  }
1366  rlc.label = conv_name;
1367  rlc.found = GNUNET_NO;
1368  rlc.res_rd_count = 0;
1369  rlc.res_rd = NULL;
1370  rlc.rd_ser_len = 0;
1371  rlc.nick = get_nick_record (&ll_msg->zone);
1373  &ll_msg->zone,
1374  conv_name,
1375  &lookup_it,
1376  &rlc);
1377  GNUNET_free (conv_name);
1378  env =
1379  GNUNET_MQ_msg_extra (llr_msg,
1380  name_len + rlc.rd_ser_len,
1382  llr_msg->gns_header.r_id = ll_msg->gns_header.r_id;
1383  llr_msg->private_key = ll_msg->zone;
1384  llr_msg->name_len = htons (name_len);
1385  llr_msg->rd_count = htons (rlc.res_rd_count);
1386  llr_msg->rd_len = htons (rlc.rd_ser_len);
1387  res_name = (char *) &llr_msg[1];
1388  if ((GNUNET_YES == rlc.found) && (GNUNET_OK == res))
1389  llr_msg->found = ntohs (GNUNET_YES);
1390  else
1391  llr_msg->found = ntohs (GNUNET_NO);
1392  GNUNET_memcpy (&llr_msg[1], name_tmp, name_len);
1393  GNUNET_memcpy (&res_name[name_len], rlc.res_rd, rlc.rd_ser_len);
1394  GNUNET_MQ_send (nc->mq, env);
1395  GNUNET_free (rlc.res_rd);
1396 }
struct GNUNET_IDENTITY_PrivateKey private_key
The private key of the authority.
Definition: namestore.h:179
struct GNUNET_MQ_Handle * mq
Message queue for transmission to client.
char * GNUNET_GNSRECORD_string_to_lowercase(const char *src)
Convert a UTF-8 string to UTF-8 lowercase.
uint32_t label_len
Length of the name.
Definition: namestore.h:132
uint16_t rd_len
Length of serialized record data.
Definition: namestore.h:163
uint32_t r_id
Request ID in NBO.
Definition: namestore.h:51
uint16_t rd_count
Number of records contained.
Definition: namestore.h:168
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
void * cls
Closure to pass to all plugin functions.
struct GNUNET_IDENTITY_PrivateKey zone
The private key of the zone to look up in.
Definition: namestore.h:137
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
A namestore client.
Closure for 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)
Function called by the namestore plugin when we are trying to lookup a record as part of handle_recor...
uint16_t name_len
Name length.
Definition: namestore.h:158
struct GNUNET_SERVICE_Client * client
The client.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2325
static int res
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
int(* lookup_records)(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
Lookup records in the datastore for which we are the authority.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
uint16_t found
Was the label found in the database?? GNUNET_YES or GNUNET_NO.
Definition: namestore.h:174
#define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE
Service to client: lookup label.
static struct GNUNET_GNSRECORD_Data * get_nick_record(const struct GNUNET_IDENTITY_PrivateKey *zone)
Return the NICK record for the zone (if it exists).
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE.
Definition: namestore.h:153
static struct GNUNET_NAMESTORE_PluginFunctions * GSN_database
Database handle.
#define GNUNET_log(kind,...)
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP.
Definition: namestore.h:127
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2244
Lookup a label.
Definition: namestore.h:148
#define GNUNET_free(ptr)
Wrapper around free.
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
clsclient sending the message
rp_msgmessage of type struct RecordStoreMessage
Returns
GNUNET_OK if rp_msg is well-formed

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

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

1408 {
1409  size_t name_len;
1410  size_t msg_size;
1411  size_t msg_size_exp;
1412  size_t rd_ser_len;
1413  const char *name_tmp;
1414 
1415  (void) cls;
1416  name_len = ntohs (rp_msg->name_len);
1417  msg_size = ntohs (rp_msg->gns_header.header.size);
1418  rd_ser_len = ntohs (rp_msg->rd_len);
1419  msg_size_exp = sizeof(struct RecordStoreMessage) + name_len + rd_ser_len;
1420  if (msg_size != msg_size_exp)
1421  {
1422  GNUNET_break (0);
1423  return GNUNET_SYSERR;
1424  }
1425  if ((0 == name_len) || (name_len > MAX_NAME_LEN))
1426  {
1427  GNUNET_break (0);
1428  return GNUNET_SYSERR;
1429  }
1430  name_tmp = (const char *) &rp_msg[1];
1431  if ('\0' != name_tmp[name_len - 1])
1432  {
1433  GNUNET_break (0);
1434  return GNUNET_SYSERR;
1435  }
1436  return GNUNET_OK;
1437 }
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE.
Definition: namestore.h:63
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_MessageHeader header
header.type will be GNUNET_MESSAGE_TYPE_NAMESTORE_* header.size will be message size ...
Definition: namestore.h:46
uint16_t rd_len
Length of serialized record data.
Definition: namestore.h:78
uint16_t name_len
Name length.
Definition: namestore.h:73
Store a record to the namestore (as authority).
Definition: namestore.h:58
#define MAX_NAME_LEN
Maximum length of any name, including 0-termination.
Definition: namecache.h:33

◆ 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
clsclient sending the message
rp_msgmessage of type struct RecordStoreMessage

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

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

1448 {
1449  struct NamestoreClient *nc = cls;
1450  size_t name_len;
1451  size_t rd_ser_len;
1452  uint32_t rid;
1453  const char *name_tmp;
1454  char *conv_name;
1455  const char *rd_ser;
1456  unsigned int rd_count;
1457  int res;
1458  struct StoreActivity *sa;
1459 
1461  "Received NAMESTORE_RECORD_STORE message\n");
1462  rid = ntohl (rp_msg->gns_header.r_id);
1463  name_len = ntohs (rp_msg->name_len);
1464  rd_count = ntohs (rp_msg->rd_count);
1465  rd_ser_len = ntohs (rp_msg->rd_len);
1466  GNUNET_break (0 == ntohs (rp_msg->reserved));
1467  name_tmp = (const char *) &rp_msg[1];
1468  rd_ser = &name_tmp[name_len];
1469  {
1470  struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)];
1471 
1472  if (GNUNET_OK !=
1473  GNUNET_GNSRECORD_records_deserialize (rd_ser_len, rd_ser, rd_count, rd))
1474  {
1475  GNUNET_break (0);
1477  return;
1478  }
1479 
1480  /* Extracting and converting private key */
1481  conv_name = GNUNET_GNSRECORD_string_to_lowercase (name_tmp);
1482  if (NULL == conv_name)
1483  {
1485  "Error converting name `%s'\n",
1486  name_tmp);
1488  return;
1489  }
1491  "Well-formed store requests received",
1492  1,
1493  GNUNET_NO);
1495  "Creating %u records for name `%s'\n",
1496  (unsigned int) rd_count,
1497  conv_name);
1498  if ((0 == rd_count) &&
1500  &rp_msg->private_key,
1501  conv_name,
1502  NULL,
1503  0)))
1504  {
1505  /* This name does not exist, so cannot be removed */
1507  "Name `%s' does not exist, no deletion required\n",
1508  conv_name);
1509  res = GNUNET_NO;
1510  }
1511  else
1512  {
1513  /* remove "NICK" records, unless this is for the
1514  #GNUNET_GNS_EMPTY_LABEL_AT label */
1515  struct GNUNET_GNSRECORD_Data rd_clean[GNUNET_NZL (rd_count)];
1516  unsigned int rd_clean_off;
1517  int have_nick;
1518 
1519  rd_clean_off = 0;
1520  have_nick = GNUNET_NO;
1521  for (unsigned int i = 0; i < rd_count; i++)
1522  {
1523  rd_clean[rd_clean_off] = rd[i];
1524  if ((0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT, conv_name)) ||
1526  rd_clean_off++;
1527 
1528  if ((0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT, conv_name)) &&
1529  (GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type))
1530  {
1531  cache_nick (&rp_msg->private_key, &rd[i]);
1532  have_nick = GNUNET_YES;
1533  }
1534  }
1535  if ((0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT, conv_name)) &&
1536  (GNUNET_NO == have_nick))
1537  {
1538  /* remove nick record from cache, in case we have one there */
1539  cache_nick (&rp_msg->private_key, NULL);
1540  }
1542  &rp_msg->private_key,
1543  conv_name,
1544  rd_clean_off,
1545  rd_clean);
1546  }
1547 
1548  if (GNUNET_OK != res)
1549  {
1550  /* store not successful, not need to tell monitors */
1551  send_store_response (nc, res, rid);
1553  GNUNET_free (conv_name);
1554  return;
1555  }
1556 
1557  sa = GNUNET_malloc (sizeof(struct StoreActivity)
1558  + ntohs (rp_msg->gns_header.header.size));
1560  sa->nc = nc;
1561  sa->rsm = (const struct RecordStoreMessage *) &sa[1];
1562  GNUNET_memcpy (&sa[1], rp_msg, ntohs (rp_msg->gns_header.header.size));
1563  sa->zm_pos = monitor_head;
1564  sa->conv_name = conv_name;
1566  }
1567 }
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE.
Definition: namestore.h:63
char * GNUNET_GNSRECORD_string_to_lowercase(const char *src)
Convert a UTF-8 string to UTF-8 lowercase.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_GNS_EMPTY_LABEL_AT
String we use to indicate an empty label (top-level entry in the zone).
uint32_t r_id
Request ID in NBO.
Definition: namestore.h:51
static struct ZoneMonitor * monitor_head
First active zone monitor.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct ZoneMonitor * zm_pos
Next zone monitor that still needs to be notified about this PUT.
int GNUNET_GNSRECORD_records_deserialize(size_t len, const char *src, unsigned int rd_count, struct GNUNET_GNSRECORD_Data *dest)
Deserialize the given records to the given destination.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_GNSRECORD_TYPE_NICK
Record type for GNS nick names ("NICK").
uint16_t reserved
always zero (for alignment)
Definition: namestore.h:88
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void * cls
Closure to pass to all plugin functions.
struct GNUNET_MessageHeader header
header.type will be GNUNET_MESSAGE_TYPE_NAMESTORE_* header.size will be message size ...
Definition: namestore.h:46
uint16_t rd_len
Length of serialized record data.
Definition: namestore.h:78
A namestore client.
static void continue_store_activity(struct StoreActivity *sa)
Continue processing the sa.
struct NamestoreClient * nc
Which client triggered the store activity?
uint16_t name_len
Name length.
Definition: namestore.h:73
struct GNUNET_SERVICE_Client * client
The client.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2325
static int res
uint16_t rd_count
Number of records contained.
Definition: namestore.h:83
char * conv_name
Label nicely canonicalized (lower case).
struct GNUNET_IDENTITY_PrivateKey private_key
The private key of the authority.
Definition: namestore.h:93
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
int(* lookup_records)(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
Lookup records in the datastore for which we are the authority.
static struct StoreActivity * sa_tail
Tail of DLL of monitor-blocked store activities.
static struct GNUNET_STATISTICS_Handle * statistics
Handle to the statistics service.
Information for an ongoing handle_record_store() operation.
#define GNUNET_NZL(l)
Macro used to avoid using 0 for the length of a variable-size array (Non-Zero-Length).
Store a record to the namestore (as authority).
Definition: namestore.h:58
int(* store_records)(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Store a record in the datastore for which we are the authority.
static void send_store_response(struct NamestoreClient *nc, int res, uint32_t rid)
Send response to the store request to the client.
uint32_t record_type
Type of the GNS/DNS record.
static struct StoreActivity * sa_head
Head of DLL of monitor-blocked store activities.
static struct GNUNET_NAMESTORE_PluginFunctions * GSN_database
Database handle.
#define GNUNET_log(kind,...)
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.
const struct RecordStoreMessage * rsm
Copy of the original store message (as data fields in rd will point into it!).
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2244
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsstruct ZoneToNameCtx *
seqsequence number of the record, MUST NOT BE ZERO
zone_keythe zone key
namename
rd_countnumber of records in rd
rdrecord data

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

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

Referenced by handle_zone_to_name().

1612 {
1613  struct ZoneToNameCtx *ztn_ctx = cls;
1614  struct GNUNET_MQ_Envelope *env;
1615  struct ZoneToNameResponseMessage *ztnr_msg;
1616  int16_t res;
1617  size_t name_len;
1618  ssize_t rd_ser_len;
1619  size_t msg_size;
1620  char *name_tmp;
1621  char *rd_tmp;
1622 
1623  GNUNET_assert (0 != seq);
1625  "Found result for zone-to-name lookup: `%s'\n",
1626  name);
1627  res = GNUNET_YES;
1628  name_len = (NULL == name) ? 0 : strlen (name) + 1;
1629  rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
1630  if (rd_ser_len < 0)
1631  {
1632  GNUNET_break (0);
1633  ztn_ctx->success = GNUNET_SYSERR;
1634  return;
1635  }
1636  msg_size = sizeof(struct ZoneToNameResponseMessage) + name_len + rd_ser_len;
1637  if (msg_size >= GNUNET_MAX_MESSAGE_SIZE)
1638  {
1639  GNUNET_break (0);
1640  ztn_ctx->success = GNUNET_SYSERR;
1641  return;
1642  }
1643  env =
1644  GNUNET_MQ_msg_extra (ztnr_msg,
1645  name_len + rd_ser_len,
1647  ztnr_msg->gns_header.header.size = htons (msg_size);
1648  ztnr_msg->gns_header.r_id = htonl (ztn_ctx->rid);
1649  ztnr_msg->res = htons (res);
1650  ztnr_msg->rd_len = htons (rd_ser_len);
1651  ztnr_msg->rd_count = htons (rd_count);
1652  ztnr_msg->name_len = htons (name_len);
1653  ztnr_msg->zone = *zone_key;
1654  name_tmp = (char *) &ztnr_msg[1];
1655  GNUNET_memcpy (name_tmp, name, name_len);
1656  rd_tmp = &name_tmp[name_len];
1657  GNUNET_assert (
1658  rd_ser_len ==
1659  GNUNET_GNSRECORD_records_serialize (rd_count, rd, rd_ser_len, rd_tmp));
1660  ztn_ctx->success = GNUNET_OK;
1661  GNUNET_MQ_send (ztn_ctx->nc->mq, env);
1662 }
GNUNET_NETWORK_STRUCT_END ssize_t GNUNET_GNSRECORD_records_get_size(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Calculate how many bytes we will need to serialize the given records.
struct GNUNET_MQ_Handle * mq
Message queue for transmission to client.
struct NamestoreClient * nc
Namestore client.
#define GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE
Service to client: result of zone-to-name lookup.
ssize_t GNUNET_GNSRECORD_records_serialize(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, size_t dest_size, char *dest)
Serialize the given records to the given destination buffer.
uint32_t r_id
Request ID in NBO.
Definition: namestore.h:51
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint16_t name_len
Length of the name.
Definition: namestore.h:223
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
int16_t res
result in NBO: GNUNET_OK on success, GNUNET_NO if there were no results, GNUNET_SYSERR on error ...
Definition: namestore.h:239
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
int success
Set to GNUNET_OK on success, GNUNET_SYSERR on error.
uint16_t rd_count
Number of records contained.
Definition: namestore.h:233
struct GNUNET_MessageHeader header
header.type will be GNUNET_MESSAGE_TYPE_NAMESTORE_* header.size will be message size ...
Definition: namestore.h:46
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
static int res
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE.
Definition: namestore.h:218
Context for record remove operations passed from handle_zone_to_name to handle_zone_to_name_it as clo...
Respone for zone to name lookup.
Definition: namestore.h:213
struct GNUNET_IDENTITY_PrivateKey zone
The private key of the zone that contained the name.
Definition: namestore.h:244
const char * name
#define GNUNET_log(kind,...)
uint16_t rd_len
Length of serialized record data.
Definition: namestore.h:228
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
uint32_t rid
Request id (to be used in the response to the client).
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
clsclient client sending the message
ztn_msgmessage of type 'struct ZoneToNameMessage'

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

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

1673 {
1674  struct NamestoreClient *nc = cls;
1675  struct ZoneToNameCtx ztn_ctx;
1676  struct GNUNET_MQ_Envelope *env;
1677  struct ZoneToNameResponseMessage *ztnr_msg;
1678 
1679  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_TO_NAME message\n");
1680  ztn_ctx.rid = ntohl (ztn_msg->gns_header.r_id);
1681  ztn_ctx.nc = nc;
1682  ztn_ctx.success = GNUNET_NO;
1684  &ztn_msg->zone,
1685  &ztn_msg->value_zone,
1687  &ztn_ctx))
1688  {
1689  /* internal error, hang up instead of signalling something
1690  that might be wrong */
1691  GNUNET_break (0);
1693  return;
1694  }
1695  if (GNUNET_NO == ztn_ctx.success)
1696  {
1697  /* no result found, send empty response */
1699  "Found no result for zone-to-name lookup.\n");
1700  env = GNUNET_MQ_msg (ztnr_msg,
1702  ztnr_msg->gns_header.r_id = ztn_msg->gns_header.r_id;
1703  ztnr_msg->res = htons (GNUNET_NO);
1704  GNUNET_MQ_send (nc->mq, env);
1705  }
1707 }
struct GNUNET_MQ_Handle * mq
Message queue for transmission to client.
#define GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE
Service to client: result of zone-to-name lookup.
uint32_t r_id
Request ID in NBO.
Definition: namestore.h:51
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME.
Definition: namestore.h:196
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
int16_t res
result in NBO: GNUNET_OK on success, GNUNET_NO if there were no results, GNUNET_SYSERR on error ...
Definition: namestore.h:239
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void * cls
Closure to pass to all plugin functions.
A namestore client.
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.
struct GNUNET_SERVICE_Client * client
The client.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2325
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
int(* zone_to_name)(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const struct GNUNET_IDENTITY_PublicKey *value_zone, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
Look for an existing PKEY delegation record for a given public key.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE.
Definition: namestore.h:218
Context for record remove operations passed from handle_zone_to_name to handle_zone_to_name_it as clo...
Respone for zone to name lookup.
Definition: namestore.h:213
static struct GNUNET_NAMESTORE_PluginFunctions * GSN_database
Database handle.
struct GNUNET_IDENTITY_PublicKey value_zone
The public key of the target zone.
Definition: namestore.h:206
#define GNUNET_log(kind,...)
struct GNUNET_IDENTITY_PrivateKey zone
The private key of the zone to look up in.
Definition: namestore.h:201
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2244
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
clsstruct ZoneIterationProcResult
seqsequence number of the record, MUST NOT BE ZERO
zone_keythe zone key
namename
rd_countnumber of records for this name
rdrecord data

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

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

Referenced by run_zone_iteration_round().

1745 {
1746  struct ZoneIterationProcResult *proc = cls;
1747  int do_refresh_block;
1748 
1749  GNUNET_assert (0 != seq);
1750  if ((NULL == zone_key) && (NULL == name))
1751  {
1752  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iteration done\n");
1753  return;
1754  }
1755  if ((NULL == zone_key) || (NULL == name))
1756  {
1757  /* what is this!? should never happen */
1758  GNUNET_break (0);
1759  return;
1760  }
1761  if (0 == proc->limit)
1762  {
1763  /* what is this!? should never happen */
1764  GNUNET_break (0);
1765  return;
1766  }
1767  proc->limit--;
1768  proc->zi->seq = seq;
1769  send_lookup_response (proc->zi->nc,
1770  proc->zi->request_id,
1771  zone_key,
1772  name,
1773  rd_count,
1774  rd);
1775 
1776 
1777  do_refresh_block = GNUNET_NO;
1778  for (unsigned int i = 0; i < rd_count; i++)
1779  if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
1780  {
1781  do_refresh_block = GNUNET_YES;
1782  break;
1783  }
1784  if (GNUNET_YES == do_refresh_block)
1785  refresh_block (NULL, proc->zi, 0, zone_key, name, rd_count, rd);
1786 }
uint64_t limit
Number of results left to be returned in this iteration.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint64_t seq
Last sequence number in the zone iteration used to address next result of the zone iteration in the s...
struct ZoneIteration * zi
The zone iteration handle.
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 notificat...
uint32_t request_id
The operation id fot the zone iteration in the response for the client.
const char * name
#define GNUNET_log(kind,...)
This expiration time of the record is a relative time (not an absolute time).
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 (encryp...
struct NamestoreClient * nc
Namestore client which intiated this zone iteration.
Context for record remove operations passed from run_zone_iteration_round to zone_iterate_proc as clo...
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
zizone iterator to process
limitnumber of results to return in one pass

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

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

Referenced by handle_iteration_next(), and handle_iteration_start().

1797 {
1798  struct ZoneIterationProcResult proc;
1799  struct GNUNET_TIME_Absolute start;
1801 
1802  memset (&proc, 0, sizeof(proc));
1804  "Asked to return up to %llu records at position %llu\n",
1805  (unsigned long long) limit,
1806  (unsigned long long) zi->seq);
1807  proc.zi = zi;
1808  proc.limit = limit;
1812  (GNUNET_YES == GNUNET_is_zero (&zi->zone))
1813  ? NULL
1814  : &zi->zone,
1815  zi->seq,
1816  limit,
1818  &proc));
1820  duration = GNUNET_TIME_relative_divide (duration, limit - proc.limit);
1822  "NAMESTORE iteration delay (μs/record)",
1823  duration.rel_value_us,
1824  GNUNET_NO);
1825  if (0 == proc.limit)
1827  "Returned %llu results, more results available\n",
1828  (unsigned long long) limit);
1829  zi->send_end = (0 != proc.limit);
1830  if (0 == zi->cache_ops)
1832 }
int send_end
Set to GNUNET_YES if the last iteration exhausted the limit set by the client and we should send the ...
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void * cls
Closure to pass to all plugin functions.
uint64_t seq
Last sequence number in the zone iteration used to address next result of the zone iteration in the s...
struct GNUNET_IDENTITY_PrivateKey zone
Key of the zone we are iterating over.
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.
unsigned int cache_ops
Number of pending cache operations triggered by this zone iteration which we need to wait for before ...
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static struct GNUNET_STATISTICS_Handle * statistics
Handle to the statistics service.
#define GNUNET_is_zero(a)
Check that memory in a is all zeros.
static struct GNUNET_NAMESTORE_PluginFunctions * GSN_database
Database handle.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:375
#define GNUNET_log(kind,...)
static struct GNUNET_TIME_Relative duration
How long do we run the test?
struct GNUNET_TIME_Relative GNUNET_TIME_relative_divide(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Divide relative time by a given factor.
Definition: time.c:527
Time for absolute times used by GNUnet, in microseconds.
int(* iterate_records)(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, uint64_t serial, uint64_t limit, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
Iterate over the results for a particular zone in the datastore.
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 ...
Time for relative time used by GNUnet, in microseconds.
Context for record remove operations passed from run_zone_iteration_round to zone_iterate_proc as clo...
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
clsthe client sending the message
zis_msgmessage from the client

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

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

1844 {
1845  struct NamestoreClient *nc = cls;
1846  struct ZoneIteration *zi;
1847 
1849  "Received ZONE_ITERATION_START message\n");
1850  zi = GNUNET_new (struct ZoneIteration);
1851  zi->request_id = ntohl (zis_msg->gns_header.r_id);
1852  zi->offset = 0;
1853  zi->nc = nc;
1854  zi->zone = zis_msg->zone;
1855 
1857  run_zone_iteration_round (zi, 1);
1858 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
uint32_t r_id
Request ID in NBO.
Definition: namestore.h:51
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_IDENTITY_PrivateKey zone
Zone key.
Definition: namestore.h:355
static void run_zone_iteration_round(struct ZoneIteration *zi, uint64_t limit)
Perform the next round of the zone iteration.
struct ZoneIteration * op_head
Head of the DLL of Zone iteration operations in progress initiated by this client.
struct GNUNET_IDENTITY_PrivateKey zone
Key of the zone we are iterating over.
A namestore client.
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START.
Definition: namestore.h:350
uint32_t offset
Offset of the zone iteration used to address next result of the zone iteration in the store...
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
uint32_t request_id
The operation id fot the zone iteration in the response for the client.
struct ZoneIteration * op_tail
Tail of the DLL of Zone iteration operations in progress initiated by this client.
A namestore iteration operation.
#define GNUNET_log(kind,...)
struct NamestoreClient * nc
Namestore client which intiated this zone iteration.
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
clsthe client sending the message
zis_msgmessage from the client

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

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

1870 {
1871  struct NamestoreClient *nc = cls;
1872  struct ZoneIteration *zi;
1873  uint32_t rid;
1874 
1876  "Received ZONE_ITERATION_STOP message\n");
1877  rid = ntohl (zis_msg->gns_header.r_id);
1878  for (zi = nc->op_head; NULL != zi; zi = zi->next)
1879  if (zi->request_id == rid)
1880  break;
1881  if (NULL == zi)
1882  {
1883  GNUNET_break (0);
1885  return;
1886  }
1888  GNUNET_free (zi);
1890 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
uint32_t r_id
Request ID in NBO.
Definition: namestore.h:51
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct ZoneIteration * op_head
Head of the DLL of Zone iteration operations in progress initiated by this client.
A namestore client.
struct ZoneIteration * next
Next element in the DLL.
struct GNUNET_SERVICE_Client * client
The client.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2325
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
uint32_t request_id
The operation id fot the zone iteration in the response for the client.
struct ZoneIteration * op_tail
Tail of the DLL of Zone iteration operations in progress initiated by this client.
A namestore iteration operation.
#define GNUNET_log(kind,...)
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2244
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP.
Definition: namestore.h:386
#define GNUNET_free(ptr)
Wrapper around free.
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
clsthe client sending the message
messagemessage from the client

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

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

1902 {
1903  struct NamestoreClient *nc = cls;
1904  struct ZoneIteration *zi;
1905  uint32_t rid;
1906  uint64_t limit;
1907 
1909  "Received ZONE_ITERATION_NEXT message\n");
1911  "Iteration NEXT messages received",
1912  1,
1913  GNUNET_NO);
1914  rid = ntohl (zis_msg->gns_header.r_id);
1915  limit = GNUNET_ntohll (zis_msg->limit);
1916  for (zi = nc->op_head; NULL != zi; zi = zi->next)
1917  if (zi->request_id == rid)
1918  break;
1919  if (NULL == zi)
1920  {
1921  GNUNET_break (0);
1923  return;
1924  }
1925  run_zone_iteration_round (zi, limit);
1926 }
uint32_t r_id
Request ID in NBO.
Definition: namestore.h:51
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static void run_zone_iteration_round(struct ZoneIteration *zi, uint64_t limit)
Perform the next round of the zone iteration.
struct ZoneIteration * op_head
Head of the DLL of Zone iteration operations in progress initiated by this client.
A namestore client.
struct ZoneIteration * next
Next element in the DLL.
struct GNUNET_SERVICE_Client * client
The client.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2325
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
uint32_t request_id
The operation id fot the zone iteration in the response for the client.
static struct GNUNET_STATISTICS_Handle * statistics
Handle to the statistics service.
A namestore iteration operation.
#define GNUNET_log(kind,...)
uint64_t limit
Number of records to return to the iterator in one shot (before GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_IT...
Definition: namestore.h:374
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT.
Definition: namestore.h:367
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
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 1935 of file gnunet-service-namestore.c.

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

Referenced by handle_monitor_next(), and monitor_sync().

1936 {
1937  struct StoreActivity *sa = sa_head;
1938 
1939  while ((NULL != sa) && (zm->limit > zm->iteration_cnt))
1940  {
1941  struct StoreActivity *sn = sa->next;
1942 
1943  if (sa->zm_pos == zm)
1945  sa = sn;
1946  }
1947  if (zm->limit > zm->iteration_cnt)
1948  {
1949  zm->sa_waiting = GNUNET_NO;
1950  if (NULL != zm->sa_wait_warning)
1951  {
1953  zm->sa_wait_warning = NULL;
1954  }
1955  }
1956  else if (GNUNET_YES == zm->sa_waiting)
1957  {
1959  if (NULL != zm->sa_wait_warning)
1961  zm->sa_wait_warning =
1964  zm);
1965  }
1966 }
uint64_t iteration_cnt
How many more requests may we receive from the iterator before it is at the limit we gave it...
struct ZoneMonitor * zm_pos
Next zone monitor that still needs to be notified about this PUT.
struct GNUNET_TIME_Absolute sa_waiting_start
Since when are we blocked on this monitor?
struct StoreActivity * next
Kept in a DLL.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
#define MONITOR_STALL_WARN_DELAY
If a monitor takes more than 1 minute to process an event, print a warning.
static void continue_store_activity(struct StoreActivity *sa)
Continue processing the sa.
uint64_t limit
Current limit of how many more messages we are allowed to queue to this monitor.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
Information for an ongoing handle_record_store() operation.
static struct StoreActivity * sa_head
Head of DLL of monitor-blocked store activities.
struct GNUNET_SCHEDULER_Task * sa_wait_warning
Task to warn about slow monitors.
int sa_waiting
Is there a store activity waiting for this monitor? We only raise the flag when it happens and search...
static void warn_monitor_slow(void *cls)
Print a warning that one of our monitors is no longer reacting.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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
zmmonitor that is now in sync

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

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

Referenced by handle_monitor_start(), and monitor_iteration_next().

1976 {
1977  struct GNUNET_MQ_Envelope *env;
1978  struct GNUNET_MessageHeader *sync;
1979 
1981  GNUNET_MQ_send (zm->nc->mq, env);
1982  /* mark iteration done */
1984  zm->iteration_cnt = 0;
1985  if ((zm->limit > 0) && (zm->sa_waiting))
1986  monitor_unblock (zm);
1987 }
struct GNUNET_MQ_Handle * mq
Message queue for transmission to client.
struct NamestoreClient * nc
Namestore client which intiated this zone monitor.
uint64_t iteration_cnt
How many more requests may we receive from the iterator before it is at the limit we gave it...
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
uint64_t limit
Current limit of how many more messages we are allowed to queue to this monitor.
int in_first_iteration
Are we (still) in the initial iteration pass?
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC
Service to client: you&#39;re now in sync.
Header for all communications.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
int sa_waiting
Is there a store activity waiting for this monitor? We only raise the flag when it happens and search...
static void monitor_unblock(struct ZoneMonitor *zm)
Function called when the monitor is ready for more data, and we should thus unblock PUT operations th...
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
clszone monitor that does its initial iteration

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

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

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

2075 {
2076  struct ZoneMonitor *zm = cls;
2077  int ret;
2078 
2079  zm->task = NULL;
2080  GNUNET_assert (0 == zm->iteration_cnt);
2081  if (zm->limit > 16)
2082  zm->iteration_cnt = zm->limit / 2; /* leave half for monitor events */
2083  else
2084  zm->iteration_cnt = zm->limit; /* use it all */
2086  (GNUNET_YES == GNUNET_is_zero (&zm->zone))
2087  ? NULL
2088  : &zm->zone,
2089  zm->seq,
2090  zm->iteration_cnt,
2092  zm);
2093  if (GNUNET_SYSERR == ret)
2094  {
2096  return;
2097  }
2098  if (GNUNET_NO == ret)
2099  {
2100  /* empty zone */
2101  monitor_sync (zm);
2102  return;
2103  }
2104 }
struct NamestoreClient * nc
Namestore client which intiated this zone monitor.
uint64_t iteration_cnt
How many more requests may we receive from the iterator before it is at the limit we gave it...
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.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint64_t seq
Last sequence number in the zone iteration used to address next result of the zone iteration in the s...
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static struct GNUNET_NAMESTORE_ZoneMonitor * zm
Monitor handle.
void * cls
Closure to pass to all plugin functions.
struct GNUNET_IDENTITY_PrivateKey zone
Private key of the zone.
static void monitor_sync(struct ZoneMonitor *zm)
Send &#39;sync&#39; message to zone monitor, we&#39;re now in sync.
uint64_t limit
Current limit of how many more messages we are allowed to queue to this monitor.
struct GNUNET_SERVICE_Client * client
The client.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2325
struct GNUNET_SCHEDULER_Task * task
Task active during initial iteration.
#define GNUNET_is_zero(a)
Check that memory in a is all zeros.
static struct GNUNET_NAMESTORE_PluginFunctions * GSN_database
Database handle.
int(* iterate_records)(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, uint64_t serial, uint64_t limit, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
Iterate over the results for a particular zone in the datastore.
A namestore monitor.
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
clsa 'struct ZoneMonitor *' with information about the monitor
seqsequence number of the record, MUST NOT BE ZERO
zone_keyzone key of the zone
namename
rd_countnumber of records in rd
rdarray of records

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

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

Referenced by monitor_iteration_next().

2016 {
2017  struct ZoneMonitor *zm = cls;
2018 
2019  GNUNET_assert (0 != seq);
2020  zm->seq = seq;
2021  GNUNET_assert (NULL != name);
2023  "Monitor notifications sent",
2024  1,
2025  GNUNET_NO);
2026  zm->limit--;
2027  zm->iteration_cnt--;
2028  send_lookup_response (zm->nc, 0, zone_key, name, rd_count, rd);
2029  if ((0 == zm->iteration_cnt) && (0 != zm->limit))
2030  {
2031  /* We are done with the current iteration batch, AND the
2032  client would right now accept more, so go again! */
2033  GNUNET_assert (NULL == zm->task);
2035  }
2036 }
struct NamestoreClient * nc
Namestore client which intiated this zone monitor.
uint64_t iteration_cnt
How many more requests may we receive from the iterator before it is at the limit we gave it...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint64_t seq
Last sequence number in the zone iteration used to address next result of the zone iteration in the s...
static struct GNUNET_NAMESTORE_ZoneMonitor * zm
Monitor handle.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static void monitor_iteration_next(void *cls)
Obtain the next datum during the zone monitor&#39;s zone initial iteration.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
uint64_t limit
Current limit of how many more messages we are allowed to queue to this monitor.
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 notificat...
struct GNUNET_SCHEDULER_Task * task
Task active during initial iteration.
static struct GNUNET_STATISTICS_Handle * statistics
Handle to the statistics service.
const char * name
A namestore monitor.
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
clsthe client sending the message
zis_msgmessage from the client

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

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

2047 {
2048  struct NamestoreClient *nc = cls;
2049  struct ZoneMonitor *zm;
2050 
2051  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_MONITOR_START message\n");
2052  zm = GNUNET_new (struct ZoneMonitor);
2053  zm->nc = nc;
2054  zm->zone = zis_msg->zone;
2055  zm->limit = 1;
2056  zm->in_first_iteration = (GNUNET_YES == ntohl (zis_msg->iterate_first));
2061  if (zm->in_first_iteration)
2063  else
2064  monitor_sync (zm);
2065 }
static struct GNUNET_NotificationContext * monitor_nc
Notification context shared by all monitors.
struct GNUNET_MQ_Handle * mq
Message queue for transmission to client.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct NamestoreClient * nc
Namestore client which intiated this zone monitor.
static struct ZoneMonitor * monitor_head
First active zone monitor.
static struct GNUNET_NAMESTORE_ZoneMonitor * zm
Monitor handle.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GNUNET_notification_context_add(struct GNUNET_NotificationContext *nc, struct GNUNET_MQ_Handle *mq)
Add a subscriber to the notification context.
Definition: nc.c:160
static void monitor_iteration_next(void *cls)
Obtain the next datum during the zone monitor&#39;s zone initial iteration.
struct GNUNET_IDENTITY_PrivateKey zone
Zone key.
Definition: namestore.h:314
static struct ZoneMonitor * monitor_tail
Last active zone monitor.
A namestore client.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
struct GNUNET_IDENTITY_PrivateKey zone
Private key of the zone.
static void monitor_sync(struct ZoneMonitor *zm)
Send &#39;sync&#39; message to zone monitor, we&#39;re now in sync.
uint64_t limit
Current limit of how many more messages we are allowed to queue to this monitor.
int in_first_iteration
Are we (still) in the initial iteration pass?
void GNUNET_SERVICE_client_mark_monitor(struct GNUNET_SERVICE_Client *c)
Set the &#39;monitor&#39; flag on this client.
Definition: service.c:2408
struct GNUNET_SERVICE_Client * client
The client.
struct GNUNET_SCHEDULER_Task * task
Task active during initial iteration.
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
uint32_t iterate_first
GNUNET_YES to first iterate over all records, GNUNET_NO to only monitor changes.o ...
Definition: namestore.h:309
#define GNUNET_log(kind,...)
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2244
A namestore monitor.
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
clsthe client sending the message
nmmessage from the client

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

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

2115 {
2116  struct NamestoreClient *nc = cls;
2117  struct ZoneMonitor *zm;
2118  uint64_t inc;
2119 
2120  inc = GNUNET_ntohll (nm->limit);
2122  "Received ZONE_MONITOR_NEXT message with limit %llu\n",
2123  (unsigned long long) inc);
2124  for (zm = monitor_head; NULL != zm; zm = zm->next)
2125  if (zm->nc == nc)
2126  break;
2127  if (NULL == zm)
2128  {
2129  GNUNET_break (0);
2131  return;
2132  }
2134  if (zm->limit + inc < zm->limit)
2135  {
2136  GNUNET_break (0);
2138  return;
2139  }
2140  zm->limit += inc;
2141  if ((zm->in_first_iteration) && (zm->limit == inc))
2142  {
2143  /* We are still iterating, and the previous iteration must
2144  have stopped due to the client's limit, so continue it! */
2145  GNUNET_assert (NULL == zm->task);
2147  }
2148  GNUNET_assert (zm->iteration_cnt <= zm->limit);
2149  if ((zm->limit > zm->iteration_cnt) && (zm->sa_waiting))
2150  {
2151  monitor_unblock (zm);
2152  }
2153  else if (GNUNET_YES == zm->sa_waiting)
2154  {
2155  if (NULL != zm->sa_wait_warning)
2158  zm->sa_wait_warning =
2161  zm);
2162  }
2163 }
struct NamestoreClient * nc
Namestore client which intiated this zone monitor.
uint64_t iteration_cnt
How many more requests may we receive from the iterator before it is at the limit we gave it...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct ZoneMonitor * monitor_head
First active zone monitor.
struct GNUNET_TIME_Absolute sa_waiting_start
Since when are we blocked on this monitor?
static struct GNUNET_NAMESTORE_ZoneMonitor * zm
Monitor handle.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint64_t limit
Number of records to return to the iterator in one shot (before #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_M...
Definition: namestore.h:338
static void monitor_iteration_next(void *cls)
Obtain the next datum during the zone monitor&#39;s zone initial iteration.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
A namestore client.
#define MONITOR_STALL_WARN_DELAY
If a monitor takes more than 1 minute to process an event, print a warning.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
uint64_t limit
Current limit of how many more messages we are allowed to queue to this monitor.
int in_first_iteration
Are we (still) in the initial iteration pass?
struct GNUNET_SERVICE_Client * client
The client.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2325
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
struct GNUNET_SCHEDULER_Task * task
Task active during initial iteration.
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
#define GNUNET_log(kind,...)
struct ZoneMonitor * next
Next element in the DLL.
struct GNUNET_SCHEDULER_Task * sa_wait_warning
Task to warn about slow monitors.
int sa_waiting
Is there a store activity waiting for this monitor? We only raise the flag when it happens and search...
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2244
static void warn_monitor_slow(void *cls)
Print a warning that one of our monitors is no longer reacting.
static void monitor_unblock(struct ZoneMonitor *zm)
Function called when the monitor is ready for more data, and we should thus unblock PUT operations th...
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
A namestore monitor.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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
clsclosure
cfgconfiguration to use
servicethe initialized service

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

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

2177 {
2178  char *database;
2179 
2180  (void) cls;
2181  (void) service;
2182  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting namestore service\n");
2183  cache_keys =
2184  GNUNET_CONFIGURATION_get_value_yesno (cfg, "namestore", "CACHE_KEYS");
2186  GNUNET_CONFIGURATION_get_value_yesno (cfg, "namecache", "DISABLE");
2187  GSN_cfg = cfg;
2190  {
2192  GNUNET_assert (NULL != namecache);
2193  }
2194  /* Loading database plugin */
2196  "namestore",
2197  "database",
2198  &database))
2199  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No database backend configured\n");
2200 
2201  GNUNET_asprintf (&db_lib_name, "libgnunet_plugin_namestore_%s", database);
2203  GNUNET_free (database);
2204  statistics = GNUNET_STATISTICS_create ("namestore", cfg);
2206  if (NULL == GSN_database)
2207  {
2209  "Could not load database backend `%s'\n",
2210  db_lib_name);
2212  return;
2213  }
2214 }
struct GNUNET_NAMECACHE_Handle * GNUNET_NAMECACHE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namecache service.
static char * db_lib_name
Name of the database plugin.
static struct GNUNET_NotificationContext * monitor_nc
Notification context shared by all monitors.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1331
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
static int disable_namecache
Use the namecache? Doing so creates additional cryptographic operations whenever we touch a record...
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
int GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
static struct GNUNET_STATISTICS_Handle * statistics
Handle to the statistics service.
struct GNUNET_NotificationContext * GNUNET_notification_context_create(unsigned int queue_length)
Create a new notification context.
Definition: nc.c:121
static const struct GNUNET_CONFIGURATION_Handle * GSN_cfg
Configuration handle.
static struct GNUNET_NAMESTORE_PluginFunctions * GSN_database
Database handle.
#define GNUNET_log(kind,...)
static void cleanup_task(void *cls)
Task run during shutdown.
void * GNUNET_PLUGIN_load(const char *library_name, void *arg)
Setup plugin (runs the "init" callback and returns whatever "init" returned).
Definition: plugin.c:207
static struct GNUNET_NAMECACHE_Handle * namecache
Namecache handle.
static int cache_keys
Optimize block insertion by caching map of private keys to public keys in memory? ...
int GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

Define "main" method using service macro.

Referenced by run().

Here is the caller graph for this function:

Variable Documentation

◆ nick_cache

struct NickCache nick_cache[16]
static

We cache nick records to reduce DB load.

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

Referenced by cache_nick(), and get_nick_record().

◆ zero

const struct GNUNET_IDENTITY_PrivateKey zero
static

◆ GSN_cfg

const struct GNUNET_CONFIGURATION_Handle* GSN_cfg
static

Configuration handle.

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

◆ statistics

struct GNUNET_STATISTICS_Handle* statistics
static

Handle to the statistics service.

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

◆ namecache

struct GNUNET_NAMECACHE_Handle* namecache
static

Namecache handle.

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

◆ GSN_database

struct GNUNET_NAMESTORE_PluginFunctions* GSN_database
static

Database handle.

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

◆ db_lib_name

char* db_lib_name
static

Name of the database plugin.

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

Referenced by cleanup_task(), and run().

◆ cop_head

struct CacheOperation* cop_head
static

Head of cop DLL.

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

◆ cop_tail

struct CacheOperation* cop_tail
static

Tail of cop DLL.

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

◆ monitor_head

struct ZoneMonitor* monitor_head
static

First active zone monitor.

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

Referenced by handle_record_store().

◆ monitor_tail

struct ZoneMonitor* monitor_tail
static

Last active zone monitor.

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

◆ sa_head

struct StoreActivity* sa_head
static

Head of DLL of monitor-blocked store activities.

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

Referenced by monitor_unblock().

◆ sa_tail

struct StoreActivity* sa_tail
static

Tail of DLL of monitor-blocked store activities.

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

◆ monitor_nc

struct GNUNET_NotificationContext* monitor_nc
static

Notification context shared by all monitors.

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

◆ cache_keys

int cache_keys
static

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

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

Referenced by refresh_block(), and run().