X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fidentity%2Fidentity_api.c;h=30a6fb23d9998e2081da42fdf72b766f34e53e85;hb=341c1dd692c62a88eeff34fca155ce2377677d4b;hp=a6d15ae38a9829ba5a596026d8cc4306aab637dc;hpb=eed7f472501226b6d6c4f32d3c88d14123f74236;p=oweals%2Fgnunet.git diff --git a/src/identity/identity_api.c b/src/identity/identity_api.c index a6d15ae38..30a6fb23d 100644 --- a/src/identity/identity_api.c +++ b/src/identity/identity_api.c @@ -1,21 +1,19 @@ /* 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 - by the Free Software Foundation; either version 3, or (at your - option) any later version. + GNUnet is free software: you can redistribute it and/or modify it + under the terms of the GNU Affero General Public License as published + by the Free Software Foundation, either version 3 of the License, + or (at your option) any later version. GNUnet is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public Liceidentity for more details. - - 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. + Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . */ /** @@ -32,7 +30,7 @@ #define LOG(kind,...) GNUNET_log_from (kind, "identity-api",__VA_ARGS__) -/** +/** * Handle for an ego. */ struct GNUNET_IDENTITY_Ego @@ -40,7 +38,7 @@ 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. @@ -59,7 +57,7 @@ struct GNUNET_IDENTITY_Ego }; -/** +/** * Handle for an operation with the identity service. */ struct GNUNET_IDENTITY_Operation @@ -69,7 +67,7 @@ struct GNUNET_IDENTITY_Operation * Main identity handle. */ struct GNUNET_IDENTITY_Handle *h; - + /** * We keep operations in a DLL. */ @@ -87,19 +85,19 @@ struct GNUNET_IDENTITY_Operation 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; @@ -117,13 +115,13 @@ struct GNUNET_IDENTITY_Handle 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; @@ -133,29 +131,24 @@ struct GNUNET_IDENTITY_Handle 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. @@ -172,21 +165,23 @@ struct GNUNET_IDENTITY_Handle /** * 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_EccPublicSignKey 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_for_signature (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; } @@ -195,11 +190,41 @@ GNUNET_IDENTITY_ego_get_anonymous () * 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; +} /** @@ -210,314 +235,310 @@ reconnect (void *cls, 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 msg message received, NULL on timeout or fatal error + * @param rcm result message received + * @return #GNUNET_OK if the message is well-formed + */ +static int +check_identity_result_code (void *cls, + const struct 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 rcm result message received */ static void -message_handler (void *cls, - const struct GNUNET_MessageHeader *msg) +handle_identity_result_code (void *cls, + const struct 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_EccPublicSignKey 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 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 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_for_signature (&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 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_for_signature (&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 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 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); } @@ -525,37 +546,44 @@ transmit_next (struct GNUNET_IDENTITY_Handle *h) * 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) { 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[] = { + GNUNET_MQ_hd_var_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_hd_var_size (identity_set_default, + GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT, + struct SetDefaultMessage, + 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); - 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); + 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); } @@ -579,8 +607,12 @@ GNUNET_IDENTITY_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, 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; } @@ -591,7 +623,7 @@ GNUNET_IDENTITY_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, * @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; @@ -606,10 +638,10 @@ GNUNET_IDENTITY_ego_get_private_key (const struct GNUNET_IDENTITY_Ego *ego) */ void GNUNET_IDENTITY_ego_get_public_key (const struct GNUNET_IDENTITY_Ego *ego, - struct GNUNET_CRYPTO_EccPublicSignKey *pk) + struct GNUNET_CRYPTO_EcdsaPublicKey *pk) { - GNUNET_CRYPTO_ecc_key_get_public_for_signature (ego->pk, - pk); + GNUNET_CRYPTO_ecdsa_key_get_public (ego->pk, + pk); } @@ -617,47 +649,48 @@ GNUNET_IDENTITY_ego_get_public_key (const struct GNUNET_IDENTITY_Ego *ego, * 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_IDENTITY_GetDefaultMessage *gdm; + struct GNUNET_MQ_Envelope *env; + struct GetDefaultMessage *gdm; size_t slen; - slen = strlen (service_name) + 1; - if (slen >= GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_IDENTITY_GetDefaultMessage)) + if (NULL == h->mq) + return NULL; + slen = strlen (service_name) + 1; + if (slen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (struct 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; } @@ -665,7 +698,7 @@ GNUNET_IDENTITY_get (struct GNUNET_IDENTITY_Handle *id, /** * 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 @@ -673,104 +706,104 @@ GNUNET_IDENTITY_get (struct GNUNET_IDENTITY_Handle *id, * @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_IDENTITY_SetDefaultMessage *sdm; + struct GNUNET_MQ_Envelope *env; + struct 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)) + if (slen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (struct 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_IDENTITY_CreateRequestMessage *crm; - struct GNUNET_CRYPTO_EccPrivateKey *pk; + struct GNUNET_MQ_Envelope *env; + struct CreateRequestMessage *crm; + 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)) + if (slen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (struct 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) @@ -778,96 +811,100 @@ GNUNET_IDENTITY_create (struct GNUNET_IDENTITY_Handle *id, * @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_IDENTITY_RenameMessage *grm; + struct GNUNET_MQ_Envelope *env; + struct 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) || - (slen_new >= GNUNET_SERVER_MAX_MESSAGE_SIZE) || - (slen_old + slen_new >= GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct GNUNET_IDENTITY_RenameMessage)) ) + if ( (slen_old >= GNUNET_MAX_MESSAGE_SIZE) || + (slen_new >= GNUNET_MAX_MESSAGE_SIZE) || + (slen_old + slen_new >= GNUNET_MAX_MESSAGE_SIZE - sizeof (struct RenameMessage)) ) { 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_IDENTITY_DeleteMessage *gdm; + struct GNUNET_MQ_Envelope *env; + struct 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)) + if (slen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (struct 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; } @@ -883,64 +920,11 @@ GNUNET_IDENTITY_delete (struct GNUNET_IDENTITY_Handle *id, 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 * @@ -952,24 +936,10 @@ GNUNET_IDENTITY_disconnect (struct GNUNET_IDENTITY_Handle *h) struct GNUNET_IDENTITY_Operation *op; GNUNET_assert (NULL != h); - while (NULL != (op = h->op_head)) - { - if (NULL != h->th) - GNUNET_CLIENT_notify_transmit_ready_cancel (h->th); - GNUNET_CONTAINER_DLL_remove (h->op_head, - h->op_tail, - op); - GNUNET_free (op); - } - 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) { @@ -979,10 +949,18 @@ GNUNET_IDENTITY_disconnect (struct GNUNET_IDENTITY_Handle *h) 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); }