From: Schanzenbach, Martin Date: Sat, 13 Apr 2019 07:50:04 +0000 (+0200) Subject: RECLAIM: Refactoring X-Git-Url: https://git.librecmc.org/?a=commitdiff_plain;h=b32899c6a24c361836c615467fb7f1557c11b9b8;p=oweals%2Fgnunet.git RECLAIM: Refactoring --- diff --git a/src/reclaim/gnunet-service-reclaim.c b/src/reclaim/gnunet-service-reclaim.c index c8ae8a238..51d8554e2 100644 --- a/src/reclaim/gnunet-service-reclaim.c +++ b/src/reclaim/gnunet-service-reclaim.c @@ -23,17 +23,17 @@ * @brief reclaim Service * */ -#include "platform.h" -#include "gnunet_util_lib.h" +#include "gnunet-service-reclaim_tickets.h" #include "gnunet_constants.h" -#include "gnunet_protocols.h" -#include "gnunet_identity_service.h" #include "gnunet_gnsrecord_lib.h" +#include "gnunet_identity_service.h" #include "gnunet_namestore_service.h" -#include "gnunet_reclaim_plugin.h" +#include "gnunet_protocols.h" #include "gnunet_reclaim_attribute_lib.h" +#include "gnunet_reclaim_plugin.h" #include "gnunet_signatures.h" -#include "gnunet-service-reclaim_tickets.h" +#include "gnunet_util_lib.h" +#include "platform.h" #include "reclaim.h" /** @@ -91,7 +91,6 @@ static struct GNUNET_SCHEDULER_Task *timeout_task; */ static struct GNUNET_SCHEDULER_Task *update_task; - /** * Our configuration. */ @@ -105,8 +104,7 @@ struct IdpClient; /** * A ticket iteration operation. */ -struct TicketIteration -{ +struct TicketIteration { /** * DLL */ @@ -133,12 +131,10 @@ struct TicketIteration struct RECLAIM_TICKETS_Iterator *iter; }; - /** * An attribute iteration operation. */ -struct AttributeIterator -{ +struct AttributeIterator { /** * Next element in the DLL */ @@ -168,16 +164,12 @@ struct AttributeIterator * The operation id fot the zone iteration in the response for the client */ uint32_t request_id; - }; - - /** * An idp client */ -struct IdpClient -{ +struct IdpClient { /** * The client @@ -252,11 +244,9 @@ struct IdpClient * Tail of DLL of attribute store ops */ struct AttributeStoreHandle *store_op_tail; - }; -struct AttributeStoreHandle -{ +struct AttributeStoreHandle { /** * DLL */ @@ -303,9 +293,7 @@ struct AttributeStoreHandle uint32_t r_id; }; - -struct ConsumeTicketOperation -{ +struct ConsumeTicketOperation { /** * DLL */ @@ -332,12 +320,10 @@ struct ConsumeTicketOperation struct RECLAIM_TICKETS_ConsumeHandle *ch; }; - /** * Updated attribute IDs */ -struct TicketAttributeUpdateEntry -{ +struct TicketAttributeUpdateEntry { /** * DLL */ @@ -362,8 +348,7 @@ struct TicketAttributeUpdateEntry /** * Ticket revocation request handle */ -struct TicketRevocationHandle -{ +struct TicketRevocationHandle { /** * DLL */ @@ -430,13 +415,10 @@ struct TicketRevocationHandle uint32_t r_id; }; - - /** * Ticket issue operation handle */ -struct TicketIssueOperation -{ +struct TicketIssueOperation { /** * DLL */ @@ -458,14 +440,12 @@ struct TicketIssueOperation uint32_t r_id; }; - /** * DLL for ego handles to egos containing the RECLAIM_ATTRS in a * map in json_t format * */ -struct EgoEntry -{ +struct EgoEntry { /** * DLL */ @@ -485,21 +465,17 @@ struct EgoEntry * Attribute map. Contains the attributes as json_t */ struct GNUNET_CONTAINER_MultiHashMap *attr_map; - }; /** * Cleanup task */ -static void -cleanup() +static void cleanup () { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Cleaning up\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n"); RECLAIM_TICKETS_deinit (); - GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name, - TKT_database)); + GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name, TKT_database)); GNUNET_free (db_lib_name); db_lib_name = NULL; if (NULL != timeout_task) @@ -517,117 +493,89 @@ cleanup() * * @param cls NULL */ -static void -do_shutdown (void *cls) +static void do_shutdown (void *cls) { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, - "Shutting down...\n"); - cleanup(); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down...\n"); + cleanup (); } - -static int -create_sym_key_from_ecdh (const struct GNUNET_HashCode *new_key_hash, - struct GNUNET_CRYPTO_SymmetricSessionKey *skey, - struct GNUNET_CRYPTO_SymmetricInitializationVector *iv) +static int create_sym_key_from_ecdh ( + const struct GNUNET_HashCode *new_key_hash, + struct GNUNET_CRYPTO_SymmetricSessionKey *skey, + struct GNUNET_CRYPTO_SymmetricInitializationVector *iv) { struct GNUNET_CRYPTO_HashAsciiEncoded new_key_hash_str; - GNUNET_CRYPTO_hash_to_enc (new_key_hash, - &new_key_hash_str); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating symmetric rsa key from %s\n", (char*)&new_key_hash_str); + GNUNET_CRYPTO_hash_to_enc (new_key_hash, &new_key_hash_str); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating symmetric rsa key from %s\n", + (char *)&new_key_hash_str); static const char ctx_key[] = "gnuid-aes-ctx-key"; GNUNET_CRYPTO_kdf (skey, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey), - new_key_hash, sizeof (struct GNUNET_HashCode), - ctx_key, strlen (ctx_key), - NULL, 0); + new_key_hash, sizeof (struct GNUNET_HashCode), ctx_key, + strlen (ctx_key), NULL, 0); static const char ctx_iv[] = "gnuid-aes-ctx-iv"; - GNUNET_CRYPTO_kdf (iv, sizeof (struct GNUNET_CRYPTO_SymmetricInitializationVector), - new_key_hash, sizeof (struct GNUNET_HashCode), - ctx_iv, strlen (ctx_iv), - NULL, 0); + GNUNET_CRYPTO_kdf ( + iv, sizeof (struct GNUNET_CRYPTO_SymmetricInitializationVector), + new_key_hash, sizeof (struct GNUNET_HashCode), ctx_iv, strlen (ctx_iv), + NULL, 0); return GNUNET_OK; } - -static void -send_ticket_result (const struct IdpClient *client, - uint32_t r_id, - const struct GNUNET_RECLAIM_Ticket *ticket, - uint32_t success) +static void send_ticket_result (const struct IdpClient *client, uint32_t r_id, + const struct GNUNET_RECLAIM_Ticket *ticket, + uint32_t success) { struct TicketResultMessage *irm; struct GNUNET_MQ_Envelope *env; struct GNUNET_RECLAIM_Ticket *ticket_buf; - if (NULL != ticket) - { - env = GNUNET_MQ_msg_extra (irm, - sizeof (struct GNUNET_RECLAIM_Ticket), + if (NULL != ticket) { + env = GNUNET_MQ_msg_extra (irm, sizeof (struct GNUNET_RECLAIM_Ticket), GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); ticket_buf = (struct GNUNET_RECLAIM_Ticket *)&irm[1]; *ticket_buf = *ticket; } else { - env = GNUNET_MQ_msg (irm, - GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); + env = GNUNET_MQ_msg (irm, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); } - //TODO add success member + // TODO add success member irm->id = htonl (r_id); - GNUNET_MQ_send (client->mq, - env); + GNUNET_MQ_send (client->mq, env); } - -static void -issue_ticket_result_cb (void *cls, - struct GNUNET_RECLAIM_Ticket *ticket, - uint32_t success, - const char* emsg) +static void issue_ticket_result_cb (void *cls, + struct GNUNET_RECLAIM_Ticket *ticket, + uint32_t success, const char *emsg) { struct TicketIssueOperation *tio = cls; - if (GNUNET_OK != success) - { - send_ticket_result (tio->client, - tio->r_id, - NULL, - GNUNET_SYSERR); + if (GNUNET_OK != success) { + send_ticket_result (tio->client, tio->r_id, NULL, GNUNET_SYSERR); GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head, - tio->client->issue_op_tail, - tio); + tio->client->issue_op_tail, tio); GNUNET_free (tio); - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Error issuing ticket: %s\n", - emsg); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error issuing ticket: %s\n", emsg); return; } - send_ticket_result (tio->client, - tio->r_id, - ticket, - GNUNET_SYSERR); + send_ticket_result (tio->client, tio->r_id, ticket, GNUNET_SYSERR); GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head, - tio->client->issue_op_tail, - tio); + tio->client->issue_op_tail, tio); GNUNET_free (tio); } -static int -check_issue_ticket_message (void *cls, - const struct IssueTicketMessage *im) +static int check_issue_ticket_message (void *cls, + const struct IssueTicketMessage *im) { uint16_t size; size = ntohs (im->header.size); - if (size <= sizeof (struct IssueTicketMessage)) - { + if (size <= sizeof (struct IssueTicketMessage)) { GNUNET_break (0); return GNUNET_SYSERR; } return GNUNET_OK; } -static void -handle_issue_ticket_message (void *cls, - const struct IssueTicketMessage *im) +static void handle_issue_ticket_message (void *cls, + const struct IssueTicketMessage *im) { struct TicketIssueOperation *tio; struct IdpClient *idp = cls; @@ -636,16 +584,11 @@ handle_issue_ticket_message (void *cls, tio = GNUNET_new (struct TicketIssueOperation); attrs_len = ntohs (im->attr_len); - attrs = GNUNET_RECLAIM_ATTRIBUTE_list_deserialize ((char*)&im[1], attrs_len); + attrs = GNUNET_RECLAIM_ATTRIBUTE_list_deserialize ((char *)&im[1], attrs_len); tio->r_id = ntohl (im->id); tio->client = idp; - GNUNET_CONTAINER_DLL_insert (idp->issue_op_head, - idp->issue_op_tail, - tio); - RECLAIM_TICKETS_issue (&im->identity, - attrs, - &im->rp, - &issue_ticket_result_cb, + GNUNET_CONTAINER_DLL_insert (idp->issue_op_head, idp->issue_op_tail, tio); + RECLAIM_TICKETS_issue (&im->identity, attrs, &im->rp, &issue_ticket_result_cb, tio); GNUNET_SERVICE_client_continue (idp->client); GNUNET_RECLAIM_ATTRIBUTE_list_destroy (attrs); @@ -660,8 +603,7 @@ handle_issue_ticket_message (void *cls, * * @param rh the ticket revocation handle */ -static void -cleanup_revoke_ticket_handle (struct TicketRevocationHandle *rh) +static void cleanup_revoke_ticket_handle (struct TicketRevocationHandle *rh) { if (NULL != rh->attrs) GNUNET_RECLAIM_ATTRIBUTE_list_destroy (rh->attrs); @@ -690,88 +632,73 @@ serialize_authz_record (const struct GNUNET_RECLAIM_Ticket *ticket, char *buf; char *write_ptr; char attrs_str_len; - char* label; + char *label; GNUNET_assert (NULL != attrs->list_head); attrs_str_len = 0; for (le = attrs->list_head; NULL != le; le = le->next) { - attrs_str_len += 15 + 1; //TODO propery calculate + attrs_str_len += 15 + 1; // TODO propery calculate } buf = GNUNET_malloc (attrs_str_len); write_ptr = buf; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Writing attributes\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Writing attributes\n"); for (le = attrs->list_head; NULL != le; le = le->next) { - label = GNUNET_STRINGS_data_to_string_alloc (&le->claim->id, - sizeof (uint64_t)); - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Adding attribute to record: %s\n", label); + label = + GNUNET_STRINGS_data_to_string_alloc (&le->claim->id, sizeof (uint64_t)); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Adding attribute to record: %s\n", + label); - GNUNET_memcpy (write_ptr, - label, - strlen (label)); + GNUNET_memcpy (write_ptr, label, strlen (label)); write_ptr[strlen (label)] = ','; write_ptr += strlen (label) + 1; GNUNET_free (label); } write_ptr--; - write_ptr[0] = '\0'; //replace last , with a 0-terminator + write_ptr[0] = '\0'; // replace last , with a 0-terminator // ECDH keypair E = eG - *ecdh_privkey = GNUNET_CRYPTO_ecdhe_key_create(); - GNUNET_CRYPTO_ecdhe_key_get_public (*ecdh_privkey, - &ecdh_pubkey); + *ecdh_privkey = GNUNET_CRYPTO_ecdhe_key_create (); + GNUNET_CRYPTO_ecdhe_key_get_public (*ecdh_privkey, &ecdh_pubkey); enc_keyinfo = GNUNET_malloc (attrs_str_len); // Derived key K = H(eB) GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecdh_ecdsa (*ecdh_privkey, &ticket->audience, &new_key_hash)); create_sym_key_from_ecdh (&new_key_hash, &skey, &iv); - enc_size = GNUNET_CRYPTO_symmetric_encrypt (buf, - attrs_str_len, - &skey, &iv, + enc_size = GNUNET_CRYPTO_symmetric_encrypt (buf, attrs_str_len, &skey, &iv, enc_keyinfo); - *result = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)+ - enc_size); - GNUNET_memcpy (*result, - &ecdh_pubkey, + *result = + GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) + enc_size); + GNUNET_memcpy (*result, &ecdh_pubkey, sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)); GNUNET_memcpy (*result + sizeof (struct GNUNET_CRYPTO_EcdhePublicKey), - enc_keyinfo, - enc_size); + enc_keyinfo, enc_size); GNUNET_free (enc_keyinfo); GNUNET_free (buf); - return sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)+enc_size; + return sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) + enc_size; } - /** * Send revocation result * * @param rh ticket revocation handle * @param success GNUNET_OK if successful result */ -static void -send_revocation_finished (struct TicketRevocationHandle *rh, - uint32_t success) +static void send_revocation_finished (struct TicketRevocationHandle *rh, + uint32_t success) { struct GNUNET_MQ_Envelope *env; struct RevokeTicketResultMessage *trm; - GNUNET_break(TKT_database->delete_ticket (TKT_database->cls, - &rh->ticket)); + GNUNET_break (TKT_database->delete_ticket (TKT_database->cls, &rh->ticket)); - env = GNUNET_MQ_msg (trm, - GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT); + env = GNUNET_MQ_msg (trm, GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT); trm->id = htonl (rh->r_id); trm->success = htonl (success); - GNUNET_MQ_send (rh->client->mq, - env); + GNUNET_MQ_send (rh->client->mq, env); GNUNET_CONTAINER_DLL_remove (rh->client->revoke_op_head, - rh->client->revoke_op_tail, - rh); + rh->client->revoke_op_tail, rh); } - /** * Process ticket from database * @@ -780,13 +707,10 @@ send_revocation_finished (struct TicketRevocationHandle *rh, * @param attrs the attributes */ static void -ticket_reissue_proc (void *cls, - const struct GNUNET_RECLAIM_Ticket *ticket, +ticket_reissue_proc (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket, const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs); -static void -revocation_reissue_tickets (struct TicketRevocationHandle *rh); - +static void revocation_reissue_tickets (struct TicketRevocationHandle *rh); static void reissue_next (void *cls) { @@ -794,19 +718,13 @@ static void reissue_next (void *cls) revocation_reissue_tickets (rh); } - -static void -reissue_ticket_cont (void *cls, - int32_t success, - const char *emsg) +static void reissue_ticket_cont (void *cls, int32_t success, const char *emsg) { struct TicketRevocationHandle *rh = cls; rh->ns_qe = NULL; - if (GNUNET_SYSERR == success) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s\n", - "Unknown Error\n"); + if (GNUNET_SYSERR == success) { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s\n", "Unknown Error\n"); send_revocation_finished (rh, GNUNET_SYSERR); cleanup_revoke_ticket_handle (rh); return; @@ -815,7 +733,6 @@ reissue_ticket_cont (void *cls, GNUNET_SCHEDULER_add_now (&reissue_next, rh); } - /** * Process ticket from database * @@ -824,8 +741,7 @@ reissue_ticket_cont (void *cls, * @param attrs the attributes */ static void -ticket_reissue_proc (void *cls, - const struct GNUNET_RECLAIM_Ticket *ticket, +ticket_reissue_proc (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket, const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs) { struct TicketRevocationHandle *rh = cls; @@ -838,30 +754,20 @@ ticket_reissue_proc (void *cls, char *authz_record_data; char *label; - - if (NULL == ticket) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Iteration done\n"); + if (NULL == ticket) { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iteration done\n"); return; } - if (0 == memcmp (&ticket->audience, - &rh->ticket.audience, - sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))) - { + if (0 == memcmp (&ticket->audience, &rh->ticket.audience, + sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Do not reissue for this identity.!\n"); label = GNUNET_STRINGS_data_to_string_alloc (&rh->ticket.rnd, sizeof (uint64_t)); - //Delete record - rh->ns_qe = GNUNET_NAMESTORE_records_store (nsh, - &rh->identity, - label, - 0, - NULL, - &reissue_ticket_cont, - rh); + // Delete record + rh->ns_qe = GNUNET_NAMESTORE_records_store (nsh, &rh->identity, label, 0, + NULL, &reissue_ticket_cont, rh); GNUNET_free (label); return; @@ -871,38 +777,29 @@ ticket_reissue_proc (void *cls, * Check if any attribute of this ticket intersects with a rollover attribute */ reissue_ticket = GNUNET_NO; - for (le = attrs->list_head; NULL != le; le = le->next) - { - for (tue = rh->attr_updates_head; - NULL != tue; - tue = tue->next) - { - if (tue->old_id == le->claim->id) - { + for (le = attrs->list_head; NULL != le; le = le->next) { + for (tue = rh->attr_updates_head; NULL != tue; tue = tue->next) { + if (tue->old_id == le->claim->id) { reissue_ticket = GNUNET_YES; le->claim->id = tue->new_id; } } } - if (GNUNET_NO == reissue_ticket) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Skipping ticket.\n"); + if (GNUNET_NO == reissue_ticket) { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Skipping ticket.\n"); rh->offset++; GNUNET_SCHEDULER_add_now (&reissue_next, rh); return; } - //Create new ABE key for RP + // Create new ABE key for RP /* If this is the RP we want to revoke attributes of, the do so */ - //TODO rename function - authz_record_len = serialize_authz_record (ticket, - attrs, - &ecdhe_privkey, + // TODO rename function + authz_record_len = serialize_authz_record (ticket, attrs, &ecdhe_privkey, &authz_record_data); code_record[0].data = authz_record_data; code_record[0].data_size = authz_record_len; @@ -910,46 +807,30 @@ ticket_reissue_proc (void *cls, code_record[0].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_AUTHZ; code_record[0].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION; - label = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd, - sizeof (uint64_t)); - //Publish record - rh->ns_qe = GNUNET_NAMESTORE_records_store (nsh, - &rh->identity, - label, - 1, - code_record, - &reissue_ticket_cont, - rh); + label = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd, sizeof (uint64_t)); + // Publish record + rh->ns_qe = GNUNET_NAMESTORE_records_store ( + nsh, &rh->identity, label, 1, code_record, &reissue_ticket_cont, rh); GNUNET_free (ecdhe_privkey); GNUNET_free (label); GNUNET_free (authz_record_data); } - /* Prototype for below function */ -static void -attr_reenc_cont (void *cls, - int32_t success, - const char *emsg); +static void attr_reenc_cont (void *cls, int32_t success, const char *emsg); -static void -revocation_reissue_tickets (struct TicketRevocationHandle *rh) +static void revocation_reissue_tickets (struct TicketRevocationHandle *rh) { int ret; /* Done, issue new keys */ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Revocation Phase III: Reissuing Tickets\n"); - if (GNUNET_SYSERR == (ret = TKT_database->iterate_tickets (TKT_database->cls, - &rh->ticket.identity, - GNUNET_NO, - rh->offset, - &ticket_reissue_proc, - rh))) - { + if (GNUNET_SYSERR == (ret = TKT_database->iterate_tickets ( + TKT_database->cls, &rh->ticket.identity, GNUNET_NO, + rh->offset, &ticket_reissue_proc, rh))) { GNUNET_break (0); } - if (GNUNET_NO == ret) - { + if (GNUNET_NO == ret) { send_revocation_finished (rh, GNUNET_OK); cleanup_revoke_ticket_handle (rh); return; @@ -959,8 +840,7 @@ revocation_reissue_tickets (struct TicketRevocationHandle *rh) /** * Failed to check for attribute */ -static void -check_attr_error (void *cls) +static void check_attr_error (void *cls) { struct TicketRevocationHandle *rh = cls; GNUNET_log (GNUNET_ERROR_TYPE_ERROR, @@ -970,156 +850,121 @@ check_attr_error (void *cls) cleanup_revoke_ticket_handle (rh); } - /** * Revoke next attribte by reencryption with * new ABE master */ -static void -reenc_next_attribute (void *cls); +static void reenc_next_attribute (void *cls); /** * Check for existing attribute and overwrite */ -static void -check_attr_cb (void *cls, - const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, - const char *label, - unsigned int rd_count, - const struct GNUNET_GNSRECORD_Data *rd_old) +static void check_attr_cb (void *cls, + const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, + const char *label, unsigned int rd_count, + const struct GNUNET_GNSRECORD_Data *rd_old) { struct TicketRevocationHandle *rh = cls; struct TicketAttributeUpdateEntry *tue; struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *le; struct GNUNET_GNSRECORD_Data rd[1]; - char* buf; + char *buf; size_t buf_size; - char* new_label; + char *new_label; rh->ns_qe = NULL; if (1 != rd_count) { le = rh->attrs->list_head; - GNUNET_CONTAINER_DLL_remove (rh->attrs->list_head, - rh->attrs->list_tail, + GNUNET_CONTAINER_DLL_remove (rh->attrs->list_head, rh->attrs->list_tail, le); GNUNET_assert (NULL != rh->rvk_attrs); GNUNET_CONTAINER_DLL_insert (rh->rvk_attrs->list_head, - rh->rvk_attrs->list_tail, - le); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Re-encrypting next attribute\n"); - GNUNET_SCHEDULER_add_now (&reenc_next_attribute, - rh); + rh->rvk_attrs->list_tail, le); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Re-encrypting next attribute\n"); + GNUNET_SCHEDULER_add_now (&reenc_next_attribute, rh); return; } - buf_size = GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size (rh->attrs->list_head->claim); + buf_size = + GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size (rh->attrs->list_head->claim); buf = GNUNET_malloc (buf_size); rh->attrs->list_head->claim->version++; - GNUNET_RECLAIM_ATTRIBUTE_serialize (rh->attrs->list_head->claim, - buf); + GNUNET_RECLAIM_ATTRIBUTE_serialize (rh->attrs->list_head->claim, buf); tue = GNUNET_new (struct TicketAttributeUpdateEntry); tue->old_id = rh->attrs->list_head->claim->id; - tue->new_id = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG, - UINT64_MAX); - GNUNET_CONTAINER_DLL_insert (rh->attr_updates_head, - rh->attr_updates_tail, + tue->new_id = + GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG, UINT64_MAX); + GNUNET_CONTAINER_DLL_insert (rh->attr_updates_head, rh->attr_updates_tail, tue); rh->attrs->list_head->claim->id = tue->new_id; - new_label = GNUNET_STRINGS_data_to_string_alloc (&tue->new_id, - sizeof (uint64_t)); - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "New attr id %s\n", new_label); + new_label = + GNUNET_STRINGS_data_to_string_alloc (&tue->new_id, sizeof (uint64_t)); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "New attr id %s\n", new_label); rd[0].data_size = buf_size; rd[0].data = buf; rd[0].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR; rd[0].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION; rd[0].expiration_time = rd_old[0].expiration_time; - rh->ns_qe = GNUNET_NAMESTORE_records_store (nsh, - &rh->identity, - new_label, - 1, - rd, - &attr_reenc_cont, - rh); + rh->ns_qe = GNUNET_NAMESTORE_records_store (nsh, &rh->identity, new_label, 1, + rd, &attr_reenc_cont, rh); } - /** * Revoke next attribte by reencryption with * new ABE master */ -static void -reenc_next_attribute (void *cls) +static void reenc_next_attribute (void *cls) { struct TicketRevocationHandle *rh = cls; char *label; - if (NULL == rh->attrs->list_head) - { + if (NULL == rh->attrs->list_head) { revocation_reissue_tickets (rh); return; } /* First check if attribute still exists */ label = GNUNET_STRINGS_data_to_string_alloc (&rh->attrs->list_head->claim->id, sizeof (uint64_t)); - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ID: %lu\n", rh->attrs->list_head->claim->id); - rh->ns_qe = GNUNET_NAMESTORE_records_lookup (nsh, - &rh->identity, - label, - &check_attr_error, - rh, - &check_attr_cb, - rh); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ID: %lu\n", + rh->attrs->list_head->claim->id); + rh->ns_qe = GNUNET_NAMESTORE_records_lookup ( + nsh, &rh->identity, label, &check_attr_error, rh, &check_attr_cb, rh); GNUNET_free (label); } - /** * Namestore callback after revoked attribute * is stored */ -static void -attr_reenc_cont (void *cls, - int32_t success, - const char *emsg) +static void attr_reenc_cont (void *cls, int32_t success, const char *emsg) { struct TicketRevocationHandle *rh = cls; struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *le; rh->ns_qe = NULL; - if (GNUNET_SYSERR == success) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Failed to reencrypt attribute %s\n", + if (GNUNET_SYSERR == success) { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to reencrypt attribute %s\n", emsg); GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); return; } - if (NULL == rh->attrs->list_head) - { + if (NULL == rh->attrs->list_head) { revocation_reissue_tickets (rh); return; } le = rh->attrs->list_head; - GNUNET_CONTAINER_DLL_remove (rh->attrs->list_head, - rh->attrs->list_tail, - le); + GNUNET_CONTAINER_DLL_remove (rh->attrs->list_head, rh->attrs->list_tail, le); GNUNET_assert (NULL != rh->rvk_attrs); GNUNET_CONTAINER_DLL_insert (rh->rvk_attrs->list_head, - rh->rvk_attrs->list_tail, - le); - + rh->rvk_attrs->list_tail, le); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Re-encrypting next attribute\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Re-encrypting next attribute\n"); reenc_next_attribute (rh); } -static void -process_attributes_to_update (void *cls, - const struct GNUNET_RECLAIM_Ticket *ticket, - const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs) +static void process_attributes_to_update ( + void *cls, const struct GNUNET_RECLAIM_Ticket *ticket, + const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs) { struct TicketRevocationHandle *rh = cls; @@ -1127,8 +972,7 @@ process_attributes_to_update (void *cls, GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Revocation Phase I: Collecting attributes\n"); /* Reencrypt all attributes with new key */ - if (NULL == rh->attrs->list_head) - { + if (NULL == rh->attrs->list_head) { /* No attributes to reencrypt */ send_revocation_finished (rh, GNUNET_OK); cleanup_revoke_ticket_handle (rh); @@ -1138,65 +982,52 @@ process_attributes_to_update (void *cls, "Revocation Phase II: Re-encrypting attributes\n"); reenc_next_attribute (rh); } - } - -static int -check_revoke_ticket_message(void *cls, - const struct RevokeTicketMessage *im) +static int check_revoke_ticket_message (void *cls, + const struct RevokeTicketMessage *im) { uint16_t size; size = ntohs (im->header.size); - if (size <= sizeof (struct RevokeTicketMessage)) - { + if (size <= sizeof (struct RevokeTicketMessage)) { GNUNET_break (0); return GNUNET_SYSERR; } return GNUNET_OK; } -static void -handle_revoke_ticket_message (void *cls, - const struct RevokeTicketMessage *rm) +static void handle_revoke_ticket_message (void *cls, + const struct RevokeTicketMessage *rm) { struct TicketRevocationHandle *rh; struct IdpClient *idp = cls; struct GNUNET_RECLAIM_Ticket *ticket; rh = GNUNET_new (struct TicketRevocationHandle); - ticket = (struct GNUNET_RECLAIM_Ticket*)&rm[1]; + ticket = (struct GNUNET_RECLAIM_Ticket *)&rm[1]; rh->rvk_attrs = GNUNET_new (struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList); rh->ticket = *ticket; rh->r_id = ntohl (rm->id); rh->client = idp; rh->identity = rm->identity; - GNUNET_CRYPTO_ecdsa_key_get_public (&rh->identity, - &rh->ticket.identity); - GNUNET_CONTAINER_DLL_insert (idp->revoke_op_head, - idp->revoke_op_tail, - rh); + GNUNET_CRYPTO_ecdsa_key_get_public (&rh->identity, &rh->ticket.identity); + GNUNET_CONTAINER_DLL_insert (idp->revoke_op_head, idp->revoke_op_tail, rh); /** * TODO replace with GNS storage */ - TKT_database->get_ticket_attributes (TKT_database->cls, - &rh->ticket, - &process_attributes_to_update, - rh); + TKT_database->get_ticket_attributes (TKT_database->cls, &rh->ticket, + &process_attributes_to_update, rh); GNUNET_SERVICE_client_continue (idp->client); - } -static int -check_consume_ticket_message (void *cls, - const struct ConsumeTicketMessage *cm) +static int check_consume_ticket_message (void *cls, + const struct ConsumeTicketMessage *cm) { uint16_t size; size = ntohs (cm->header.size); - if (size <= sizeof (struct ConsumeTicketMessage)) - { + if (size <= sizeof (struct ConsumeTicketMessage)) { GNUNET_break (0); return GNUNET_SYSERR; } @@ -1207,42 +1038,33 @@ static void consume_result_cb (void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs, - uint32_t success, - const char *emsg) + uint32_t success, const char *emsg) { struct ConsumeTicketOperation *cop = cls; struct ConsumeTicketResultMessage *crm; struct GNUNET_MQ_Envelope *env; char *data_tmp; size_t attrs_len; - if (GNUNET_OK != success) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Error consuming ticket: %s\n", - emsg); + if (GNUNET_OK != success) { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error consuming ticket: %s\n", emsg); } attrs_len = GNUNET_RECLAIM_ATTRIBUTE_list_serialize_get_size (attrs); - env = GNUNET_MQ_msg_extra (crm, - attrs_len, + env = GNUNET_MQ_msg_extra (crm, attrs_len, GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT); crm->id = htonl (cop->r_id); crm->attrs_len = htons (attrs_len); crm->identity = *identity; crm->result = htonl (success); - data_tmp = (char *) &crm[1]; - GNUNET_RECLAIM_ATTRIBUTE_list_serialize (attrs, - data_tmp); + data_tmp = (char *)&crm[1]; + GNUNET_RECLAIM_ATTRIBUTE_list_serialize (attrs, data_tmp); GNUNET_MQ_send (cop->client->mq, env); GNUNET_CONTAINER_DLL_remove (cop->client->consume_op_head, - cop->client->consume_op_tail, - cop); + cop->client->consume_op_tail, cop); GNUNET_free (cop); - } static void -handle_consume_ticket_message (void *cls, - const struct ConsumeTicketMessage *cm) +handle_consume_ticket_message (void *cls, const struct ConsumeTicketMessage *cm) { struct ConsumeTicketOperation *cop; struct GNUNET_RECLAIM_Ticket *ticket; @@ -1251,14 +1073,10 @@ handle_consume_ticket_message (void *cls, cop = GNUNET_new (struct ConsumeTicketOperation); cop->r_id = ntohl (cm->id); cop->client = idp; - ticket = (struct GNUNET_RECLAIM_Ticket*)&cm[1]; - cop->ch = RECLAIM_TICKETS_consume (&cm->identity, - ticket, - &consume_result_cb, - cop); - GNUNET_CONTAINER_DLL_insert (idp->consume_op_head, - idp->consume_op_tail, - cop); + ticket = (struct GNUNET_RECLAIM_Ticket *)&cm[1]; + cop->ch = + RECLAIM_TICKETS_consume (&cm->identity, ticket, &consume_result_cb, cop); + GNUNET_CONTAINER_DLL_insert (idp->consume_op_head, idp->consume_op_tail, cop); GNUNET_SERVICE_client_continue (idp->client); } @@ -1271,8 +1089,7 @@ handle_consume_ticket_message (void *cls, * * @param handle handle to clean up */ -static void -cleanup_as_handle (struct AttributeStoreHandle *ash) +static void cleanup_as_handle (struct AttributeStoreHandle *ash) { if (NULL != ash->ns_qe) GNUNET_NAMESTORE_cancel (ash->ns_qe); @@ -1281,10 +1098,7 @@ cleanup_as_handle (struct AttributeStoreHandle *ash) GNUNET_free (ash); } -static void -attr_store_cont (void *cls, - int32_t success, - const char *emsg) +static void attr_store_cont (void *cls, int32_t success, const char *emsg) { struct AttributeStoreHandle *ash = cls; struct GNUNET_MQ_Envelope *env; @@ -1292,13 +1106,10 @@ attr_store_cont (void *cls, ash->ns_qe = NULL; GNUNET_CONTAINER_DLL_remove (ash->client->store_op_head, - ash->client->store_op_tail, - ash); + ash->client->store_op_tail, ash); - if (GNUNET_SYSERR == success) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Failed to store attribute %s\n", + if (GNUNET_SYSERR == success) { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to store attribute %s\n", emsg); cleanup_as_handle (ash); GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); @@ -1311,8 +1122,7 @@ attr_store_cont (void *cls, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE_RESPONSE); acr_msg->id = htonl (ash->r_id); acr_msg->op_result = htonl (GNUNET_OK); - GNUNET_MQ_send (ash->client->mq, - env); + GNUNET_MQ_send (ash->client->mq, env); cleanup_as_handle (ash); } @@ -1321,61 +1131,49 @@ attr_store_cont (void *cls, * * @param cls the AttributeStoreHandle */ -static void -attr_store_task (void *cls) +static void attr_store_task (void *cls) { struct AttributeStoreHandle *ash = cls; struct GNUNET_GNSRECORD_Data rd[1]; - char* buf; - char* label; + char *buf; + char *label; size_t buf_size; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Storing attribute\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing attribute\n"); buf_size = GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size (ash->claim); buf = GNUNET_malloc (buf_size); - //Give the ash a new id - ash->claim->id = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG, - UINT64_MAX); - GNUNET_RECLAIM_ATTRIBUTE_serialize (ash->claim, - buf); - label = GNUNET_STRINGS_data_to_string_alloc (&ash->claim->id, - sizeof (uint64_t)); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Encrypting with label %s\n", label); + // Give the ash a new id + ash->claim->id = + GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG, UINT64_MAX); + GNUNET_RECLAIM_ATTRIBUTE_serialize (ash->claim, buf); + label = + GNUNET_STRINGS_data_to_string_alloc (&ash->claim->id, sizeof (uint64_t)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypting with label %s\n", label); rd[0].data_size = buf_size; rd[0].data = buf; rd[0].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR; rd[0].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION; rd[0].expiration_time = ash->exp.rel_value_us; - ash->ns_qe = GNUNET_NAMESTORE_records_store (nsh, - &ash->identity, - label, - 1, - rd, - &attr_store_cont, - ash); + ash->ns_qe = GNUNET_NAMESTORE_records_store (nsh, &ash->identity, label, 1, + rd, &attr_store_cont, ash); GNUNET_free (buf); } - static int -check_attribute_store_message(void *cls, - const struct AttributeStoreMessage *sam) +check_attribute_store_message (void *cls, + const struct AttributeStoreMessage *sam) { uint16_t size; size = ntohs (sam->header.size); - if (size <= sizeof (struct AttributeStoreMessage)) - { + if (size <= sizeof (struct AttributeStoreMessage)) { GNUNET_break (0); return GNUNET_SYSERR; } return GNUNET_OK; } - static void handle_attribute_store_message (void *cls, const struct AttributeStoreMessage *sam) @@ -1383,26 +1181,21 @@ handle_attribute_store_message (void *cls, struct AttributeStoreHandle *ash; struct IdpClient *idp = cls; size_t data_len; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received ATTRIBUTE_STORE message\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_STORE message\n"); data_len = ntohs (sam->attr_len); ash = GNUNET_new (struct AttributeStoreHandle); - ash->claim = GNUNET_RECLAIM_ATTRIBUTE_deserialize ((char*)&sam[1], - data_len); + ash->claim = GNUNET_RECLAIM_ATTRIBUTE_deserialize ((char *)&sam[1], data_len); ash->r_id = ntohl (sam->id); ash->identity = sam->identity; ash->exp.rel_value_us = GNUNET_ntohll (sam->exp); - GNUNET_CRYPTO_ecdsa_key_get_public (&sam->identity, - &ash->identity_pkey); + GNUNET_CRYPTO_ecdsa_key_get_public (&sam->identity, &ash->identity_pkey); GNUNET_SERVICE_client_continue (idp->client); ash->client = idp; - GNUNET_CONTAINER_DLL_insert (idp->store_op_head, - idp->store_op_tail, - ash); + GNUNET_CONTAINER_DLL_insert (idp->store_op_head, idp->store_op_tail, ash); GNUNET_SCHEDULER_add_now (&attr_store_task, ash); } @@ -1410,85 +1203,66 @@ handle_attribute_store_message (void *cls, * Attrubute iteration *************************************************/ -static void -cleanup_attribute_iter_handle (struct AttributeIterator *ai) +static void cleanup_attribute_iter_handle (struct AttributeIterator *ai) { GNUNET_free (ai); } -static void -attr_iter_error (void *cls) +static void attr_iter_error (void *cls) { struct AttributeIterator *ai = cls; - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Failed to iterate over attributes\n"); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over attributes\n"); GNUNET_CONTAINER_DLL_remove (ai->client->attr_iter_head, - ai->client->attr_iter_tail, - ai); + ai->client->attr_iter_tail, ai); cleanup_attribute_iter_handle (ai); GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); } -static void -attr_iter_finished (void *cls) +static void attr_iter_finished (void *cls) { struct AttributeIterator *ai = cls; struct GNUNET_MQ_Envelope *env; struct AttributeResultMessage *arm; - env = GNUNET_MQ_msg (arm, - GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT); + env = GNUNET_MQ_msg (arm, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT); arm->id = htonl (ai->request_id); arm->attr_len = htons (0); GNUNET_MQ_send (ai->client->mq, env); GNUNET_CONTAINER_DLL_remove (ai->client->attr_iter_head, - ai->client->attr_iter_tail, - ai); + ai->client->attr_iter_tail, ai); cleanup_attribute_iter_handle (ai); } -static void -attr_iter_cb (void *cls, - const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, - const char *label, - unsigned int rd_count, - const struct GNUNET_GNSRECORD_Data *rd) +static void attr_iter_cb (void *cls, + const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, + const char *label, unsigned int rd_count, + const struct GNUNET_GNSRECORD_Data *rd) { struct AttributeIterator *ai = cls; struct AttributeResultMessage *arm; struct GNUNET_MQ_Envelope *env; - char* data_tmp; + char *data_tmp; - if (rd_count != 1) - { - GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, - 1); + if (rd_count != 1) { + GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1); return; } - if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR != rd->record_type) - { - GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, - 1); + if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR != rd->record_type) { + GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1); return; } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Found attribute under: %s\n", label); - env = GNUNET_MQ_msg_extra (arm, - rd->data_size, + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found attribute under: %s\n", label); + env = GNUNET_MQ_msg_extra (arm, rd->data_size, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT); arm->id = htonl (ai->request_id); arm->attr_len = htons (rd->data_size); - GNUNET_CRYPTO_ecdsa_key_get_public (zone, - &arm->identity); - data_tmp = (char *) &arm[1]; - GNUNET_memcpy (data_tmp, - rd->data, - rd->data_size); + GNUNET_CRYPTO_ecdsa_key_get_public (zone, &arm->identity); + data_tmp = (char *)&arm[1]; + GNUNET_memcpy (data_tmp, rd->data, rd->data_size); GNUNET_MQ_send (ai->client->mq, env); } - static void handle_iteration_start (void *cls, const struct AttributeIterationStartMessage *ais_msg) @@ -1503,21 +1277,13 @@ handle_iteration_start (void *cls, ai->client = idp; ai->identity = ais_msg->identity; - GNUNET_CONTAINER_DLL_insert (idp->attr_iter_head, - idp->attr_iter_tail, - ai); - ai->ns_it = GNUNET_NAMESTORE_zone_iteration_start (nsh, - &ai->identity, - &attr_iter_error, - ai, - &attr_iter_cb, - ai, - &attr_iter_finished, - ai); + GNUNET_CONTAINER_DLL_insert (idp->attr_iter_head, idp->attr_iter_tail, ai); + ai->ns_it = GNUNET_NAMESTORE_zone_iteration_start ( + nsh, &ai->identity, &attr_iter_error, ai, &attr_iter_cb, ai, + &attr_iter_finished, ai); GNUNET_SERVICE_client_continue (idp->client); } - static void handle_iteration_stop (void *cls, const struct AttributeIterationStopMessage *ais_msg) @@ -1526,27 +1292,22 @@ handle_iteration_stop (void *cls, struct AttributeIterator *ai; uint32_t rid; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received `%s' message\n", + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "ATTRIBUTE_ITERATION_STOP"); rid = ntohl (ais_msg->id); for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next) if (ai->request_id == rid) break; - if (NULL == ai) - { + if (NULL == ai) { GNUNET_break (0); GNUNET_SERVICE_client_drop (idp->client); return; } - GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, - idp->attr_iter_tail, - ai); + GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai); GNUNET_free (ai); GNUNET_SERVICE_client_continue (idp->client); } - static void handle_iteration_next (void *cls, const struct AttributeIterationNextMessage *ais_msg) @@ -1561,14 +1322,12 @@ handle_iteration_next (void *cls, for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next) if (ai->request_id == rid) break; - if (NULL == ai) - { + if (NULL == ai) { GNUNET_break (0); GNUNET_SERVICE_client_drop (idp->client); return; } - GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, - 1); + GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1); GNUNET_SERVICE_client_continue (idp->client); } @@ -1576,37 +1335,29 @@ handle_iteration_next (void *cls, * Ticket iteration ******************************************************/ -static void -ticket_iter_cb (void *cls, - struct GNUNET_RECLAIM_Ticket *ticket) +static void ticket_iter_cb (void *cls, struct GNUNET_RECLAIM_Ticket *ticket) { struct TicketIteration *ti = cls; struct GNUNET_MQ_Envelope *env; struct TicketResultMessage *trm; - if (NULL == ticket) - { + if (NULL == ticket) { /* send empty response to indicate end of list */ - env = GNUNET_MQ_msg (trm, - GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); + env = GNUNET_MQ_msg (trm, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); GNUNET_CONTAINER_DLL_remove (ti->client->ticket_iter_head, - ti->client->ticket_iter_tail, - ti); + ti->client->ticket_iter_tail, ti); } else { - env = GNUNET_MQ_msg_extra (trm, - sizeof (struct GNUNET_RECLAIM_Ticket), + env = GNUNET_MQ_msg_extra (trm, sizeof (struct GNUNET_RECLAIM_Ticket), GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); } trm->id = htonl (ti->r_id); - GNUNET_MQ_send (ti->client->mq, - env); + GNUNET_MQ_send (ti->client->mq, env); if (NULL == ticket) GNUNET_free (ti); } -static void -handle_ticket_iteration_start (void *cls, - const struct TicketIterationStartMessage *tis_msg) +static void handle_ticket_iteration_start ( + void *cls, const struct TicketIterationStartMessage *tis_msg) { struct IdpClient *client = cls; struct TicketIteration *ti; @@ -1618,15 +1369,12 @@ handle_ticket_iteration_start (void *cls, ti->client = client; GNUNET_CONTAINER_DLL_insert (client->ticket_iter_head, - client->ticket_iter_tail, - ti); - ti->iter = RECLAIM_TICKETS_iteration_start (&tis_msg->identity, - &ticket_iter_cb, - ti); + client->ticket_iter_tail, ti); + ti->iter = + RECLAIM_TICKETS_iteration_start (&tis_msg->identity, &ticket_iter_cb, ti); GNUNET_SERVICE_client_continue (client->client); } - static void handle_ticket_iteration_stop (void *cls, const struct TicketIterationStopMessage *tis_msg) @@ -1635,28 +1383,24 @@ handle_ticket_iteration_stop (void *cls, struct TicketIteration *ti; uint32_t rid; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received `%s' message\n", + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n", "TICKET_ITERATION_STOP"); rid = ntohl (tis_msg->id); for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next) if (ti->r_id == rid) break; - if (NULL == ti) - { + if (NULL == ti) { GNUNET_break (0); GNUNET_SERVICE_client_drop (client->client); return; } RECLAIM_TICKETS_iteration_stop (ti->iter); GNUNET_CONTAINER_DLL_remove (client->ticket_iter_head, - client->ticket_iter_tail, - ti); + client->ticket_iter_tail, ti); GNUNET_free (ti); GNUNET_SERVICE_client_continue (client->client); } - static void handle_ticket_iteration_next (void *cls, const struct TicketIterationNextMessage *tis_msg) @@ -1671,8 +1415,7 @@ handle_ticket_iteration_next (void *cls, for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next) if (ti->r_id == rid) break; - if (NULL == ti) - { + if (NULL == ti) { GNUNET_break (0); GNUNET_SERVICE_client_drop (client->client); return; @@ -1681,9 +1424,6 @@ handle_ticket_iteration_next (void *cls, GNUNET_SERVICE_client_continue (client->client); } - - - /** * Main function that will be run * @@ -1691,65 +1431,46 @@ handle_ticket_iteration_next (void *cls, * @param c the configuration used * @param server the service handle */ -static void -run (void *cls, - const struct GNUNET_CONFIGURATION_Handle *c, - struct GNUNET_SERVICE_Handle *server) +static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, + struct GNUNET_SERVICE_Handle *server) { char *database; cfg = c; - - if (GNUNET_OK != RECLAIM_TICKETS_init (cfg)) - { + if (GNUNET_OK != RECLAIM_TICKETS_init (cfg)) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unable to initialized TICKETS subsystem.\n"); GNUNET_SCHEDULER_shutdown (); return; } - //Connect to identity and namestore services + // Connect to identity and namestore services nsh = GNUNET_NAMESTORE_connect (cfg); - if (NULL == nsh) - { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "error connecting to namestore"); + if (NULL == nsh) { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, + "error connecting to namestore"); } - identity_handle = GNUNET_IDENTITY_connect (cfg, - NULL, - NULL); + identity_handle = GNUNET_IDENTITY_connect (cfg, NULL, NULL); /* Loading DB plugin */ - if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_string (cfg, - "reclaim", - "database", - &database)) - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "No database backend configured\n"); - GNUNET_asprintf (&db_lib_name, - "libgnunet_plugin_reclaim_%s", - database); - TKT_database = GNUNET_PLUGIN_load (db_lib_name, - (void *) cfg); + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string ( + cfg, "reclaim", "database", &database)) + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No database backend configured\n"); + GNUNET_asprintf (&db_lib_name, "libgnunet_plugin_reclaim_%s", database); + TKT_database = GNUNET_PLUGIN_load (db_lib_name, (void *)cfg); GNUNET_free (database); - if (NULL == TKT_database) - { + if (NULL == TKT_database) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Could not load database backend `%s'\n", - db_lib_name); + "Could not load database backend `%s'\n", db_lib_name); GNUNET_SCHEDULER_shutdown (); return; } - if (GNUNET_OK == - GNUNET_CONFIGURATION_get_value_time (cfg, - "reclaim", - "TOKEN_EXPIRATION_INTERVAL", - &token_expiration_interval)) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Time window for zone iteration: %s\n", - GNUNET_STRINGS_relative_time_to_string (token_expiration_interval, - GNUNET_YES)); + if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_time ( + cfg, "reclaim", "TOKEN_EXPIRATION_INTERVAL", + &token_expiration_interval)) { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Time window for zone iteration: %s\n", + GNUNET_STRINGS_relative_time_to_string ( + token_expiration_interval, GNUNET_YES)); } else { token_expiration_interval = DEFAULT_TOKEN_EXPIRATION_INTERVAL; } @@ -1764,10 +1485,9 @@ run (void *cls, * @param client identification of the client * @param app_ctx @a client */ -static void -client_disconnect_cb (void *cls, - struct GNUNET_SERVICE_Client *client, - void *app_ctx) +static void client_disconnect_cb (void *cls, + struct GNUNET_SERVICE_Client *client, + void *app_ctx) { struct IdpClient *idp = app_ctx; struct AttributeIterator *ai; @@ -1777,61 +1497,42 @@ client_disconnect_cb (void *cls, struct ConsumeTicketOperation *ct; struct AttributeStoreHandle *as; - //TODO other operations + // TODO other operations - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Client %p disconnected\n", - client); - - while (NULL != (iss = idp->issue_op_head)) - { - GNUNET_CONTAINER_DLL_remove (idp->issue_op_head, - idp->issue_op_tail, - iss); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p disconnected\n", client); + + while (NULL != (iss = idp->issue_op_head)) { + GNUNET_CONTAINER_DLL_remove (idp->issue_op_head, idp->issue_op_tail, iss); GNUNET_free (iss); } - while (NULL != (ct = idp->consume_op_head)) - { - GNUNET_CONTAINER_DLL_remove (idp->consume_op_head, - idp->consume_op_tail, + while (NULL != (ct = idp->consume_op_head)) { + GNUNET_CONTAINER_DLL_remove (idp->consume_op_head, idp->consume_op_tail, ct); if (NULL != ct->ch) RECLAIM_TICKETS_consume_cancel (ct->ch); GNUNET_free (ct); } - while (NULL != (as = idp->store_op_head)) - { - GNUNET_CONTAINER_DLL_remove (idp->store_op_head, - idp->store_op_tail, - as); + while (NULL != (as = idp->store_op_head)) { + GNUNET_CONTAINER_DLL_remove (idp->store_op_head, idp->store_op_tail, as); cleanup_as_handle (as); } - while (NULL != (ai = idp->attr_iter_head)) - { - GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, - idp->attr_iter_tail, - ai); + while (NULL != (ai = idp->attr_iter_head)) { + GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai); cleanup_attribute_iter_handle (ai); } - while (NULL != (rh = idp->revoke_op_head)) - { - GNUNET_CONTAINER_DLL_remove (idp->revoke_op_head, - idp->revoke_op_tail, - rh); + while (NULL != (rh = idp->revoke_op_head)) { + GNUNET_CONTAINER_DLL_remove (idp->revoke_op_head, idp->revoke_op_tail, rh); cleanup_revoke_ticket_handle (rh); } - while (NULL != (ti = idp->ticket_iter_head)) - { - GNUNET_CONTAINER_DLL_remove (idp->ticket_iter_head, - idp->ticket_iter_tail, + while (NULL != (ti = idp->ticket_iter_head)) { + GNUNET_CONTAINER_DLL_remove (idp->ticket_iter_head, idp->ticket_iter_tail, ti); GNUNET_free (ti); } GNUNET_free (idp); } - /** * Add a client to our list of active clients. * @@ -1840,72 +1541,52 @@ client_disconnect_cb (void *cls, * @param mq message queue for @a client * @return internal namestore client structure for this client */ -static void * -client_connect_cb (void *cls, - struct GNUNET_SERVICE_Client *client, - struct GNUNET_MQ_Handle *mq) +static void *client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, + struct GNUNET_MQ_Handle *mq) { struct IdpClient *idp; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Client %p connected\n", - client); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client); idp = GNUNET_new (struct IdpClient); idp->client = client; idp->mq = mq; return idp; } - - /** * Define "main" method using service macro. */ -GNUNET_SERVICE_MAIN -("reclaim", - GNUNET_SERVICE_OPTION_NONE, - &run, - &client_connect_cb, - &client_disconnect_cb, - NULL, - GNUNET_MQ_hd_var_size (attribute_store_message, - GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE, - struct AttributeStoreMessage, - NULL), - GNUNET_MQ_hd_fixed_size (iteration_start, - GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START, - struct AttributeIterationStartMessage, - NULL), - GNUNET_MQ_hd_fixed_size (iteration_next, - GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT, - struct AttributeIterationNextMessage, - NULL), - GNUNET_MQ_hd_fixed_size (iteration_stop, - GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP, - struct AttributeIterationStopMessage, - NULL), - GNUNET_MQ_hd_var_size (issue_ticket_message, - GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET, - struct IssueTicketMessage, - NULL), - GNUNET_MQ_hd_var_size (consume_ticket_message, - GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET, - struct ConsumeTicketMessage, - NULL), - GNUNET_MQ_hd_fixed_size (ticket_iteration_start, - GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START, - struct TicketIterationStartMessage, - NULL), - GNUNET_MQ_hd_fixed_size (ticket_iteration_next, - GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT, - struct TicketIterationNextMessage, - NULL), - GNUNET_MQ_hd_fixed_size (ticket_iteration_stop, - GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_STOP, - struct TicketIterationStopMessage, - NULL), - GNUNET_MQ_hd_var_size (revoke_ticket_message, - GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET, - struct RevokeTicketMessage, - NULL), - GNUNET_MQ_handler_end()); +GNUNET_SERVICE_MAIN ( + "reclaim", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, + &client_disconnect_cb, NULL, + GNUNET_MQ_hd_var_size (attribute_store_message, + GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE, + struct AttributeStoreMessage, NULL), + GNUNET_MQ_hd_fixed_size ( + iteration_start, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START, + struct AttributeIterationStartMessage, NULL), + GNUNET_MQ_hd_fixed_size ( + iteration_next, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT, + struct AttributeIterationNextMessage, NULL), + GNUNET_MQ_hd_fixed_size ( + iteration_stop, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP, + struct AttributeIterationStopMessage, NULL), + GNUNET_MQ_hd_var_size (issue_ticket_message, + GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET, + struct IssueTicketMessage, NULL), + GNUNET_MQ_hd_var_size (consume_ticket_message, + GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET, + struct ConsumeTicketMessage, NULL), + GNUNET_MQ_hd_fixed_size (ticket_iteration_start, + GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START, + struct TicketIterationStartMessage, NULL), + GNUNET_MQ_hd_fixed_size (ticket_iteration_next, + GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT, + struct TicketIterationNextMessage, NULL), + GNUNET_MQ_hd_fixed_size (ticket_iteration_stop, + GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_STOP, + struct TicketIterationStopMessage, NULL), + GNUNET_MQ_hd_var_size (revoke_ticket_message, + GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET, + struct RevokeTicketMessage, NULL), + GNUNET_MQ_handler_end ()); /* end of gnunet-service-reclaim.c */ diff --git a/src/reclaim/gnunet-service-reclaim_tickets.c b/src/reclaim/gnunet-service-reclaim_tickets.c index a39a4be5a..54e5659a4 100644 --- a/src/reclaim/gnunet-service-reclaim_tickets.c +++ b/src/reclaim/gnunet-service-reclaim_tickets.c @@ -28,8 +28,7 @@ struct ParallelLookup; -struct RECLAIM_TICKETS_ConsumeHandle -{ +struct RECLAIM_TICKETS_ConsumeHandle { /** * Ticket */ @@ -84,14 +83,12 @@ struct RECLAIM_TICKETS_ConsumeHandle * Callbacl closure */ void *cb_cls; - }; /** * Handle for a parallel GNS lookup job */ -struct ParallelLookup -{ +struct ParallelLookup { /* DLL */ struct ParallelLookup *next; @@ -117,8 +114,7 @@ struct ParallelLookup /** * A reference to a ticket stored in GNS */ -struct TicketReference -{ +struct TicketReference { /** * DLL */ @@ -144,8 +140,7 @@ struct TicketReference /** * Ticket issue request handle */ -struct TicketIssueHandle -{ +struct TicketIssueHandle { /** * Attributes to issue */ @@ -190,14 +185,12 @@ struct TicketIssueHandle * Callback cls */ void *cb_cls; - }; /** * Ticket iterator */ -struct RECLAIM_TICKETS_Iterator -{ +struct RECLAIM_TICKETS_Iterator { /** * Issuer Key */ @@ -243,26 +236,25 @@ static struct GNUNET_GNS_Handle *gns; /* Handle to the statistics service */ static struct GNUNET_STATISTICS_Handle *stats; -static int -create_sym_key_from_ecdh (const struct GNUNET_HashCode *new_key_hash, - struct GNUNET_CRYPTO_SymmetricSessionKey *skey, - struct GNUNET_CRYPTO_SymmetricInitializationVector *iv) +static int create_sym_key_from_ecdh ( + const struct GNUNET_HashCode *new_key_hash, + struct GNUNET_CRYPTO_SymmetricSessionKey *skey, + struct GNUNET_CRYPTO_SymmetricInitializationVector *iv) { struct GNUNET_CRYPTO_HashAsciiEncoded new_key_hash_str; - GNUNET_CRYPTO_hash_to_enc (new_key_hash, - &new_key_hash_str); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating symmetric rsa key from %s\n", (char*)&new_key_hash_str); + GNUNET_CRYPTO_hash_to_enc (new_key_hash, &new_key_hash_str); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating symmetric rsa key from %s\n", + (char *)&new_key_hash_str); static const char ctx_key[] = "gnuid-aes-ctx-key"; GNUNET_CRYPTO_kdf (skey, sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey), - new_key_hash, sizeof (struct GNUNET_HashCode), - ctx_key, strlen (ctx_key), - NULL, 0); + new_key_hash, sizeof (struct GNUNET_HashCode), ctx_key, + strlen (ctx_key), NULL, 0); static const char ctx_iv[] = "gnuid-aes-ctx-iv"; - GNUNET_CRYPTO_kdf (iv, sizeof (struct GNUNET_CRYPTO_SymmetricInitializationVector), - new_key_hash, sizeof (struct GNUNET_HashCode), - ctx_iv, strlen (ctx_iv), - NULL, 0); + GNUNET_CRYPTO_kdf ( + iv, sizeof (struct GNUNET_CRYPTO_SymmetricInitializationVector), + new_key_hash, sizeof (struct GNUNET_HashCode), ctx_iv, strlen (ctx_iv), + NULL, 0); return GNUNET_OK; } @@ -271,21 +263,18 @@ create_sym_key_from_ecdh (const struct GNUNET_HashCode *new_key_hash, * Cleanup ticket consume handle * @param cth the handle to clean up */ -static void -cleanup_cth (struct RECLAIM_TICKETS_ConsumeHandle *cth) +static void cleanup_cth (struct RECLAIM_TICKETS_ConsumeHandle *cth) { struct ParallelLookup *lu; struct ParallelLookup *tmp; if (NULL != cth->lookup_request) GNUNET_GNS_lookup_cancel (cth->lookup_request); - for (lu = cth->parallel_lookups_head; - NULL != lu;) { + for (lu = cth->parallel_lookups_head; NULL != lu;) { GNUNET_GNS_lookup_cancel (lu->lookup_request); GNUNET_free (lu->label); tmp = lu->next; GNUNET_CONTAINER_DLL_remove (cth->parallel_lookups_head, - cth->parallel_lookups_tail, - lu); + cth->parallel_lookups_tail, lu); GNUNET_free (lu); lu = tmp; } @@ -297,90 +286,69 @@ cleanup_cth (struct RECLAIM_TICKETS_ConsumeHandle *cth) static void -process_parallel_lookup_result (void *cls, - uint32_t rd_count, - const struct GNUNET_GNSRECORD_Data *rd) +process_parallel_lookup_result (void *cls, uint32_t rd_count, + const struct GNUNET_GNSRECORD_Data *rd) { struct ParallelLookup *parallel_lookup = cls; struct RECLAIM_TICKETS_ConsumeHandle *cth = parallel_lookup->handle; struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *attr_le; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Parallel lookup finished (count=%u)\n", rd_count); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Parallel lookup finished (count=%u)\n", + rd_count); GNUNET_CONTAINER_DLL_remove (cth->parallel_lookups_head, - cth->parallel_lookups_tail, - parallel_lookup); + cth->parallel_lookups_tail, parallel_lookup); GNUNET_free (parallel_lookup->label); - GNUNET_STATISTICS_update (stats, - "attribute_lookup_time_total", - GNUNET_TIME_absolute_get_duration (parallel_lookup->lookup_start_time).rel_value_us, - GNUNET_YES); - GNUNET_STATISTICS_update (stats, - "attribute_lookups_count", - 1, - GNUNET_YES); + GNUNET_STATISTICS_update ( + stats, "attribute_lookup_time_total", + GNUNET_TIME_absolute_get_duration (parallel_lookup->lookup_start_time) + .rel_value_us, + GNUNET_YES); + GNUNET_STATISTICS_update (stats, "attribute_lookups_count", 1, GNUNET_YES); GNUNET_free (parallel_lookup); if (1 != rd_count) - GNUNET_break(0);//TODO - if (rd->record_type == GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR) - { + GNUNET_break (0); // TODO + if (rd->record_type == GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR) { attr_le = GNUNET_new (struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry); - attr_le->claim = GNUNET_RECLAIM_ATTRIBUTE_deserialize (rd->data, - rd->data_size); - GNUNET_CONTAINER_DLL_insert (cth->attrs->list_head, - cth->attrs->list_tail, + attr_le->claim = + GNUNET_RECLAIM_ATTRIBUTE_deserialize (rd->data, rd->data_size); + GNUNET_CONTAINER_DLL_insert (cth->attrs->list_head, cth->attrs->list_tail, attr_le); } if (NULL != cth->parallel_lookups_head) - return; //Wait for more + return; // Wait for more /* Else we are done */ GNUNET_SCHEDULER_cancel (cth->kill_task); - cth->cb (cth->cb_cls, - &cth->ticket.identity, - cth->attrs, - GNUNET_OK, - NULL); + cth->cb (cth->cb_cls, &cth->ticket.identity, cth->attrs, GNUNET_OK, NULL); cleanup_cth (cth); } -static void -abort_parallel_lookups (void *cls) +static void abort_parallel_lookups (void *cls) { struct RECLAIM_TICKETS_ConsumeHandle *cth = cls; struct ParallelLookup *lu; struct ParallelLookup *tmp; cth->kill_task = NULL; - for (lu = cth->parallel_lookups_head; - NULL != lu;) { + for (lu = cth->parallel_lookups_head; NULL != lu;) { GNUNET_GNS_lookup_cancel (lu->lookup_request); GNUNET_free (lu->label); tmp = lu->next; GNUNET_CONTAINER_DLL_remove (cth->parallel_lookups_head, - cth->parallel_lookups_tail, - lu); + cth->parallel_lookups_tail, lu); GNUNET_free (lu); lu = tmp; } - cth->cb (cth->cb_cls, - NULL, - NULL, - GNUNET_SYSERR, - "Aborted"); - + cth->cb (cth->cb_cls, NULL, NULL, GNUNET_SYSERR, "Aborted"); } - -static void -lookup_authz_cb (void *cls, - uint32_t rd_count, - const struct GNUNET_GNSRECORD_Data *rd) +static void lookup_authz_cb (void *cls, uint32_t rd_count, + const struct GNUNET_GNSRECORD_Data *rd) { struct RECLAIM_TICKETS_ConsumeHandle *cth = cls; struct GNUNET_HashCode new_key_hash; @@ -394,125 +362,90 @@ lookup_authz_cb (void *cls, char *lbls; cth->lookup_request = NULL; - if (1 != rd_count) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Number of keys %d != 1.", - rd_count); - cth->cb (cth->cb_cls, - NULL, - NULL, - GNUNET_SYSERR, - "Number of keys %d != 1."); + if (1 != rd_count) { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Number of keys %d != 1.", rd_count); + cth->cb (cth->cb_cls, NULL, NULL, GNUNET_SYSERR, "Number of keys %d != 1."); cleanup_cth (cth); return; } - //Decrypt + // Decrypt ecdh_key = (struct GNUNET_CRYPTO_EcdhePublicKey *)rd->data; - buf = GNUNET_malloc (rd->data_size - - sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)); - - //Calculate symmetric key from ecdh parameters - GNUNET_assert (GNUNET_OK == - GNUNET_CRYPTO_ecdsa_ecdh (&cth->identity, - ecdh_key, - &new_key_hash)); - create_sym_key_from_ecdh (&new_key_hash, - &enc_key, - &enc_iv); - size = GNUNET_CRYPTO_symmetric_decrypt (rd->data - + sizeof (struct GNUNET_CRYPTO_EcdhePublicKey), - rd->data_size - - sizeof (struct GNUNET_CRYPTO_EcdhePublicKey), - &enc_key, - &enc_iv, - buf); + buf = GNUNET_malloc (rd->data_size - + sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)); + + // Calculate symmetric key from ecdh parameters + GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecdsa_ecdh ( + &cth->identity, ecdh_key, &new_key_hash)); + create_sym_key_from_ecdh (&new_key_hash, &enc_key, &enc_iv); + size = GNUNET_CRYPTO_symmetric_decrypt ( + rd->data + sizeof (struct GNUNET_CRYPTO_EcdhePublicKey), + rd->data_size - sizeof (struct GNUNET_CRYPTO_EcdhePublicKey), &enc_key, + &enc_iv, buf); GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Decrypted bytes: %zd Expected bytes: %zd\n", - size, + "Decrypted bytes: %zd Expected bytes: %zd\n", size, rd->data_size - sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)); - GNUNET_STATISTICS_update (stats, - "reclaim_authz_lookup_time_total", - GNUNET_TIME_absolute_get_duration (cth->lookup_start_time).rel_value_us, - GNUNET_YES); - GNUNET_STATISTICS_update (stats, - "reclaim_authz_lookups_count", - 1, + GNUNET_STATISTICS_update ( + stats, "reclaim_authz_lookup_time_total", + GNUNET_TIME_absolute_get_duration (cth->lookup_start_time).rel_value_us, + GNUNET_YES); + GNUNET_STATISTICS_update (stats, "reclaim_authz_lookups_count", 1, GNUNET_YES); lbls = GNUNET_strdup (buf); - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Attributes found %s\n", lbls); - - for (attr_lbl = strtok (lbls, ","); - NULL != attr_lbl; - attr_lbl = strtok (NULL, ",")) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Looking up %s\n", attr_lbl); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Attributes found %s\n", lbls); + + for (attr_lbl = strtok (lbls, ","); NULL != attr_lbl; + attr_lbl = strtok (NULL, ",")) { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Looking up %s\n", attr_lbl); parallel_lookup = GNUNET_new (struct ParallelLookup); parallel_lookup->handle = cth; parallel_lookup->label = GNUNET_strdup (attr_lbl); - parallel_lookup->lookup_start_time = GNUNET_TIME_absolute_get(); - parallel_lookup->lookup_request - = GNUNET_GNS_lookup (gns, - attr_lbl, - &cth->ticket.identity, - GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR, - GNUNET_GNS_LO_DEFAULT, - &process_parallel_lookup_result, - parallel_lookup); + parallel_lookup->lookup_start_time = GNUNET_TIME_absolute_get (); + parallel_lookup->lookup_request = GNUNET_GNS_lookup ( + gns, attr_lbl, &cth->ticket.identity, + GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR, GNUNET_GNS_LO_DEFAULT, + &process_parallel_lookup_result, parallel_lookup); GNUNET_CONTAINER_DLL_insert (cth->parallel_lookups_head, - cth->parallel_lookups_tail, - parallel_lookup); + cth->parallel_lookups_tail, parallel_lookup); } GNUNET_free (lbls); GNUNET_free (buf); cth->kill_task = GNUNET_SCHEDULER_add_delayed ( - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES,3), - &abort_parallel_lookups, - cth); + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 3), + &abort_parallel_lookups, cth); } - -struct RECLAIM_TICKETS_ConsumeHandle* +struct RECLAIM_TICKETS_ConsumeHandle * RECLAIM_TICKETS_consume (const struct GNUNET_CRYPTO_EcdsaPrivateKey *id, - const struct GNUNET_RECLAIM_Ticket *ticket, - RECLAIM_TICKETS_ConsumeCallback cb, - void* cb_cls) + const struct GNUNET_RECLAIM_Ticket *ticket, + RECLAIM_TICKETS_ConsumeCallback cb, void *cb_cls) { struct RECLAIM_TICKETS_ConsumeHandle *cth; char *label; cth = GNUNET_new (struct RECLAIM_TICKETS_ConsumeHandle); cth->identity = *id; - GNUNET_CRYPTO_ecdsa_key_get_public (&cth->identity, - &cth->identity_pub); + GNUNET_CRYPTO_ecdsa_key_get_public (&cth->identity, &cth->identity_pub); cth->attrs = GNUNET_new (struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList); cth->ticket = *ticket; cth->cb = cb; cth->cb_cls = cb_cls; - label = GNUNET_STRINGS_data_to_string_alloc (&cth->ticket.rnd, - sizeof (uint64_t)); - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Looking for AuthZ info under %s\n", label); + label = + GNUNET_STRINGS_data_to_string_alloc (&cth->ticket.rnd, sizeof (uint64_t)); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Looking for AuthZ info under %s\n", + label); cth->lookup_start_time = GNUNET_TIME_absolute_get (); - cth->lookup_request = GNUNET_GNS_lookup (gns, - label, - &cth->ticket.identity, - GNUNET_GNSRECORD_TYPE_RECLAIM_AUTHZ, - GNUNET_GNS_LO_DEFAULT, - &lookup_authz_cb, - cth); + cth->lookup_request = GNUNET_GNS_lookup ( + gns, label, &cth->ticket.identity, GNUNET_GNSRECORD_TYPE_RECLAIM_AUTHZ, + GNUNET_GNS_LO_DEFAULT, &lookup_authz_cb, cth); GNUNET_free (label); return cth; } -void -RECLAIM_TICKETS_consume_cancel (struct RECLAIM_TICKETS_ConsumeHandle *cth) +void RECLAIM_TICKETS_consume_cancel (struct RECLAIM_TICKETS_ConsumeHandle *cth) { cleanup_cth (cth); return; @@ -527,8 +460,7 @@ RECLAIM_TICKETS_consume_cancel (struct RECLAIM_TICKETS_ConsumeHandle *cth) * Cleanup ticket consume handle * @param handle the handle to clean up */ -static void -cleanup_issue_handle (struct TicketIssueHandle *handle) +static void cleanup_issue_handle (struct TicketIssueHandle *handle) { struct TicketReference *tr; struct TicketReference *tr_tmp; @@ -536,8 +468,7 @@ cleanup_issue_handle (struct TicketIssueHandle *handle) GNUNET_RECLAIM_ATTRIBUTE_list_destroy (handle->attrs); if (NULL != handle->ns_qe) GNUNET_NAMESTORE_cancel (handle->ns_qe); - for (tr = handle->ticket_refs_head; NULL != tr;) - { + for (tr = handle->ticket_refs_head; NULL != tr;) { if (NULL != tr->attrs) GNUNET_RECLAIM_ATTRIBUTE_list_destroy (tr->attrs); tr_tmp = tr; @@ -548,156 +479,119 @@ cleanup_issue_handle (struct TicketIssueHandle *handle) } - -static void -store_ticket_refs_cont (void *cls, - int32_t success, - const char *emsg) +static void store_ticket_refs_cont (void *cls, int32_t success, + const char *emsg) { struct TicketIssueHandle *handle = cls; handle->ns_qe = NULL; - if (GNUNET_OK != success) - { - handle->cb (handle->cb_cls, - NULL, - GNUNET_SYSERR, + if (GNUNET_OK != success) { + handle->cb (handle->cb_cls, NULL, GNUNET_SYSERR, "Error storing updated ticket refs in GNS"); cleanup_issue_handle (handle); return; } - handle->cb (handle->cb_cls, - &handle->ticket, - GNUNET_OK, - NULL); + handle->cb (handle->cb_cls, &handle->ticket, GNUNET_OK, NULL); cleanup_issue_handle (handle); } - -static void -update_ticket_refs (void* cls) +static void update_ticket_refs (void *cls) { struct TicketIssueHandle *handle = cls; struct GNUNET_GNSRECORD_Data refs_rd[handle->ticket_ref_num]; struct TicketReference *tr; - char* buf; + char *buf; size_t buf_size; tr = handle->ticket_refs_head; - for (int i = 0; i < handle->ticket_ref_num; i++) - { + for (int i = 0; i < handle->ticket_ref_num; i++) { buf_size = GNUNET_RECLAIM_ATTRIBUTE_list_serialize_get_size (tr->attrs); buf_size += sizeof (struct GNUNET_RECLAIM_Ticket); buf = GNUNET_malloc (buf_size); memcpy (buf, &tr->ticket, sizeof (struct GNUNET_RECLAIM_Ticket)); - GNUNET_RECLAIM_ATTRIBUTE_list_serialize (tr->attrs, - buf + sizeof (struct GNUNET_RECLAIM_Ticket)); + GNUNET_RECLAIM_ATTRIBUTE_list_serialize ( + tr->attrs, buf + sizeof (struct GNUNET_RECLAIM_Ticket)); refs_rd[i].data = buf; refs_rd[i].data_size = buf_size; refs_rd[i].expiration_time = GNUNET_TIME_UNIT_DAYS.rel_value_us; refs_rd[i].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_TICKETREF; - refs_rd[i].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION | - GNUNET_GNSRECORD_RF_PRIVATE; + refs_rd[i].flags = + GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION | GNUNET_GNSRECORD_RF_PRIVATE; tr = tr->next; } - handle->ns_qe = GNUNET_NAMESTORE_records_store (nsh, - &handle->identity, - GNUNET_GNS_EMPTY_LABEL_AT, - handle->ticket_ref_num, - refs_rd, - &store_ticket_refs_cont, - handle); + handle->ns_qe = GNUNET_NAMESTORE_records_store ( + nsh, &handle->identity, GNUNET_GNS_EMPTY_LABEL_AT, handle->ticket_ref_num, + refs_rd, &store_ticket_refs_cont, handle); for (int i = 0; i < handle->ticket_ref_num; i++) - GNUNET_free ((char*)refs_rd[i].data); + GNUNET_free ((char *)refs_rd[i].data); } - -static void -ticket_lookup_cb (void *cls, - const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, - const char *label, - unsigned int rd_count, - const struct GNUNET_GNSRECORD_Data *rd) +static void ticket_lookup_cb (void *cls, + const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, + const char *label, unsigned int rd_count, + const struct GNUNET_GNSRECORD_Data *rd) { struct TicketIssueHandle *handle = cls; struct TicketReference *tr; - const char* attr_data; + const char *attr_data; size_t attr_data_len; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received tickets from local namestore.\n"); handle->ns_qe = NULL; - for (int i = 0; i < rd_count; i++) - { + for (int i = 0; i < rd_count; i++) { if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKETREF != rd[i].record_type) continue; tr = GNUNET_new (struct TicketReference); - memcpy (&tr->ticket, rd[i].data, - sizeof (struct GNUNET_RECLAIM_Ticket)); - if (0 != memcmp (&tr->ticket.identity, - &handle->ticket.identity, - sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))) - { - //Not our ticket + memcpy (&tr->ticket, rd[i].data, sizeof (struct GNUNET_RECLAIM_Ticket)); + if (0 != memcmp (&tr->ticket.identity, &handle->ticket.identity, + sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))) { + // Not our ticket GNUNET_free (tr); continue; } attr_data = rd[i].data + sizeof (struct GNUNET_RECLAIM_Ticket); attr_data_len = rd[i].data_size - sizeof (struct GNUNET_RECLAIM_Ticket); - tr->attrs = GNUNET_RECLAIM_ATTRIBUTE_list_deserialize (attr_data, - attr_data_len); + tr->attrs = + GNUNET_RECLAIM_ATTRIBUTE_list_deserialize (attr_data, attr_data_len); GNUNET_CONTAINER_DLL_insert (handle->ticket_refs_head, - handle->ticket_refs_tail, - tr); + handle->ticket_refs_tail, tr); handle->ticket_ref_num++; } tr = GNUNET_new (struct TicketReference); tr->ticket = handle->ticket; tr->attrs = GNUNET_RECLAIM_ATTRIBUTE_list_dup (handle->attrs); GNUNET_CONTAINER_DLL_insert (handle->ticket_refs_head, - handle->ticket_refs_tail, - tr); + handle->ticket_refs_tail, tr); handle->ticket_ref_num++; GNUNET_SCHEDULER_add_now (&update_ticket_refs, handle); } -static void -ticket_lookup_error_cb (void *cls) +static void ticket_lookup_error_cb (void *cls) { struct TicketIssueHandle *handle = cls; handle->ns_qe = NULL; - handle->cb (handle->cb_cls, - &handle->ticket, - GNUNET_SYSERR, + handle->cb (handle->cb_cls, &handle->ticket, GNUNET_SYSERR, "Error checking for ticketsin GNS\n"); cleanup_issue_handle (handle); } -static void -store_ticket_issue_cont (void *cls, - int32_t success, - const char *emsg) +static void store_ticket_issue_cont (void *cls, int32_t success, + const char *emsg) { struct TicketIssueHandle *handle = cls; handle->ns_qe = NULL; - if (GNUNET_SYSERR == success) - { - handle->cb (handle->cb_cls, - &handle->ticket, - GNUNET_SYSERR, + if (GNUNET_SYSERR == success) { + handle->cb (handle->cb_cls, &handle->ticket, GNUNET_SYSERR, "Error storing AuthZ ticket in GNS"); return; } /* First, local references to tickets */ - handle->ns_qe = GNUNET_NAMESTORE_records_lookup (nsh, - &handle->identity, - GNUNET_GNS_EMPTY_LABEL_AT, - &ticket_lookup_error_cb, - handle, - &ticket_lookup_cb, - handle); + handle->ns_qe = GNUNET_NAMESTORE_records_lookup ( + nsh, &handle->identity, GNUNET_GNS_EMPTY_LABEL_AT, + &ticket_lookup_error_cb, handle, &ticket_lookup_cb, handle); } @@ -717,63 +611,53 @@ serialize_authz_record (const struct GNUNET_RECLAIM_Ticket *ticket, char *buf; char *write_ptr; char attrs_str_len; - char* label; + char *label; GNUNET_assert (NULL != attrs->list_head); attrs_str_len = 0; for (le = attrs->list_head; NULL != le; le = le->next) { - attrs_str_len += 15 + 1; //TODO propery calculate + attrs_str_len += 15 + 1; // TODO propery calculate } buf = GNUNET_malloc (attrs_str_len); write_ptr = buf; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Writing attributes\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Writing attributes\n"); for (le = attrs->list_head; NULL != le; le = le->next) { - label = GNUNET_STRINGS_data_to_string_alloc (&le->claim->id, - sizeof (uint64_t)); - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Adding attribute to record: %s\n", label); - - GNUNET_memcpy (write_ptr, - label, - strlen (label)); + label = + GNUNET_STRINGS_data_to_string_alloc (&le->claim->id, sizeof (uint64_t)); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Adding attribute to record: %s\n", + label); + + GNUNET_memcpy (write_ptr, label, strlen (label)); write_ptr[strlen (label)] = ','; write_ptr += strlen (label) + 1; GNUNET_free (label); } write_ptr--; - write_ptr[0] = '\0'; //replace last , with a 0-terminator + write_ptr[0] = '\0'; // replace last , with a 0-terminator // ECDH keypair E = eG - *ecdh_privkey = GNUNET_CRYPTO_ecdhe_key_create(); - GNUNET_CRYPTO_ecdhe_key_get_public (*ecdh_privkey, - &ecdh_pubkey); + *ecdh_privkey = GNUNET_CRYPTO_ecdhe_key_create (); + GNUNET_CRYPTO_ecdhe_key_get_public (*ecdh_privkey, &ecdh_pubkey); enc_keyinfo = GNUNET_malloc (attrs_str_len); // Derived key K = H(eB) GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecdh_ecdsa (*ecdh_privkey, &ticket->audience, &new_key_hash)); create_sym_key_from_ecdh (&new_key_hash, &skey, &iv); - enc_size = GNUNET_CRYPTO_symmetric_encrypt (buf, - attrs_str_len, - &skey, &iv, + enc_size = GNUNET_CRYPTO_symmetric_encrypt (buf, attrs_str_len, &skey, &iv, enc_keyinfo); - *result = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)+ - enc_size); - GNUNET_memcpy (*result, - &ecdh_pubkey, + *result = + GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) + enc_size); + GNUNET_memcpy (*result, &ecdh_pubkey, sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)); GNUNET_memcpy (*result + sizeof (struct GNUNET_CRYPTO_EcdhePublicKey), - enc_keyinfo, - enc_size); + enc_keyinfo, enc_size); GNUNET_free (enc_keyinfo); GNUNET_free (buf); - return sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)+enc_size; + return sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) + enc_size; } - -static void -issue_ticket (struct TicketIssueHandle *ih) +static void issue_ticket (struct TicketIssueHandle *ih) { struct GNUNET_CRYPTO_EcdhePrivateKey *ecdhe_privkey; struct GNUNET_GNSRECORD_Data code_record[1]; @@ -781,41 +665,31 @@ issue_ticket (struct TicketIssueHandle *ih) size_t authz_record_len; char *label; - //TODO rename function - authz_record_len = serialize_authz_record (&ih->ticket, - ih->attrs, - &ecdhe_privkey, - &authz_record_data); + // TODO rename function + authz_record_len = serialize_authz_record ( + &ih->ticket, ih->attrs, &ecdhe_privkey, &authz_record_data); code_record[0].data = authz_record_data; code_record[0].data_size = authz_record_len; code_record[0].expiration_time = GNUNET_TIME_UNIT_DAYS.rel_value_us; code_record[0].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_AUTHZ; code_record[0].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION; - label = GNUNET_STRINGS_data_to_string_alloc (&ih->ticket.rnd, - sizeof (uint64_t)); - //Publish record - ih->ns_qe = GNUNET_NAMESTORE_records_store (nsh, - &ih->identity, - label, - 1, - code_record, - &store_ticket_issue_cont, - ih); + label = + GNUNET_STRINGS_data_to_string_alloc (&ih->ticket.rnd, sizeof (uint64_t)); + // Publish record + ih->ns_qe = GNUNET_NAMESTORE_records_store ( + nsh, &ih->identity, label, 1, code_record, &store_ticket_issue_cont, ih); GNUNET_free (ecdhe_privkey); GNUNET_free (label); GNUNET_free (authz_record_data); } - - -void -RECLAIM_TICKETS_issue (const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, - const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs, - const struct GNUNET_CRYPTO_EcdsaPublicKey *audience, - RECLAIM_TICKETS_TicketResult cb, - void* cb_cls) +void RECLAIM_TICKETS_issue ( + const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, + const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs, + const struct GNUNET_CRYPTO_EcdsaPublicKey *audience, + RECLAIM_TICKETS_TicketResult cb, void *cb_cls) { struct TicketIssueHandle *tih; tih = GNUNET_new (struct TicketIssueHandle); @@ -823,11 +697,9 @@ RECLAIM_TICKETS_issue (const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, tih->cb_cls = cb_cls; tih->attrs = GNUNET_RECLAIM_ATTRIBUTE_list_dup (attrs); tih->identity = *identity; - GNUNET_CRYPTO_ecdsa_key_get_public (identity, - &tih->ticket.identity); + GNUNET_CRYPTO_ecdsa_key_get_public (identity, &tih->ticket.identity); tih->ticket.rnd = - GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG, - UINT64_MAX); + GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG, UINT64_MAX); tih->ticket.audience = *audience; issue_ticket (tih); } @@ -836,15 +708,13 @@ RECLAIM_TICKETS_issue (const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, * Ticket iteration ************************************/ -static void -cleanup_iter (struct RECLAIM_TICKETS_Iterator *iter) +static void cleanup_iter (struct RECLAIM_TICKETS_Iterator *iter) { struct TicketReference *tr; struct TicketReference *tr_tmp; if (NULL != iter->ns_qe) GNUNET_NAMESTORE_cancel (iter->ns_qe); - for (tr = iter->tickets_head; NULL != tr;) - { + for (tr = iter->tickets_head; NULL != tr;) { if (NULL != tr->attrs) GNUNET_RECLAIM_ATTRIBUTE_list_destroy (tr->attrs); tr_tmp = tr; @@ -854,8 +724,7 @@ cleanup_iter (struct RECLAIM_TICKETS_Iterator *iter) GNUNET_free (iter); } -static void -do_cleanup_iter (void* cls) +static void do_cleanup_iter (void *cls) { struct RECLAIM_TICKETS_Iterator *iter = cls; cleanup_iter (iter); @@ -866,140 +735,109 @@ do_cleanup_iter (void* cls) * * @param ti ticket iterator to process */ -static void -run_ticket_iteration_round (struct RECLAIM_TICKETS_Iterator *iter) +static void run_ticket_iteration_round (struct RECLAIM_TICKETS_Iterator *iter) { struct TicketReference *tr; - if (NULL == iter->tickets_head) - { - //No more tickets - iter->cb (iter->cb_cls, - NULL); + if (NULL == iter->tickets_head) { + // No more tickets + iter->cb (iter->cb_cls, NULL); GNUNET_SCHEDULER_add_now (&do_cleanup_iter, iter); return; } tr = iter->tickets_head; - GNUNET_CONTAINER_DLL_remove (iter->tickets_head, - iter->tickets_tail, - tr); - iter->cb (iter->cb_cls, - &tr->ticket); + GNUNET_CONTAINER_DLL_remove (iter->tickets_head, iter->tickets_tail, tr); + iter->cb (iter->cb_cls, &tr->ticket); if (NULL != tr->attrs) GNUNET_RECLAIM_ATTRIBUTE_list_destroy (tr->attrs); GNUNET_free (tr); } static void -collect_tickets_cb (void *cls, - const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, - const char *label, - unsigned int rd_count, +collect_tickets_cb (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, + const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd) { struct RECLAIM_TICKETS_Iterator *iter = cls; struct TicketReference *tr; size_t attr_data_len; - const char* attr_data; + const char *attr_data; iter->ns_qe = NULL; - for (int i = 0; i < rd_count; i++) - { + for (int i = 0; i < rd_count; i++) { if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKETREF != rd[i].record_type) continue; tr = GNUNET_new (struct TicketReference); - memcpy (&tr->ticket, rd[i].data, - sizeof (struct GNUNET_RECLAIM_Ticket)); - if (0 != memcmp (&tr->ticket.identity, - &iter->identity_pub, - sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))) - { - //Not our ticket + memcpy (&tr->ticket, rd[i].data, sizeof (struct GNUNET_RECLAIM_Ticket)); + if (0 != memcmp (&tr->ticket.identity, &iter->identity_pub, + sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))) { + // Not our ticket GNUNET_free (tr); continue; } attr_data = rd[i].data + sizeof (struct GNUNET_RECLAIM_Ticket); attr_data_len = rd[i].data_size - sizeof (struct GNUNET_RECLAIM_Ticket); - tr->attrs = GNUNET_RECLAIM_ATTRIBUTE_list_deserialize (attr_data, - attr_data_len); - GNUNET_CONTAINER_DLL_insert (iter->tickets_head, - iter->tickets_tail, - tr); + tr->attrs = + GNUNET_RECLAIM_ATTRIBUTE_list_deserialize (attr_data, attr_data_len); + GNUNET_CONTAINER_DLL_insert (iter->tickets_head, iter->tickets_tail, tr); } run_ticket_iteration_round (iter); } -static void -collect_tickets_error_cb (void *cls) +static void collect_tickets_error_cb (void *cls) { struct RECLAIM_TICKETS_Iterator *iter = cls; iter->ns_qe = NULL; - iter->cb (iter->cb_cls, - NULL); + iter->cb (iter->cb_cls, NULL); cleanup_iter (iter); } -void -RECLAIM_TICKETS_iteration_next (struct RECLAIM_TICKETS_Iterator *iter) +void RECLAIM_TICKETS_iteration_next (struct RECLAIM_TICKETS_Iterator *iter) { run_ticket_iteration_round (iter); } -void -RECLAIM_TICKETS_iteration_stop (struct RECLAIM_TICKETS_Iterator *iter) +void RECLAIM_TICKETS_iteration_stop (struct RECLAIM_TICKETS_Iterator *iter) { cleanup_iter (iter); } -struct RECLAIM_TICKETS_Iterator* -RECLAIM_TICKETS_iteration_start (const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, - RECLAIM_TICKETS_TicketIter cb, - void* cb_cls) +struct RECLAIM_TICKETS_Iterator *RECLAIM_TICKETS_iteration_start ( + const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, + RECLAIM_TICKETS_TicketIter cb, void *cb_cls) { struct RECLAIM_TICKETS_Iterator *iter; iter = GNUNET_new (struct RECLAIM_TICKETS_Iterator); iter->identity = *identity; - GNUNET_CRYPTO_ecdsa_key_get_public (identity, - &iter->identity_pub); + GNUNET_CRYPTO_ecdsa_key_get_public (identity, &iter->identity_pub); iter->cb = cb; iter->cb_cls = cb_cls; - iter->ns_qe = GNUNET_NAMESTORE_records_lookup (nsh, - identity, - GNUNET_GNS_EMPTY_LABEL_AT, - &collect_tickets_error_cb, - iter, - &collect_tickets_cb, - iter); + iter->ns_qe = GNUNET_NAMESTORE_records_lookup ( + nsh, identity, GNUNET_GNS_EMPTY_LABEL_AT, &collect_tickets_error_cb, iter, + &collect_tickets_cb, iter); return iter; } - - -int -RECLAIM_TICKETS_init (const struct GNUNET_CONFIGURATION_Handle *c) +int RECLAIM_TICKETS_init (const struct GNUNET_CONFIGURATION_Handle *c) { - //Connect to identity and namestore services + // Connect to identity and namestore services nsh = GNUNET_NAMESTORE_connect (c); - if (NULL == nsh) - { + if (NULL == nsh) { GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "error connecting to namestore"); return GNUNET_SYSERR; } gns = GNUNET_GNS_connect (c); - if (NULL == gns) - { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, - "error connecting to gns"); + if (NULL == gns) { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "error connecting to gns"); return GNUNET_SYSERR; } stats = GNUNET_STATISTICS_create ("reclaim", c); return GNUNET_OK; } -void -RECLAIM_TICKETS_deinit (void) +void RECLAIM_TICKETS_deinit (void) { if (NULL != nsh) GNUNET_NAMESTORE_disconnect (nsh); @@ -1007,8 +845,7 @@ RECLAIM_TICKETS_deinit (void) if (NULL != gns) GNUNET_GNS_disconnect (gns); gns = NULL; - if (NULL != stats) - { + if (NULL != stats) { GNUNET_STATISTICS_destroy (stats, GNUNET_NO); stats = NULL; }