identity_api.c File Reference

api to interact with the identity service More...

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

Include dependency graph for identity_api.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_IDENTITY_Operation
	Handle for an operation with the identity service. More...
struct	GNUNET_IDENTITY_Handle
	Handle for the service. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "identity-api", __VA_ARGS__)

Functions
struct GNUNET_IDENTITY_Ego *	GNUNET_IDENTITY_ego_get_anonymous ()
	Obtain the ego representing 'anonymous' users. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_key_get_public (const struct GNUNET_IDENTITY_PrivateKey *privkey, struct GNUNET_IDENTITY_PublicKey *key)
	Retrieves the public key representation of a private key. More...
static enum GNUNET_GenericReturnValue	private_key_create (enum GNUNET_IDENTITY_KeyType ktype, struct GNUNET_IDENTITY_PrivateKey *key)
static void	reconnect (void *cls)
	Try again to connect to the identity service. More...
static int	free_ego (void *cls, const struct GNUNET_HashCode *key, void *value)
	Free ego from hash map. More...
static void	reschedule_connect (struct GNUNET_IDENTITY_Handle *h)
	Reschedule a connect attempt to the service. More...
static void	mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue. More...
static void	handle_identity_result_code (void *cls, const struct ResultCodeMessage *rcm)
	We received a result code from the service. More...
static int	check_identity_update (void *cls, const struct UpdateMessage *um)
	Check validity of identity update message. More...
static void	handle_identity_update (void *cls, const struct UpdateMessage *um)
	Handle identity update message. More...
struct GNUNET_IDENTITY_Handle *	GNUNET_IDENTITY_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
	Connect to the identity service. More...
const struct GNUNET_IDENTITY_PrivateKey *	GNUNET_IDENTITY_ego_get_private_key (const struct GNUNET_IDENTITY_Ego *ego)
	Obtain the ECC key associated with a ego. More...
void	GNUNET_IDENTITY_ego_get_public_key (struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_IDENTITY_PublicKey *pk)
	Get the identifier (public key) of an ego. More...
struct GNUNET_IDENTITY_Operation *	GNUNET_IDENTITY_create (struct GNUNET_IDENTITY_Handle *h, const char *name, const struct GNUNET_IDENTITY_PrivateKey *privkey, enum GNUNET_IDENTITY_KeyType ktype, GNUNET_IDENTITY_CreateContinuation cont, void *cont_cls)
	Create a new ego with the given name. More...
struct GNUNET_IDENTITY_Operation *	GNUNET_IDENTITY_rename (struct GNUNET_IDENTITY_Handle *h, const char *old_name, const char *new_name, GNUNET_IDENTITY_Continuation cb, void *cb_cls)
	Renames an existing identity. More...
struct GNUNET_IDENTITY_Operation *	GNUNET_IDENTITY_delete (struct GNUNET_IDENTITY_Handle *h, const char *name, GNUNET_IDENTITY_Continuation cb, void *cb_cls)
	Delete an existing identity. More...
void	GNUNET_IDENTITY_cancel (struct GNUNET_IDENTITY_Operation *op)
	Cancel an identity operation. More...
void	GNUNET_IDENTITY_disconnect (struct GNUNET_IDENTITY_Handle *h)
	Disconnect from identity service. More...
static enum GNUNET_GenericReturnValue	check_key_type (uint32_t type)
ssize_t	GNUNET_IDENTITY_private_key_get_length (const struct GNUNET_IDENTITY_PrivateKey *key)
	Get the compacted length of a GNUNET_IDENTITY_PrivateKey. More...
ssize_t	GNUNET_IDENTITY_public_key_get_length (const struct GNUNET_IDENTITY_PublicKey *key)
	Get the compacted length of a GNUNET_IDENTITY_PublicKey. More...
ssize_t	GNUNET_IDENTITY_private_key_length_by_type (enum GNUNET_IDENTITY_KeyType kt)
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_read_public_key_from_buffer (const void *buffer, size_t len, struct GNUNET_IDENTITY_PublicKey *key, size_t *kb_read)
	Reads a GNUNET_IDENTITY_PublicKey from a compact buffer. More...
ssize_t	GNUNET_IDENTITY_write_public_key_to_buffer (const struct GNUNET_IDENTITY_PublicKey *key, void *buffer, size_t len)
	Writes a GNUNET_IDENTITY_PublicKey to a compact buffer. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_read_private_key_from_buffer (const void *buffer, size_t len, struct GNUNET_IDENTITY_PrivateKey *key, size_t *kb_read)
	Reads a GNUNET_IDENTITY_PrivateKey from a compact buffer. More...
ssize_t	GNUNET_IDENTITY_write_private_key_to_buffer (const struct GNUNET_IDENTITY_PrivateKey *key, void *buffer, size_t len)
	Writes a GNUNET_IDENTITY_PrivateKey to a compact buffer. More...
