gnunet-service-identity.c File Reference

identity management service More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_statistics_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.
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
	Called whenever a client is disconnected.
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.
static void	shutdown_task (void *cls)
	Task run during shutdown.
static void	send_result_code (struct GNUNET_SERVICE_Client *client, uint32_t result_code)
	Send a result code back to the client.
static struct GNUNET_MQ_Envelope *	create_update_message (struct Ego *ego)
	Create an update message with information about the current state of an ego.
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.
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.
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.
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.
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.
static void	notify_listeners (struct Ego *ego)
	Send an updated message for the given ego to all listeners.
static int	check_create_message (void *cls, const struct CreateRequestMessage *msg)
	Checks a GNUNET_MESSAGE_TYPE_IDENTITY_CREATE message.
static void	handle_create_message (void *cls, const struct CreateRequestMessage *crm)
	Handler for CREATE message from client, creates new identity.
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.
static int	check_rename_message (void *cls, const struct RenameMessage *msg)
	Checks a GNUNET_MESSAGE_TYPE_IDENTITY_RENAME message.
static void	handle_rename_message (void *cls, const struct RenameMessage *rm)
	Handler for RENAME message from client, creates new identity.
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.
static int	check_delete_message (void *cls, const struct DeleteMessage *msg)
	Checks a GNUNET_MESSAGE_TYPE_IDENTITY_DELETE message.
static void	handle_delete_message (void *cls, const struct DeleteMessage *dm)
	Handler for DELETE message from client, creates new identity.
static int	read_from_file (const char *filename, void *buf, size_t buf_size)
static int	process_ego_file (void *cls, const char *filename)
	Process the given file from the "EGODIR".
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
	Handle network size estimate clients.
	GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet(), "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(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.

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

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 116 of file gnunet-service-identity.c.

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

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

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

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 137 of file gnunet-service-identity.c.

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

References GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

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 156 of file gnunet-service-identity.c.

{
  return client;
}

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

unused

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

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

References ego_directory, ego_head, ego_tail, GNUNET_CONFIGURATION_destroy(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NO, GNUNET_notification_context_destroy(), GNUNET_STATISTICS_destroy(), Ego::identifier, nc, stats, subsystem_cfg, and subsystem_cfg_file.

Here is the call graph for this function:

send_result_code()

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

static

Send a result code back to the client.

Parameters

client	client that should receive the result code
result_code	code to transmit

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

{
  struct ResultCodeMessage *rcm;
  struct GNUNET_MQ_Envelope *env;
 
  env =
    GNUNET_MQ_msg (rcm, GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE);
  rcm->result_code = htonl (result_code);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending result %d (%s) to client\n",
              (int) result_code,
              GNUNET_ErrorCode_get_hint (result_code));
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
}

References env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ErrorCode_get_hint(), GNUNET_log, GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_get_mq(), and ResultCodeMessage::result_code.

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

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 232 of file gnunet-service-identity.c.

{
  struct UpdateMessage *um;
  struct GNUNET_MQ_Envelope *env;
  size_t name_len;
  ssize_t key_len;
 
  key_len = GNUNET_CRYPTO_blindable_sk_get_length (&ego->pk);
  name_len = (NULL == ego->identifier) ? 0 : (strlen (ego->identifier) + 1);
  env = GNUNET_MQ_msg_extra (um, name_len + key_len,
                             GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE);
  um->name_len = htons (name_len);
  um->end_of_list = htons (GNUNET_NO);
  um->key_len = htons (key_len);
  GNUNET_memcpy (&um[1], ego->identifier, name_len);
  GNUNET_CRYPTO_write_blindable_sk_to_buffer (&ego->pk,
                                              ((char*) &um[1]) + name_len,
                                              key_len);
  return env;
}

References UpdateMessage::end_of_list, env, GNUNET_CRYPTO_blindable_sk_get_length(), GNUNET_CRYPTO_write_blindable_sk_to_buffer(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE, GNUNET_MQ_msg_extra, GNUNET_NO, Ego::identifier, UpdateMessage::key_len, UpdateMessage::name_len, and Ego::pk.

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

Here is the call graph for this function:

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 264 of file gnunet-service-identity.c.

{
  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);
    ume->key_len = htons (0);
    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
                    env);
  }
  GNUNET_SERVICE_client_continue (client);
}

