/*
This file is part of GNUnet.
- (C) 2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2013, 2016 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public Liceidentity as published
You should have received a copy of the GNU General Public Liceidentity
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
#define LOG(kind,...) GNUNET_log_from (kind, "identity-api",__VA_ARGS__)
-/**
+/**
* Handle for an ego.
*/
struct GNUNET_IDENTITY_Ego
/**
* Private key associated with this ego.
*/
- struct GNUNET_CRYPTO_EccPrivateKey *pk;
+ struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
/**
* Current name associated with this ego.
};
-/**
+/**
* Handle for an operation with the identity service.
*/
struct GNUNET_IDENTITY_Operation
* Main identity handle.
*/
struct GNUNET_IDENTITY_Handle *h;
-
+
/**
* We keep operations in a DLL.
*/
const struct GNUNET_MessageHeader *msg;
/**
- * Continuation to invoke with the result of the transmission; 'cb'
+ * Continuation to invoke with the result of the transmission; @e cb
* will be NULL in this case.
*/
GNUNET_IDENTITY_Continuation cont;
/**
* Continuation to invoke with the result of the transmission for
- * 'get' operations ('cont' will be NULL in this case).
+ * 'get' operations (@e cont will be NULL in this case).
*/
GNUNET_IDENTITY_Callback cb;
/**
- * Closure for 'cont' or 'cb'.
+ * Closure for @e cont or @e cb.
*/
void *cls;
const struct GNUNET_CONFIGURATION_Handle *cfg;
/**
- * Socket (if available).
+ * Connection to service.
*/
- struct GNUNET_CLIENT_Connection *client;
+ struct GNUNET_MQ_Handle *mq;
/**
* Hash map from the hash of the public key to the
- * respective 'GNUNET_IDENTITY_Ego' handle.
+ * respective `GNUNET_IDENTITY_Ego` handle.
*/
struct GNUNET_CONTAINER_MultiHashMap *egos;
GNUNET_IDENTITY_Callback cb;
/**
- * Closure for 'cb'.
+ * Closure for @e cb.
*/
void *cb_cls;
/**
* Head of active operations.
- */
+ */
struct GNUNET_IDENTITY_Operation *op_head;
/**
* Tail of active operations.
- */
- struct GNUNET_IDENTITY_Operation *op_tail;
-
- /**
- * Currently pending transmission request, or NULL for none.
*/
- struct GNUNET_CLIENT_TransmitHandle *th;
+ struct GNUNET_IDENTITY_Operation *op_tail;
/**
* Task doing exponential back-off trying to reconnect.
*/
- GNUNET_SCHEDULER_TaskIdentifier reconnect_task;
+ struct GNUNET_SCHEDULER_Task *reconnect_task;
/**
* Time for next connect retry.
/**
* Obtain the ego representing 'anonymous' users.
- *
+ *
* @return handle for the anonymous user, must not be freed
*/
const struct GNUNET_IDENTITY_Ego *
GNUNET_IDENTITY_ego_get_anonymous ()
{
static struct GNUNET_IDENTITY_Ego anon;
- struct GNUNET_CRYPTO_EccPublicKey pub;
+ struct GNUNET_CRYPTO_EcdsaPublicKey pub;
if (NULL != anon.pk)
return &anon;
- anon.pk = (struct GNUNET_CRYPTO_EccPrivateKey *) GNUNET_CRYPTO_ecc_key_get_anonymous ();
- GNUNET_CRYPTO_ecc_key_get_public (anon.pk,
- &pub);
- GNUNET_CRYPTO_hash (&pub, sizeof (pub), &anon.id);
+ anon.pk = (struct GNUNET_CRYPTO_EcdsaPrivateKey *) GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
+ GNUNET_CRYPTO_ecdsa_key_get_public (anon.pk,
+ &pub);
+ GNUNET_CRYPTO_hash (&pub,
+ sizeof (pub),
+ &anon.id);
return &anon;
}
* Try again to connect to the identity service.
*
* @param cls handle to the identity service.
- * @param tc scheduler context
*/
static void
-reconnect (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc);
+reconnect (void *cls);
+
+
+/**
+ * Free ego from hash map.
+ *
+ * @param cls identity service handle
+ * @param key unused
+ * @param value ego to free
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+free_ego (void *cls,
+ const struct GNUNET_HashCode *key,
+ void *value)
+{
+ 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->pk);
+ GNUNET_free (ego->name);
+ GNUNET_assert (GNUNET_YES ==
+ GNUNET_CONTAINER_multihashmap_remove (h->egos,
+ key,
+ value));
+ GNUNET_free (ego);
+ return GNUNET_OK;
+}
/**
static void
reschedule_connect (struct GNUNET_IDENTITY_Handle *h)
{
- GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
+ struct GNUNET_IDENTITY_Operation *op;
+
+ GNUNET_assert (NULL == h->reconnect_task);
- if (NULL != h->th)
+ if (NULL != h->mq)
{
- GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
- h->th = NULL;
+ GNUNET_MQ_destroy (h->mq);
+ h->mq = NULL;
}
- if (NULL != h->client)
+ while (NULL != (op = h->op_head))
{
- GNUNET_CLIENT_disconnect (h->client);
- h->client = NULL;
+ GNUNET_CONTAINER_DLL_remove (h->op_head,
+ h->op_tail,
+ op);
+ if (NULL != op->cont)
+ op->cont (op->cls,
+ "Error in communication with the identity service");
+ else if (NULL != op->cb)
+ op->cb (op->cls,
+ NULL,
+ NULL,
+ NULL);
+ GNUNET_free (op);
}
- h->in_receive = GNUNET_NO;
+ 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));
+ GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay,
+ GNUNET_YES));
h->reconnect_task =
- GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
+ GNUNET_SCHEDULER_add_delayed (h->reconnect_delay,
+ &reconnect,
+ h);
h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
}
/**
- * Type of a function to call when we receive a message
- * from the service.
+ * 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.
+ *
+ * @param cls closure with the `struct GNUNET_IDENTITY_Handle *`
+ * @param error error code
+ */
+static void
+mq_error_handler (void *cls,
+ enum GNUNET_MQ_Error error)
+{
+ struct GNUNET_IDENTITY_Handle *h = cls;
+
+ reschedule_connect (h);
+}
+
+
+/**
+ * We received a result code from the service. Check the message
+ * is well-formed.
+ *
+ * @param cls closure
+ * @param rcm result message received
+ * @return #GNUNET_OK if the message is well-formed
+ */
+static int
+check_identity_result_code (void *cls,
+ const struct GNUNET_IDENTITY_ResultCodeMessage *rcm)
+{
+ uint16_t size = ntohs (rcm->header.size) - sizeof (*rcm);
+ const char *str = (const char *) &rcm[1];
+
+ if (0 == size)
+ return GNUNET_OK;
+ if ('\0' != str[size - 1])
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ return GNUNET_OK;
+}
+
+
+/**
+ * We received a result code from the service.
*
* @param cls closure
- * @param msg message received, NULL on timeout or fatal error
+ * @param rcm result message received
*/
static void
-message_handler (void *cls,
- const struct GNUNET_MessageHeader *msg)
+handle_identity_result_code (void *cls,
+ const struct GNUNET_IDENTITY_ResultCodeMessage *rcm)
{
struct GNUNET_IDENTITY_Handle *h = cls;
struct GNUNET_IDENTITY_Operation *op;
- struct GNUNET_IDENTITY_Ego *ego;
- const struct GNUNET_IDENTITY_ResultCodeMessage *rcm;
- const struct GNUNET_IDENTITY_UpdateMessage *um;
- const struct GNUNET_IDENTITY_SetDefaultMessage *sdm;
- struct GNUNET_CRYPTO_EccPublicKey pub;
- struct GNUNET_HashCode id;
- const char *str;
- uint16_t size;
- uint16_t name_len;
+ uint16_t size = ntohs (rcm->header.size) - sizeof (*rcm);
+ const char *str = (0 == size) ? NULL : (const char *) &rcm[1];
- if (NULL == msg)
+ op = h->op_head;
+ if (NULL == op)
{
+ GNUNET_break (0);
reschedule_connect (h);
return;
}
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received message of type %d from identity service\n",
- ntohs (msg->type));
- size = ntohs (msg->size);
- switch (ntohs (msg->type))
+ GNUNET_CONTAINER_DLL_remove (h->op_head,
+ h->op_tail,
+ op);
+ if (NULL != op->cont)
+ op->cont (op->cls,
+ str);
+ else if (NULL != op->cb)
+ op->cb (op->cls, NULL, NULL, NULL);
+ GNUNET_free (op);
+}
+
+
+/**
+ * Check validity of identity update message.
+ *
+ * @param cls closure
+ * @param um message received
+ * @return #GNUNET_OK if the message is well-formed
+ */
+static int
+check_identity_update (void *cls,
+ const struct GNUNET_IDENTITY_UpdateMessage *um)
+{
+ 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 GNUNET_IDENTITY_UpdateMessage)) ||
+ ( (0 != name_len) &&
+ ('\0' != str[name_len - 1])) )
{
- case GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE:
- if (size < sizeof (struct GNUNET_IDENTITY_ResultCodeMessage))
- {
- GNUNET_break (0);
- reschedule_connect (h);
- return;
- }
- rcm = (const struct GNUNET_IDENTITY_ResultCodeMessage *) msg;
- str = (const char *) &rcm[1];
- if ( (size > sizeof (struct GNUNET_IDENTITY_ResultCodeMessage)) &&
- ('\0' != str[size - sizeof (struct GNUNET_IDENTITY_ResultCodeMessage) - 1]) )
- {
- GNUNET_break (0);
- reschedule_connect (h);
- return;
- }
- if (size == sizeof (struct GNUNET_IDENTITY_ResultCodeMessage))
- str = NULL;
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ return GNUNET_OK;
+}
- op = h->op_head;
- GNUNET_CONTAINER_DLL_remove (h->op_head,
- h->op_tail,
- op);
- GNUNET_CLIENT_receive (h->client, &message_handler, h,
- GNUNET_TIME_UNIT_FOREVER_REL);
- if (NULL != op->cont)
- op->cont (op->cls,
- str);
- else if (NULL != op->cb)
- op->cb (op->cls, NULL, NULL, NULL);
- GNUNET_free (op);
- break;
- case GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE:
- if (size < sizeof (struct GNUNET_IDENTITY_UpdateMessage))
- {
- GNUNET_break (0);
- reschedule_connect (h);
- return;
- }
- um = (const struct GNUNET_IDENTITY_UpdateMessage *) msg;
- name_len = ntohs (um->name_len);
-
- str = (const char *) &um[1];
- if ( (size != name_len + sizeof (struct GNUNET_IDENTITY_UpdateMessage)) ||
- ( (0 != name_len) &&
- ('\0' != str[name_len - 1])) )
- {
- GNUNET_break (0);
- reschedule_connect (h);
- return;
- }
- if (GNUNET_YES == ntohs (um->end_of_list))
- {
- /* end of initial list of data */
- GNUNET_CLIENT_receive (h->client, &message_handler, h,
- GNUNET_TIME_UNIT_FOREVER_REL);
- if (NULL != h->cb)
- h->cb (h->cb_cls, NULL, NULL, NULL);
- break;
- }
- GNUNET_CRYPTO_ecc_key_get_public (&um->private_key,
- &pub);
- GNUNET_CRYPTO_hash (&pub, sizeof (pub), &id);
- if (0 == name_len)
- str = NULL;
- else
- str = (const char *) &um[1];
- 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->pk = GNUNET_new (struct GNUNET_CRYPTO_EccPrivateKey);
- *ego->pk = um->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);
- }
- GNUNET_CLIENT_receive (h->client, &message_handler, h,
- GNUNET_TIME_UNIT_FOREVER_REL);
- /* inform application about change */
+
+/**
+ * Handle identity update message.
+ *
+ * @param cls closure
+ * @param um message received
+ */
+static void
+handle_identity_update (void *cls,
+ const struct GNUNET_IDENTITY_UpdateMessage *um)
+{
+ struct GNUNET_IDENTITY_Handle *h = cls;
+ uint16_t name_len = ntohs (um->name_len);
+ const char *str = (0 == name_len) ? NULL : (const char *) &um[1];
+ struct GNUNET_CRYPTO_EcdsaPublicKey pub;
+ struct GNUNET_HashCode id;
+ struct GNUNET_IDENTITY_Ego *ego;
+
+ if (GNUNET_YES == ntohs (um->end_of_list))
+ {
+ /* end of initial list of data */
if (NULL != h->cb)
h->cb (h->cb_cls,
- ego,
- &ego->ctx,
- str);
- if (NULL == str)
- {
- GNUNET_free (ego->pk);
- GNUNET_free (ego->name);
- GNUNET_free (ego);
- }
- break;
- case GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT:
- if (size < sizeof (struct GNUNET_IDENTITY_SetDefaultMessage))
- {
- GNUNET_break (0);
- reschedule_connect (h);
- return;
- }
- sdm = (const struct GNUNET_IDENTITY_SetDefaultMessage *) msg;
- GNUNET_break (0 == ntohs (sdm->reserved));
- name_len = ntohs (sdm->name_len);
- str = (const char *) &sdm[1];
- if ( (size != name_len + sizeof (struct GNUNET_IDENTITY_SetDefaultMessage)) ||
- ( (0 != name_len) &&
- ('\0' != str[name_len - 1]) ) )
- {
- GNUNET_break (0);
- reschedule_connect (h);
- return;
- }
- /* Note: we know which service this should be for, so we're not
- really using 'str' henceforth */
- GNUNET_CRYPTO_ecc_key_get_public (&sdm->private_key,
+ NULL,
+ NULL,
+ NULL);
+ return;
+ }
+ GNUNET_CRYPTO_ecdsa_key_get_public (&um->private_key,
&pub);
- GNUNET_CRYPTO_hash (&pub, sizeof (pub), &id);
- ego = GNUNET_CONTAINER_multihashmap_get (h->egos,
- &id);
- if (NULL == ego)
+ GNUNET_CRYPTO_hash (&pub,
+ sizeof (pub),
+ &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;
}
- op = h->op_head;
- GNUNET_CONTAINER_DLL_remove (h->op_head,
- h->op_tail,
- op);
- GNUNET_CLIENT_receive (h->client, &message_handler, h,
- GNUNET_TIME_UNIT_FOREVER_REL);
- if (NULL != op->cb)
- op->cb (op->cls,
- ego,
- &ego->ctx,
- ego->name);
- GNUNET_free (op);
- break;
- default:
- GNUNET_break (0);
- reschedule_connect (h);
- return;
+ ego = GNUNET_new (struct GNUNET_IDENTITY_Ego);
+ ego->pk = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
+ *ego->pk = um->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->pk);
+ GNUNET_free (ego->name);
+ GNUNET_free (ego);
}
}
/**
- * Schedule transmission of the next message from our queue.
- *
- * @param h identity handle
- */
-static void
-transmit_next (struct GNUNET_IDENTITY_Handle *h);
-
-
-/**
- * Transmit next message to service.
+ * Function called when we receive a set default message from the
+ * service.
*
- * @param cls the `struct GNUNET_IDENTITY_Handle`.
- * @param size number of bytes available in @a buf
- * @param buf where to copy the message
- * @return number of bytes copied to buf
+ * @param cls closure
+ * @param sdm message received
+ * @return #GNUNET_OK if the message is well-formed
*/
-static size_t
-send_next_message (void *cls,
- size_t size,
- void *buf)
+static int
+check_identity_set_default (void *cls,
+ const struct GNUNET_IDENTITY_SetDefaultMessage *sdm)
{
- struct GNUNET_IDENTITY_Handle *h = cls;
- struct GNUNET_IDENTITY_Operation *op = h->op_head;
- size_t ret;
-
- h->th = NULL;
- if (NULL == op)
- return 0;
- ret = ntohs (op->msg->size);
- if (ret > size)
- {
- reschedule_connect (h);
- return 0;
- }
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Sending message of type %d to identity service\n",
- ntohs (op->msg->type));
- memcpy (buf, op->msg, ret);
- if ( (NULL == op->cont) &&
- (NULL == op->cb) )
- {
- GNUNET_CONTAINER_DLL_remove (h->op_head,
- h->op_tail,
- op);
- GNUNET_free (op);
- transmit_next (h);
- }
- if (GNUNET_NO == h->in_receive)
+ uint16_t size = ntohs (sdm->header.size) - sizeof (*sdm);
+ uint16_t name_len = ntohs (sdm->name_len);
+ const char *str = (const char *) &sdm[1];
+
+ if ( (size != name_len) ||
+ ( (0 != name_len) &&
+ ('\0' != str[name_len - 1]) ) )
{
- h->in_receive = GNUNET_YES;
- GNUNET_CLIENT_receive (h->client,
- &message_handler, h,
- GNUNET_TIME_UNIT_FOREVER_REL);
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
}
- return ret;
+ GNUNET_break (0 == ntohs (sdm->reserved));
+ return GNUNET_OK;
}
/**
- * Schedule transmission of the next message from our queue.
+ * Type of a function to call when we receive a message
+ * from the service.
*
- * @param h identity handle
+ * @param cls closure
+ * @param sdm message received
*/
static void
-transmit_next (struct GNUNET_IDENTITY_Handle *h)
+handle_identity_set_default (void *cls,
+ const struct GNUNET_IDENTITY_SetDefaultMessage *sdm)
{
- struct GNUNET_IDENTITY_Operation *op = h->op_head;
+ struct GNUNET_IDENTITY_Handle *h = cls;
+ struct GNUNET_IDENTITY_Operation *op;
+ struct GNUNET_CRYPTO_EcdsaPublicKey pub;
+ struct GNUNET_HashCode id;
+ struct GNUNET_IDENTITY_Ego *ego;
- GNUNET_assert (NULL == h->th);
- if (NULL == op)
+ GNUNET_CRYPTO_ecdsa_key_get_public (&sdm->private_key,
+ &pub);
+ GNUNET_CRYPTO_hash (&pub,
+ sizeof (pub),
+ &id);
+ ego = GNUNET_CONTAINER_multihashmap_get (h->egos,
+ &id);
+ if (NULL == ego)
+ {
+ GNUNET_break (0);
+ reschedule_connect (h);
return;
- if (NULL == h->client)
+ }
+ op = h->op_head;
+ if (NULL == op)
+ {
+ GNUNET_break (0);
+ reschedule_connect (h);
return;
- h->th = GNUNET_CLIENT_notify_transmit_ready (h->client,
- ntohs (op->msg->size),
- GNUNET_TIME_UNIT_FOREVER_REL,
- GNUNET_NO,
- &send_next_message,
- h);
+ }
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Received SET_DEFAULT message from identity service\n");
+ GNUNET_CONTAINER_DLL_remove (h->op_head,
+ h->op_tail,
+ op);
+ if (NULL != op->cb)
+ op->cb (op->cls,
+ ego,
+ &ego->ctx,
+ ego->name);
+ GNUNET_free (op);
}
* Try again to connect to the identity service.
*
* @param cls handle to the identity service.
- * @param tc scheduler context
*/
static void
-reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+reconnect (void *cls)
{
+ GNUNET_MQ_hd_var_size (identity_result_code,
+ GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE,
+ struct GNUNET_IDENTITY_ResultCodeMessage);
+ GNUNET_MQ_hd_var_size (identity_update,
+ GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE,
+ struct GNUNET_IDENTITY_UpdateMessage);
+ GNUNET_MQ_hd_var_size (identity_set_default,
+ GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT,
+ struct GNUNET_IDENTITY_SetDefaultMessage);
struct GNUNET_IDENTITY_Handle *h = cls;
- struct GNUNET_IDENTITY_Operation *op;
- struct GNUNET_MessageHeader msg;
-
- h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+ struct GNUNET_MQ_MessageHandler handlers[] = {
+ make_identity_result_code_handler (h),
+ make_identity_update_handler (h),
+ make_identity_set_default_handler (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->client);
- h->client = GNUNET_CLIENT_connect ("identity", h->cfg);
- GNUNET_assert (NULL != h->client);
- op = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Operation) +
- sizeof (struct GNUNET_MessageHeader));
- op->h = h;
- op->msg = (const struct GNUNET_MessageHeader *) &op[1];
- msg.size = htons (sizeof (msg));
- msg.type = htons (GNUNET_MESSAGE_TYPE_IDENTITY_START);
- memcpy (&op[1], &msg, sizeof (msg));
- GNUNET_CONTAINER_DLL_insert (h->op_head,
- h->op_tail,
- op);
- transmit_next (h);
- GNUNET_assert (NULL != h->th);
+ GNUNET_assert (NULL == h->mq);
+ h->mq = GNUNET_CLIENT_connecT (h->cfg,
+ "identity",
+ handlers,
+ &mq_error_handler,
+ h);
+ if (NULL == h->mq)
+ return;
+ env = GNUNET_MQ_msg (msg,
+ GNUNET_MESSAGE_TYPE_IDENTITY_START);
+ GNUNET_MQ_send (h->mq,
+ env);
}
h->cb = cb;
h->cb_cls = cb_cls;
h->egos = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_YES);
- h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
- h->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect, h);
+ reconnect (h);
+ if (NULL == h->mq)
+ {
+ GNUNET_free (h);
+ return NULL;
+ }
return h;
}
* @param ego the ego
* @return associated ECC key, valid as long as the ego is valid
*/
-const struct GNUNET_CRYPTO_EccPrivateKey *
+const struct GNUNET_CRYPTO_EcdsaPrivateKey *
GNUNET_IDENTITY_ego_get_private_key (const struct GNUNET_IDENTITY_Ego *ego)
{
return ego->pk;
*/
void
GNUNET_IDENTITY_ego_get_public_key (const struct GNUNET_IDENTITY_Ego *ego,
- struct GNUNET_CRYPTO_EccPublicKey *pk)
+ struct GNUNET_CRYPTO_EcdsaPublicKey *pk)
{
- GNUNET_CRYPTO_ecc_key_get_public (ego->pk,
- pk);
+ GNUNET_CRYPTO_ecdsa_key_get_public (ego->pk,
+ pk);
}
* Obtain the identity that is currently preferred/default
* for a service.
*
- * @param id identity service to query
+ * @param h identity service to query
* @param service_name for which service is an identity wanted
* @param cb function to call with the result (will only be called once)
* @param cb_cls closure for @a cb
* @return handle to abort the operation
*/
struct GNUNET_IDENTITY_Operation *
-GNUNET_IDENTITY_get (struct GNUNET_IDENTITY_Handle *id,
+GNUNET_IDENTITY_get (struct GNUNET_IDENTITY_Handle *h,
const char *service_name,
GNUNET_IDENTITY_Callback cb,
void *cb_cls)
{
struct GNUNET_IDENTITY_Operation *op;
+ struct GNUNET_MQ_Envelope *env;
struct GNUNET_IDENTITY_GetDefaultMessage *gdm;
size_t slen;
- slen = strlen (service_name) + 1;
+ if (NULL == h->mq)
+ return NULL;
+ slen = strlen (service_name) + 1;
if (slen >= GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_IDENTITY_GetDefaultMessage))
{
GNUNET_break (0);
return NULL;
}
- op = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Operation) +
- sizeof (struct GNUNET_IDENTITY_GetDefaultMessage) +
- slen);
- op->h = id;
+ op = GNUNET_new (struct GNUNET_IDENTITY_Operation);
+ op->h = h;
op->cb = cb;
op->cls = cb_cls;
- gdm = (struct GNUNET_IDENTITY_GetDefaultMessage *) &op[1];
- gdm->header.type = htons (GNUNET_MESSAGE_TYPE_IDENTITY_GET_DEFAULT);
- gdm->header.size = htons (sizeof (struct GNUNET_IDENTITY_GetDefaultMessage) +
- slen);
+ GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
+ h->op_tail,
+ op);
+ env = GNUNET_MQ_msg_extra (gdm,
+ slen,
+ GNUNET_MESSAGE_TYPE_IDENTITY_GET_DEFAULT);
gdm->name_len = htons (slen);
gdm->reserved = htons (0);
- memcpy (&gdm[1], service_name, slen);
- op->msg = &gdm->header;
- GNUNET_CONTAINER_DLL_insert_tail (id->op_head,
- id->op_tail,
- op);
- if (NULL == id->th)
- transmit_next (id);
+ GNUNET_memcpy (&gdm[1],
+ service_name,
+ slen);
+ GNUNET_MQ_send (h->mq,
+ env);
return op;
}
/**
* Set the preferred/default identity for a service.
*
- * @param id identity service to inform
+ * @param h identity service to inform
* @param service_name for which service is an identity set
* @param ego new default identity to be set for this service
* @param cont function to call once the operation finished
* @return handle to abort the operation
*/
struct GNUNET_IDENTITY_Operation *
-GNUNET_IDENTITY_set (struct GNUNET_IDENTITY_Handle *id,
+GNUNET_IDENTITY_set (struct GNUNET_IDENTITY_Handle *h,
const char *service_name,
struct GNUNET_IDENTITY_Ego *ego,
GNUNET_IDENTITY_Continuation cont,
void *cont_cls)
{
struct GNUNET_IDENTITY_Operation *op;
+ struct GNUNET_MQ_Envelope *env;
struct GNUNET_IDENTITY_SetDefaultMessage *sdm;
size_t slen;
+ if (NULL == h->mq)
+ return NULL;
slen = strlen (service_name) + 1;
if (slen >= GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_IDENTITY_SetDefaultMessage))
{
GNUNET_break (0);
return NULL;
}
- op = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Operation) +
- sizeof (struct GNUNET_IDENTITY_SetDefaultMessage) +
- slen);
- op->h = id;
+ op = GNUNET_new (struct GNUNET_IDENTITY_Operation);
+ op->h = h;
op->cont = cont;
op->cls = cont_cls;
- sdm = (struct GNUNET_IDENTITY_SetDefaultMessage *) &op[1];
- sdm->header.type = htons (GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT);
- sdm->header.size = htons (sizeof (struct GNUNET_IDENTITY_SetDefaultMessage) +
- slen);
+ GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
+ h->op_tail,
+ op);
+ env = GNUNET_MQ_msg_extra (sdm,
+ slen,
+ GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT);
sdm->name_len = htons (slen);
sdm->reserved = htons (0);
sdm->private_key = *ego->pk;
- memcpy (&sdm[1], service_name, slen);
- op->msg = &sdm->header;
- GNUNET_CONTAINER_DLL_insert_tail (id->op_head,
- id->op_tail,
- op);
- if (NULL == id->th)
- transmit_next (id);
+ GNUNET_memcpy (&sdm[1],
+ service_name,
+ slen);
+ GNUNET_MQ_send (h->mq,
+ env);
return op;
}
-/**
+/**
* Create a new identity with the given name.
*
- * @param id identity service to use
+ * @param h identity service to use
* @param name desired name
* @param cont function to call with the result (will only be called once)
* @param cont_cls closure for @a cont
* @return handle to abort the operation
*/
struct GNUNET_IDENTITY_Operation *
-GNUNET_IDENTITY_create (struct GNUNET_IDENTITY_Handle *id,
+GNUNET_IDENTITY_create (struct GNUNET_IDENTITY_Handle *h,
const char *name,
GNUNET_IDENTITY_Continuation cont,
void *cont_cls)
{
struct GNUNET_IDENTITY_Operation *op;
+ struct GNUNET_MQ_Envelope *env;
struct GNUNET_IDENTITY_CreateRequestMessage *crm;
- struct GNUNET_CRYPTO_EccPrivateKey *pk;
+ struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
size_t slen;
+ if (NULL == h->mq)
+ return NULL;
slen = strlen (name) + 1;
- pk = GNUNET_CRYPTO_ecc_key_create ();
-
if (slen >= GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_IDENTITY_CreateRequestMessage))
{
GNUNET_break (0);
- GNUNET_free (pk);
return NULL;
}
- op = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Operation) +
- sizeof (struct GNUNET_IDENTITY_CreateRequestMessage) +
- slen);
- op->h = id;
+ op = GNUNET_new (struct GNUNET_IDENTITY_Operation);
+ op->h = h;
op->cont = cont;
op->cls = cont_cls;
- crm = (struct GNUNET_IDENTITY_CreateRequestMessage *) &op[1];
- crm->header.type = htons (GNUNET_MESSAGE_TYPE_IDENTITY_CREATE);
- crm->header.size = htons (sizeof (struct GNUNET_IDENTITY_CreateRequestMessage) +
- slen);
+ GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
+ h->op_tail,
+ op);
+ env = GNUNET_MQ_msg_extra (crm,
+ slen,
+ GNUNET_MESSAGE_TYPE_IDENTITY_CREATE);
crm->name_len = htons (slen);
crm->reserved = htons (0);
+ pk = GNUNET_CRYPTO_ecdsa_key_create ();
crm->private_key = *pk;
- memcpy (&crm[1], name, slen);
- op->msg = &crm->header;
- GNUNET_CONTAINER_DLL_insert_tail (id->op_head,
- id->op_tail,
- op);
- if (NULL == id->th)
- transmit_next (id);
GNUNET_free (pk);
+ GNUNET_memcpy (&crm[1],
+ name,
+ slen);
+ GNUNET_MQ_send (h->mq,
+ env);
return op;
}
-/**
+/**
* Renames an existing identity.
*
- * @param id identity service to use
+ * @param h identity service to use
* @param old_name old name
* @param new_name desired new name
* @param cb function to call with the result (will only be called once)
* @return handle to abort the operation
*/
struct GNUNET_IDENTITY_Operation *
-GNUNET_IDENTITY_rename (struct GNUNET_IDENTITY_Handle *id,
+GNUNET_IDENTITY_rename (struct GNUNET_IDENTITY_Handle *h,
const char *old_name,
const char *new_name,
GNUNET_IDENTITY_Continuation cb,
void *cb_cls)
{
struct GNUNET_IDENTITY_Operation *op;
+ struct GNUNET_MQ_Envelope *env;
struct GNUNET_IDENTITY_RenameMessage *grm;
size_t slen_old;
size_t slen_new;
char *dst;
+ if (NULL == h->mq)
+ return NULL;
slen_old = strlen (old_name) + 1;
slen_new = strlen (new_name) + 1;
if ( (slen_old >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
GNUNET_break (0);
return NULL;
}
- op = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Operation) +
- sizeof (struct GNUNET_IDENTITY_RenameMessage) +
- slen_old + slen_new);
- op->h = id;
+ op = GNUNET_new (struct GNUNET_IDENTITY_Operation);
+ op->h = h;
op->cont = cb;
op->cls = cb_cls;
- grm = (struct GNUNET_IDENTITY_RenameMessage *) &op[1];
- grm->header.type = htons (GNUNET_MESSAGE_TYPE_IDENTITY_RENAME);
- grm->header.size = htons (sizeof (struct GNUNET_IDENTITY_RenameMessage) +
- slen_old + slen_new);
+ GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
+ h->op_tail,
+ op);
+ env = GNUNET_MQ_msg_extra (grm,
+ slen_old + slen_new,
+ GNUNET_MESSAGE_TYPE_IDENTITY_RENAME);
grm->old_name_len = htons (slen_old);
grm->new_name_len = htons (slen_new);
dst = (char *) &grm[1];
- memcpy (dst, old_name, slen_old);
- memcpy (&dst[slen_old], new_name, slen_new);
- op->msg = &grm->header;
- GNUNET_CONTAINER_DLL_insert_tail (id->op_head,
- id->op_tail,
- op);
- if (NULL == id->th)
- transmit_next (id);
+ GNUNET_memcpy (dst,
+ old_name,
+ slen_old);
+ GNUNET_memcpy (&dst[slen_old],
+ new_name,
+ slen_new);
+ GNUNET_MQ_send (h->mq,
+ env);
return op;
}
-/**
+/**
* Delete an existing identity.
*
- * @param id identity service to use
+ * @param h identity service to use
* @param name name of the identity to delete
* @param cb function to call with the result (will only be called once)
* @param cb_cls closure for @a cb
* @return handle to abort the operation
*/
struct GNUNET_IDENTITY_Operation *
-GNUNET_IDENTITY_delete (struct GNUNET_IDENTITY_Handle *id,
+GNUNET_IDENTITY_delete (struct GNUNET_IDENTITY_Handle *h,
const char *name,
GNUNET_IDENTITY_Continuation cb,
void *cb_cls)
{
struct GNUNET_IDENTITY_Operation *op;
+ struct GNUNET_MQ_Envelope *env;
struct GNUNET_IDENTITY_DeleteMessage *gdm;
size_t slen;
+ if (NULL == h->mq)
+ return NULL;
slen = strlen (name) + 1;
if (slen >= GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_IDENTITY_DeleteMessage))
{
GNUNET_break (0);
return NULL;
}
- op = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Operation) +
- sizeof (struct GNUNET_IDENTITY_DeleteMessage) +
- slen);
- op->h = id;
+ op = GNUNET_new (struct GNUNET_IDENTITY_Operation);
+ op->h = h;
op->cont = cb;
op->cls = cb_cls;
- gdm = (struct GNUNET_IDENTITY_DeleteMessage *) &op[1];
- gdm->header.type = htons (GNUNET_MESSAGE_TYPE_IDENTITY_DELETE);
- gdm->header.size = htons (sizeof (struct GNUNET_IDENTITY_DeleteMessage) +
- slen);
+ GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
+ h->op_tail,
+ op);
+ env = GNUNET_MQ_msg_extra (gdm,
+ slen,
+ GNUNET_MESSAGE_TYPE_IDENTITY_DELETE);
gdm->name_len = htons (slen);
gdm->reserved = htons (0);
- memcpy (&gdm[1], name, slen);
- op->msg = &gdm->header;
- GNUNET_CONTAINER_DLL_insert_tail (id->op_head,
- id->op_tail,
- op);
- if (NULL == id->th)
- transmit_next (id);
+ GNUNET_memcpy (&gdm[1],
+ name,
+ slen);
+ GNUNET_MQ_send (h->mq,
+ env);
return op;
}
void
GNUNET_IDENTITY_cancel (struct GNUNET_IDENTITY_Operation *op)
{
- struct GNUNET_IDENTITY_Handle *h = op->h;
-
- if ( (h->op_head != op) ||
- (NULL == h->client) )
- {
- /* request not active, can simply remove */
- GNUNET_CONTAINER_DLL_remove (h->op_head,
- h->op_tail,
- op);
- GNUNET_free (op);
- return;
- }
- if (NULL != h->th)
- {
- /* request active but not yet with service, can still abort */
- GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
- h->th = NULL;
- GNUNET_CONTAINER_DLL_remove (h->op_head,
- h->op_tail,
- op);
- GNUNET_free (op);
- transmit_next (h);
- return;
- }
- /* request active with service, simply ensure continuations are not called */
op->cont = NULL;
op->cb = NULL;
}
-/**
- * Free ego from hash map.
- *
- * @param cls identity service handle
- * @param key unused
- * @param value ego to free
- * @return #GNUNET_OK (continue to iterate)
- */
-static int
-free_ego (void *cls,
- const struct GNUNET_HashCode *key,
- void *value)
-{
- 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->pk);
- GNUNET_free (ego->name);
- GNUNET_free (ego);
- return GNUNET_OK;
-}
-
-
/**
* Disconnect from identity service
*
void
GNUNET_IDENTITY_disconnect (struct GNUNET_IDENTITY_Handle *h)
{
+ struct GNUNET_IDENTITY_Operation *op;
+
GNUNET_assert (NULL != h);
- GNUNET_assert (h->op_head == h->op_tail);
- if (h->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
+ if (h->reconnect_task != NULL)
{
GNUNET_SCHEDULER_cancel (h->reconnect_task);
- h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
- }
- if (NULL != h->th)
- {
- GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
- h->th = NULL;
+ h->reconnect_task = NULL;
}
if (NULL != h->egos)
{
GNUNET_CONTAINER_multihashmap_destroy (h->egos);
h->egos = NULL;
}
- if (NULL != h->client)
+ while (NULL != (op = h->op_head))
+ {
+ GNUNET_break (NULL == op->cont);
+ GNUNET_CONTAINER_DLL_remove (h->op_head,
+ h->op_tail,
+ op);
+ GNUNET_free (op);
+ }
+ if (NULL != h->mq)
{
- GNUNET_CLIENT_disconnect (h->client);
- h->client = NULL;
+ GNUNET_MQ_destroy (h->mq);
+ h->mq = NULL;
}
GNUNET_free (h);
}
projects / oweals / gnunet.git / blobdiff