ssize_t	GNUNET_IDENTITY_signature_get_length (const struct GNUNET_IDENTITY_Signature *sig)
	Get the compacted length of a GNUNET_IDENTITY_Signature. More...
ssize_t	GNUNET_IDENTITY_signature_get_raw_length_by_type (uint32_t type)
	Get the compacted length of a signature by type. More...
ssize_t	GNUNET_IDENTITY_read_signature_from_buffer (struct GNUNET_IDENTITY_Signature *sig, const void *buffer, size_t len)
	Reads a GNUNET_IDENTITY_Signature from a compact buffer. More...
ssize_t	GNUNET_IDENTITY_write_signature_to_buffer (const struct GNUNET_IDENTITY_Signature *sig, void *buffer, size_t len)
	Writes a GNUNET_IDENTITY_Signature to a compact buffer. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_sign_raw_ (const struct GNUNET_IDENTITY_PrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, unsigned char *sig)
	Sign a given block. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_sign_ (const struct GNUNET_IDENTITY_PrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_IDENTITY_Signature *sig)
	Sign a given block. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_signature_verify_ (uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_IDENTITY_Signature *sig, const struct GNUNET_IDENTITY_PublicKey *pub)
	Verify a given signature. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_signature_verify_raw_ (uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const unsigned char *sig, const struct GNUNET_IDENTITY_PublicKey *pub)
	Verify a given signature. More...
ssize_t	GNUNET_IDENTITY_encrypt (const void *block, size_t size, const struct GNUNET_IDENTITY_PublicKey *pub, struct GNUNET_CRYPTO_EcdhePublicKey *ecc, void *result)
	Encrypt a block with GNUNET_IDENTITY_PublicKey and derives a GNUNET_CRYPTO_EcdhePublicKey which is required for decryption using ecdh to derive a symmetric key. More...
ssize_t	GNUNET_IDENTITY_decrypt (const void *block, size_t size, const struct GNUNET_IDENTITY_PrivateKey *priv, const struct GNUNET_CRYPTO_EcdhePublicKey *ecc, void *result)
	Decrypt a given block with GNUNET_IDENTITY_PrivateKey and a given GNUNET_CRYPTO_EcdhePublicKey using ecdh to derive a symmetric key. More...
char *	GNUNET_IDENTITY_public_key_to_string (const struct GNUNET_IDENTITY_PublicKey *key)
	Creates a (Base32) string representation of the public key. More...
char *	GNUNET_IDENTITY_private_key_to_string (const struct GNUNET_IDENTITY_PrivateKey *key)
	Creates a (Base32) string representation of the private key. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_public_key_from_string (const char *str, struct GNUNET_IDENTITY_PublicKey *key)
	Parses a (Base32) string representation of the public key. More...
enum GNUNET_GenericReturnValue	GNUNET_IDENTITY_private_key_from_string (const char *str, struct GNUNET_IDENTITY_PrivateKey *key)
	Parses a (Base32) string representation of the private key. More...

Detailed Description

api to interact with the identity service

Author

Christian Grothoff

Definition in file identity_api.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "identity-api", __VA_ARGS__)

Definition at line 34 of file identity_api.c.

Function Documentation

private_key_create()

static enum GNUNET_GenericReturnValue private_key_create ( enum GNUNET_IDENTITY_KeyType  ktype, struct GNUNET_IDENTITY_PrivateKey *  key  )

static

Definition at line 157 of file identity_api.c.