References create_update_message(), ego_head, 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::key_len, UpdateMessage::name_len, nc, and Ego::next.

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 306 of file gnunet-service-identity.c.

{
  GNUNET_MQ_check_zero_termination (message);
  return GNUNET_OK;
}

References GNUNET_MQ_check_zero_termination, and 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 322 of file gnunet-service-identity.c.

{
  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, GNUNET_EC_IDENTITY_NOT_FOUND);
  GNUNET_SERVICE_client_continue (client);
}

References create_update_message(), ego_head, env, GNUNET_EC_IDENTITY_NOT_FOUND, 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().

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 356 of file gnunet-service-identity.c.

{
  GNUNET_MQ_check_zero_termination (message);
  return GNUNET_OK;
}

References GNUNET_MQ_check_zero_termination, and 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 372 of file gnunet-service-identity.c.

{
  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, GNUNET_EC_IDENTITY_NOT_FOUND);
  GNUNET_SERVICE_client_continue (client);
}

References create_update_message(), ego_head, env, GNUNET_EC_IDENTITY_NOT_FOUND, 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().

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 416 of file gnunet-service-identity.c.

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

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

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

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 447 of file gnunet-service-identity.c.

{
  uint16_t size;
  uint16_t name_len;
  size_t key_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);
  key_len = ntohs (msg->key_len);
  if (name_len + key_len + sizeof(struct CreateRequestMessage) != size)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  str = (const char *) &msg[1] + key_len;
  if ('\0' != str[name_len - 1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, UpdateMessage::key_len, msg, UpdateMessage::name_len, GNUNET_MessageHeader::size, size, and str.

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
crm	the message received

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

{
  struct GNUNET_CRYPTO_BlindablePrivateKey private_key;
  struct GNUNET_SERVICE_Client *client = cls;
  struct Ego *ego;
  char *str;
  char *fn;
  size_t key_len;
  size_t kb_read;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREATE message from client\n");
  key_len = ntohs (crm->key_len);
  if ((GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_private_key_from_buffer (&crm[1],
                                                   key_len,
                                                   &private_key,
                                                   &kb_read)) ||
      (kb_read != key_len))
  {
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  str = GNUNET_strdup ((const char *) &crm[1] + key_len);
  GNUNET_STRINGS_utf8_tolower ((const char *) &crm[1] + key_len, str);
  for (ego = ego_head; NULL != ego; ego = ego->next)
  {
    if (0 == strcmp (ego->identifier, str))
    {
      send_result_code (client,
                        GNUNET_EC_IDENTITY_NAME_CONFLICT);
      GNUNET_SERVICE_client_continue (client);
      GNUNET_free (str);
      return;
    }
  }
  ego = GNUNET_new (struct Ego);
  ego->pk = private_key;
  ego->identifier = GNUNET_strdup (str);
  GNUNET_CONTAINER_DLL_insert (ego_head,
                               ego_tail,
                               ego);
  send_result_code (client, GNUNET_EC_NONE);
  fn = get_ego_filename (ego);
  if (GNUNET_OK !=
      GNUNET_DISK_fn_write (fn,
                            &private_key,
                            sizeof(struct GNUNET_CRYPTO_BlindablePrivateKey),
                            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);
}

References ego_head, ego_tail, get_ego_filename(), GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_DISK_fn_write(), GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_EC_IDENTITY_NAME_CONFLICT, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_strerror_file, GNUNET_new, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), GNUNET_SYSERR, Ego::identifier, CreateRequestMessage::key_len, Ego::next, notify_listeners(), Ego::pk, send_result_code(), and str.

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 567 of file gnunet-service-identity.c.

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

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

Referenced by handle_rename_message().

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 598 of file gnunet-service-identity.c.

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

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, msg, RenameContext::new_name, RenameContext::old_name, GNUNET_MessageHeader::size, and size.

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
rm	the message received

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

{
  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, GNUNET_EC_IDENTITY_NAME_CONFLICT);
      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, GNUNET_EC_NONE);
      GNUNET_SERVICE_client_continue (client);
      return;
    }
  }
 
  /* failed to locate old name */
  send_result_code (client, GNUNET_EC_IDENTITY_NOT_FOUND);
  GNUNET_free (old_name);
  GNUNET_free (new_name);
  GNUNET_SERVICE_client_continue (client);
}

