gnunet-service-namecache.c File Reference

namecache for the GNUnet naming system More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet_namecache_service.h"
#include "gnunet_namecache_plugin.h"
#include "gnunet_signatures.h"
#include "namecache.h"

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

Go to the source code of this file.

Data Structures
struct	NamecacheClient
	A namecache client. More...
struct	LookupBlockContext
	Context for name lookups passed from handle_lookup_block to handle_lookup_block_it as closure. More...

Macros
#define	LOG_STRERROR_FILE(kind, syscall, filename)

Functions
static void	cleanup_task (void *cls)
	Task run during shutdown. 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	handle_lookup_block_it (void *cls, const struct GNUNET_GNSRECORD_Block *block)
	A GNUNET_NAMECACHE_BlockCallback for name lookups in handle_lookup_block. More...
static void	handle_lookup_block (void *cls, const struct LookupBlockMessage *ln_msg)
	Handles a GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK message. More...
static int	check_block_cache (void *cls, const struct BlockCacheMessage *rp_msg)
	Check a GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE message. More...
static void	handle_block_cache (void *cls, const struct BlockCacheMessage *rp_msg)
	Handles a GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE message. More...
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *service)
	Process namecache requests. More...
	GNUNET_SERVICE_MAIN ("namecache", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(lookup_block, GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK, struct LookupBlockMessage, NULL), GNUNET_MQ_hd_var_size(block_cache, GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE, struct BlockCacheMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro. More...

Variables
static const struct GNUNET_CONFIGURATION_Handle *	GSN_cfg
	Configuration handle. More...
static struct GNUNET_STATISTICS_Handle *	statistics
	Handle to the statistics service. More...
static struct GNUNET_NAMECACHE_PluginFunctions *	GSN_database
	Database handle. More...
static char *	db_lib_name
	Name of the database plugin. More...

Detailed Description

namecache for the GNUnet naming system

Author

Matthias Wachs

Christian Grothoff

Definition in file gnunet-service-namecache.c.

Macro Definition Documentation

LOG_STRERROR_FILE

#define LOG_STRERROR_FILE	(		kind,
			syscall,
			filename
	)

Value:

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

Definition at line 35 of file gnunet-service-namecache.c.

Function Documentation

cleanup_task()

static void cleanup_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

unused

Definition at line 85 of file gnunet-service-namecache.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Stopping namecache service\n");
  GNUNET_break (NULL ==
                GNUNET_PLUGIN_unload (db_lib_name,
                                      GSN_database));
  GNUNET_free (db_lib_name);
  db_lib_name = NULL;
  if (NULL != statistics)
  {
    GNUNET_STATISTICS_destroy (statistics,
                               GNUNET_NO);
    statistics = NULL;
  }
}

References db_lib_name, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_PLUGIN_unload(), GNUNET_STATISTICS_destroy(), GSN_database, and statistics.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

client_disconnect_cb()

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

static

Called whenever a client is disconnected.

Frees our resources associated with that client.

Parameters

cls	closure
client	identification of the client
app_ctx	the struct NamecacheClient for this client

Definition at line 112 of file gnunet-service-namecache.c.

{
  struct NamecacheClient *nc = app_ctx;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client %p disconnected\n",
              client);
  GNUNET_free (nc);
}

References NamecacheClient::client, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, and nc.

client_connect_cb()

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

static

Add a client to our list of active clients.

Parameters

cls	NULL
client	client to add
mq	queue to talk to client

Returns

internal namecache client structure for this client

Definition at line 134 of file gnunet-service-namecache.c.

{
  struct NamecacheClient *nc;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client %p connected\n",
              client);
  nc = GNUNET_new (struct NamecacheClient);
  nc->client = client;
  nc->mq = mq;
  return nc;
}

References NamecacheClient::client, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, mq, and nc.

handle_lookup_block_it()

static void handle_lookup_block_it ( void *  cls, const struct GNUNET_GNSRECORD_Block *  block  )

static

A GNUNET_NAMECACHE_BlockCallback for name lookups in handle_lookup_block.

Parameters

cls	a struct LookupNameContext * with information about the request
block	the block

Definition at line 180 of file gnunet-service-namecache.c.