{
  key->type = htonl (ktype);
  switch (ktype)
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    GNUNET_CRYPTO_ecdsa_key_create (&key->ecdsa_key);
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    GNUNET_CRYPTO_eddsa_key_create (&key->eddsa_key);
    break;
  default:
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

Referenced by GNUNET_IDENTITY_create().

Here is the caller graph for this function:

reconnect()

static void reconnect ( void *  cls )

static

Try again to connect to the identity service.

Parameters

cls	handle to the identity service.

Definition at line 484 of file identity_api.c.

{
  struct GNUNET_IDENTITY_Handle *h = cls;
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size (identity_result_code,
                             GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE,
                             struct ResultCodeMessage,
                             h),
    GNUNET_MQ_hd_var_size (identity_update,
                           GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE,
                           struct UpdateMessage,
                           h),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
 
  h->reconnect_task = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Connecting to identity service.\n");
  GNUNET_assert (NULL == h->mq);
  h->mq = GNUNET_CLIENT_connect (h->cfg,
                                 "identity",
                                 handlers,
                                 &mq_error_handler,
                                 h);
  if (NULL == h->mq)
    return;
  if (NULL != h->cb)
  {
    env = GNUNET_MQ_msg (msg,
                         GNUNET_MESSAGE_TYPE_IDENTITY_START);
    GNUNET_MQ_send (h->mq,
                    env);
  }
}

References GNUNET_ARM_Handle::cfg, env, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE, GNUNET_MESSAGE_TYPE_IDENTITY_START, GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg, GNUNET_MQ_send(), h, handlers, LOG, GNUNET_ARM_Handle::mq, mq_error_handler(), msg, and GNUNET_ARM_Handle::reconnect_task.

Referenced by GNUNET_IDENTITY_connect(), and reschedule_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

free_ego()

static int free_ego ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Free ego from hash map.

Parameters

cls	identity service handle
key	unused
value	ego to free

Returns

GNUNET_OK (continue to iterate)

Definition at line 241 of file identity_api.c.

{
  struct GNUNET_IDENTITY_Handle *h = cls;
  struct GNUNET_IDENTITY_Ego *ego = value;
 
  if (NULL != h->cb)
    h->cb (h->cb_cls, ego,
           &ego->ctx,
           NULL);
  GNUNET_free (ego->name);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap_remove (h->egos,
                                                       key,
                                                       value));
  GNUNET_free (ego);
  return GNUNET_OK;
}

References GNUNET_IDENTITY_Ego::ctx, GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_OK, GNUNET_YES, h, key, GNUNET_IDENTITY_Ego::name, and value.

Referenced by check_key_type(), and reschedule_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

reschedule_connect()

static void reschedule_connect ( struct GNUNET_IDENTITY_Handle *  h )

static

Reschedule a connect attempt to the service.

Parameters

h	transport service to reconnect

Definition at line 268 of file identity_api.c.

{
  struct GNUNET_IDENTITY_Operation *op;
 
  GNUNET_assert (NULL == h->reconnect_task);
 
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
  while (NULL != (op = h->op_head))
  {
    GNUNET_CONTAINER_DLL_remove (h->op_head,
                                 h->op_tail,
                                 op);
    if (NULL != op->cont)
      op->cont (op->cls,
                GNUNET_EC_SERVICE_COMMUNICATION_FAILED);
    else if (NULL != op->cb)
      op->cb (op->cls, NULL, NULL, NULL);
    else if (NULL != op->create_cont)
      op->create_cont (op->cls,
                       NULL,
                       GNUNET_EC_SERVICE_COMMUNICATION_FAILED);
    GNUNET_free (op);
  }
  GNUNET_CONTAINER_multihashmap_iterate (h->egos,
                                         &free_ego,
                                         h);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Scheduling task to reconnect to identity service in %s.\n",
       GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay,
                                               GNUNET_YES));
  h->reconnect_task =
    GNUNET_SCHEDULER_add_delayed (h->reconnect_delay,
                                  &reconnect,
                                  h);
  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
}