References _, ego_head, get_ego_filename(), GNUNET_CONFIGURATION_iterate_sections(), GNUNET_CONFIGURATION_write(), GNUNET_EC_IDENTITY_NAME_CONFLICT, GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_EC_NONE, 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(), subsystem_cfg, and subsystem_cfg_file.

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 718 of file gnunet-service-identity.c.

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

References GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_OK, id, and subsystem_cfg.

Referenced by handle_delete_message().

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 749 of file gnunet-service-identity.c.

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

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, msg, name, GNUNET_MessageHeader::size, and size.

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
dm	the message received

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

{
  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, GNUNET_EC_NONE);
      GNUNET_SERVICE_client_continue (client);
      return;
    }
  }
 
  send_result_code (client, GNUNET_EC_IDENTITY_NOT_FOUND);
  GNUNET_free (name);
  GNUNET_SERVICE_client_continue (client);
}

References _, ego_head, ego_tail, get_ego_filename(), GNUNET_CONFIGURATION_iterate_sections(), GNUNET_CONFIGURATION_write(), GNUNET_CONTAINER_DLL_remove, GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_EC_NONE, 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(), subsystem_cfg, and subsystem_cfg_file.

Here is the call graph for this function:

read_from_file()

static int read_from_file ( const char *  filename, void *  buf, size_t  buf_size  )

static

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

{
  int fd;
  struct stat sb;
 
  fd = open (filename,
             O_RDONLY);
  if (-1 == fd)
  {
    memset (buf,
            0,
            buf_size);
    return GNUNET_SYSERR;
  }
  if (0 != fstat (fd,
                  &sb))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                              "stat",
                              filename);
    GNUNET_assert (0 == close (fd));
    memset (buf,
            0,
            buf_size);
    return GNUNET_SYSERR;
  }
  if (sb.st_size != buf_size)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "File `%s' has wrong size (%llu), expected %llu bytes\n",
                filename,
                (unsigned long long) sb.st_size,
                (unsigned long long) buf_size);
    GNUNET_assert (0 == close (fd));
    memset (buf,
            0,
            buf_size);
    return GNUNET_SYSERR;
  }
  if (buf_size !=
      read (fd,
            buf,
            buf_size))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                              "read",
                              filename);
    GNUNET_assert (0 == close (fd));
    memset (buf,
            0,
            buf_size);
    return GNUNET_SYSERR;
  }
  GNUNET_assert (0 == close (fd));
  return GNUNET_OK;
}

References filename, GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror_file, GNUNET_OK, and GNUNET_SYSERR.

Referenced by process_ego_file().

Here is the caller 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 899 of file gnunet-service-identity.c.

{
  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 !=
      read_from_file (filename,
                      &ego->pk,
                      sizeof (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;
}

References _, DIR_SEPARATOR, ego_head, ego_tail, filename, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_strdup, Ego::identifier, Ego::pk, and read_from_file().

Referenced by run().

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 940 of file gnunet-service-identity.c.

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

References _, cfg, 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_notification_context_create(), GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_YES, nc, process_ego_file(), shutdown_task, stats, subsystem_cfg, and subsystem_cfg_file.

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	GNUNET_OS_project_data_gnunet()	,
		"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(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.

Variable Documentation

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Handle to our current configuration.

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

Referenced by run().

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 76 of file gnunet-service-identity.c.

Referenced by handle_delete_message(), handle_ego_delete(), handle_ego_rename(), handle_rename_message(), run(), and shutdown_task().

stats

struct GNUNET_STATISTICS_Handle* stats

static

Handle to the statistics service.

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

Referenced by run(), and shutdown_task().

nc

struct GNUNET_NotificationContext* nc

static

Notification context, simplifies client broadcasts.

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

Referenced by handle_start_message(), notify_listeners(), run(), and shutdown_task().

ego_directory

char* ego_directory

static

Directory where we store the identities.

Definition at line 91 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 96 of file gnunet-service-identity.c.

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

ego_head

struct Ego* ego_head

static

Head of DLL of all egos.

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

Referenced by handle_create_message(), handle_delete_message(), handle_lookup_by_suffix_message(), handle_lookup_message(), handle_rename_message(), handle_start_message(), process_ego_file(), and shutdown_task().

ego_tail

struct Ego* ego_tail

static

Tail of DLL of all egos.

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

Referenced by handle_create_message(), handle_delete_message(), process_ego_file(), and shutdown_task().