/*
This file is part of GNUnet.
- (C) 2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2013 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.
*/
/**
* @author Christian Grothoff
*/
#include "platform.h"
-#include "gnunet_client_lib.h"
+#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
-#include "gnunet_container_lib.h"
-#include "gnunet_arm_service.h"
-#include "gnunet_hello_lib.h"
#include "gnunet_protocols.h"
-#include "gnunet_server_lib.h"
-#include "gnunet_time_lib.h"
#include "gnunet_identity_service.h"
#include "identity.h"
#define LOG(kind,...) GNUNET_log_from (kind, "identity-api",__VA_ARGS__)
-/**
- * Handle for a ego.
+/**
+ * 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;
/**
* Head of active operations.
- */
+ */
struct GNUNET_IDENTITY_Operation *op_head;
/**
* Tail of active operations.
- */
+ */
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,
+ 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 network size estimation service.
+ * Try again to connect to the identity service.
*
- * @param cls the handle to the transport service
- * @param tc scheduler context
+ * @param cls handle to the identity service.
*/
static void
-reconnect (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc);
+reconnect (void *cls);
/**
static void
reschedule_connect (struct GNUNET_IDENTITY_Handle *h)
{
- GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
+ GNUNET_assert (h->reconnect_task == NULL);
if (NULL != h->th)
{
* @param msg message received, NULL on timeout or fatal error
*/
static void
-message_handler (void *cls,
+message_handler (void *cls,
const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_IDENTITY_Handle *h = cls;
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_CRYPTO_EcdsaPublicKey pub;
struct GNUNET_HashCode id;
const char *str;
uint16_t size;
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);
}
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) &&
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,
+ GNUNET_CRYPTO_ecdsa_key_get_public (&um->private_key,
&pub);
GNUNET_CRYPTO_hash (&pub, sizeof (pub), &id);
if (0 == name_len)
return;
}
ego = GNUNET_new (struct GNUNET_IDENTITY_Ego);
- ego->pk = GNUNET_new (struct GNUNET_CRYPTO_EccPrivateKey);
+ ego->pk = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
*ego->pk = um->private_key;
ego->name = GNUNET_strdup (str);
ego->id = id;
ego,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
}
- /* inform application about change */
- if (NULL != h->cb)
- h->cb (h->cb_cls,
- ego,
- &ego->ctx,
- str);
if (NULL == str)
{
/* ego was deleted */
GNUNET_CONTAINER_multihashmap_remove (h->egos,
&ego->id,
ego));
- GNUNET_CRYPTO_ecc_key_free (ego->pk);
- GNUNET_free (ego->name);
- GNUNET_free (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 */
+ 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))
reschedule_connect (h);
return;
}
- GNUNET_CRYPTO_ecc_key_get_public (&sdm->private_key,
+ /* Note: we know which service this should be for, so we're not
+ really using 'str' henceforth */
+ GNUNET_CRYPTO_ecdsa_key_get_public (&sdm->private_key,
&pub);
GNUNET_CRYPTO_hash (&pub, sizeof (pub), &id);
- if (0 == name_len)
- str = NULL;
- else
- str = (const char *) &sdm[1];
ego = GNUNET_CONTAINER_multihashmap_get (h->egos,
&id);
if (NULL == ego)
return;
}
op = h->op_head;
+ if (NULL == op)
+ {
+ GNUNET_break (0);
+ reschedule_connect (h);
+ return;
+ }
+ 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);
+ GNUNET_CLIENT_receive (h->client, &message_handler, h,
+ GNUNET_TIME_UNIT_FOREVER_REL);
if (NULL != op->cb)
op->cb (op->cls,
ego,
reschedule_connect (h);
return;
}
- GNUNET_CLIENT_receive (h->client, &message_handler, h,
- GNUNET_TIME_UNIT_FOREVER_REL);
}
/**
* Transmit next message to service.
*
- * @param cls the 'struct GNUNET_IDENTITY_Handle'.
- * @param size number of bytes available in buf
+ * @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
*/
static size_t
-send_next_message (void *cls,
- size_t size,
+send_next_message (void *cls,
+ size_t size,
void *buf)
{
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;
{
reschedule_connect (h);
return 0;
- }
+ }
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Sending message of type %d to identity service\n",
ntohs (op->msg->type));
/**
- * Try again to connect to network size estimation service.
+ * Try again to connect to the identity service.
*
- * @param cls the handle to the transport service
- * @param tc scheduler context
+ * @param cls handle to the identity service.
*/
static void
-reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+reconnect (void *cls)
{
struct GNUNET_IDENTITY_Handle *h = cls;
struct GNUNET_IDENTITY_Operation *op;
struct GNUNET_MessageHeader msg;
- h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+ 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);
+ if ( (NULL == h->op_head) ||
+ (GNUNET_MESSAGE_TYPE_IDENTITY_START != ntohs (h->op_head->msg->type)) )
+ {
+ 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);
}
*
* @param cfg the configuration to use
* @param cb function to call on all identity events, can be NULL
- * @param cb_cls closure for 'cb'
+ * @param cb_cls closure for @a cb
* @return handle to use
*/
struct GNUNET_IDENTITY_Handle *
{
struct GNUNET_IDENTITY_Handle *h;
- h = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Handle));
+ h = GNUNET_new (struct GNUNET_IDENTITY_Handle);
h->cfg = cfg;
h->cb = cb;
h->cb_cls = cb_cls;
* @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,
+ GNUNET_CRYPTO_ecdsa_key_get_public (ego->pk,
pk);
}
* @param id 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 cb
+ * @param cb_cls closure for @a cb
* @return handle to abort the operation
*/
struct GNUNET_IDENTITY_Operation *
struct GNUNET_IDENTITY_GetDefaultMessage *gdm;
size_t slen;
- slen = strlen (service_name) + 1;
+ slen = strlen (service_name) + 1;
if (slen >= GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_IDENTITY_GetDefaultMessage))
{
GNUNET_break (0);
}
op = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Operation) +
sizeof (struct GNUNET_IDENTITY_GetDefaultMessage) +
- slen);
+ slen);
op->h = id;
op->cb = cb;
op->cls = cb_cls;
* @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
- * @param cont_cls closure for cont
+ * @param cont_cls closure for @a cont
* @return handle to abort the operation
*/
struct GNUNET_IDENTITY_Operation *
}
op = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Operation) +
sizeof (struct GNUNET_IDENTITY_SetDefaultMessage) +
- slen);
+ slen);
op->h = id;
op->cont = cont;
op->cls = cont_cls;
}
-/**
+/**
* Create a new identity with the given name.
*
* @param id 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 cont
+ * @param cont_cls closure for @a cont
* @return handle to abort the operation
*/
struct GNUNET_IDENTITY_Operation *
{
struct GNUNET_IDENTITY_Operation *op;
struct GNUNET_IDENTITY_CreateRequestMessage *crm;
- struct GNUNET_CRYPTO_EccPrivateKey *pk;
+ struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
size_t slen;
slen = strlen (name) + 1;
- pk = GNUNET_CRYPTO_ecc_key_create ();
+ pk = GNUNET_CRYPTO_ecdsa_key_create ();
if (slen >= GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_IDENTITY_CreateRequestMessage))
{
GNUNET_break (0);
- GNUNET_CRYPTO_ecc_key_free (pk);
+ GNUNET_free (pk);
return NULL;
}
op = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Operation) +
sizeof (struct GNUNET_IDENTITY_CreateRequestMessage) +
- slen);
+ slen);
op->h = id;
op->cont = cont;
op->cls = cont_cls;
op);
if (NULL == id->th)
transmit_next (id);
- GNUNET_CRYPTO_ecc_key_free (pk);
+ GNUNET_free (pk);
return op;
}
-/**
+/**
* Renames an existing identity.
*
* @param id 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)
- * @param cb_cls closure for cb
+ * @param cb_cls closure for @a cb
* @return handle to abort the operation
*/
struct GNUNET_IDENTITY_Operation *
}
-/**
+/**
* Delete an existing identity.
*
* @param id 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 cb
+ * @param cb_cls closure for @a cb
* @return handle to abort the operation
*/
struct GNUNET_IDENTITY_Operation *
}
op = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Operation) +
sizeof (struct GNUNET_IDENTITY_DeleteMessage) +
- slen);
+ slen);
op->h = id;
op->cont = cb;
op->cls = cb_cls;
(NULL == h->client) )
{
/* request not active, can simply remove */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Client aborted non-head operation, simply removing it\n");
GNUNET_CONTAINER_DLL_remove (h->op_head,
h->op_tail,
op);
if (NULL != h->th)
{
/* request active but not yet with service, can still abort */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Client aborted head operation prior to transmission, aborting it\n");
GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
h->th = NULL;
GNUNET_CONTAINER_DLL_remove (h->op_head,
return;
}
/* request active with service, simply ensure continuations are not called */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Client aborted active request, NULLing continuation\n");
op->cont = NULL;
op->cb = NULL;
}
* @param cls identity service handle
* @param key unused
* @param value ego to free
- * @return GNUNET_OK (continue to iterate)
+ * @return #GNUNET_OK (continue to iterate)
*/
static int
free_ego (void *cls,
struct GNUNET_IDENTITY_Handle *h = cls;
struct GNUNET_IDENTITY_Ego *ego = value;
- h->cb (h->cb_cls,
- ego,
- &ego->ctx,
- NULL);
- GNUNET_CRYPTO_ecc_key_free (ego->pk);
+ 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;
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;
+ h->reconnect_task = NULL;
}
if (NULL != h->th)
{
GNUNET_CONTAINER_multihashmap_destroy (h->egos);
h->egos = NULL;
}
+ 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->client)
{
GNUNET_CLIENT_disconnect (h->client);
projects / oweals / gnunet.git / blobdiff