References free_ego(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_EC_SERVICE_COMMUNICATION_FAILED, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_STD_BACKOFF, GNUNET_YES, h, LOG, GNUNET_ARM_Handle::mq, op, reconnect(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by handle_identity_result_code(), handle_identity_update(), and mq_error_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_error_handler()

static void mq_error_handler ( void *  cls, enum GNUNET_MQ_Error  error  )

static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters

cls	closure with the struct GNUNET_IDENTITY_Handle *
error	error code

Definition at line 319 of file identity_api.c.

{
  struct GNUNET_IDENTITY_Handle *h = cls;
 
  reschedule_connect (h);
}

References h, and reschedule_connect().

Referenced by reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_identity_result_code()

static void handle_identity_result_code ( void *  cls, const struct ResultCodeMessage *  rcm  )

static

We received a result code from the service.

Parameters

cls	closure
rcm	result message received

Definition at line 335 of file identity_api.c.

{
  struct GNUNET_IDENTITY_Handle *h = cls;
  struct GNUNET_IDENTITY_Operation *op;
  enum GNUNET_ErrorCode ec = ntohl (rcm->result_code);
 
  op = h->op_head;
  if (NULL == op)
  {
    GNUNET_break (0);
    reschedule_connect (h);
    return;
  }
  GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
  if (NULL != op->cont)
    op->cont (op->cls, ec);
  else if (NULL != op->cb)
    op->cb (op->cls, NULL, NULL, NULL);
  else if (NULL != op->create_cont)
    op->create_cont (op->cls, (GNUNET_EC_NONE == ec) ? &op->pk : NULL, ec);
  GNUNET_free (op);
}

References GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_EC_NONE, GNUNET_free, h, op, reschedule_connect(), and ResultCodeMessage::result_code.

Here is the call graph for this function:

check_identity_update()

static int check_identity_update ( void *  cls, const struct UpdateMessage *  um  )

static

Check validity of identity update message.

Parameters

cls	closure
um	message received

Returns

GNUNET_OK if the message is well-formed

Definition at line 368 of file identity_api.c.

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

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

handle_identity_update()

static void handle_identity_update ( void *  cls, const struct UpdateMessage *  um  )

static

Handle identity update message.

Parameters

cls	closure
um	message received

Definition at line 392 of file identity_api.c.

{
  struct GNUNET_IDENTITY_Handle *h = cls;
  uint16_t name_len = ntohs (um->name_len);
  const char *str;
  size_t key_len;
  size_t kb_read;
  struct GNUNET_HashCode id;
  struct GNUNET_IDENTITY_Ego *ego;
  struct GNUNET_IDENTITY_PrivateKey private_key;
  const char *tmp;
 
  if (GNUNET_YES == ntohs (um->end_of_list))
  {
    /* end of initial list of data */
    if (NULL != h->cb)
      h->cb (h->cb_cls, NULL, NULL, NULL);
    return;
  }
  tmp = (const char*) &um[1];
  str = (0 == name_len) ? NULL : tmp;
  memset (&private_key, 0, sizeof (private_key));
  key_len = ntohs (um->key_len);
  GNUNET_assert (GNUNET_SYSERR !=
                 GNUNET_IDENTITY_read_private_key_from_buffer (tmp + name_len,
                                                               key_len,
                                                               &private_key,
                                                               &kb_read));
  GNUNET_assert (0 <= GNUNET_IDENTITY_private_key_get_length (&private_key));
  GNUNET_CRYPTO_hash (&private_key,
                      GNUNET_IDENTITY_private_key_get_length (&private_key),
                      &id);
  ego = GNUNET_CONTAINER_multihashmap_get (h->egos,
                                           &id);
  if (NULL == ego)
  {
    /* ego was created */
    if (NULL == str)
    {
      /* deletion of unknown ego? not allowed */
      GNUNET_break (0);
      reschedule_connect (h);
      return;
    }
    ego = GNUNET_new (struct GNUNET_IDENTITY_Ego);
    ego->pub_initialized = GNUNET_NO;
    ego->pk = private_key;
    ego->name = GNUNET_strdup (str);
    ego->id = id;
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multihashmap_put (
                     h->egos,
                     &ego->id,
                     ego,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  }
  if (NULL == str)
  {
    /* ego was deleted */
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multihashmap_remove (h->egos,
                                                         &ego->id,
                                                         ego));
  }
  else
  {
    /* ego changed name */
    GNUNET_free (ego->name);
    ego->name = GNUNET_strdup (str);
  }
  /* inform application about change */
  if (NULL != h->cb)
    h->cb (h->cb_cls,
           ego,
           &ego->ctx,
           str);
  /* complete deletion */
  if (NULL == str)
  {
    GNUNET_free (ego->name);
    GNUNET_free (ego);
  }
}

References GNUNET_IDENTITY_Ego::ctx, UpdateMessage::end_of_list, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_IDENTITY_private_key_get_length(), GNUNET_IDENTITY_read_private_key_from_buffer(), GNUNET_new, GNUNET_NO, GNUNET_strdup, GNUNET_SYSERR, GNUNET_YES, h, id, GNUNET_IDENTITY_Ego::id, UpdateMessage::key_len, GNUNET_IDENTITY_Ego::name, UpdateMessage::name_len, GNUNET_IDENTITY_Ego::pk, GNUNET_IDENTITY_Ego::pub_initialized, and reschedule_connect().

Here is the call graph for this function:

check_key_type()

static enum GNUNET_GenericReturnValue check_key_type ( uint32_t  type )

static

Definition at line 757 of file identity_api.c.

{
  switch (type)
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
  case GNUNET_IDENTITY_TYPE_EDDSA:
    return GNUNET_OK;
  default:
    return GNUNET_SYSERR;
  }
  return GNUNET_SYSERR;
}

References free_ego(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), h, GNUNET_ARM_Handle::mq, op, and GNUNET_ARM_Handle::reconnect_task.

Here is the call graph for this function:

GNUNET_IDENTITY_private_key_length_by_type()

ssize_t GNUNET_IDENTITY_private_key_length_by_type

(

enum GNUNET_IDENTITY_KeyType

kt

)

Definition at line 847 of file identity_api.c.

{
  switch (kt)
  {
  case GNUNET_IDENTITY_TYPE_ECDSA:
    return sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey);
    break;
  case GNUNET_IDENTITY_TYPE_EDDSA:
    return sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey);
    break;
  default:
    GNUNET_break (0);
  }
  return -1;
}

References GNUNET_break, GNUNET_IDENTITY_TYPE_ECDSA, and GNUNET_IDENTITY_TYPE_EDDSA.