diff options
Diffstat (limited to 'src/reclaim/gnunet-service-reclaim.c')
-rw-r--r-- | src/reclaim/gnunet-service-reclaim.c | 299 |
1 files changed, 158 insertions, 141 deletions
diff --git a/src/reclaim/gnunet-service-reclaim.c b/src/reclaim/gnunet-service-reclaim.c index 84afd482e..d2cdc62a2 100644 --- a/src/reclaim/gnunet-service-reclaim.c +++ b/src/reclaim/gnunet-service-reclaim.c | |||
@@ -170,17 +170,17 @@ struct IdpClient | |||
170 | 170 | ||
171 | /** | 171 | /** |
172 | * Head of the DLL of | 172 | * Head of the DLL of |
173 | * Attribute iteration operations in | 173 | * Credential iteration operations in |
174 | * progress initiated by this client | 174 | * progress initiated by this client |
175 | */ | 175 | */ |
176 | struct Iterator *attest_iter_head; | 176 | struct Iterator *cred_iter_head; |
177 | 177 | ||
178 | /** | 178 | /** |
179 | * Tail of the DLL of | 179 | * Tail of the DLL of |
180 | * Attribute iteration operations | 180 | * Credential iteration operations |
181 | * in progress initiated by this client | 181 | * in progress initiated by this client |
182 | */ | 182 | */ |
183 | struct Iterator *attest_iter_tail; | 183 | struct Iterator *cred_iter_tail; |
184 | 184 | ||
185 | /** | 185 | /** |
186 | * Head of DLL of ticket iteration ops | 186 | * Head of DLL of ticket iteration ops |
@@ -285,9 +285,9 @@ struct AttributeDeleteHandle | |||
285 | struct GNUNET_RECLAIM_Attribute *claim; | 285 | struct GNUNET_RECLAIM_Attribute *claim; |
286 | 286 | ||
287 | /** | 287 | /** |
288 | * The attestation to delete | 288 | * The credential to delete |
289 | */ | 289 | */ |
290 | struct GNUNET_RECLAIM_Attestation *attest; | 290 | struct GNUNET_RECLAIM_Credential *credential; |
291 | 291 | ||
292 | /** | 292 | /** |
293 | * Tickets to update | 293 | * Tickets to update |
@@ -352,9 +352,9 @@ struct AttributeStoreHandle | |||
352 | struct GNUNET_RECLAIM_Attribute *claim; | 352 | struct GNUNET_RECLAIM_Attribute *claim; |
353 | 353 | ||
354 | /** | 354 | /** |
355 | * The attestation to store | 355 | * The credential to store |
356 | */ | 356 | */ |
357 | struct GNUNET_RECLAIM_Attestation *attest; | 357 | struct GNUNET_RECLAIM_Credential *credential; |
358 | 358 | ||
359 | /** | 359 | /** |
360 | * The attribute expiration interval | 360 | * The attribute expiration interval |
@@ -488,8 +488,8 @@ cleanup_adh (struct AttributeDeleteHandle *adh) | |||
488 | GNUNET_free (adh->label); | 488 | GNUNET_free (adh->label); |
489 | if (NULL != adh->claim) | 489 | if (NULL != adh->claim) |
490 | GNUNET_free (adh->claim); | 490 | GNUNET_free (adh->claim); |
491 | if (NULL != adh->attest) | 491 | if (NULL != adh->credential) |
492 | GNUNET_free (adh->attest); | 492 | GNUNET_free (adh->credential); |
493 | while (NULL != (le = adh->tickets_to_update_head)) | 493 | while (NULL != (le = adh->tickets_to_update_head)) |
494 | { | 494 | { |
495 | GNUNET_CONTAINER_DLL_remove (adh->tickets_to_update_head, | 495 | GNUNET_CONTAINER_DLL_remove (adh->tickets_to_update_head, |
@@ -517,8 +517,8 @@ cleanup_as_handle (struct AttributeStoreHandle *ash) | |||
517 | GNUNET_NAMESTORE_cancel (ash->ns_qe); | 517 | GNUNET_NAMESTORE_cancel (ash->ns_qe); |
518 | if (NULL != ash->claim) | 518 | if (NULL != ash->claim) |
519 | GNUNET_free (ash->claim); | 519 | GNUNET_free (ash->claim); |
520 | if (NULL != ash->attest) | 520 | if (NULL != ash->credential) |
521 | GNUNET_free (ash->attest); | 521 | GNUNET_free (ash->credential); |
522 | GNUNET_free (ash); | 522 | GNUNET_free (ash); |
523 | } | 523 | } |
524 | 524 | ||
@@ -569,9 +569,9 @@ cleanup_client (struct IdpClient *idp) | |||
569 | GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai); | 569 | GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai); |
570 | GNUNET_free (ai); | 570 | GNUNET_free (ai); |
571 | } | 571 | } |
572 | while (NULL != (ai = idp->attest_iter_head)) | 572 | while (NULL != (ai = idp->cred_iter_head)) |
573 | { | 573 | { |
574 | GNUNET_CONTAINER_DLL_remove (idp->attest_iter_head, idp->attest_iter_tail, | 574 | GNUNET_CONTAINER_DLL_remove (idp->cred_iter_head, idp->cred_iter_tail, |
575 | ai); | 575 | ai); |
576 | GNUNET_free (ai); | 576 | GNUNET_free (ai); |
577 | } | 577 | } |
@@ -646,19 +646,33 @@ static void | |||
646 | send_ticket_result (const struct IdpClient *client, | 646 | send_ticket_result (const struct IdpClient *client, |
647 | uint32_t r_id, | 647 | uint32_t r_id, |
648 | const struct GNUNET_RECLAIM_Ticket *ticket, | 648 | const struct GNUNET_RECLAIM_Ticket *ticket, |
649 | const struct GNUNET_RECLAIM_PresentationList *presentations, | ||
649 | uint32_t success) | 650 | uint32_t success) |
650 | { | 651 | { |
651 | struct TicketResultMessage *irm; | 652 | struct TicketResultMessage *irm; |
652 | struct GNUNET_MQ_Envelope *env; | 653 | struct GNUNET_MQ_Envelope *env; |
654 | size_t pres_len = 0; | ||
653 | 655 | ||
654 | env = GNUNET_MQ_msg (irm, | 656 | if (NULL != presentations) |
655 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); | 657 | { |
658 | pres_len = | ||
659 | GNUNET_RECLAIM_presentation_list_serialize_get_size (presentations); | ||
660 | } | ||
661 | env = GNUNET_MQ_msg_extra (irm, | ||
662 | pres_len, | ||
663 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); | ||
656 | if (NULL != ticket) | 664 | if (NULL != ticket) |
657 | { | 665 | { |
658 | irm->ticket = *ticket; | 666 | irm->ticket = *ticket; |
659 | } | 667 | } |
660 | // TODO add success member | 668 | // TODO add success member |
661 | irm->id = htonl (r_id); | 669 | irm->id = htonl (r_id); |
670 | irm->presentations_len = htons (pres_len); | ||
671 | if (NULL != presentations) | ||
672 | { | ||
673 | GNUNET_RECLAIM_presentation_list_serialize (presentations, | ||
674 | (char*) &irm[1]); | ||
675 | } | ||
662 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n"); | 676 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n"); |
663 | GNUNET_MQ_send (client->mq, env); | 677 | GNUNET_MQ_send (client->mq, env); |
664 | } | 678 | } |
@@ -669,12 +683,14 @@ send_ticket_result (const struct IdpClient *client, | |||
669 | * | 683 | * |
670 | * @param cls out ticket issue operation handle | 684 | * @param cls out ticket issue operation handle |
671 | * @param ticket the issued ticket | 685 | * @param ticket the issued ticket |
686 | * @param presentations newly created credential presentations (NULL on error) | ||
672 | * @param success issue success status (GNUNET_OK if successful) | 687 | * @param success issue success status (GNUNET_OK if successful) |
673 | * @param emsg error message (NULL of success is GNUNET_OK) | 688 | * @param emsg error message (NULL of success is GNUNET_OK) |
674 | */ | 689 | */ |
675 | static void | 690 | static void |
676 | issue_ticket_result_cb (void *cls, | 691 | issue_ticket_result_cb (void *cls, |
677 | struct GNUNET_RECLAIM_Ticket *ticket, | 692 | struct GNUNET_RECLAIM_Ticket *ticket, |
693 | struct GNUNET_RECLAIM_PresentationList *presentations, | ||
678 | int32_t success, | 694 | int32_t success, |
679 | const char *emsg) | 695 | const char *emsg) |
680 | { | 696 | { |
@@ -682,7 +698,7 @@ issue_ticket_result_cb (void *cls, | |||
682 | 698 | ||
683 | if (GNUNET_OK != success) | 699 | if (GNUNET_OK != success) |
684 | { | 700 | { |
685 | send_ticket_result (tio->client, tio->r_id, NULL, GNUNET_SYSERR); | 701 | send_ticket_result (tio->client, tio->r_id, NULL, NULL, GNUNET_SYSERR); |
686 | GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head, | 702 | GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head, |
687 | tio->client->issue_op_tail, | 703 | tio->client->issue_op_tail, |
688 | tio); | 704 | tio); |
@@ -690,7 +706,8 @@ issue_ticket_result_cb (void *cls, | |||
690 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error issuing ticket: %s\n", emsg); | 706 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error issuing ticket: %s\n", emsg); |
691 | return; | 707 | return; |
692 | } | 708 | } |
693 | send_ticket_result (tio->client, tio->r_id, ticket, GNUNET_SYSERR); | 709 | send_ticket_result (tio->client, tio->r_id, |
710 | ticket, presentations, GNUNET_SYSERR); | ||
694 | GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head, | 711 | GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head, |
695 | tio->client->issue_op_tail, | 712 | tio->client->issue_op_tail, |
696 | tio); | 713 | tio); |
@@ -847,7 +864,7 @@ static void | |||
847 | consume_result_cb (void *cls, | 864 | consume_result_cb (void *cls, |
848 | const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, | 865 | const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, |
849 | const struct GNUNET_RECLAIM_AttributeList *attrs, | 866 | const struct GNUNET_RECLAIM_AttributeList *attrs, |
850 | const struct GNUNET_RECLAIM_AttestationList *attests, | 867 | const struct GNUNET_RECLAIM_PresentationList *presentations, |
851 | int32_t success, | 868 | int32_t success, |
852 | const char *emsg) | 869 | const char *emsg) |
853 | { | 870 | { |
@@ -856,28 +873,28 @@ consume_result_cb (void *cls, | |||
856 | struct GNUNET_MQ_Envelope *env; | 873 | struct GNUNET_MQ_Envelope *env; |
857 | char *data_tmp; | 874 | char *data_tmp; |
858 | size_t attrs_len = 0; | 875 | size_t attrs_len = 0; |
859 | size_t attests_len = 0; | 876 | size_t pres_len = 0; |
860 | 877 | ||
861 | if (GNUNET_OK != success) | 878 | if (GNUNET_OK != success) |
862 | { | 879 | { |
863 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error consuming ticket: %s\n", emsg); | 880 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error consuming ticket: %s\n", emsg); |
864 | } | 881 | } |
865 | attrs_len = GNUNET_RECLAIM_attribute_list_serialize_get_size (attrs); | 882 | attrs_len = GNUNET_RECLAIM_attribute_list_serialize_get_size (attrs); |
866 | attests_len = GNUNET_RECLAIM_attestation_list_serialize_get_size (attests); | 883 | pres_len = GNUNET_RECLAIM_presentation_list_serialize_get_size (presentations); |
867 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 884 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
868 | "Sending CONSUME_TICKET_RESULT message\n"); | 885 | "Sending CONSUME_TICKET_RESULT message\n"); |
869 | env = GNUNET_MQ_msg_extra (crm, | 886 | env = GNUNET_MQ_msg_extra (crm, |
870 | attrs_len + attests_len, | 887 | attrs_len + pres_len, |
871 | GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT); | 888 | GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT); |
872 | crm->id = htonl (cop->r_id); | 889 | crm->id = htonl (cop->r_id); |
873 | crm->attrs_len = htons (attrs_len); | 890 | crm->attrs_len = htons (attrs_len); |
874 | crm->attestations_len = htons (attests_len); | 891 | crm->presentations_len = htons (pres_len); |
875 | crm->identity = *identity; | 892 | crm->identity = *identity; |
876 | crm->result = htonl (success); | 893 | crm->result = htonl (success); |
877 | data_tmp = (char *) &crm[1]; | 894 | data_tmp = (char *) &crm[1]; |
878 | GNUNET_RECLAIM_attribute_list_serialize (attrs, data_tmp); | 895 | GNUNET_RECLAIM_attribute_list_serialize (attrs, data_tmp); |
879 | data_tmp += attrs_len; | 896 | data_tmp += attrs_len; |
880 | GNUNET_RECLAIM_attestation_list_serialize (attests, data_tmp); | 897 | GNUNET_RECLAIM_presentation_list_serialize (presentations, data_tmp); |
881 | GNUNET_MQ_send (cop->client->mq, env); | 898 | GNUNET_MQ_send (cop->client->mq, env); |
882 | GNUNET_CONTAINER_DLL_remove (cop->client->consume_op_head, | 899 | GNUNET_CONTAINER_DLL_remove (cop->client->consume_op_head, |
883 | cop->client->consume_op_tail, | 900 | cop->client->consume_op_tail, |
@@ -1075,14 +1092,14 @@ handle_attribute_store_message (void *cls, | |||
1075 | 1092 | ||
1076 | 1093 | ||
1077 | /** | 1094 | /** |
1078 | * Attestation store result handler | 1095 | * Credential store result handler |
1079 | * | 1096 | * |
1080 | * @param cls our attribute store handle | 1097 | * @param cls our attribute store handle |
1081 | * @param success GNUNET_OK if successful | 1098 | * @param success GNUNET_OK if successful |
1082 | * @param emsg error message (NULL if success=GNUNET_OK) | 1099 | * @param emsg error message (NULL if success=GNUNET_OK) |
1083 | */ | 1100 | */ |
1084 | static void | 1101 | static void |
1085 | attest_store_cont (void *cls, int32_t success, const char *emsg) | 1102 | cred_store_cont (void *cls, int32_t success, const char *emsg) |
1086 | { | 1103 | { |
1087 | struct AttributeStoreHandle *ash = cls; | 1104 | struct AttributeStoreHandle *ash = cls; |
1088 | struct GNUNET_MQ_Envelope *env; | 1105 | struct GNUNET_MQ_Envelope *env; |
@@ -1096,7 +1113,7 @@ attest_store_cont (void *cls, int32_t success, const char *emsg) | |||
1096 | if (GNUNET_SYSERR == success) | 1113 | if (GNUNET_SYSERR == success) |
1097 | { | 1114 | { |
1098 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1115 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1099 | "Failed to store attestation %s\n", | 1116 | "Failed to store credential: %s\n", |
1100 | emsg); | 1117 | emsg); |
1101 | cleanup_as_handle (ash); | 1118 | cleanup_as_handle (ash); |
1102 | GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); | 1119 | GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); |
@@ -1113,16 +1130,16 @@ attest_store_cont (void *cls, int32_t success, const char *emsg) | |||
1113 | 1130 | ||
1114 | 1131 | ||
1115 | /** | 1132 | /** |
1116 | * Error looking up potential attestation. Abort. | 1133 | * Error looking up potential credential. Abort. |
1117 | * | 1134 | * |
1118 | * @param cls our attribute store handle | 1135 | * @param cls our attribute store handle |
1119 | */ | 1136 | */ |
1120 | static void | 1137 | static void |
1121 | attest_error (void *cls) | 1138 | cred_error (void *cls) |
1122 | { | 1139 | { |
1123 | struct AttributeStoreHandle *ash = cls; | 1140 | struct AttributeStoreHandle *ash = cls; |
1124 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1141 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1125 | "Failed to check for existing Attestation\n"); | 1142 | "Failed to check for existing credential.\n"); |
1126 | cleanup_as_handle (ash); | 1143 | cleanup_as_handle (ash); |
1127 | GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); | 1144 | GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); |
1128 | return; | 1145 | return; |
@@ -1130,7 +1147,7 @@ attest_error (void *cls) | |||
1130 | 1147 | ||
1131 | 1148 | ||
1132 | /** | 1149 | /** |
1133 | * Check for existing record before storing attestation | 1150 | * Check for existing record before storing credential |
1134 | * | 1151 | * |
1135 | * @param cls our attribute store handle | 1152 | * @param cls our attribute store handle |
1136 | * @param zone zone we are iterating | 1153 | * @param zone zone we are iterating |
@@ -1139,33 +1156,34 @@ attest_error (void *cls) | |||
1139 | * @param rd records | 1156 | * @param rd records |
1140 | */ | 1157 | */ |
1141 | static void | 1158 | static void |
1142 | attest_add_cb (void *cls, | 1159 | cred_add_cb (void *cls, |
1143 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, | 1160 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, |
1144 | const char *label, | 1161 | const char *label, |
1145 | unsigned int rd_count, | 1162 | unsigned int rd_count, |
1146 | const struct GNUNET_GNSRECORD_Data *rd) | 1163 | const struct GNUNET_GNSRECORD_Data *rd) |
1147 | { | 1164 | { |
1148 | struct AttributeStoreHandle *ash = cls; | 1165 | struct AttributeStoreHandle *ash = cls; |
1166 | struct GNUNET_GNSRECORD_Data rd_new[1]; | ||
1149 | char *buf; | 1167 | char *buf; |
1150 | size_t buf_size; | 1168 | size_t buf_size; |
1151 | buf_size = GNUNET_RECLAIM_attestation_serialize_get_size (ash->attest); | 1169 | |
1170 | buf_size = GNUNET_RECLAIM_credential_serialize_get_size (ash->credential); | ||
1152 | buf = GNUNET_malloc (buf_size); | 1171 | buf = GNUNET_malloc (buf_size); |
1153 | GNUNET_RECLAIM_attestation_serialize (ash->attest, buf); | 1172 | GNUNET_RECLAIM_credential_serialize (ash->credential, buf); |
1154 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1173 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1155 | "Storing new Attestation\n"); | 1174 | "Storing new credential under `%s'.\n", |
1156 | struct GNUNET_GNSRECORD_Data rd_new[1]; | 1175 | label); |
1157 | rd_new[0].data_size = buf_size; | 1176 | rd_new[0].data_size = buf_size; |
1158 | rd_new[0].data = buf; | 1177 | rd_new[0].data = buf; |
1159 | rd_new[0].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_ATTESTATION; | 1178 | rd_new[0].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL; |
1160 | rd_new[0].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION; | 1179 | rd_new[0].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION; |
1161 | rd_new[0].expiration_time = ash->exp.rel_value_us; | 1180 | rd_new[0].expiration_time = ash->exp.rel_value_us; |
1162 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypting with label %s\n", label); | ||
1163 | ash->ns_qe = GNUNET_NAMESTORE_records_store (nsh, | 1181 | ash->ns_qe = GNUNET_NAMESTORE_records_store (nsh, |
1164 | &ash->identity, | 1182 | &ash->identity, |
1165 | label, | 1183 | label, |
1166 | 1, | 1184 | 1, |
1167 | rd_new, | 1185 | rd_new, |
1168 | &attest_store_cont, | 1186 | &cred_store_cont, |
1169 | ash); | 1187 | ash); |
1170 | GNUNET_free (buf); | 1188 | GNUNET_free (buf); |
1171 | return; | 1189 | return; |
@@ -1173,44 +1191,43 @@ attest_add_cb (void *cls, | |||
1173 | 1191 | ||
1174 | 1192 | ||
1175 | /** | 1193 | /** |
1176 | * Add a new attestation | 1194 | * Add a new credential |
1177 | * | 1195 | * |
1178 | * @param cls the AttributeStoreHandle | 1196 | * @param cls the AttributeStoreHandle |
1179 | */ | 1197 | */ |
1180 | static void | 1198 | static void |
1181 | attest_store_task (void *cls) | 1199 | cred_store_task (void *cls) |
1182 | { | 1200 | { |
1183 | struct AttributeStoreHandle *ash = cls; | 1201 | struct AttributeStoreHandle *ash = cls; |
1184 | char *label; | 1202 | char *label; |
1185 | 1203 | ||
1186 | // Give the ash a new id if unset | 1204 | // Give the ash a new id if unset |
1187 | if (GNUNET_YES == GNUNET_RECLAIM_id_is_zero (&ash->attest->id)) | 1205 | if (GNUNET_YES == GNUNET_RECLAIM_id_is_zero (&ash->credential->id)) |
1188 | GNUNET_RECLAIM_id_generate (&ash->attest->id); | 1206 | GNUNET_RECLAIM_id_generate (&ash->credential->id); |
1189 | label = GNUNET_STRINGS_data_to_string_alloc (&ash->attest->id, | 1207 | label = GNUNET_STRINGS_data_to_string_alloc (&ash->credential->id, |
1190 | sizeof (ash->attest->id)); | 1208 | sizeof (ash->credential->id)); |
1191 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1209 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1192 | "Looking up existing data under label %s\n", label); | 1210 | "Looking up existing data under label `%s'\n", label); |
1193 | // Test for the content of the existing ID | ||
1194 | ash->ns_qe = GNUNET_NAMESTORE_records_lookup (nsh, | 1211 | ash->ns_qe = GNUNET_NAMESTORE_records_lookup (nsh, |
1195 | &ash->identity, | 1212 | &ash->identity, |
1196 | label, | 1213 | label, |
1197 | &attest_error, | 1214 | &cred_error, |
1198 | ash, | 1215 | ash, |
1199 | &attest_add_cb, | 1216 | &cred_add_cb, |
1200 | ash); | 1217 | ash); |
1201 | GNUNET_free (label); | 1218 | GNUNET_free (label); |
1202 | } | 1219 | } |
1203 | 1220 | ||
1204 | 1221 | ||
1205 | /** | 1222 | /** |
1206 | * Check an attestation store message | 1223 | * Check an credential store message |
1207 | * | 1224 | * |
1208 | * @param cls unused | 1225 | * @param cls unused |
1209 | * @param sam the message to check | 1226 | * @param sam the message to check |
1210 | */ | 1227 | */ |
1211 | static int | 1228 | static int |
1212 | check_attestation_store_message (void *cls, | 1229 | check_credential_store_message (void *cls, |
1213 | const struct AttributeStoreMessage *sam) | 1230 | const struct AttributeStoreMessage *sam) |
1214 | { | 1231 | { |
1215 | uint16_t size; | 1232 | uint16_t size; |
1216 | 1233 | ||
@@ -1225,26 +1242,26 @@ check_attestation_store_message (void *cls, | |||
1225 | 1242 | ||
1226 | 1243 | ||
1227 | /** | 1244 | /** |
1228 | * Handle an attestation store message | 1245 | * Handle a credential store message |
1229 | * | 1246 | * |
1230 | * @param cls our client | 1247 | * @param cls our client |
1231 | * @param sam the message to handle | 1248 | * @param sam the message to handle |
1232 | */ | 1249 | */ |
1233 | static void | 1250 | static void |
1234 | handle_attestation_store_message (void *cls, | 1251 | handle_credential_store_message (void *cls, |
1235 | const struct AttributeStoreMessage *sam) | 1252 | const struct AttributeStoreMessage *sam) |
1236 | { | 1253 | { |
1237 | struct AttributeStoreHandle *ash; | 1254 | struct AttributeStoreHandle *ash; |
1238 | struct IdpClient *idp = cls; | 1255 | struct IdpClient *idp = cls; |
1239 | size_t data_len; | 1256 | size_t data_len; |
1240 | 1257 | ||
1241 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTESTATION_STORE message\n"); | 1258 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREDENTIAL_STORE message\n"); |
1242 | 1259 | ||
1243 | data_len = ntohs (sam->attr_len); | 1260 | data_len = ntohs (sam->attr_len); |
1244 | 1261 | ||
1245 | ash = GNUNET_new (struct AttributeStoreHandle); | 1262 | ash = GNUNET_new (struct AttributeStoreHandle); |
1246 | ash->attest = GNUNET_RECLAIM_attestation_deserialize ((char *) &sam[1], | 1263 | ash->credential = GNUNET_RECLAIM_credential_deserialize ((char *) &sam[1], |
1247 | data_len); | 1264 | data_len); |
1248 | 1265 | ||
1249 | ash->r_id = ntohl (sam->id); | 1266 | ash->r_id = ntohl (sam->id); |
1250 | ash->identity = sam->identity; | 1267 | ash->identity = sam->identity; |
@@ -1254,7 +1271,7 @@ handle_attestation_store_message (void *cls, | |||
1254 | GNUNET_SERVICE_client_continue (idp->client); | 1271 | GNUNET_SERVICE_client_continue (idp->client); |
1255 | ash->client = idp; | 1272 | ash->client = idp; |
1256 | GNUNET_CONTAINER_DLL_insert (idp->store_op_head, idp->store_op_tail, ash); | 1273 | GNUNET_CONTAINER_DLL_insert (idp->store_op_head, idp->store_op_tail, ash); |
1257 | GNUNET_SCHEDULER_add_now (&attest_store_task, ash); | 1274 | GNUNET_SCHEDULER_add_now (&cred_store_task, ash); |
1258 | } | 1275 | } |
1259 | 1276 | ||
1260 | 1277 | ||
@@ -1310,12 +1327,12 @@ ticket_iter (void *cls, | |||
1310 | if (GNUNET_YES != GNUNET_RECLAIM_id_is_equal (rd[i].data, | 1327 | if (GNUNET_YES != GNUNET_RECLAIM_id_is_equal (rd[i].data, |
1311 | &adh->claim->id)) | 1328 | &adh->claim->id)) |
1312 | continue; | 1329 | continue; |
1313 | if (adh->attest != NULL) | 1330 | if (adh->credential != NULL) |
1314 | if (GNUNET_YES != GNUNET_RECLAIM_id_is_equal (rd[i].data, | 1331 | if (GNUNET_YES != GNUNET_RECLAIM_id_is_equal (rd[i].data, |
1315 | &adh->attest->id)) | 1332 | &adh->credential->id)) |
1316 | continue; | 1333 | continue; |
1317 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1334 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1318 | "Attribute or Attestation to delete found (%s)\n", | 1335 | "Attribute to delete found (%s)\n", |
1319 | adh->label); | 1336 | adh->label); |
1320 | has_changed = GNUNET_YES; | 1337 | has_changed = GNUNET_YES; |
1321 | break; | 1338 | break; |
@@ -1410,10 +1427,10 @@ update_tickets (void *cls) | |||
1410 | && (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (rd[i].data, | 1427 | && (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (rd[i].data, |
1411 | &adh->claim->id))) | 1428 | &adh->claim->id))) |
1412 | continue; | 1429 | continue; |
1413 | if (adh->attest != NULL) | 1430 | if (adh->credential != NULL) |
1414 | if ((GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF == rd[i].record_type) | 1431 | if ((GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF == rd[i].record_type) |
1415 | && (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (rd[i].data, | 1432 | && (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (rd[i].data, |
1416 | &adh->attest->id))) | 1433 | &adh->credential->id))) |
1417 | continue; | 1434 | continue; |
1418 | rd_new[j] = rd[i]; | 1435 | rd_new[j] = rd[i]; |
1419 | j++; | 1436 | j++; |
@@ -1557,7 +1574,7 @@ handle_attribute_delete_message (void *cls, | |||
1557 | GNUNET_RECLAIM_attribute_deserialize ((char *) &dam[1], | 1574 | GNUNET_RECLAIM_attribute_deserialize ((char *) &dam[1], |
1558 | data_len, | 1575 | data_len, |
1559 | &adh->claim); | 1576 | &adh->claim); |
1560 | adh->attest = NULL; | 1577 | adh->credential = NULL; |
1561 | 1578 | ||
1562 | adh->r_id = ntohl (dam->id); | 1579 | adh->r_id = ntohl (dam->id); |
1563 | adh->identity = dam->identity; | 1580 | adh->identity = dam->identity; |
@@ -1578,14 +1595,14 @@ handle_attribute_delete_message (void *cls, | |||
1578 | 1595 | ||
1579 | 1596 | ||
1580 | /** | 1597 | /** |
1581 | * Attestation deleted callback | 1598 | * Credential deleted callback |
1582 | * | 1599 | * |
1583 | * @param cls our handle | 1600 | * @param cls our handle |
1584 | * @param success success status | 1601 | * @param success success status |
1585 | * @param emsg error message (NULL if success=GNUNET_OK) | 1602 | * @param emsg error message (NULL if success=GNUNET_OK) |
1586 | */ | 1603 | */ |
1587 | static void | 1604 | static void |
1588 | attest_delete_cont (void *cls, int32_t success, const char *emsg) | 1605 | cred_delete_cont (void *cls, int32_t success, const char *emsg) |
1589 | { | 1606 | { |
1590 | struct AttributeDeleteHandle *adh = cls; | 1607 | struct AttributeDeleteHandle *adh = cls; |
1591 | 1608 | ||
@@ -1593,7 +1610,7 @@ attest_delete_cont (void *cls, int32_t success, const char *emsg) | |||
1593 | if (GNUNET_SYSERR == success) | 1610 | if (GNUNET_SYSERR == success) |
1594 | { | 1611 | { |
1595 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1612 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1596 | "Error deleting attestation %s\n", | 1613 | "Error deleting credential `%s'\n", |
1597 | adh->label); | 1614 | adh->label); |
1598 | send_delete_response (adh, GNUNET_SYSERR); | 1615 | send_delete_response (adh, GNUNET_SYSERR); |
1599 | cleanup_adh (adh); | 1616 | cleanup_adh (adh); |
@@ -1605,14 +1622,14 @@ attest_delete_cont (void *cls, int32_t success, const char *emsg) | |||
1605 | 1622 | ||
1606 | 1623 | ||
1607 | /** | 1624 | /** |
1608 | * Check attestation delete message format | 1625 | * Check credential delete message format |
1609 | * | 1626 | * |
1610 | * @cls unused | 1627 | * @cls unused |
1611 | * @dam message to check | 1628 | * @dam message to check |
1612 | */ | 1629 | */ |
1613 | static int | 1630 | static int |
1614 | check_attestation_delete_message (void *cls, | 1631 | check_credential_delete_message (void *cls, |
1615 | const struct AttributeDeleteMessage *dam) | 1632 | const struct AttributeDeleteMessage *dam) |
1616 | { | 1633 | { |
1617 | uint16_t size; | 1634 | uint16_t size; |
1618 | 1635 | ||
@@ -1627,33 +1644,33 @@ check_attestation_delete_message (void *cls, | |||
1627 | 1644 | ||
1628 | 1645 | ||
1629 | /** | 1646 | /** |
1630 | * Handle attestation deletion | 1647 | * Handle credential deletion |
1631 | * | 1648 | * |
1632 | * @param cls our client | 1649 | * @param cls our client |
1633 | * @param dam deletion message | 1650 | * @param dam deletion message |
1634 | */ | 1651 | */ |
1635 | static void | 1652 | static void |
1636 | handle_attestation_delete_message (void *cls, | 1653 | handle_credential_delete_message (void *cls, |
1637 | const struct AttributeDeleteMessage *dam) | 1654 | const struct AttributeDeleteMessage *dam) |
1638 | { | 1655 | { |
1639 | struct AttributeDeleteHandle *adh; | 1656 | struct AttributeDeleteHandle *adh; |
1640 | struct IdpClient *idp = cls; | 1657 | struct IdpClient *idp = cls; |
1641 | size_t data_len; | 1658 | size_t data_len; |
1642 | 1659 | ||
1643 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTESTATION_DELETE message\n"); | 1660 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREDENTIAL_DELETE message\n"); |
1644 | 1661 | ||
1645 | data_len = ntohs (dam->attr_len); | 1662 | data_len = ntohs (dam->attr_len); |
1646 | 1663 | ||
1647 | adh = GNUNET_new (struct AttributeDeleteHandle); | 1664 | adh = GNUNET_new (struct AttributeDeleteHandle); |
1648 | adh->attest = GNUNET_RECLAIM_attestation_deserialize ((char *) &dam[1], | 1665 | adh->credential = GNUNET_RECLAIM_credential_deserialize ((char *) &dam[1], |
1649 | data_len); | 1666 | data_len); |
1650 | adh->claim = NULL; | 1667 | adh->claim = NULL; |
1651 | 1668 | ||
1652 | adh->r_id = ntohl (dam->id); | 1669 | adh->r_id = ntohl (dam->id); |
1653 | adh->identity = dam->identity; | 1670 | adh->identity = dam->identity; |
1654 | adh->label | 1671 | adh->label |
1655 | = GNUNET_STRINGS_data_to_string_alloc (&adh->attest->id, | 1672 | = GNUNET_STRINGS_data_to_string_alloc (&adh->credential->id, |
1656 | sizeof(adh->attest->id)); | 1673 | sizeof(adh->credential->id)); |
1657 | GNUNET_SERVICE_client_continue (idp->client); | 1674 | GNUNET_SERVICE_client_continue (idp->client); |
1658 | adh->client = idp; | 1675 | adh->client = idp; |
1659 | GNUNET_CONTAINER_DLL_insert (idp->delete_op_head, idp->delete_op_tail, adh); | 1676 | GNUNET_CONTAINER_DLL_insert (idp->delete_op_head, idp->delete_op_tail, adh); |
@@ -1662,7 +1679,7 @@ handle_attestation_delete_message (void *cls, | |||
1662 | adh->label, | 1679 | adh->label, |
1663 | 0, | 1680 | 0, |
1664 | NULL, | 1681 | NULL, |
1665 | &attest_delete_cont, | 1682 | &cred_delete_cont, |
1666 | adh); | 1683 | adh); |
1667 | } | 1684 | } |
1668 | 1685 | ||
@@ -1712,7 +1729,7 @@ attr_iter_error (void *cls) | |||
1712 | 1729 | ||
1713 | 1730 | ||
1714 | /** | 1731 | /** |
1715 | * Got record. Return if it is an attribute or attestation. | 1732 | * Got record. Return if it is an attribute. |
1716 | * | 1733 | * |
1717 | * @param cls our attribute iterator | 1734 | * @param cls our attribute iterator |
1718 | * @param zone zone we are iterating | 1735 | * @param zone zone we are iterating |
@@ -1852,51 +1869,51 @@ handle_iteration_next (void *cls, | |||
1852 | 1869 | ||
1853 | 1870 | ||
1854 | /************************************************* | 1871 | /************************************************* |
1855 | * Attestation iteration | 1872 | * Credential iteration |
1856 | *************************************************/ | 1873 | *************************************************/ |
1857 | 1874 | ||
1858 | 1875 | ||
1859 | /** | 1876 | /** |
1860 | * Done iterating over attestations | 1877 | * Done iterating over credentials |
1861 | * | 1878 | * |
1862 | * @param cls our iterator handle | 1879 | * @param cls our iterator handle |
1863 | */ | 1880 | */ |
1864 | static void | 1881 | static void |
1865 | attest_iter_finished (void *cls) | 1882 | cred_iter_finished (void *cls) |
1866 | { | 1883 | { |
1867 | struct Iterator *ai = cls; | 1884 | struct Iterator *ai = cls; |
1868 | struct GNUNET_MQ_Envelope *env; | 1885 | struct GNUNET_MQ_Envelope *env; |
1869 | struct AttestationResultMessage *arm; | 1886 | struct CredentialResultMessage *arm; |
1870 | 1887 | ||
1871 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ATTESTATION_RESULT message\n"); | 1888 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending CREDENTIAL_RESULT message\n"); |
1872 | env = GNUNET_MQ_msg (arm, GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_RESULT); | 1889 | env = GNUNET_MQ_msg (arm, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT); |
1873 | arm->id = htonl (ai->request_id); | 1890 | arm->id = htonl (ai->request_id); |
1874 | arm->attestation_len = htons (0); | 1891 | arm->credential_len = htons (0); |
1875 | GNUNET_MQ_send (ai->client->mq, env); | 1892 | GNUNET_MQ_send (ai->client->mq, env); |
1876 | GNUNET_CONTAINER_DLL_remove (ai->client->attest_iter_head, | 1893 | GNUNET_CONTAINER_DLL_remove (ai->client->cred_iter_head, |
1877 | ai->client->attest_iter_tail, | 1894 | ai->client->cred_iter_tail, |
1878 | ai); | 1895 | ai); |
1879 | GNUNET_free (ai); | 1896 | GNUNET_free (ai); |
1880 | } | 1897 | } |
1881 | 1898 | ||
1882 | 1899 | ||
1883 | /** | 1900 | /** |
1884 | * Error iterating over attestations. Abort. | 1901 | * Error iterating over credentials. Abort. |
1885 | * | 1902 | * |
1886 | * @param cls our attribute iteration handle | 1903 | * @param cls our attribute iteration handle |
1887 | */ | 1904 | */ |
1888 | static void | 1905 | static void |
1889 | attest_iter_error (void *cls) | 1906 | cred_iter_error (void *cls) |
1890 | { | 1907 | { |
1891 | struct Iterator *ai = cls; | 1908 | struct Iterator *ai = cls; |
1892 | 1909 | ||
1893 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over attestations\n"); | 1910 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over credentials\n"); |
1894 | attest_iter_finished (ai); | 1911 | cred_iter_finished (ai); |
1895 | } | 1912 | } |
1896 | 1913 | ||
1897 | 1914 | ||
1898 | /** | 1915 | /** |
1899 | * Got record. Return attestation. | 1916 | * Got record. Return credential. |
1900 | * | 1917 | * |
1901 | * @param cls our attribute iterator | 1918 | * @param cls our attribute iterator |
1902 | * @param zone zone we are iterating | 1919 | * @param zone zone we are iterating |
@@ -1905,32 +1922,32 @@ attest_iter_error (void *cls) | |||
1905 | * @param rd records | 1922 | * @param rd records |
1906 | */ | 1923 | */ |
1907 | static void | 1924 | static void |
1908 | attest_iter_cb (void *cls, | 1925 | cred_iter_cb (void *cls, |
1909 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, | 1926 | const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, |
1910 | const char *label, | 1927 | const char *label, |
1911 | unsigned int rd_count, | 1928 | unsigned int rd_count, |
1912 | const struct GNUNET_GNSRECORD_Data *rd) | 1929 | const struct GNUNET_GNSRECORD_Data *rd) |
1913 | { | 1930 | { |
1914 | struct Iterator *ai = cls; | 1931 | struct Iterator *ai = cls; |
1915 | struct GNUNET_MQ_Envelope *env; | 1932 | struct GNUNET_MQ_Envelope *env; |
1916 | struct AttestationResultMessage *arm; | 1933 | struct CredentialResultMessage *arm; |
1917 | char *data_tmp; | 1934 | char *data_tmp; |
1918 | 1935 | ||
1919 | if ((rd_count != 1) || | 1936 | if ((rd_count != 1) || |
1920 | (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTESTATION != rd->record_type)) | 1937 | (GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL != rd->record_type)) |
1921 | { | 1938 | { |
1922 | GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1); | 1939 | GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1); |
1923 | return; | 1940 | return; |
1924 | } | 1941 | } |
1925 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found attestation under: %s\n", | 1942 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found credential under: %s\n", |
1926 | label); | 1943 | label); |
1927 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1944 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1928 | "Sending ATTESTATION_RESULT message\n"); | 1945 | "Sending CREDENTIAL_RESULT message\n"); |
1929 | env = GNUNET_MQ_msg_extra (arm, | 1946 | env = GNUNET_MQ_msg_extra (arm, |
1930 | rd->data_size, | 1947 | rd->data_size, |
1931 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_RESULT); | 1948 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT); |
1932 | arm->id = htonl (ai->request_id); | 1949 | arm->id = htonl (ai->request_id); |
1933 | arm->attestation_len = htons (rd->data_size); | 1950 | arm->credential_len = htons (rd->data_size); |
1934 | GNUNET_CRYPTO_ecdsa_key_get_public (zone, &arm->identity); | 1951 | GNUNET_CRYPTO_ecdsa_key_get_public (zone, &arm->identity); |
1935 | data_tmp = (char *) &arm[1]; | 1952 | data_tmp = (char *) &arm[1]; |
1936 | GNUNET_memcpy (data_tmp, rd->data, rd->data_size); | 1953 | GNUNET_memcpy (data_tmp, rd->data, rd->data_size); |
@@ -1946,29 +1963,29 @@ attest_iter_cb (void *cls, | |||
1946 | * @param ais_msg the iteration message to start | 1963 | * @param ais_msg the iteration message to start |
1947 | */ | 1964 | */ |
1948 | static void | 1965 | static void |
1949 | handle_attestation_iteration_start (void *cls, | 1966 | handle_credential_iteration_start (void *cls, |
1950 | const struct | 1967 | const struct |
1951 | AttestationIterationStartMessage *ais_msg) | 1968 | CredentialIterationStartMessage *ais_msg) |
1952 | { | 1969 | { |
1953 | struct IdpClient *idp = cls; | 1970 | struct IdpClient *idp = cls; |
1954 | struct Iterator *ai; | 1971 | struct Iterator *ai; |
1955 | 1972 | ||
1956 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1973 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1957 | "Received ATTESTATION_ITERATION_START message\n"); | 1974 | "Received CREDENTIAL_ITERATION_START message\n"); |
1958 | ai = GNUNET_new (struct Iterator); | 1975 | ai = GNUNET_new (struct Iterator); |
1959 | ai->request_id = ntohl (ais_msg->id); | 1976 | ai->request_id = ntohl (ais_msg->id); |
1960 | ai->client = idp; | 1977 | ai->client = idp; |
1961 | ai->identity = ais_msg->identity; | 1978 | ai->identity = ais_msg->identity; |
1962 | 1979 | ||
1963 | GNUNET_CONTAINER_DLL_insert (idp->attest_iter_head, idp->attest_iter_tail, | 1980 | GNUNET_CONTAINER_DLL_insert (idp->cred_iter_head, idp->cred_iter_tail, |
1964 | ai); | 1981 | ai); |
1965 | ai->ns_it = GNUNET_NAMESTORE_zone_iteration_start (nsh, | 1982 | ai->ns_it = GNUNET_NAMESTORE_zone_iteration_start (nsh, |
1966 | &ai->identity, | 1983 | &ai->identity, |
1967 | &attest_iter_error, | 1984 | &cred_iter_error, |
1968 | ai, | 1985 | ai, |
1969 | &attest_iter_cb, | 1986 | &cred_iter_cb, |
1970 | ai, | 1987 | ai, |
1971 | &attest_iter_finished, | 1988 | &cred_iter_finished, |
1972 | ai); | 1989 | ai); |
1973 | GNUNET_SERVICE_client_continue (idp->client); | 1990 | GNUNET_SERVICE_client_continue (idp->client); |
1974 | } | 1991 | } |
@@ -1981,9 +1998,9 @@ handle_attestation_iteration_start (void *cls, | |||
1981 | * @param ais_msg the stop message | 1998 | * @param ais_msg the stop message |
1982 | */ | 1999 | */ |
1983 | static void | 2000 | static void |
1984 | handle_attestation_iteration_stop (void *cls, | 2001 | handle_credential_iteration_stop (void *cls, |
1985 | const struct | 2002 | const struct |
1986 | AttestationIterationStopMessage *ais_msg) | 2003 | CredentialIterationStopMessage *ais_msg) |
1987 | { | 2004 | { |
1988 | struct IdpClient *idp = cls; | 2005 | struct IdpClient *idp = cls; |
1989 | struct Iterator *ai; | 2006 | struct Iterator *ai; |
@@ -1991,9 +2008,9 @@ handle_attestation_iteration_stop (void *cls, | |||
1991 | 2008 | ||
1992 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2009 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1993 | "Received `%s' message\n", | 2010 | "Received `%s' message\n", |
1994 | "ATTESTATION_ITERATION_STOP"); | 2011 | "CREDENTIAL_ITERATION_STOP"); |
1995 | rid = ntohl (ais_msg->id); | 2012 | rid = ntohl (ais_msg->id); |
1996 | for (ai = idp->attest_iter_head; NULL != ai; ai = ai->next) | 2013 | for (ai = idp->cred_iter_head; NULL != ai; ai = ai->next) |
1997 | if (ai->request_id == rid) | 2014 | if (ai->request_id == rid) |
1998 | break; | 2015 | break; |
1999 | if (NULL == ai) | 2016 | if (NULL == ai) |
@@ -2002,7 +2019,7 @@ handle_attestation_iteration_stop (void *cls, | |||
2002 | GNUNET_SERVICE_client_drop (idp->client); | 2019 | GNUNET_SERVICE_client_drop (idp->client); |
2003 | return; | 2020 | return; |
2004 | } | 2021 | } |
2005 | GNUNET_CONTAINER_DLL_remove (idp->attest_iter_head, idp->attest_iter_tail, | 2022 | GNUNET_CONTAINER_DLL_remove (idp->cred_iter_head, idp->cred_iter_tail, |
2006 | ai); | 2023 | ai); |
2007 | GNUNET_free (ai); | 2024 | GNUNET_free (ai); |
2008 | GNUNET_SERVICE_client_continue (idp->client); | 2025 | GNUNET_SERVICE_client_continue (idp->client); |
@@ -2010,24 +2027,24 @@ handle_attestation_iteration_stop (void *cls, | |||
2010 | 2027 | ||
2011 | 2028 | ||
2012 | /** | 2029 | /** |
2013 | * Client requests next attestation from iterator | 2030 | * Client requests next credential from iterator |
2014 | * | 2031 | * |
2015 | * @param cls the client | 2032 | * @param cls the client |
2016 | * @param ais_msg the message | 2033 | * @param ais_msg the message |
2017 | */ | 2034 | */ |
2018 | static void | 2035 | static void |
2019 | handle_attestation_iteration_next (void *cls, | 2036 | handle_credential_iteration_next (void *cls, |
2020 | const struct | 2037 | const struct |
2021 | AttestationIterationNextMessage *ais_msg) | 2038 | CredentialIterationNextMessage *ais_msg) |
2022 | { | 2039 | { |
2023 | struct IdpClient *idp = cls; | 2040 | struct IdpClient *idp = cls; |
2024 | struct Iterator *ai; | 2041 | struct Iterator *ai; |
2025 | uint32_t rid; | 2042 | uint32_t rid; |
2026 | 2043 | ||
2027 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2044 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2028 | "Received ATTESTATION_ITERATION_NEXT message\n"); | 2045 | "Received CREDENTIAL_ITERATION_NEXT message\n"); |
2029 | rid = ntohl (ais_msg->id); | 2046 | rid = ntohl (ais_msg->id); |
2030 | for (ai = idp->attest_iter_head; NULL != ai; ai = ai->next) | 2047 | for (ai = idp->cred_iter_head; NULL != ai; ai = ai->next) |
2031 | if (ai->request_id == rid) | 2048 | if (ai->request_id == rid) |
2032 | break; | 2049 | break; |
2033 | if (NULL == ai) | 2050 | if (NULL == ai) |
@@ -2269,16 +2286,16 @@ GNUNET_SERVICE_MAIN ( | |||
2269 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE, | 2286 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE, |
2270 | struct AttributeStoreMessage, | 2287 | struct AttributeStoreMessage, |
2271 | NULL), | 2288 | NULL), |
2272 | GNUNET_MQ_hd_var_size (attestation_store_message, | 2289 | GNUNET_MQ_hd_var_size (credential_store_message, |
2273 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_STORE, | 2290 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_STORE, |
2274 | struct AttributeStoreMessage, | 2291 | struct AttributeStoreMessage, |
2275 | NULL), | 2292 | NULL), |
2276 | GNUNET_MQ_hd_var_size (attribute_delete_message, | 2293 | GNUNET_MQ_hd_var_size (attribute_delete_message, |
2277 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE, | 2294 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE, |
2278 | struct AttributeDeleteMessage, | 2295 | struct AttributeDeleteMessage, |
2279 | NULL), | 2296 | NULL), |
2280 | GNUNET_MQ_hd_var_size (attestation_delete_message, | 2297 | GNUNET_MQ_hd_var_size (credential_delete_message, |
2281 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_DELETE, | 2298 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_DELETE, |
2282 | struct AttributeDeleteMessage, | 2299 | struct AttributeDeleteMessage, |
2283 | NULL), | 2300 | NULL), |
2284 | GNUNET_MQ_hd_fixed_size (iteration_start, | 2301 | GNUNET_MQ_hd_fixed_size (iteration_start, |
@@ -2293,17 +2310,17 @@ GNUNET_SERVICE_MAIN ( | |||
2293 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP, | 2310 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP, |
2294 | struct AttributeIterationStopMessage, | 2311 | struct AttributeIterationStopMessage, |
2295 | NULL), | 2312 | NULL), |
2296 | GNUNET_MQ_hd_fixed_size (attestation_iteration_start, | 2313 | GNUNET_MQ_hd_fixed_size (credential_iteration_start, |
2297 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_ITERATION_START, | 2314 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START, |
2298 | struct AttestationIterationStartMessage, | 2315 | struct CredentialIterationStartMessage, |
2299 | NULL), | 2316 | NULL), |
2300 | GNUNET_MQ_hd_fixed_size (attestation_iteration_next, | 2317 | GNUNET_MQ_hd_fixed_size (credential_iteration_next, |
2301 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_ITERATION_NEXT, | 2318 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_NEXT, |
2302 | struct AttestationIterationNextMessage, | 2319 | struct CredentialIterationNextMessage, |
2303 | NULL), | 2320 | NULL), |
2304 | GNUNET_MQ_hd_fixed_size (attestation_iteration_stop, | 2321 | GNUNET_MQ_hd_fixed_size (credential_iteration_stop, |
2305 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_ITERATION_STOP, | 2322 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_STOP, |
2306 | struct AttestationIterationStopMessage, | 2323 | struct CredentialIterationStopMessage, |
2307 | NULL), | 2324 | NULL), |
2308 | 2325 | ||
2309 | GNUNET_MQ_hd_var_size (issue_ticket_message, | 2326 | GNUNET_MQ_hd_var_size (issue_ticket_message, |