{
  struct LookupBlockContext *lnc = cls;
  struct GNUNET_MQ_Envelope *env;
  struct LookupBlockResponseMessage *r;
  size_t bsize;
 
  bsize = GNUNET_GNSRECORD_block_get_size (block);
  env = GNUNET_MQ_msg_extra (r,
                             bsize,
                             GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK_RESPONSE);
  r->gns_header.r_id = htonl (lnc->request_id);
  GNUNET_memcpy (&r[1],
                 block,
                 bsize);
  GNUNET_STATISTICS_update (statistics,
                            "blocks found in cache",
                            1,
                            GNUNET_NO);
  r->expire = GNUNET_TIME_absolute_hton (
    GNUNET_GNSRECORD_block_get_expiration (block));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending NAMECACHE_LOOKUP_BLOCK_RESPONSE message\n");
  GNUNET_MQ_send (lnc->nc->mq,
                  env);
}

References bsize, env, LookupBlockResponseMessage::expire, LookupBlockResponseMessage::gns_header, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_block_get_expiration(), GNUNET_GNSRECORD_block_get_size(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK_RESPONSE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_hton(), NamecacheClient::mq, LookupBlockContext::nc, GNUNET_NAMECACHE_Header::r_id, LookupBlockContext::request_id, and statistics.

Referenced by handle_lookup_block().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_lookup_block()

static void handle_lookup_block ( void *  cls, const struct LookupBlockMessage *  ln_msg  )

static

Handles a GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK message.

Parameters

cls	a struct NamecacheClient *
ln_msg	the inbound message

Definition at line 216 of file gnunet-service-namecache.c.

{
  struct NamecacheClient *nc = cls;
  struct GNUNET_MQ_Envelope *env;
  struct LookupBlockContext lnc;
  struct LookupBlockResponseMessage *zir_end;
  int ret;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received NAMECACHE_LOOKUP_BLOCK message\n");
  GNUNET_STATISTICS_update (statistics,
                            "blocks looked up",
                            1,
                            GNUNET_NO);
  lnc.request_id = ntohl (ln_msg->gns_header.r_id);
  lnc.nc = nc;
  lnc.status = GNUNET_OK;
  if (GNUNET_SYSERR ==
      (ret = GSN_database->lookup_block (GSN_database->cls,
                                         &ln_msg->query,
                                         &handle_lookup_block_it,
                                         &lnc)))
  {
    /* internal error (in database plugin); might be best to just hang up on
       plugin rather than to signal that there are 'no' results, which
       might also be false... */
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (nc->client);
    return;
  }
  if ((0 == ret) || (GNUNET_SYSERR == lnc.status))
  {
    /* no records match at all, generate empty response */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending empty NAMECACHE_LOOKUP_BLOCK_RESPONSE message\n");
    env = GNUNET_MQ_msg (zir_end,
                         GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK_RESPONSE);
    zir_end->gns_header.r_id = ln_msg->gns_header.r_id;
    GNUNET_MQ_send (nc->mq,
                    env);
  }
  GNUNET_SERVICE_client_continue (nc->client);
}

References GNUNET_NAMECACHE_PluginFunctions::cls, env, LookupBlockMessage::gns_header, LookupBlockResponseMessage::gns_header, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK_RESPONSE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GSN_database, handle_lookup_block_it(), GNUNET_NAMECACHE_PluginFunctions::lookup_block, nc, LookupBlockContext::nc, LookupBlockMessage::query, GNUNET_NAMECACHE_Header::r_id, LookupBlockContext::request_id, ret, statistics, and LookupBlockContext::status.

Here is the call graph for this function:

check_block_cache()

static int check_block_cache ( void *  cls, const struct BlockCacheMessage *  rp_msg  )

static

Check a GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE message.

Parameters

cls	our struct NamecacheClient
rp_msg	message to process

Returns

GNUNET_OK (always fine)

Definition at line 270 of file gnunet-service-namecache.c.

{
  return GNUNET_OK;
}

References GNUNET_OK.

handle_block_cache()

static void handle_block_cache ( void *  cls, const struct BlockCacheMessage *  rp_msg  )

static

Handles a GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE message.

Parameters

cls	our struct NamecacheClient
rp_msg	message to process

Definition at line 284 of file gnunet-service-namecache.c.

{
  struct NamecacheClient *nc = cls;
  struct GNUNET_MQ_Envelope *env;
  struct BlockCacheResponseMessage *rpr_msg;
  struct GNUNET_GNSRECORD_Block *block;
  size_t esize;
  int res;
 
  GNUNET_STATISTICS_update (statistics,
                            "blocks cached",
                            1,
                            GNUNET_NO);
  esize = ntohs (rp_msg->gns_header.header.size) - sizeof(struct
                                                          BlockCacheMessage);
  block = GNUNET_malloc (esize);
  memcpy (block, &rp_msg[1], esize);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received NAMECACHE_BLOCK_CACHE message with type %u\n",
              htonl (block->type));
  res = GSN_database->cache_block (GSN_database->cls,
                                   block);
  GNUNET_free (block);
  env = GNUNET_MQ_msg (rpr_msg,
                       GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE_RESPONSE);
  rpr_msg->gns_header.r_id = rp_msg->gns_header.r_id;
  rpr_msg->op_result = htonl (res);
  GNUNET_MQ_send (nc->mq,
                  env);
  GNUNET_SERVICE_client_continue (nc->client);
}

