gnunet-service-identity.c File Reference

identity management service More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_protocols.h"
#include "gnunet_statistics_service.h"
#include "gnunet_identity_service.h"
#include "identity.h"

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

Go to the source code of this file.

Data Structures
struct	Ego
	Information we keep about each ego. More...
struct	RenameContext
	Closure for 'handle_ego_rename'. More...

Functions
static char *	get_ego_filename (struct Ego *ego)
	Get the name of the file we use to store a given ego. 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	shutdown_task (void *cls)
	Task run during shutdown. More...
static void	send_result_code (struct GNUNET_SERVICE_Client *client, uint32_t result_code, const char *emsg)
	Send a result code back to the client. More...
static struct GNUNET_MQ_Envelope *	create_update_message (struct Ego *ego)
	Create an update message with information about the current state of an ego. More...
static struct GNUNET_MQ_Envelope *	create_set_default_message (struct Ego *ego, const char *servicename)
	Create a set default message with information about the current state of an ego. More...
static void	handle_start_message (void *cls, const struct GNUNET_MessageHeader *message)
	Handler for START message from client, sends information about all identities to the client immediately and adds the client to the notification context for future updates. More...
static int	check_lookup_message (void *cls, const struct LookupMessage *message)
	Handler for LOOKUP message from client, sends information about ONE identity to the client immediately. More...
static void	handle_lookup_message (void *cls, const struct LookupMessage *message)
	Handler for LOOKUP message from client, sends information about ONE identity to the client immediately. More...
static int	check_lookup_by_suffix_message (void *cls, const struct LookupMessage *message)
	Handler for LOOKUP message from client, sends information about ONE identity to the client immediately. More...
static void	handle_lookup_by_suffix_message (void *cls, const struct LookupMessage *message)
	Handler for LOOKUP_BY_SUFFIX message from client, sends information about ONE identity to the client immediately. More...
static int	check_get_default_message (void *cls, const struct GetDefaultMessage *msg)
	Checks a GNUNET_MESSAGE_TYPE_IDENTITY_GET_DEFAULT message. More...
static void	handle_get_default_message (void *cls, const struct GetDefaultMessage *gdm)
	Handler for GET_DEFAULT message from client, returns default identity for some service. More...
static int	key_cmp (const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk1, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk2)
	Compare the given two private keys for equality. More...
static int	check_set_default_message (void *cls, const struct SetDefaultMessage *msg)
	Checks a GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT message. More...
static void	handle_set_default_message (void *cls, const struct SetDefaultMessage *sdm)
	Handler for SET_DEFAULT message from client, updates default identity for some service. More...
static void	notify_listeners (struct Ego *ego)
	Send an updated message for the given ego to all listeners. More...
static int	check_create_message (void *cls, const struct CreateRequestMessage *msg)
	Checks a GNUNET_MESSAGE_TYPE_IDENTITY_CREATE message. More...
static void	handle_create_message (void *cls, const struct CreateRequestMessage *crm)
	Handler for CREATE message from client, creates new identity. More...
static void	handle_ego_rename (void *cls, const char *section)
	An ego was renamed; rename it in all subsystems where it is currently set as the default. More...
static int	check_rename_message (void *cls, const struct RenameMessage *msg)
	Checks a GNUNET_MESSAGE_TYPE_IDENTITY_RENAME message. More...
static void	handle_rename_message (void *cls, const struct RenameMessage *rm)
	Handler for RENAME message from client, creates new identity. More...
static void	handle_ego_delete (void *cls, const char *section)
	An ego was removed, remove it from all subsystems where it is currently set as the default. More...
static int	check_delete_message (void *cls, const struct DeleteMessage *msg)
	Checks a GNUNET_MESSAGE_TYPE_IDENTITY_DELETE message. More...
static void	handle_delete_message (void *cls, const struct DeleteMessage *dm)
	Handler for DELETE message from client, creates new identity. More...