References GNUNET_NAMECACHE_PluginFunctions::cache_block, GNUNET_NAMECACHE_PluginFunctions::cls, env, BlockCacheMessage::gns_header, BlockCacheResponseMessage::gns_header, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE_RESPONSE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GSN_database, GNUNET_NAMECACHE_Header::header, nc, BlockCacheResponseMessage::op_result, GNUNET_NAMECACHE_Header::r_id, res, GNUNET_MessageHeader::size, statistics, and GNUNET_GNSRECORD_Block::type.

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 namecache requests.

Parameters

cls	closure
cfg	configuration to use
service	the initialized service

Definition at line 326 of file gnunet-service-namecache.c.

{
  char *database;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting namecache service\n");
  GSN_cfg = cfg;
 
  /* Loading database plugin */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             "namecache",
                                             "database",
                                             &database))
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "No database backend configured\n");
 
  GNUNET_asprintf (&db_lib_name,
                   "libgnunet_plugin_namecache_%s",
                   database);
  GSN_database = GNUNET_PLUGIN_load (db_lib_name,
                                     (void *) GSN_cfg);
  GNUNET_free (database);
  if (NULL == GSN_database)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Could not load database backend `%s'\n",
                db_lib_name);
    GNUNET_SCHEDULER_add_now (&cleanup_task,
                              NULL);
    return;
  }
  statistics = GNUNET_STATISTICS_create ("namecache",
                                         cfg);
 
  /* Configuring server handles */
  GNUNET_SCHEDULER_add_shutdown (&cleanup_task,
                                 NULL);
}

References cfg, cleanup_task(), db_lib_name, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_PLUGIN_load(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_STATISTICS_create(), GSN_cfg, GSN_database, and statistics.

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	"namecache"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_fixed_size(lookup_block, GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK, struct LookupBlockMessage, NULL)	,
		GNUNET_MQ_hd_var_size(block_cache, GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE, struct BlockCacheMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

GSN_cfg

const struct GNUNET_CONFIGURATION_Handle* GSN_cfg

static

Configuration handle.

Definition at line 61 of file gnunet-service-namecache.c.

Referenced by run().

statistics

struct GNUNET_STATISTICS_Handle* statistics

static

Handle to the statistics service.

Definition at line 66 of file gnunet-service-namecache.c.

Referenced by cleanup_task(), handle_block_cache(), handle_lookup_block(), handle_lookup_block_it(), and run().

GSN_database

struct GNUNET_NAMECACHE_PluginFunctions* GSN_database

static

Database handle.

Definition at line 71 of file gnunet-service-namecache.c.

Referenced by cleanup_task(), handle_block_cache(), handle_lookup_block(), and run().

db_lib_name

char* db_lib_name

static

Name of the database plugin.

Definition at line 76 of file gnunet-service-namecache.c.

Referenced by cleanup_task(), and run().