static int	process_ego_file (void *cls, const char *filename)
	Process the given file from the "EGODIR". More...
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
	Handle network size estimate clients. More...
	GNUNET_SERVICE_MAIN ("identity", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(start_message, GNUNET_MESSAGE_TYPE_IDENTITY_START, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_var_size(lookup_message, GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP, struct LookupMessage, NULL), GNUNET_MQ_hd_var_size(lookup_by_suffix_message, GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP_BY_SUFFIX, struct LookupMessage, NULL), GNUNET_MQ_hd_var_size(get_default_message, GNUNET_MESSAGE_TYPE_IDENTITY_GET_DEFAULT, struct GetDefaultMessage, NULL), GNUNET_MQ_hd_var_size(set_default_message, GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT, struct SetDefaultMessage, NULL), GNUNET_MQ_hd_var_size(create_message, GNUNET_MESSAGE_TYPE_IDENTITY_CREATE, struct CreateRequestMessage, NULL), GNUNET_MQ_hd_var_size(rename_message, GNUNET_MESSAGE_TYPE_IDENTITY_RENAME, struct RenameMessage, NULL), GNUNET_MQ_hd_var_size(delete_message, GNUNET_MESSAGE_TYPE_IDENTITY_DELETE, struct DeleteMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro. More...

Variables
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Handle to our current configuration. More...
static struct GNUNET_CONFIGURATION_Handle *	subsystem_cfg
	Handle to subsystem configuration which for each subsystem contains the name of the default ego. More...
static struct GNUNET_STATISTICS_Handle *	stats
	Handle to the statistics service. More...
static struct GNUNET_NotificationContext *	nc
	Notification context, simplifies client broadcasts. More...
static char *	ego_directory
	Directory where we store the identities. More...
static char *	subsystem_cfg_file
	Configuration file name where subsystem information is kept. More...
static struct Ego *	ego_head
	Head of DLL of all egos. More...
static struct Ego *	ego_tail
	Tail of DLL of all egos. More...

Detailed Description

identity management service

Author

Christian Grothoff

The purpose of this service is to manage private keys that represent the various egos/pseudonyms/identities of a GNUnet user.

Todo:

• auto-initialze default egos; maybe trigger default initializations (such as gnunet-gns-import.sh?)

Definition in file gnunet-service-identity.c.

Function Documentation

get_ego_filename()

static char* get_ego_filename ( struct Ego *  ego )

static

Get the name of the file we use to store a given ego.

Parameters

ego	ego for which we need the filename

Returns

full filename for the given ego

Definition at line 118 of file gnunet-service-identity.c.

References DIR_SEPARATOR_STR, ego_directory, filename, GNUNET_asprintf(), and Ego::identifier.

Referenced by handle_create_message(), handle_delete_message(), and handle_rename_message().

{
  char *filename;

  GNUNET_asprintf (&filename,
                   "%s%s%s",
                   ego_directory,
                   DIR_SEPARATOR_STR,
                   ego->identifier);
  return filename;
}

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.

Parameters

cls	closure
client	identification of the client
app_ctx	client

Definition at line 139 of file gnunet-service-identity.c.

References GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

Referenced by run().

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client %p disconnected\n",
              client);
}

Here is the caller graph for this function:

client_connect_cb()

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

static

Add a client to our list of active clients.

Parameters

cls	NULL
client	client to add
mq	message queue for client

Returns

internal namestore client structure for this client

Definition at line 158 of file gnunet-service-identity.c.

Referenced by run().

{
  return client;
}

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

unused

Definition at line 172 of file gnunet-service-identity.c.

References e, ego_directory, GNUNET_CONFIGURATION_destroy(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NO, GNUNET_notification_context_destroy(), GNUNET_STATISTICS_destroy(), Ego::identifier, and subsystem_cfg_file.

Referenced by run().

{
  struct Ego *e;

  if (NULL != nc)
  {
    GNUNET_notification_context_destroy (nc);
    nc = NULL;
  }
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
    stats = NULL;
  }
  GNUNET_CONFIGURATION_destroy (subsystem_cfg);
  subsystem_cfg = NULL;
  GNUNET_free (subsystem_cfg_file);
  subsystem_cfg_file = NULL;
  GNUNET_free (ego_directory);
  ego_directory = NULL;
  while (NULL != (e = ego_head))
  {
    GNUNET_CONTAINER_DLL_remove (ego_head,
                                 ego_tail,
                                 e);
    GNUNET_free (e->identifier);
    GNUNET_free (e);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_result_code()

static void send_result_code ( struct GNUNET_SERVICE_Client *  client, uint32_t  result_code, const char *  emsg  )

static

Send a result code back to the client.

Parameters

client	client that should receive the result code
result_code	code to transmit
emsg	error message to include (or NULL for none)

Definition at line 211 of file gnunet-service-identity.c.

References env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_SERVICE_client_get_mq(), and ResultCodeMessage::result_code.

Referenced by handle_create_message(), handle_delete_message(), handle_get_default_message(), handle_lookup_by_suffix_message(), handle_lookup_message(), handle_rename_message(), and handle_set_default_message().

{
  struct ResultCodeMessage *rcm;
  struct GNUNET_MQ_Envelope *env;
  size_t elen;

  if (NULL == emsg)
    elen = 0;
  else
    elen = strlen (emsg) + 1;
  env =
    GNUNET_MQ_msg_extra (rcm, elen, GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE);
  rcm->result_code = htonl (result_code);
  if (0 < elen)
    GNUNET_memcpy (&rcm[1], emsg, elen);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending result %d (%s) to client\n",
              (int) result_code,
              emsg);
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_update_message()

static struct GNUNET_MQ_Envelope* create_update_message ( struct Ego *  ego )

static

Create an update message with information about the current state of an ego.

Parameters

ego	ego to create message for

Returns

corresponding update message

Definition at line 243 of file gnunet-service-identity.c.

References UpdateMessage::end_of_list, env, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE, GNUNET_MQ_msg_extra, GNUNET_NO, Ego::identifier, UpdateMessage::name_len, Ego::pk, and UpdateMessage::private_key.

Referenced by handle_lookup_by_suffix_message(), handle_lookup_message(), and handle_start_message().

{
  struct UpdateMessage *um;
  struct GNUNET_MQ_Envelope *env;
  size_t name_len;

  name_len = (NULL == ego->identifier) ? 0 : (strlen (ego->identifier) + 1);
  env = GNUNET_MQ_msg_extra (um, name_len, GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE);
  um->name_len = htons (name_len);
  um->end_of_list = htons (GNUNET_NO);
  um->private_key = ego->pk;
  GNUNET_memcpy (&um[1], ego->identifier, name_len);
  return env;
}

Here is the caller graph for this function:

create_set_default_message()

static struct GNUNET_MQ_Envelope* create_set_default_message ( struct Ego *  ego, const char *  servicename  )

static

Create a set default message with information about the current state of an ego.

Parameters

ego	ego to create message for
servicename	name of the service to provide in the message

Returns

corresponding set default message

Definition at line 267 of file gnunet-service-identity.c.

References env, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT, GNUNET_MQ_msg_extra, SetDefaultMessage::name_len, Ego::pk, SetDefaultMessage::private_key, and SetDefaultMessage::reserved.

Referenced by handle_get_default_message().

{
  struct SetDefaultMessage *sdm;
  struct GNUNET_MQ_Envelope *env;
  size_t name_len;

  name_len = (NULL == servicename) ? 0 : (strlen (servicename) + 1);
  env = GNUNET_MQ_msg_extra (sdm,
                             name_len,
                             GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT);
  sdm->name_len = htons (name_len);
  sdm->reserved = htons (0);
  sdm->private_key = ego->pk;
  GNUNET_memcpy (&sdm[1], servicename, name_len);
  return env;
}

Here is the caller graph for this function:

handle_start_message()

static void handle_start_message ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Handler for START message from client, sends information about all identities to the client immediately and adds the client to the notification context for future updates.

Parameters

cls	a struct GNUNET_SERVICE_Client *
message	the message received

Definition at line 296 of file gnunet-service-identity.c.

References create_update_message(), UpdateMessage::end_of_list, env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_notification_context_add(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_disable_continue_warning(), GNUNET_SERVICE_client_get_mq(), GNUNET_SERVICE_client_mark_monitor(), GNUNET_YES, UpdateMessage::name_len, and Ego::next.

{
  struct GNUNET_SERVICE_Client *client = cls;

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received START message from client\n");
  GNUNET_SERVICE_client_mark_monitor (client);
  GNUNET_SERVICE_client_disable_continue_warning (client);
  GNUNET_notification_context_add (nc,
                                   GNUNET_SERVICE_client_get_mq (client));
  for (struct Ego *ego = ego_head; NULL != ego; ego = ego->next)
  {
    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
                    create_update_message (ego));
  }
  {
    struct UpdateMessage *ume;
    struct GNUNET_MQ_Envelope *env;

    env = GNUNET_MQ_msg_extra (ume,
                               0,
                               GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE);
    ume->end_of_list = htons (GNUNET_YES);
    ume->name_len = htons (0);
    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
                    env);
  }
  GNUNET_SERVICE_client_continue (client);
}

Here is the call graph for this function:

check_lookup_message()

static int check_lookup_message ( void *  cls, const struct LookupMessage *  message  )

static

Handler for LOOKUP message from client, sends information about ONE identity to the client immediately.

Parameters

cls	unused
message	the message received

Returns

GNUNET_SYSERR if message was ill-formed

Definition at line 337 of file gnunet-service-identity.c.

References GNUNET_MQ_check_zero_termination, and GNUNET_OK.

{
  GNUNET_MQ_check_zero_termination (message);
  return GNUNET_OK;
}

handle_lookup_message()

static void handle_lookup_message ( void *  cls, const struct LookupMessage *  message  )

static

Handler for LOOKUP message from client, sends information about ONE identity to the client immediately.

Parameters

cls	a struct GNUNET_SERVICE_Client *
message	the message received

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

References create_update_message(), env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), Ego::identifier, name, Ego::next, and send_result_code().

{
  struct GNUNET_SERVICE_Client *client = cls;
  const char *name;
  struct GNUNET_MQ_Envelope *env;
  struct Ego *ego;

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received LOOKUP message from client\n");
  name = (const char *) &message[1];
  for (ego = ego_head; NULL != ego; ego = ego->next)
  {
    if (0 != strcasecmp (name, ego->identifier))
      continue;
    env = create_update_message (ego);
    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  send_result_code (client, 0, "ego not found");
  GNUNET_SERVICE_client_continue (client);
}

Here is the call graph for this function:

check_lookup_by_suffix_message()

static int check_lookup_by_suffix_message ( void *  cls, const struct LookupMessage *  message  )

static

Handler for LOOKUP message from client, sends information about ONE identity to the client immediately.

Parameters

cls	unused
message	the message received

Returns

GNUNET_SYSERR if message was ill-formed

Definition at line 387 of file gnunet-service-identity.c.

References GNUNET_MQ_check_zero_termination, and GNUNET_OK.

{
  GNUNET_MQ_check_zero_termination (message);
  return GNUNET_OK;
}

handle_lookup_by_suffix_message()

static void handle_lookup_by_suffix_message ( void *  cls, const struct LookupMessage *  message  )

static

Handler for LOOKUP_BY_SUFFIX message from client, sends information about ONE identity to the client immediately.

Parameters

cls	a struct GNUNET_SERVICE_Client *
message	the message received

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

References create_update_message(), env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), Ego::identifier, name, Ego::next, and send_result_code().

{
  struct GNUNET_SERVICE_Client *client = cls;
  const char *name;
  struct GNUNET_MQ_Envelope *env;
  struct Ego *lprefix;

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received LOOKUP_BY_SUFFIX message from client\n");
  name = (const char *) &message[1];
  lprefix = NULL;
  for (struct Ego *ego = ego_head; NULL != ego; ego = ego->next)
  {
    if ((strlen (ego->identifier) <= strlen (name)) &&
        (0 == strcmp (ego->identifier,
                      &name[strlen (name) - strlen (ego->identifier)])) &&
        ((strlen (name) == strlen (ego->identifier)) ||
         ('.' == name[strlen (name) - strlen (ego->identifier) - 1])) &&
        ((NULL == lprefix) ||
         (strlen (ego->identifier) > strlen (lprefix->identifier))))
    {
      /* found better match, update! */
      lprefix = ego;
    }
  }
  if (NULL != lprefix)
  {
    env = create_update_message (lprefix);
    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  send_result_code (client, 0, "ego not found");
  GNUNET_SERVICE_client_continue (client);
}

Here is the call graph for this function:

check_get_default_message()

static int check_get_default_message ( void *  cls, const struct GetDefaultMessage *  msg  )

static

Checks a GNUNET_MESSAGE_TYPE_IDENTITY_GET_DEFAULT message.

Parameters

cls	client sending the message
msg	message of type struct GetDefaultMessage

Returns

GNUNET_OK if msg is well-formed

Definition at line 449 of file gnunet-service-identity.c.

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, GetDefaultMessage::header, name, GetDefaultMessage::name_len, GetDefaultMessage::reserved, size, and GNUNET_MessageHeader::size.

{
  uint16_t size;
  uint16_t name_len;
  const char *name;

  size = ntohs (msg->header.size);
  if (size <= sizeof(struct GetDefaultMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  name = (const char *) &msg[1];
  name_len = ntohs (msg->name_len);
  if ((name_len + sizeof(struct GetDefaultMessage) != size) ||
      (0 != ntohs (msg->reserved)) || ('\0' != name[name_len - 1]))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

handle_get_default_message()

static void handle_get_default_message ( void *  cls, const struct GetDefaultMessage *  gdm  )

static

Handler for GET_DEFAULT message from client, returns default identity for some service.

Parameters

cls	unused
client	who sent the message
message	the message received

Definition at line 483 of file gnunet-service-identity.c.

References create_set_default_message(), env, gettext_noop, GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_MQ_send(), GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), Ego::identifier, name, Ego::next, and send_result_code().

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_SERVICE_Client *client = cls;
  char *name;
  char *identifier;

  name = GNUNET_strdup ((const char *) &gdm[1]);
  GNUNET_STRINGS_utf8_tolower ((const char *) &gdm[1],
                               name);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received GET_DEFAULT for service `%s' from client\n",
              name);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (subsystem_cfg,
                                             name,
                                             "DEFAULT_IDENTIFIER",
                                             &identifier))
  {
    send_result_code (client, 1, gettext_noop ("no default known"));
    GNUNET_SERVICE_client_continue (client);
    GNUNET_free (name);
    return;
  }
  for (struct Ego *ego = ego_head; NULL != ego; ego = ego->next)
  {
    if (0 == strcmp (ego->identifier, identifier))
    {
      env = create_set_default_message (ego, name);
      GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
      GNUNET_SERVICE_client_continue (client);
      GNUNET_free (identifier);
      GNUNET_free (name);
      return;
    }
  }
  GNUNET_free (identifier);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Failed to find ego `%s'\n",
              name);
  GNUNET_free (name);
  send_result_code (client,
                    1,
                    gettext_noop (
                      "default configured, but ego unknown (internal error)"));
  GNUNET_SERVICE_client_continue (client);
}

Here is the call graph for this function:

key_cmp()

static int key_cmp ( const struct GNUNET_CRYPTO_EcdsaPrivateKey *  pk1, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  pk2  )

static

Compare the given two private keys for equality.

Parameters

pk1	one private key
pk2	another private key

Returns

0 if the keys are equal

Definition at line 541 of file gnunet-service-identity.c.

References GNUNET_memcmp.

Referenced by handle_set_default_message().

{
  return GNUNET_memcmp (pk1, pk2);
}

Here is the caller graph for this function:

check_set_default_message()

static int check_set_default_message ( void *  cls, const struct SetDefaultMessage *  msg  )

static

Checks a GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT message.

Parameters

cls	client sending the message
msg	message of type struct SetDefaultMessage

Returns

GNUNET_OK if msg is well-formed

Definition at line 556 of file gnunet-service-identity.c.

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, SetDefaultMessage::header, SetDefaultMessage::name_len, SetDefaultMessage::reserved, size, and GNUNET_MessageHeader::size.

{
  uint16_t size;
  uint16_t name_len;
  const char *str;

  size = ntohs (msg->header.size);
  if (size <= sizeof(struct SetDefaultMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  name_len = ntohs (msg->name_len);
  GNUNET_break (0 == ntohs (msg->reserved));
  if (name_len + sizeof(struct SetDefaultMessage) != size)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  str = (const char *) &msg[1];
  if ('\0' != str[name_len - 1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

handle_set_default_message()

static void handle_set_default_message ( void *  cls, const struct SetDefaultMessage *  sdm  )

static

Handler for SET_DEFAULT message from client, updates default identity for some service.

Parameters

cls	unused
client	who sent the message
message	the message received

Definition at line 595 of file gnunet-service-identity.c.

References _, GNUNET_CONFIGURATION_set_value_string(), GNUNET_CONFIGURATION_write(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), Ego::identifier, key_cmp(), Ego::next, Ego::pk, send_result_code(), and subsystem_cfg_file.

{
  struct Ego *ego;
  struct GNUNET_SERVICE_Client *client = cls;
  char *str;

  str = GNUNET_strdup ((const char *) &sdm[1]);
  GNUNET_STRINGS_utf8_tolower ((const char *) &sdm[1], str);

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received SET_DEFAULT for service `%s' from client\n",
              str);
  for (ego = ego_head; NULL != ego; ego = ego->next)
  {
    if (0 == key_cmp (&ego->pk,
                      &sdm->private_key))
    {
      GNUNET_CONFIGURATION_set_value_string (subsystem_cfg,
                                             str,
                                             "DEFAULT_IDENTIFIER",
                                             ego->identifier);
      if (GNUNET_OK !=
          GNUNET_CONFIGURATION_write (subsystem_cfg, subsystem_cfg_file))
        GNUNET_log (
          GNUNET_ERROR_TYPE_ERROR,
          _ ("Failed to write subsystem default identifier map to `%s'.\n"),
          subsystem_cfg_file);
      send_result_code (client, 0, NULL);
      GNUNET_SERVICE_client_continue (client);
      GNUNET_free (str);
      return;
    }
  }
  send_result_code (client,
                    1,
                    _ ("Unknown ego specified for service (internal error)"));
  GNUNET_free (str);
  GNUNET_SERVICE_client_continue (client);
}

Here is the call graph for this function:

notify_listeners()

static void notify_listeners ( struct Ego *  ego )

static

Send an updated message for the given ego to all listeners.

Parameters

ego	ego to send the update for

Definition at line 643 of file gnunet-service-identity.c.

References UpdateMessage::end_of_list, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE, GNUNET_NO, GNUNET_notification_context_broadcast(), UpdateMessage::header, Ego::identifier, UpdateMessage::name_len, Ego::pk, UpdateMessage::private_key, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by handle_create_message(), handle_delete_message(), and handle_rename_message().

{
  struct UpdateMessage *um;
  size_t name_len;

  name_len = (NULL == ego->identifier) ? 0 : (strlen (ego->identifier) + 1);
  um = GNUNET_malloc (sizeof(struct UpdateMessage) + name_len);
  um->header.type = htons (GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE);
  um->header.size = htons (sizeof(struct UpdateMessage) + name_len);
  um->name_len = htons (name_len);
  um->end_of_list = htons (GNUNET_NO);
  um->private_key = ego->pk;
  GNUNET_memcpy (&um[1], ego->identifier, name_len);
  GNUNET_notification_context_broadcast (nc, &um->header, GNUNET_NO);
  GNUNET_free (um);
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_create_message()

static int check_create_message ( void *  cls, const struct CreateRequestMessage *  msg  )

static

Checks a GNUNET_MESSAGE_TYPE_IDENTITY_CREATE message.

Parameters

cls	client sending the message
msg	message of type struct CreateRequestMessage

Returns

GNUNET_OK if msg is well-formed

Definition at line 669 of file gnunet-service-identity.c.

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, CreateRequestMessage::header, UpdateMessage::name_len, CreateRequestMessage::name_len, CreateRequestMessage::reserved, size, and GNUNET_MessageHeader::size.

{
  uint16_t size;
  uint16_t name_len;
  const char *str;

  size = ntohs (msg->header.size);
  if (size <= sizeof(struct CreateRequestMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  name_len = ntohs (msg->name_len);
  GNUNET_break (0 == ntohs (msg->reserved));
  if (name_len + sizeof(struct CreateRequestMessage) != size)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  str = (const char *) &msg[1];
  if ('\0' != str[name_len - 1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

handle_create_message()

static void handle_create_message ( void *  cls, const struct CreateRequestMessage *  crm  )

static

Handler for CREATE message from client, creates new identity.

Parameters

cls	unused
client	who sent the message
message	the message received

Definition at line 708 of file gnunet-service-identity.c.

References fn, get_ego_filename(), gettext_noop, GNUNET_CONTAINER_DLL_insert, GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_fn_write(), GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_strerror_file, GNUNET_new, GNUNET_SERVICE_client_continue(), GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), Ego::identifier, Ego::next, notify_listeners(), Ego::pk, and send_result_code().

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct Ego *ego;
  char *str;
  char *fn;

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREATE message from client\n");
  str = GNUNET_strdup ((const char *) &crm[1]);
  GNUNET_STRINGS_utf8_tolower ((const char *) &crm[1], str);
  for (ego = ego_head; NULL != ego; ego = ego->next)
  {
    if (0 == strcmp (ego->identifier, str))
    {
      send_result_code (client,
                        1,
                        gettext_noop (
                          "identifier already in use for another ego"));
      GNUNET_SERVICE_client_continue (client);
      GNUNET_free (str);
      return;
    }
  }
  ego = GNUNET_new (struct Ego);
  ego->pk = crm->private_key;
  ego->identifier = GNUNET_strdup (str);
  GNUNET_CONTAINER_DLL_insert (ego_head,
                               ego_tail,
                               ego);
  send_result_code (client, 0, NULL);
  fn = get_ego_filename (ego);
  (void) GNUNET_DISK_directory_create_for_file (fn);
  if (sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey) !=
      GNUNET_DISK_fn_write (fn,
                            &crm->private_key,
                            sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey),
                            GNUNET_DISK_PERM_USER_READ
                            | GNUNET_DISK_PERM_USER_WRITE))
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "write", fn);
  GNUNET_free (fn);
  GNUNET_free (str);
  notify_listeners (ego);
  GNUNET_SERVICE_client_continue (client);
}

Here is the call graph for this function:

handle_ego_rename()

static void handle_ego_rename ( void *  cls, const char *  section  )

static

An ego was renamed; rename it in all subsystems where it is currently set as the default.

Parameters

cls	the 'struct RenameContext'
section	a section in the configuration to process

Definition at line 779 of file gnunet-service-identity.c.

References GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_OK, id, RenameContext::new_name, and RenameContext::old_name.

Referenced by handle_rename_message().

{
  struct RenameContext *rc = cls;
  char *id;

  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (subsystem_cfg,
                                                          section,
                                                          "DEFAULT_IDENTIFIER",
                                                          &id))
    return;
  if (0 != strcmp (id, rc->old_name))
  {
    GNUNET_free (id);
    return;
  }
  GNUNET_CONFIGURATION_set_value_string (subsystem_cfg,
                                         section,
                                         "DEFAULT_IDENTIFIER",
                                         rc->new_name);
  GNUNET_free (id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_rename_message()

static int check_rename_message ( void *  cls, const struct RenameMessage *  msg  )

static

Checks a GNUNET_MESSAGE_TYPE_IDENTITY_RENAME message.

Parameters

cls	client sending the message
msg	message of type struct RenameMessage

Returns

GNUNET_OK if msg is well-formed

Definition at line 810 of file gnunet-service-identity.c.

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, RenameMessage::header, RenameContext::new_name, RenameMessage::new_name_len, RenameContext::old_name, RenameMessage::old_name_len, size, and GNUNET_MessageHeader::size.

{
  uint16_t size;
  uint16_t old_name_len;
  uint16_t new_name_len;
  const char *old_name;
  const char *new_name;

  size = ntohs (msg->header.size);
  if (size <= sizeof(struct RenameMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  old_name_len = ntohs (msg->old_name_len);
  new_name_len = ntohs (msg->new_name_len);
  old_name = (const char *) &msg[1];
  new_name = &old_name[old_name_len];
  if ((old_name_len + new_name_len + sizeof(struct RenameMessage) != size) ||
      ('\0' != old_name[old_name_len - 1]) ||
      ('\0' != new_name[new_name_len - 1]))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }

  return GNUNET_OK;
}

handle_rename_message()

static void handle_rename_message ( void *  cls, const struct RenameMessage *  rm  )

static

Handler for RENAME message from client, creates new identity.

Parameters

cls	unused
client	who sent the message
message	the message received

Definition at line 849 of file gnunet-service-identity.c.

References _, get_ego_filename(), gettext_noop, GNUNET_CONFIGURATION_iterate_sections(), GNUNET_CONFIGURATION_write(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_strerror_file, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), handle_ego_rename(), Ego::identifier, RenameContext::new_name, Ego::next, notify_listeners(), RenameContext::old_name, RenameMessage::old_name_len, send_result_code(), and subsystem_cfg_file.

{
  uint16_t old_name_len;
  struct Ego *ego;
  char *old_name;
  char *new_name;
  struct RenameContext rename_ctx;
  struct GNUNET_SERVICE_Client *client = cls;
  char *fn_old;
  char *fn_new;
  const char *old_name_tmp;

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received RENAME message from client\n");
  old_name_len = ntohs (rm->old_name_len);
  old_name_tmp = (const char *) &rm[1];
  old_name = GNUNET_strdup (old_name_tmp);
  GNUNET_STRINGS_utf8_tolower (old_name_tmp, old_name);
  new_name = GNUNET_strdup (&old_name_tmp[old_name_len]);
  GNUNET_STRINGS_utf8_tolower (&old_name_tmp[old_name_len], new_name);

  /* check if new name is already in use */
  for (ego = ego_head; NULL != ego; ego = ego->next)
  {
    if (0 == strcmp (ego->identifier, new_name))
    {
      send_result_code (client, 1, gettext_noop ("target name already exists"));
      GNUNET_SERVICE_client_continue (client);
      GNUNET_free (old_name);
      GNUNET_free (new_name);
      return;
    }
  }

  /* locate old name and, if found, perform rename */
  for (ego = ego_head; NULL != ego; ego = ego->next)
  {
    if (0 == strcmp (ego->identifier, old_name))
    {
      fn_old = get_ego_filename (ego);
      GNUNET_free (ego->identifier);
      rename_ctx.old_name = old_name;
      rename_ctx.new_name = new_name;
      GNUNET_CONFIGURATION_iterate_sections (subsystem_cfg,
                                             &handle_ego_rename,
                                             &rename_ctx);
      if (GNUNET_OK !=
          GNUNET_CONFIGURATION_write (subsystem_cfg, subsystem_cfg_file))
        GNUNET_log (
          GNUNET_ERROR_TYPE_ERROR,
          _ ("Failed to write subsystem default identifier map to `%s'.\n"),
          subsystem_cfg_file);
      ego->identifier = GNUNET_strdup (new_name);
      fn_new = get_ego_filename (ego);
      if (0 != rename (fn_old, fn_new))
        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "rename", fn_old);
      GNUNET_free (fn_old);
      GNUNET_free (fn_new);
      GNUNET_free (old_name);
      GNUNET_free (new_name);
      notify_listeners (ego);
      send_result_code (client, 0, NULL);
      GNUNET_SERVICE_client_continue (client);
      return;
    }
  }

  /* failed to locate old name */
  send_result_code (client, 1, gettext_noop ("no matching ego found"));
  GNUNET_free (old_name);
  GNUNET_free (new_name);
  GNUNET_SERVICE_client_continue (client);
}

Here is the call graph for this function:

handle_ego_delete()

static void handle_ego_delete ( void *  cls, const char *  section  )

static

An ego was removed, remove it from all subsystems where it is currently set as the default.

Parameters

cls	name of the removed ego (const char *)
section	a section in the configuration to process

Definition at line 931 of file gnunet-service-identity.c.

References GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_OK, id, and Ego::identifier.

Referenced by handle_delete_message().

{
  const char *identifier = cls;
  char *id;

  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (subsystem_cfg,
                                                          section,
                                                          "DEFAULT_IDENTIFIER",
                                                          &id))
    return;
  if (0 != strcmp (id, identifier))
  {
    GNUNET_free (id);
    return;
  }
  GNUNET_CONFIGURATION_set_value_string (subsystem_cfg,
                                         section,
                                         "DEFAULT_IDENTIFIER",
                                         NULL);
  GNUNET_free (id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_delete_message()

static int check_delete_message ( void *  cls, const struct DeleteMessage *  msg  )

static

Checks a GNUNET_MESSAGE_TYPE_IDENTITY_DELETE message.

Parameters

cls	client sending the message
msg	message of type struct DeleteMessage

Returns

GNUNET_OK if msg is well-formed

Definition at line 962 of file gnunet-service-identity.c.

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, DeleteMessage::header, name, DeleteMessage::name_len, DeleteMessage::reserved, size, and GNUNET_MessageHeader::size.

{
  uint16_t size;
  uint16_t name_len;
  const char *name;

  size = ntohs (msg->header.size);
  if (size <= sizeof(struct DeleteMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  name = (const char *) &msg[1];
  name_len = ntohs (msg->name_len);
  if ((name_len + sizeof(struct DeleteMessage) != size) ||
      (0 != ntohs (msg->reserved)) || ('\0' != name[name_len - 1]))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

handle_delete_message()

static void handle_delete_message ( void *  cls, const struct DeleteMessage *  dm  )

static

Handler for DELETE message from client, creates new identity.

Parameters

cls	unused
client	who sent the message
message	the message received

Definition at line 995 of file gnunet-service-identity.c.

References _, fn, get_ego_filename(), gettext_noop, GNUNET_CONFIGURATION_iterate_sections(), GNUNET_CONFIGURATION_write(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_strerror_file, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), handle_ego_delete(), Ego::identifier, name, Ego::next, notify_listeners(), send_result_code(), and subsystem_cfg_file.

{
  struct Ego *ego;
  char *name;
  char *fn;
  struct GNUNET_SERVICE_Client *client = cls;

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received DELETE message from client\n");
  name = GNUNET_strdup ((const char *) &dm[1]);
  GNUNET_STRINGS_utf8_tolower ((const char *) &dm[1], name);

  for (ego = ego_head; NULL != ego; ego = ego->next)
  {
    if (0 == strcmp (ego->identifier, name))
    {
      GNUNET_CONTAINER_DLL_remove (ego_head, ego_tail, ego);
      GNUNET_CONFIGURATION_iterate_sections (subsystem_cfg,
                                             &handle_ego_delete,
                                             ego->identifier);
      if (GNUNET_OK !=
          GNUNET_CONFIGURATION_write (subsystem_cfg, subsystem_cfg_file))
        GNUNET_log (
          GNUNET_ERROR_TYPE_ERROR,
          _ ("Failed to write subsystem default identifier map to `%s'.\n"),
          subsystem_cfg_file);
      fn = get_ego_filename (ego);
      if (0 != unlink (fn))
        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
      GNUNET_free (fn);
      GNUNET_free (ego->identifier);
      ego->identifier = NULL;
      notify_listeners (ego);
      GNUNET_free (ego);
      GNUNET_free (name);
      send_result_code (client, 0, NULL);
      GNUNET_SERVICE_client_continue (client);
      return;
    }
  }

  send_result_code (client, 1, gettext_noop ("no matching ego found"));
  GNUNET_free (name);
  GNUNET_SERVICE_client_continue (client);
}

Here is the call graph for this function:

process_ego_file()

static int process_ego_file ( void *  cls, const char *  filename  )

static

Process the given file from the "EGODIR".

Parses the file and creates the respective 'struct Ego' in memory.

Parameters

cls	NULL
filename	name of the file to parse

Returns

GNUNET_OK to continue to iterate, GNUNET_NO to stop iteration with no error, GNUNET_SYSERR to abort iteration with error!

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

References _, DIR_SEPARATOR, fn, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_ecdsa_key_from_file(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_strdup, Ego::identifier, and Ego::pk.

Referenced by run().

{
  struct Ego *ego;
  const char *fn;

  fn = strrchr (filename, (int) DIR_SEPARATOR);
  if (NULL == fn)
  {
    GNUNET_break (0);
    return GNUNET_OK;
  }
  ego = GNUNET_new (struct Ego);
  if (GNUNET_OK !=
      GNUNET_CRYPTO_ecdsa_key_from_file (filename,
                                         GNUNET_NO,
                                         &ego->pk))
  {
    GNUNET_free (ego);
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to parse ego information in `%s'\n"),
                filename);
    return GNUNET_OK;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Loaded ego `%s'\n",
              fn + 1);
  ego->identifier = GNUNET_strdup (fn + 1);
  GNUNET_CONTAINER_DLL_insert (ego_head, ego_tail, ego);
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

run()

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

static

Handle network size estimate clients.

Parameters

cls	closure
server	the initialized server
c	configuration to use

Definition at line 1093 of file gnunet-service-identity.c.

References _, client_connect_cb(), client_disconnect_cb(), ego_directory, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_parse(), GNUNET_DISK_directory_create(), GNUNET_DISK_directory_scan(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_log_config_missing(), GNUNET_MESSAGE_TYPE_IDENTITY_CREATE, GNUNET_MESSAGE_TYPE_IDENTITY_DELETE, GNUNET_MESSAGE_TYPE_IDENTITY_GET_DEFAULT, GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP, GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP_BY_SUFFIX, GNUNET_MESSAGE_TYPE_IDENTITY_RENAME, GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT, GNUNET_MESSAGE_TYPE_IDENTITY_START, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_notification_context_create(), GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SERVICE_MAIN(), GNUNET_SERVICE_OPTION_NONE, GNUNET_STATISTICS_create(), GNUNET_YES, process_ego_file(), shutdown_task(), and subsystem_cfg_file.

{
  cfg = c;
  nc = GNUNET_notification_context_create (1);
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                            "identity",
                                                            "EGODIR",
                                                            &ego_directory))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "identity", "EGODIR");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg,
                                               "identity",
                                               "SUBSYSTEM_CFG",
                                               &subsystem_cfg_file))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "identity",
                               "SUBSYSTEM_CFG");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Loading subsystem configuration `%s'\n",
              subsystem_cfg_file);
  subsystem_cfg = GNUNET_CONFIGURATION_create ();
  if ((GNUNET_YES == GNUNET_DISK_file_test (subsystem_cfg_file)) &&
      (GNUNET_OK !=
       GNUNET_CONFIGURATION_parse (subsystem_cfg, subsystem_cfg_file)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ (
                  "Failed to parse subsystem identity configuration file `%s'\n"),
                subsystem_cfg_file);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  stats = GNUNET_STATISTICS_create ("identity", cfg);
  if (GNUNET_OK != GNUNET_DISK_directory_create (ego_directory))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to create directory `%s' for storing egos\n"),
                ego_directory);
  }
  GNUNET_DISK_directory_scan (ego_directory,
                              &process_ego_file,
                              NULL);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
}

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	"identity"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_fixed_size(start_message, GNUNET_MESSAGE_TYPE_IDENTITY_START, struct GNUNET_MessageHeader, NULL)	,
		GNUNET_MQ_hd_var_size(lookup_message, GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP, struct LookupMessage, NULL)	,
		GNUNET_MQ_hd_var_size(lookup_by_suffix_message, GNUNET_MESSAGE_TYPE_IDENTITY_LOOKUP_BY_SUFFIX, struct LookupMessage, NULL)	,
		GNUNET_MQ_hd_var_size(get_default_message, GNUNET_MESSAGE_TYPE_IDENTITY_GET_DEFAULT, struct GetDefaultMessage, NULL)	,
		GNUNET_MQ_hd_var_size(set_default_message, GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT, struct SetDefaultMessage, NULL)	,
		GNUNET_MQ_hd_var_size(create_message, GNUNET_MESSAGE_TYPE_IDENTITY_CREATE, struct CreateRequestMessage, NULL)	,
		GNUNET_MQ_hd_var_size(rename_message, GNUNET_MESSAGE_TYPE_IDENTITY_RENAME, struct RenameMessage, NULL)	,
		GNUNET_MQ_hd_var_size(delete_message, GNUNET_MESSAGE_TYPE_IDENTITY_DELETE, struct DeleteMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Referenced by run().

Here is the caller graph for this function:

Variable Documentation

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Handle to our current configuration.

Definition at line 72 of file gnunet-service-identity.c.

subsystem_cfg

struct GNUNET_CONFIGURATION_Handle* subsystem_cfg

static

Handle to subsystem configuration which for each subsystem contains the name of the default ego.

Definition at line 78 of file gnunet-service-identity.c.

stats

struct GNUNET_STATISTICS_Handle* stats

static

Handle to the statistics service.

Definition at line 83 of file gnunet-service-identity.c.

nc

struct GNUNET_NotificationContext* nc

static

Notification context, simplifies client broadcasts.

Definition at line 88 of file gnunet-service-identity.c.

ego_directory

char* ego_directory

static

Directory where we store the identities.

Definition at line 93 of file gnunet-service-identity.c.

Referenced by get_ego_filename(), run(), and shutdown_task().

subsystem_cfg_file

char* subsystem_cfg_file

static

Configuration file name where subsystem information is kept.

Definition at line 98 of file gnunet-service-identity.c.

Referenced by handle_delete_message(), handle_rename_message(), handle_set_default_message(), run(), and shutdown_task().

ego_head

struct Ego* ego_head

static

Head of DLL of all egos.

Definition at line 103 of file gnunet-service-identity.c.

ego_tail

struct Ego* ego_tail

static

Tail of DLL of all egos.

Definition at line 108 of file gnunet-service-identity.c.