GNUnet  0.11.x
gnunet-service-reclaim.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2012-2015 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
29 #include "gnunet_constants.h"
30 #include "gnunet_gnsrecord_lib.h"
31 #include "gnunet_protocols.h"
32 #include "gnunet_reclaim_lib.h"
33 #include "gnunet_reclaim_service.h"
34 #include "gnunet_signatures.h"
35 #include "reclaim.h"
36 
37 
42 
47 
51 static const struct GNUNET_CONFIGURATION_Handle *cfg;
52 
56 struct IdpClient;
57 
62 {
67 
72 
76  struct IdpClient *client;
77 
81  uint32_t r_id;
82 
87 };
88 
89 
93 struct Iterator
94 {
98  struct Iterator *next;
99 
103  struct Iterator *prev;
104 
108  struct IdpClient *client;
109 
114 
119 
123  uint32_t request_id;
124 
128  void *ctx;
129 };
130 
131 
135 struct IdpClient
136 {
140  struct IdpClient *prev;
141 
145  struct IdpClient *next;
146 
151 
156 
163 
170 
177 
184 
189 
194 
199 
204 
209 
214 
219 
224 
229 
238 
243 };
244 
245 
250 {
255 
260 
264  struct IdpClient *client;
265 
270 
271 
276 
281 
286 
291 
296 
301 
305  char *label;
306 
310  uint32_t r_id;
311 };
312 
313 
318 {
323 
328 
332  struct IdpClient *client;
333 
338 
342  struct GNUNET_CRYPTO_EcdsaPublicKey identity_pkey;
343 
348 
353 
358 
363 
367  uint32_t r_id;
368 };
369 
370 
375 {
380 
385 
389  struct IdpClient *client;
390 
394  uint32_t r_id;
395 
400 };
401 
402 
407 {
412 
417 
421  struct IdpClient *client;
422 
427 
431  uint32_t r_id;
432 };
433 
434 
439 {
444 
449 
453  struct IdpClient *client;
454 
458  uint32_t r_id;
459 };
460 
461 
465 static struct IdpClient *client_list_head = NULL;
466 
470 static struct IdpClient *client_list_tail = NULL;
471 
472 
478 static void
480 {
481  struct TicketRecordsEntry *le;
482 
483  if (NULL != adh->ns_it)
485  if (NULL != adh->ns_qe)
487  if (NULL != adh->label)
488  GNUNET_free (adh->label);
489  if (NULL != adh->claim)
490  GNUNET_free (adh->claim);
491  if (NULL != adh->attest)
492  GNUNET_free (adh->attest);
493  while (NULL != (le = adh->tickets_to_update_head))
494  {
497  le);
498  if (NULL != le->label)
499  GNUNET_free (le->label);
500  if (NULL != le->data)
501  GNUNET_free (le->data);
502  GNUNET_free (le);
503  }
504  GNUNET_free (adh);
505 }
506 
507 
513 static void
515 {
516  if (NULL != ash->ns_qe)
518  if (NULL != ash->claim)
519  GNUNET_free (ash->claim);
520  if (NULL != ash->attest)
521  GNUNET_free (ash->attest);
522  GNUNET_free (ash);
523 }
524 
525 
531 static void
533 {
534  struct Iterator *ai;
535  struct TicketIteration *ti;
536  struct TicketRevocationOperation *rop;
537  struct TicketIssueOperation *iss;
538  struct ConsumeTicketOperation *ct;
539  struct AttributeStoreHandle *as;
540  struct AttributeDeleteHandle *adh;
541 
542  while (NULL != (iss = idp->issue_op_head))
543  {
545  GNUNET_free (iss);
546  }
547  while (NULL != (ct = idp->consume_op_head))
548  {
550  idp->consume_op_tail,
551  ct);
552  if (NULL != ct->ch)
554  GNUNET_free (ct);
555  }
556  while (NULL != (as = idp->store_op_head))
557  {
559  cleanup_as_handle (as);
560  }
561  while (NULL != (adh = idp->delete_op_head))
562  {
564  cleanup_adh (adh);
565  }
566 
567  while (NULL != (ai = idp->attr_iter_head))
568  {
570  GNUNET_free (ai);
571  }
572  while (NULL != (ai = idp->attest_iter_head))
573  {
575  ai);
576  GNUNET_free (ai);
577  }
578 
579  while (NULL != (rop = idp->revoke_op_head))
580  {
582  if (NULL != rop->rh)
584  GNUNET_free (rop);
585  }
586  while (NULL != (ti = idp->ticket_iter_head))
587  {
589  idp->ticket_iter_tail,
590  ti);
591  if (NULL != ti->iter)
593  GNUNET_free (ti);
594  }
595  GNUNET_free (idp);
596 }
597 
598 
602 static void
604 {
605  struct IdpClient *cl;
606 
607  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
608 
609  while (NULL != (cl = client_list_head))
610  {
611  GNUNET_CONTAINER_DLL_remove (client_list_head,
612  client_list_tail,
613  cl);
614  cleanup_client (cl);
615  }
617  if (NULL != timeout_task)
618  GNUNET_SCHEDULER_cancel (timeout_task);
619  if (NULL != nsh)
621 }
622 
623 
629 static void
630 do_shutdown (void *cls)
631 {
632  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down...\n");
633  cleanup ();
634 }
635 
636 
645 static void
647  uint32_t r_id,
648  const struct GNUNET_RECLAIM_Ticket *ticket,
649  uint32_t success)
650 {
651  struct TicketResultMessage *irm;
652  struct GNUNET_MQ_Envelope *env;
653 
654  env = GNUNET_MQ_msg (irm,
656  if (NULL != ticket)
657  {
658  irm->ticket = *ticket;
659  }
660  // TODO add success member
661  irm->id = htonl (r_id);
662  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
663  GNUNET_MQ_send (client->mq, env);
664 }
665 
666 
675 static void
678  int32_t success,
679  const char *emsg)
680 {
681  struct TicketIssueOperation *tio = cls;
682 
683  if (GNUNET_OK != success)
684  {
685  send_ticket_result (tio->client, tio->r_id, NULL, GNUNET_SYSERR);
687  tio->client->issue_op_tail,
688  tio);
689  GNUNET_free (tio);
690  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error issuing ticket: %s\n", emsg);
691  return;
692  }
693  send_ticket_result (tio->client, tio->r_id, ticket, GNUNET_SYSERR);
695  tio->client->issue_op_tail,
696  tio);
697  GNUNET_free (tio);
698 }
699 
700 
708 static int
709 check_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
710 {
711  uint16_t size;
712 
713  size = ntohs (im->header.size);
714  if (size <= sizeof(struct IssueTicketMessage))
715  {
716  GNUNET_break (0);
717  return GNUNET_SYSERR;
718  }
719  return GNUNET_OK;
720 }
721 
722 
729 static void
730 handle_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
731 {
732  struct TicketIssueOperation *tio;
733  struct IdpClient *idp = cls;
734  struct GNUNET_RECLAIM_AttributeList *attrs;
735  size_t attrs_len;
736 
737  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ISSUE_TICKET message\n");
738  tio = GNUNET_new (struct TicketIssueOperation);
739  attrs_len = ntohs (im->attr_len);
740  attrs = GNUNET_RECLAIM_attribute_list_deserialize ((char *) &im[1],
741  attrs_len);
742  tio->r_id = ntohl (im->id);
743  tio->client = idp;
745  RECLAIM_TICKETS_issue (&im->identity,
746  attrs,
747  &im->rp,
749  tio);
752 }
753 
754 
755 /**********************************************************
756 * Revocation
757 **********************************************************/
758 
765 static void
766 revoke_result_cb (void *cls, int32_t success)
767 {
768  struct TicketRevocationOperation *rop = cls;
769  struct GNUNET_MQ_Envelope *env;
770  struct RevokeTicketResultMessage *trm;
771 
773  "Sending REVOKE_TICKET_RESULT message\n");
774  rop->rh = NULL;
776  trm->id = htonl (rop->r_id);
777  trm->success = htonl (success);
778  GNUNET_MQ_send (rop->client->mq, env);
780  rop->client->revoke_op_tail,
781  rop);
782  GNUNET_free (rop);
783 }
784 
785 
793 static int
795 {
796  uint16_t size;
797 
798  size = ntohs (im->header.size);
799  if (size != sizeof(struct RevokeTicketMessage))
800  {
801  GNUNET_break (0);
802  return GNUNET_SYSERR;
803  }
804  return GNUNET_OK;
805 }
806 
807 
814 static void
816 {
817  struct TicketRevocationOperation *rop;
818  struct IdpClient *idp = cls;
819 
820  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received REVOKE_TICKET message\n");
821  rop = GNUNET_new (struct TicketRevocationOperation);
822  rop->r_id = ntohl (rm->id);
823  rop->client = idp;
825  rop->rh
827  rop);
829 }
830 
831 
841 static void
842 consume_result_cb (void *cls,
844  const struct GNUNET_RECLAIM_AttributeList *attrs,
845  const struct GNUNET_RECLAIM_AttestationList *attests,
846  int32_t success,
847  const char *emsg)
848 {
849  struct ConsumeTicketOperation *cop = cls;
850  struct ConsumeTicketResultMessage *crm;
851  struct GNUNET_MQ_Envelope *env;
852  char *data_tmp;
853  size_t attrs_len;
854  size_t attests_len;
855 
856  if (GNUNET_OK != success)
857  {
858  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error consuming ticket: %s\n", emsg);
859  }
863  "Sending CONSUME_TICKET_RESULT message\n");
864  env = GNUNET_MQ_msg_extra (crm,
865  attrs_len + attests_len,
867  crm->id = htonl (cop->r_id);
868  crm->attrs_len = htons (attrs_len);
869  crm->attestations_len = htons (attests_len);
870  crm->identity = *identity;
871  crm->result = htonl (success);
872  data_tmp = (char *) &crm[1];
873  GNUNET_RECLAIM_attribute_list_serialize (attrs, data_tmp);
874  data_tmp += attrs_len;
875  GNUNET_RECLAIM_attestation_list_serialize (attests, data_tmp);
876  GNUNET_MQ_send (cop->client->mq, env);
878  cop->client->consume_op_tail,
879  cop);
880  GNUNET_free (cop);
881 }
882 
883 
890 static int
892 {
893  uint16_t size;
894 
895  size = ntohs (cm->header.size);
896  if (size != sizeof(struct ConsumeTicketMessage))
897  {
898  GNUNET_break (0);
899  return GNUNET_SYSERR;
900  }
901  return GNUNET_OK;
902 }
903 
904 
911 static void
913 {
914  struct ConsumeTicketOperation *cop;
915  struct IdpClient *idp = cls;
916 
917  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CONSUME_TICKET message\n");
918  cop = GNUNET_new (struct ConsumeTicketOperation);
919  cop->r_id = ntohl (cm->id);
920  cop->client = idp;
921  cop->ch
923  cop);
926 }
927 
928 
929 /*****************************************
930 * Attribute store
931 *****************************************/
932 
933 
941 static void
942 attr_store_cont (void *cls, int32_t success, const char *emsg)
943 {
944  struct AttributeStoreHandle *ash = cls;
945  struct GNUNET_MQ_Envelope *env;
946  struct SuccessResultMessage *acr_msg;
947 
948  ash->ns_qe = NULL;
950  ash->client->store_op_tail,
951  ash);
952 
953  if (GNUNET_SYSERR == success)
954  {
956  "Failed to store attribute %s\n",
957  emsg);
958  cleanup_as_handle (ash);
960  return;
961  }
962 
963  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
965  acr_msg->id = htonl (ash->r_id);
966  acr_msg->op_result = htonl (GNUNET_OK);
967  GNUNET_MQ_send (ash->client->mq, env);
968  cleanup_as_handle (ash);
969 }
970 
971 
977 static void
978 attr_store_task (void *cls)
979 {
980  struct AttributeStoreHandle *ash = cls;
981  struct GNUNET_GNSRECORD_Data rd[1];
982  char *buf;
983  char *label;
984  size_t buf_size;
985 
986  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing attribute\n");
988  buf = GNUNET_malloc (buf_size);
989  // Give the ash a new id if unset
993  label
995  sizeof (ash->claim->id));
996  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypting with label %s\n", label);
997 
998  rd[0].data_size = buf_size;
999  rd[0].data = buf;
1002  rd[0].expiration_time = ash->exp.rel_value_us;
1004  &ash->identity,
1005  label,
1006  1,
1007  rd,
1008  &attr_store_cont,
1009  ash);
1010  GNUNET_free (buf);
1011  GNUNET_free (label);
1012 }
1013 
1014 
1021 static int
1023  const struct AttributeStoreMessage *sam)
1024 {
1025  uint16_t size;
1026 
1027  size = ntohs (sam->header.size);
1028  if (size <= sizeof(struct AttributeStoreMessage))
1029  {
1030  GNUNET_break (0);
1031  return GNUNET_SYSERR;
1032  }
1033  return GNUNET_OK;
1034 }
1035 
1036 
1043 static void
1045  const struct AttributeStoreMessage *sam)
1046 {
1047  struct AttributeStoreHandle *ash;
1048  struct IdpClient *idp = cls;
1049  size_t data_len;
1050 
1051  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_STORE message\n");
1052 
1053  data_len = ntohs (sam->attr_len);
1054 
1055  ash = GNUNET_new (struct AttributeStoreHandle);
1056  ash->claim = GNUNET_RECLAIM_attribute_deserialize ((char *) &sam[1],
1057  data_len);
1058 
1059  ash->r_id = ntohl (sam->id);
1060  ash->identity = sam->identity;
1061  ash->exp.rel_value_us = GNUNET_ntohll (sam->exp);
1062  GNUNET_CRYPTO_ecdsa_key_get_public (&sam->identity, &ash->identity_pkey);
1063 
1065  ash->client = idp;
1068 }
1069 
1070 
1078 static void
1079 attest_store_cont (void *cls, int32_t success, const char *emsg)
1080 {
1081  struct AttributeStoreHandle *ash = cls;
1082  struct GNUNET_MQ_Envelope *env;
1083  struct SuccessResultMessage *acr_msg;
1084 
1085  ash->ns_qe = NULL;
1087  ash->client->store_op_tail,
1088  ash);
1089 
1090  if (GNUNET_SYSERR == success)
1091  {
1093  "Failed to store attestation %s\n",
1094  emsg);
1095  cleanup_as_handle (ash);
1097  return;
1098  }
1099 
1100  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
1102  acr_msg->id = htonl (ash->r_id);
1103  acr_msg->op_result = htonl (GNUNET_OK);
1104  GNUNET_MQ_send (ash->client->mq, env);
1105  cleanup_as_handle (ash);
1106 }
1107 
1108 
1114 static void
1115 attest_error (void *cls)
1116 {
1117  struct AttributeStoreHandle *ash = cls;
1119  "Failed to check for existing Attestation\n");
1120  cleanup_as_handle (ash);
1122  return;
1123 }
1124 
1125 
1135 static void
1136 attest_add_cb (void *cls,
1137  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
1138  const char *label,
1139  unsigned int rd_count,
1140  const struct GNUNET_GNSRECORD_Data *rd)
1141 {
1142  struct AttributeStoreHandle *ash = cls;
1143  char *buf;
1144  size_t buf_size;
1146  buf = GNUNET_malloc (buf_size);
1149  "Storing new Attestation\n");
1150  struct GNUNET_GNSRECORD_Data rd_new[1];
1151  rd_new[0].data_size = buf_size;
1152  rd_new[0].data = buf;
1155  rd_new[0].expiration_time = ash->exp.rel_value_us;
1156  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypting with label %s\n", label);
1158  &ash->identity,
1159  label,
1160  1,
1161  rd_new,
1163  ash);
1164  GNUNET_free (buf);
1165  return;
1166 }
1167 
1168 
1174 static void
1176 {
1177  struct AttributeStoreHandle *ash = cls;
1178  char *label;
1179 
1180  // Give the ash a new id if unset
1184  sizeof (ash->attest->id));
1186  "Looking up existing data under label %s\n", label);
1187 // Test for the content of the existing ID
1189  &ash->identity,
1190  label,
1191  &attest_error,
1192  ash,
1193  &attest_add_cb,
1194  ash);
1195  GNUNET_free (label);
1196 }
1197 
1198 
1205 static int
1207  const struct AttributeStoreMessage *sam)
1208 {
1209  uint16_t size;
1210 
1211  size = ntohs (sam->header.size);
1212  if (size <= sizeof(struct AttributeStoreMessage))
1213  {
1214  GNUNET_break (0);
1215  return GNUNET_SYSERR;
1216  }
1217  return GNUNET_OK;
1218 }
1219 
1220 
1227 static void
1229  const struct AttributeStoreMessage *sam)
1230 {
1231  struct AttributeStoreHandle *ash;
1232  struct IdpClient *idp = cls;
1233  size_t data_len;
1234 
1235  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTESTATION_STORE message\n");
1236 
1237  data_len = ntohs (sam->attr_len);
1238 
1239  ash = GNUNET_new (struct AttributeStoreHandle);
1240  ash->attest = GNUNET_RECLAIM_attestation_deserialize ((char *) &sam[1],
1241  data_len);
1242 
1243  ash->r_id = ntohl (sam->id);
1244  ash->identity = sam->identity;
1245  ash->exp.rel_value_us = GNUNET_ntohll (sam->exp);
1246  GNUNET_CRYPTO_ecdsa_key_get_public (&sam->identity, &ash->identity_pkey);
1247 
1249  ash->client = idp;
1252 }
1253 
1254 
1261 static void
1262 send_delete_response (struct AttributeDeleteHandle *adh, int32_t success)
1263 {
1264  struct GNUNET_MQ_Envelope *env;
1265  struct SuccessResultMessage *acr_msg;
1266 
1268  adh->client->delete_op_tail,
1269  adh);
1270 
1271  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
1273  acr_msg->id = htonl (adh->r_id);
1274  acr_msg->op_result = htonl (success);
1275  GNUNET_MQ_send (adh->client->mq, env);
1276 }
1277 
1278 
1289 static void
1290 ticket_iter (void *cls,
1291  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
1292  const char *label,
1293  unsigned int rd_count,
1294  const struct GNUNET_GNSRECORD_Data *rd)
1295 {
1296  struct AttributeDeleteHandle *adh = cls;
1297  struct TicketRecordsEntry *le;
1298  int has_changed = GNUNET_NO;
1299  for (int i = 0; i < rd_count; i++)
1300  {
1301  if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF != rd[i].record_type)
1302  continue;
1303  if (adh->claim != NULL)
1305  &adh->claim->id))
1306  continue;
1307  if (adh->attest != NULL)
1308  if (GNUNET_YES != GNUNET_RECLAIM_id_is_equal (rd[i].data,
1309  &adh->attest->id))
1310  continue;
1312  "Attribute or Attestation to delete found (%s)\n",
1313  adh->label);
1314  has_changed = GNUNET_YES;
1315  break;
1316  }
1317  if (GNUNET_YES == has_changed)
1318  {
1319  le = GNUNET_new (struct TicketRecordsEntry);
1320  le->data_size = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
1321  le->data = GNUNET_malloc (le->data_size);
1322  le->rd_count = rd_count;
1323  le->label = GNUNET_strdup (label);
1324  GNUNET_GNSRECORD_records_serialize (rd_count, rd, le->data_size, le->data);
1327  le);
1328  }
1330 }
1331 
1332 
1337 static void
1338 update_tickets (void *cls);
1339 
1340 
1348 static void
1349 ticket_updated (void *cls, int32_t success, const char *emsg)
1350 {
1351  struct AttributeDeleteHandle *adh = cls;
1352 
1353  adh->ns_qe = NULL;
1355 }
1356 
1357 
1365 static void
1366 update_tickets (void *cls)
1367 {
1368  struct AttributeDeleteHandle *adh = cls;
1369  struct TicketRecordsEntry *le;
1370 
1371  if (NULL == adh->tickets_to_update_head)
1372  {
1374  "Finished updating tickets, success\n");
1376  cleanup_adh (adh);
1377  return;
1378  }
1380  "Updating %s\n",
1382  le = adh->tickets_to_update_head;
1385  le);
1386  struct GNUNET_GNSRECORD_Data rd[le->rd_count];
1387  struct GNUNET_GNSRECORD_Data rd_new[le->rd_count - 1];
1389  le->data,
1390  le->rd_count,
1391  rd))
1392  {
1394  "Unable to deserialize record data!\n");
1396  cleanup_adh (adh);
1397  return;
1398  }
1399  int j = 0;
1400  for (int i = 0; i < le->rd_count; i++)
1401  {
1402  if (adh->claim != NULL)
1405  &adh->claim->id)))
1406  continue;
1407  if (adh->attest != NULL)
1408  if ((GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF == rd[i].record_type)
1409  && (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (rd[i].data,
1410  &adh->attest->id)))
1411  continue;
1412  rd_new[j] = rd[i];
1413  j++;
1414  }
1416  &adh->identity,
1417  le->label,
1418  j,
1419  rd_new,
1420  &ticket_updated,
1421  adh);
1422  GNUNET_free (le->label);
1423  GNUNET_free (le->data);
1424  GNUNET_free (le);
1425 }
1426 
1427 
1433 static void
1434 ticket_iter_fin (void *cls)
1435 {
1436  struct AttributeDeleteHandle *adh = cls;
1437  adh->ns_it = NULL;
1439 }
1440 
1441 
1447 static void
1448 ticket_iter_err (void *cls)
1449 {
1450  struct AttributeDeleteHandle *adh = cls;
1451 
1452  adh->ns_it = NULL;
1454  "Namestore error on delete %s\n",
1455  adh->label);
1457  cleanup_adh (adh);
1458 }
1459 
1460 
1467 static void
1469 {
1470  struct AttributeDeleteHandle *adh = cls;
1471 
1473  &adh->identity,
1474  &ticket_iter_err,
1475  adh,
1476  &ticket_iter,
1477  adh,
1478  &ticket_iter_fin,
1479  adh);
1480 }
1481 
1482 
1490 static void
1491 attr_delete_cont (void *cls, int32_t success, const char *emsg)
1492 {
1493  struct AttributeDeleteHandle *adh = cls;
1494 
1495  adh->ns_qe = NULL;
1496  if (GNUNET_SYSERR == success)
1497  {
1499  "Error deleting attribute %s\n",
1500  adh->label);
1502  cleanup_adh (adh);
1503  return;
1504  }
1505  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating tickets...\n");
1507 }
1508 
1509 
1516 static int
1518  const struct AttributeDeleteMessage *dam)
1519 {
1520  uint16_t size;
1521 
1522  size = ntohs (dam->header.size);
1523  if (size <= sizeof(struct AttributeDeleteMessage))
1524  {
1525  GNUNET_break (0);
1526  return GNUNET_SYSERR;
1527  }
1528  return GNUNET_OK;
1529 }
1530 
1531 
1538 static void
1540  const struct AttributeDeleteMessage *dam)
1541 {
1542  struct AttributeDeleteHandle *adh;
1543  struct IdpClient *idp = cls;
1544  size_t data_len;
1545 
1546  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_DELETE message\n");
1547 
1548  data_len = ntohs (dam->attr_len);
1549 
1550  adh = GNUNET_new (struct AttributeDeleteHandle);
1551  adh->claim = GNUNET_RECLAIM_attribute_deserialize ((char *) &dam[1],
1552  data_len);
1553  adh->attest = NULL;
1554 
1555  adh->r_id = ntohl (dam->id);
1556  adh->identity = dam->identity;
1557  adh->label
1559  sizeof(adh->claim->id));
1561  adh->client = idp;
1564  &adh->identity,
1565  adh->label,
1566  0,
1567  NULL,
1569  adh);
1570 }
1571 
1572 
1580 static void
1581 attest_delete_cont (void *cls, int32_t success, const char *emsg)
1582 {
1583  struct AttributeDeleteHandle *adh = cls;
1584 
1585  adh->ns_qe = NULL;
1586  if (GNUNET_SYSERR == success)
1587  {
1589  "Error deleting attestation %s\n",
1590  adh->label);
1592  cleanup_adh (adh);
1593  return;
1594  }
1595  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating tickets...\n");
1597 }
1598 
1599 
1606 static int
1608  const struct AttributeDeleteMessage *dam)
1609 {
1610  uint16_t size;
1611 
1612  size = ntohs (dam->header.size);
1613  if (size <= sizeof(struct AttributeDeleteMessage))
1614  {
1615  GNUNET_break (0);
1616  return GNUNET_SYSERR;
1617  }
1618  return GNUNET_OK;
1619 }
1620 
1621 
1628 static void
1630  const struct AttributeDeleteMessage *dam)
1631 {
1632  struct AttributeDeleteHandle *adh;
1633  struct IdpClient *idp = cls;
1634  size_t data_len;
1635 
1636  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTESTATION_DELETE message\n");
1637 
1638  data_len = ntohs (dam->attr_len);
1639 
1640  adh = GNUNET_new (struct AttributeDeleteHandle);
1641  adh->attest = GNUNET_RECLAIM_attestation_deserialize ((char *) &dam[1],
1642  data_len);
1643  adh->claim = NULL;
1644 
1645  adh->r_id = ntohl (dam->id);
1646  adh->identity = dam->identity;
1647  adh->label
1649  sizeof(adh->attest->id));
1651  adh->client = idp;
1654  &adh->identity,
1655  adh->label,
1656  0,
1657  NULL,
1659  adh);
1660 }
1661 
1662 
1663 /*************************************************
1664 * Attrubute iteration
1665 *************************************************/
1666 
1667 
1673 static void
1675 {
1676  struct Iterator *ai = cls;
1677  struct GNUNET_MQ_Envelope *env;
1678  struct AttributeResultMessage *arm;
1679 
1680  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ATTRIBUTE_RESULT message\n");
1682  arm->id = htonl (ai->request_id);
1683  arm->attr_len = htons (0);
1684  GNUNET_MQ_send (ai->client->mq, env);
1686  ai->client->attr_iter_tail,
1687  ai);
1688  GNUNET_free (ai);
1689 }
1690 
1691 
1697 static void
1698 attr_iter_error (void *cls)
1699 {
1700  struct Iterator *ai = cls;
1701 
1702  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over attributes\n");
1703  attr_iter_finished (ai);
1704 }
1705 
1706 
1716 static void
1717 attr_iter_cb (void *cls,
1718  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
1719  const char *label,
1720  unsigned int rd_count,
1721  const struct GNUNET_GNSRECORD_Data *rd)
1722 {
1723  struct Iterator *ai = cls;
1724  struct GNUNET_MQ_Envelope *env;
1725  char *data_tmp;
1726 
1727  if ((rd_count != 1) ||
1729  {
1731  return;
1732  }
1733  struct AttributeResultMessage *arm;
1734  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found attribute under: %s\n",
1735  label);
1737  "Sending ATTRIBUTE_RESULT message\n");
1738  env = GNUNET_MQ_msg_extra (arm,
1739  rd->data_size,
1741  arm->id = htonl (ai->request_id);
1742  arm->attr_len = htons (rd->data_size);
1744  data_tmp = (char *) &arm[1];
1745  GNUNET_memcpy (data_tmp, rd->data, rd->data_size);
1746  GNUNET_MQ_send (ai->client->mq, env);
1747 }
1748 
1749 
1756 static void
1758  const struct AttributeIterationStartMessage *ais_msg)
1759 {
1760  struct IdpClient *idp = cls;
1761  struct Iterator *ai;
1762 
1764  "Received ATTRIBUTE_ITERATION_START message\n");
1765  ai = GNUNET_new (struct Iterator);
1766  ai->request_id = ntohl (ais_msg->id);
1767  ai->client = idp;
1768  ai->identity = ais_msg->identity;
1769 
1772  &ai->identity,
1773  &attr_iter_error,
1774  ai,
1775  &attr_iter_cb,
1776  ai,
1778  ai);
1780 }
1781 
1782 
1789 static void
1791  const struct AttributeIterationStopMessage *ais_msg)
1792 {
1793  struct IdpClient *idp = cls;
1794  struct Iterator *ai;
1795  uint32_t rid;
1796 
1798  "Received `%s' message\n",
1799  "ATTRIBUTE_ITERATION_STOP");
1800  rid = ntohl (ais_msg->id);
1801  for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
1802  if (ai->request_id == rid)
1803  break;
1804  if (NULL == ai)
1805  {
1806  GNUNET_break (0);
1808  return;
1809  }
1811  GNUNET_free (ai);
1813 }
1814 
1815 
1822 static void
1824  const struct AttributeIterationNextMessage *ais_msg)
1825 {
1826  struct IdpClient *idp = cls;
1827  struct Iterator *ai;
1828  uint32_t rid;
1829 
1831  "Received ATTRIBUTE_ITERATION_NEXT message\n");
1832  rid = ntohl (ais_msg->id);
1833  for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
1834  if (ai->request_id == rid)
1835  break;
1836  if (NULL == ai)
1837  {
1838  GNUNET_break (0);
1840  return;
1841  }
1844 }
1845 
1846 
1847 /*************************************************
1848 * Attestation iteration
1849 *************************************************/
1850 
1851 
1857 static void
1859 {
1860  struct Iterator *ai = cls;
1861  struct GNUNET_MQ_Envelope *env;
1862  struct AttestationResultMessage *arm;
1863 
1864  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ATTESTATION_RESULT message\n");
1866  arm->id = htonl (ai->request_id);
1867  arm->attestation_len = htons (0);
1868  GNUNET_MQ_send (ai->client->mq, env);
1870  ai->client->attest_iter_tail,
1871  ai);
1872  GNUNET_free (ai);
1873 }
1874 
1875 
1881 static void
1883 {
1884  struct Iterator *ai = cls;
1885 
1886  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over attestations\n");
1887  attest_iter_finished (ai);
1888 }
1889 
1890 
1900 static void
1901 attest_iter_cb (void *cls,
1902  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
1903  const char *label,
1904  unsigned int rd_count,
1905  const struct GNUNET_GNSRECORD_Data *rd)
1906 {
1907  struct Iterator *ai = cls;
1908  struct GNUNET_MQ_Envelope *env;
1909  struct AttestationResultMessage *arm;
1910  char *data_tmp;
1911 
1912  if ((rd_count != 1) ||
1914  {
1916  return;
1917  }
1918  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found attestation under: %s\n",
1919  label);
1921  "Sending ATTESTATION_RESULT message\n");
1922  env = GNUNET_MQ_msg_extra (arm,
1923  rd->data_size,
1925  arm->id = htonl (ai->request_id);
1926  arm->attestation_len = htons (rd->data_size);
1928  data_tmp = (char *) &arm[1];
1929  GNUNET_memcpy (data_tmp, rd->data, rd->data_size);
1930 
1931  GNUNET_MQ_send (ai->client->mq, env);
1932 }
1933 
1934 
1941 static void
1943  const struct
1945 {
1946  struct IdpClient *idp = cls;
1947  struct Iterator *ai;
1948 
1950  "Received ATTESTATION_ITERATION_START message\n");
1951  ai = GNUNET_new (struct Iterator);
1952  ai->request_id = ntohl (ais_msg->id);
1953  ai->client = idp;
1954  ai->identity = ais_msg->identity;
1955 
1957  ai);
1959  &ai->identity,
1961  ai,
1962  &attest_iter_cb,
1963  ai,
1965  ai);
1967 }
1968 
1969 
1976 static void
1978  const struct
1980 {
1981  struct IdpClient *idp = cls;
1982  struct Iterator *ai;
1983  uint32_t rid;
1984 
1986  "Received `%s' message\n",
1987  "ATTESTATION_ITERATION_STOP");
1988  rid = ntohl (ais_msg->id);
1989  for (ai = idp->attest_iter_head; NULL != ai; ai = ai->next)
1990  if (ai->request_id == rid)
1991  break;
1992  if (NULL == ai)
1993  {
1994  GNUNET_break (0);
1996  return;
1997  }
1999  ai);
2000  GNUNET_free (ai);
2002 }
2003 
2004 
2011 static void
2013  const struct
2015 {
2016  struct IdpClient *idp = cls;
2017  struct Iterator *ai;
2018  uint32_t rid;
2019 
2021  "Received ATTESTATION_ITERATION_NEXT message\n");
2022  rid = ntohl (ais_msg->id);
2023  for (ai = idp->attest_iter_head; NULL != ai; ai = ai->next)
2024  if (ai->request_id == rid)
2025  break;
2026  if (NULL == ai)
2027  {
2028  GNUNET_break (0);
2030  return;
2031  }
2034 }
2035 
2036 
2037 /******************************************************
2038 * Ticket iteration
2039 ******************************************************/
2040 
2047 static void
2049 {
2050  struct TicketIteration *ti = cls;
2051  struct GNUNET_MQ_Envelope *env;
2052  struct TicketResultMessage *trm;
2053 
2055  if (NULL == ticket)
2056  {
2057  /* send empty response to indicate end of list */
2059  ti->client->ticket_iter_tail,
2060  ti);
2061  }
2062  else
2063  {
2064  trm->ticket = *ticket;
2065  }
2066  trm->id = htonl (ti->r_id);
2067  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
2068  GNUNET_MQ_send (ti->client->mq, env);
2069  if (NULL == ticket)
2070  GNUNET_free (ti);
2071 }
2072 
2073 
2080 static void
2082  void *cls,
2083  const struct TicketIterationStartMessage *tis_msg)
2084 {
2085  struct IdpClient *client = cls;
2086  struct TicketIteration *ti;
2087 
2089  "Received TICKET_ITERATION_START message\n");
2090  ti = GNUNET_new (struct TicketIteration);
2091  ti->r_id = ntohl (tis_msg->id);
2092  ti->client = client;
2093 
2095  client->ticket_iter_tail,
2096  ti);
2097  ti->iter
2100 }
2101 
2102 
2109 static void
2111  const struct TicketIterationStopMessage *tis_msg)
2112 {
2113  struct IdpClient *client = cls;
2114  struct TicketIteration *ti;
2115  uint32_t rid;
2116 
2118  "Received `%s' message\n",
2119  "TICKET_ITERATION_STOP");
2120  rid = ntohl (tis_msg->id);
2121  for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next)
2122  if (ti->r_id == rid)
2123  break;
2124  if (NULL == ti)
2125  {
2126  GNUNET_break (0);
2128  return;
2129  }
2132  client->ticket_iter_tail,
2133  ti);
2134  GNUNET_free (ti);
2136 }
2137 
2138 
2145 static void
2147  const struct TicketIterationNextMessage *tis_msg)
2148 {
2149  struct IdpClient *client = cls;
2150  struct TicketIteration *ti;
2151  uint32_t rid;
2152 
2154  "Received TICKET_ITERATION_NEXT message\n");
2155  rid = ntohl (tis_msg->id);
2156  for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next)
2157  if (ti->r_id == rid)
2158  break;
2159  if (NULL == ti)
2160  {
2161  GNUNET_break (0);
2163  return;
2164  }
2167 }
2168 
2169 
2177 static void
2178 run (void *cls,
2179  const struct GNUNET_CONFIGURATION_Handle *c,
2180  struct GNUNET_SERVICE_Handle *server)
2181 {
2182  cfg = c;
2183 
2184  if (GNUNET_OK != RECLAIM_TICKETS_init (cfg))
2185  {
2187  "Unable to initialize TICKETS subsystem.\n");
2189  return;
2190  }
2191  // Connect to identity and namestore services
2192  nsh = GNUNET_NAMESTORE_connect (cfg);
2193  if (NULL == nsh)
2194  {
2196  "error connecting to namestore");
2197  }
2198 
2200 }
2201 
2202 
2210 static void
2212  struct GNUNET_SERVICE_Client *client,
2213  void *app_ctx)
2214 {
2215  struct IdpClient *idp = app_ctx;
2216 
2217  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p disconnected\n", client);
2218  GNUNET_CONTAINER_DLL_remove (client_list_head,
2219  client_list_tail,
2220  idp);
2221  cleanup_client (idp);
2222 }
2223 
2224 
2233 static void *
2235  struct GNUNET_SERVICE_Client *client,
2236  struct GNUNET_MQ_Handle *mq)
2237 {
2238  struct IdpClient *idp;
2239 
2240  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
2241  idp = GNUNET_new (struct IdpClient);
2242  idp->client = client;
2243  idp->mq = mq;
2244  GNUNET_CONTAINER_DLL_insert (client_list_head,
2245  client_list_tail,
2246  idp);
2247  return idp;
2248 }
2249 
2250 
2255  "reclaim",
2257  &run,
2260  NULL,
2261  GNUNET_MQ_hd_var_size (attribute_store_message,
2263  struct AttributeStoreMessage,
2264  NULL),
2265  GNUNET_MQ_hd_var_size (attestation_store_message,
2267  struct AttributeStoreMessage,
2268  NULL),
2269  GNUNET_MQ_hd_var_size (attribute_delete_message,
2271  struct AttributeDeleteMessage,
2272  NULL),
2273  GNUNET_MQ_hd_var_size (attestation_delete_message,
2275  struct AttributeDeleteMessage,
2276  NULL),
2280  NULL),
2281  GNUNET_MQ_hd_fixed_size (iteration_next,
2284  NULL),
2285  GNUNET_MQ_hd_fixed_size (iteration_stop,
2288  NULL),
2289  GNUNET_MQ_hd_fixed_size (attestation_iteration_start,
2292  NULL),
2293  GNUNET_MQ_hd_fixed_size (attestation_iteration_next,
2296  NULL),
2297  GNUNET_MQ_hd_fixed_size (attestation_iteration_stop,
2300  NULL),
2301 
2302  GNUNET_MQ_hd_var_size (issue_ticket_message,
2304  struct IssueTicketMessage,
2305  NULL),
2306  GNUNET_MQ_hd_var_size (consume_ticket_message,
2308  struct ConsumeTicketMessage,
2309  NULL),
2310  GNUNET_MQ_hd_fixed_size (ticket_iteration_start,
2313  NULL),
2314  GNUNET_MQ_hd_fixed_size (ticket_iteration_next,
2317  NULL),
2318  GNUNET_MQ_hd_fixed_size (ticket_iteration_stop,
2321  NULL),
2322  GNUNET_MQ_hd_var_size (revoke_ticket_message,
2324  struct RevokeTicketMessage,
2325  NULL),
2327 /* end of gnunet-service-reclaim.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Handle for attribute deletion request.
struct TicketIteration * ticket_iter_tail
Tail of DLL of ticket iteration ops.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET
struct GNUNET_CRYPTO_EcdsaPrivateKey identity
Identity.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_RESULT
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:463
static void attr_delete_cont(void *cls, int32_t success, const char *emsg)
Attribute deleted callback.
Ticket result message.
Definition: reclaim.h:453
size_t GNUNET_RECLAIM_attestation_list_serialize(const struct GNUNET_RECLAIM_AttestationList *attrs, char *result)
Serialize an attribute list.
struct GNUNET_CRYPTO_EcdsaPrivateKey identity
Identity.
Definition: reclaim.h:415
The authorization ticket.
struct GNUNET_RECLAIM_Attestation * attest
The attestation to delete.
static int check_attestation_store_message(void *cls, const struct AttributeStoreMessage *sam)
Check an attestation store message.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_DELETE
static void update_tickets(void *cls)
Recursion prototype for function.
GNUNET_NETWORK_STRUCT_END ssize_t GNUNET_GNSRECORD_records_get_size(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Calculate how many bytes we will need to serialize the given records.
static void revoke_result_cb(void *cls, int32_t success)
Handles revocation result.
static struct GNUNET_CADET_ListTunnels * tio
Active tunnel listing operation.
Definition: gnunet-cadet.c:112
struct GNUNET_RECLAIM_Ticket ticket
The new ticket.
Definition: reclaim.h:468
static void handle_ticket_iteration_start(void *cls, const struct TicketIterationStartMessage *tis_msg)
Client requests a ticket iteration.
struct TicketRecordsEntry * tickets_to_update_tail
Tickets to update.
static void attest_error(void *cls)
Error looking up potential attestation.
void RECLAIM_TICKETS_issue(const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, const struct GNUNET_RECLAIM_AttributeList *attrs, const struct GNUNET_CRYPTO_EcdsaPublicKey *audience, RECLAIM_TICKETS_TicketResult cb, void *cb_cls)
Issue a new reclaim ticket, thereby authorizing the audience to access the set of provided attributes...
struct TicketIssueOperation * prev
DLL.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_ITERATION_NEXT
Attribute list is returned from the idp.
Definition: reclaim.h:500
static void ticket_iter_err(void *cls)
Error collecting affected tickets.
uint64_t rel_value_us
The actual value.
struct IdpClient * client
Client connection.
Ticket revocation request handle.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_ITERATION_STOP
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:271
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET.
Definition: reclaim.h:405
#define GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT
struct GNUNET_CRYPTO_EcdsaPrivateKey identity
Identity.
Definition: reclaim.h:326
Ticket consume message.
Definition: reclaim.h:474
struct GNUNET_RECLAIM_Attestation * attest
The attestation to store.
void GNUNET_RECLAIM_attribute_list_destroy(struct GNUNET_RECLAIM_AttributeList *attrs)
Destroy claim list.
Handle to a service.
Definition: service.c:116
struct ConsumeTicketOperation * consume_op_head
Head of DLL of ticket consume ops.
An idp client.
size_t GNUNET_RECLAIM_attestation_serialize(const struct GNUNET_RECLAIM_Attestation *attestation, char *result)
Serialize an attestation.
static void ticket_iter(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Namestore iteration within attribute deletion.
Start a attribute iteration for the given identity.
Definition: reclaim.h:200
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_lookup(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor rm, void *rm_cls)
Lookup an item in the namestore.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Ticket issue operation handle.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1333
ssize_t GNUNET_GNSRECORD_records_serialize(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, size_t dest_size, char *dest)
Serialize the given records to the given destination buffer.
struct GNUNET_NAMESTORE_ZoneIterator * GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
Starts a new zone iteration (used to periodically PUT all of our records into our DHT)...
static void attr_iter_error(void *cls)
Error iterating over attributes.
static int check_attribute_store_message(void *cls, const struct AttributeStoreMessage *sam)
Check an attribute store message.
struct GNUNET_CRYPTO_EcdsaPrivateKey identity
Identity.
Definition: reclaim.h:254
Stop attribute iteration for the given operation.
Definition: reclaim.h:295
static void handle_attestation_delete_message(void *cls, const struct AttributeDeleteMessage *dam)
Handle attestation deletion.
int32_t op_result
GNUNET_SYSERR on failure, GNUNET_OK on success
Definition: reclaim.h:118
void RECLAIM_TICKETS_iteration_stop(struct RECLAIM_TICKETS_Iterator *iter)
Stop a running ticket iteration.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:410
static void handle_attestation_iteration_next(void *cls, const struct AttestationIterationNextMessage *ais_msg)
Client requests next attestation from iterator.
struct RECLAIM_TICKETS_Iterator * iter
The ticket iterator.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:134
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:510
struct GNUNET_RECLAIM_AttributeList * GNUNET_RECLAIM_attribute_list_deserialize(const char *data, size_t data_size)
Deserialize an attribute list.
struct TicketRevocationOperation * revoke_op_tail
Tail of DLL of ticket revocation ops.
#define GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT
struct AttributeDeleteHandle * prev
DLL.
static void attr_store_cont(void *cls, int32_t success, const char *emsg)
Attribute store result handler.
Use to delete an identity attribute.
Definition: reclaim.h:74
struct IdpClient * client
Client connection.
struct Iterator * attr_iter_head
Head of the DLL of Attribute iteration operations in progress initiated by this client.
static void handle_attestation_iteration_start(void *cls, const struct AttestationIterationStartMessage *ais_msg)
Iterate over zone to get attributes.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:249
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
static void handle_attribute_store_message(void *cls, const struct AttributeStoreMessage *sam)
Handle an attribute store message.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
Called whenever a client is disconnected.
An attribute iteration operation.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_STORE
#define GNUNET_NO
Definition: gnunet_common.h:86
static void handle_attribute_delete_message(void *cls, const struct AttributeDeleteMessage *dam)
Handle attribute deletion.
#define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT
A list of GNUNET_RECLAIM_Attribute structures.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:83
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_ITERATION_START
size_t data_size
Number of bytes in data.
A list of GNUNET_RECLAIM_Attestation structures.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
QueueEntry.
void GNUNET_NAMESTORE_zone_iterator_next(struct GNUNET_NAMESTORE_ZoneIterator *it, uint64_t limit)
Calls the record processor specified in GNUNET_NAMESTORE_zone_iteration_start for the next record...
Private ECC key encoded for transmission.
static void attest_delete_cont(void *cls, int32_t success, const char *emsg)
Attestation deleted callback.
struct Iterator * attest_iter_head
Head of the DLL of Attribute iteration operations in progress initiated by this client.
struct TicketIssueOperation * issue_op_head
Head of DLL of ticket issue ops.
static void cleanup_client(struct IdpClient *idp)
Cleanup client.
uint32_t r_id
The operation id fot the iteration in the response for the client.
uint32_t attr_len
The length of the attribute.
Definition: reclaim.h:89
int GNUNET_GNSRECORD_records_deserialize(size_t len, const char *src, unsigned int rd_count, struct GNUNET_GNSRECORD_Data *dest)
Deserialize the given records to the given destination.
uint32_t result
Result.
Definition: reclaim.h:515
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
struct RECLAIM_TICKETS_Iterator * RECLAIM_TICKETS_iteration_start(const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, RECLAIM_TICKETS_TicketIter cb, void *cb_cls)
Iterate over all tickets issued by an identity.
size_t GNUNET_RECLAIM_attribute_serialize(const struct GNUNET_RECLAIM_Attribute *attr, char *result)
Serialize an attribute.
uint32_t r_id
request id
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
Use to store an identity attribute.
Definition: reclaim.h:40
struct AttributeStoreHandle * store_op_head
Head of DLL of attribute store ops.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct IdpClient * client
IDP client which intiated this zone iteration.
Start a attestation iteration for the given identity.
Definition: reclaim.h:239
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
Add a client to our list of active clients.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:174
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET.
Definition: reclaim.h:372
struct IdpClient * client
Client which intiated this zone iteration.
size_t GNUNET_RECLAIM_attribute_serialize_get_size(const struct GNUNET_RECLAIM_Attribute *attr)
Get required size for serialization buffer.
static void handle_consume_ticket_message(void *cls, const struct ConsumeTicketMessage *cm)
Handle a consume ticket message.
struct RECLAIM_TICKETS_RevokeHandle * rh
Revocation handle.
Ask for next result of ticket iteration for the given operation.
Definition: reclaim.h:333
struct GNUNET_SERVICE_Client * client
The client.
void GNUNET_NAMESTORE_cancel(struct GNUNET_NAMESTORE_QueueEntry *qe)
Cancel a namestore operation.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_store(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the namestore.
struct TicketIteration * ticket_iter_head
Head of DLL of ticket iteration ops.
static void cleanup_as_handle(struct AttributeStoreHandle *ash)
Cleanup attribute store handle.
Handle to a client that is connected to a service.
Definition: service.c:250
Common type definitions for the identity provider service and API.
static char * zone
Name of the zone we manage.
static void handle_iteration_start(void *cls, const struct AttributeIterationStartMessage *ais_msg)
Iterate over zone to get attributes.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:343
struct GNUNET_MQ_Handle * mq
Message queue for transmission to client.
static void attest_iter_error(void *cls)
Error iterating over attestations.
struct GNUNET_NAMESTORE_ZoneIterator * ns_it
Iterator.
static struct GNUNET_RECLAIM_Ticket ticket
Ticket to consume.
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
Stop attestation iteration for the given operation.
Definition: reclaim.h:278
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
static void handle_ticket_iteration_next(void *cls, const struct TicketIterationNextMessage *tis_msg)
Client requests next result.
struct AttributeStoreHandle * prev
DLL.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
Handle for a zone iterator operation.
uint32_t r_id
request id
static void cleanup()
Cleanup task.
static void attr_store_task(void *cls)
Add a new attribute.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:305
const void * data
Binary value stored in the DNS record.
struct GNUNET_TIME_Relative exp
The attribute expiration interval.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT.
Definition: reclaim.h:79
static void send_delete_response(struct AttributeDeleteHandle *adh, int32_t success)
Send a deletion success response.
#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF
Record type for reclaim records.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
static void ticket_iter_fin(void *cls)
Done collecting affected tickets, start updating.
struct GNUNET_CRYPTO_EcdsaPrivateKey identity
Identity.
Definition: reclaim.h:489
Connection to the NAMESTORE service.
struct TicketIteration * prev
DLL.
Stop ticket iteration for the given operation.
Definition: reclaim.h:350
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:232
struct GNUNET_RECLAIM_Attribute * GNUNET_RECLAIM_attribute_deserialize(const char *data, size_t data_size)
Deserialize an attribute.
uint64_t expiration_time
Expiration time for the DNS record.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1298
struct GNUNET_RECLAIM_Ticket ticket
The ticket to revoke.
Definition: reclaim.h:425
unsigned int rd_count
Record count.
Handle to a consume operation.
static struct IdpClient * client_list_head
Client list.
static void handle_attestation_store_message(void *cls, const struct AttributeStoreMessage *sam)
Handle an attestation store message.
uint16_t attestations_len
Length of attestation data.
Definition: reclaim.h:525
Handle for attribute store request.
struct ConsumeTicketOperation * next
DLL.
static char buf[2048]
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:288
void RECLAIM_TICKETS_iteration_next(struct RECLAIM_TICKETS_Iterator *iter)
Continue ticket iteration.
struct AttributeStoreHandle * store_op_tail
Tail of DLL of attribute store ops.
static void issue_ticket_result_cb(void *cls, struct GNUNET_RECLAIM_Ticket *ticket, int32_t success, const char *emsg)
Issue ticket result.
struct GNUNET_RECLAIM_Identifier id
ID.
static int check_attestation_delete_message(void *cls, const struct AttributeDeleteMessage *dam)
Check attestation delete message format.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT
struct GNUNET_CRYPTO_EcdsaPrivateKey identity
Identity.
Definition: reclaim.h:215
struct IdpClient * client
Client connection.
uint32_t attr_len
The length of the attribute.
Definition: reclaim.h:55
struct TicketRecordsEntry * tickets_to_update_head
Tickets to update.
struct GNUNET_CRYPTO_EcdsaPrivateKey identity
Key of the zone we are iterating over.
static void consume_result_cb(void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, const struct GNUNET_RECLAIM_AttributeList *attrs, const struct GNUNET_RECLAIM_AttestationList *attests, int32_t success, const char *emsg)
Handle a ticket consume result.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:210
Ticket issue message.
Definition: reclaim.h:367
struct IdpClient * prev
DLL.
struct GNUNET_NAMESTORE_ZoneIterator * ns_it
Namestore iterator.
void GNUNET_NAMESTORE_zone_iteration_stop(struct GNUNET_NAMESTORE_ZoneIterator *it)
Stops iteration and releases the namestore handle for further calls.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE
struct GNUNET_RECLAIM_Attestation * GNUNET_RECLAIM_attestation_deserialize(const char *data, size_t data_size)
Deserialize an attestation.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2321
size_t GNUNET_RECLAIM_attestation_serialize_get_size(const struct GNUNET_RECLAIM_Attestation *attestation)
Get required size for serialization buffer.
struct GNUNET_CRYPTO_EcdsaPublicKey identity_pkey
Identity pubkey.
uint16_t attestation_len
Length of serialized attribute data.
Definition: reclaim.h:179
struct GNUNET_CRYPTO_EcdsaPublicKey identity
The public key of the identity.
Definition: reclaim.h:189
struct IdpClient * client
Client connection.
struct TicketRevocationOperation * next
DLL.
struct TicketIteration * next
DLL.
Attribute store/delete response message.
Definition: reclaim.h:103
struct GNUNET_RECLAIM_Identifier id
ID.
static void attest_store_cont(void *cls, int32_t success, const char *emsg)
Attestation store result handler.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT.
Definition: reclaim.h:45
void RECLAIM_TICKETS_consume_cancel(struct RECLAIM_TICKETS_ConsumeHandle *cth)
Cancel a consume operation.
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static void handle_revoke_ticket_message(void *cls, const struct RevokeTicketMessage *rm)
Handle a revocation message to a ticket.
uint32_t attr_len
length of serialized attribute list
Definition: reclaim.h:392
struct RECLAIM_TICKETS_ConsumeHandle * ch
Ticket consume handle.
static void start_ticket_update(void *cls)
Start processing tickets which may still contain reference to deleted attribute.
#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTESTATION
Record type for an attribute attestation.
char * label
Attribute label.
#define GNUNET_SYSERR
Definition: gnunet_common.h:84
struct GNUNET_RECLAIM_Ticket ticket
The ticket to consume.
Definition: reclaim.h:494
static unsigned int size
Size of the "table".
Definition: peer.c:67
#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE
Record type for identity attributes (of RECLAIM).
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
void GNUNET_CRYPTO_ecdsa_key_get_public(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:172
An QueueEntry used to store information for a pending NAMESTORE record operation. ...
Definition: namestore_api.c:53
size_t GNUNET_RECLAIM_attribute_list_serialize(const struct GNUNET_RECLAIM_AttributeList *attrs, char *result)
Serialize an attribute list.
Ask for next result of attribute iteration for the given operation.
Definition: reclaim.h:222
static void attest_add_cb(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Check for existing record before storing attestation.
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
struct IdpClient * client
Client connection.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct ConsumeTicketOperation * consume_op_tail
Tail of DLL of ticket consume ops.
struct TicketRevocationOperation * revoke_op_head
Head of DLL of ticket revocation ops.
static void iteration_start()
struct TicketRevocationOperation * prev
DLL.
struct Iterator * prev
Previous element in the DLL.
static void ticket_updated(void *cls, int32_t success, const char *emsg)
Callback called when a ticket was updated.
struct Iterator * attest_iter_tail
Tail of the DLL of Attribute iteration operations in progress initiated by this client.
static void handle_ticket_iteration_stop(void *cls, const struct TicketIterationStopMessage *tis_msg)
Client has had enough tickets.
void RECLAIM_TICKETS_revoke_cancel(struct RECLAIM_TICKETS_RevokeHandle *rh)
Cancel a revocation.
struct AttributeDeleteHandle * delete_op_head
Head of DLL of attribute delete ops.
struct TicketIssueOperation * issue_op_tail
Tail of DLL of ticket issue ops.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START
struct Iterator * next
Next element in the DLL.
#define GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE
Handle to a message queue.
Definition: mq.c:85
static void handle_attestation_iteration_stop(void *cls, const struct AttestationIterationStopMessage *ais_msg)
Handle iteration stop message from client.
void * ctx
Context.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP
A ticket iteration operation.
struct GNUNET_CRYPTO_EcdsaPublicKey identity
The public key of the identity.
Definition: reclaim.h:535
#define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START
Ticket revocation request handle.
static void handle_iteration_next(void *cls, const struct AttributeIterationNextMessage *ais_msg)
Client requests next attribute from iterator.
uint32_t record_type
Type of the GNS/DNS record.
Ticket revoke message.
Definition: reclaim.h:431
struct RECLAIM_TICKETS_RevokeHandle * RECLAIM_TICKETS_revoke(const struct GNUNET_RECLAIM_Ticket *ticket, const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, RECLAIM_TICKETS_RevokeCallback cb, void *cb_cls)
Revoke a ticket.
configuration data
Definition: configuration.c:84
struct AttributeStoreHandle * next
DLL.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:321
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:441
void RECLAIM_TICKETS_deinit(void)
Close handles and clean up.
Attribute is returned from the idp.
Definition: reclaim.h:124
uint16_t attr_len
Length of serialized attribute data.
Definition: reclaim.h:139
#define GNUNET_RECLAIM_id_is_equal(a, b)
Start a ticket iteration for the given identity.
Definition: reclaim.h:311
struct AttributeDeleteHandle * next
DLL.
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)
Consume a ticket.
uint16_t attrs_len
Length of serialized attribute data.
Definition: reclaim.h:520
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static struct GNUNET_SCHEDULER_Task * timeout_task
Timeout task.
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
struct AttributeDeleteHandle * delete_op_tail
Tail of DLL of attribute delete ops.
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)
Got record.
Handle for ticket consume request.
struct GNUNET_CRYPTO_EcdsaPublicKey identity
The public key of the identity.
Definition: reclaim.h:154
size_t GNUNET_RECLAIM_attribute_list_serialize_get_size(const struct GNUNET_RECLAIM_AttributeList *attrs)
Get required size for serialization buffer.
static void handle_issue_ticket_message(void *cls, const struct IssueTicketMessage *im)
Handle ticket issue message.
static struct GNUNET_NAMESTORE_Handle * nsh
Namestore handle.
#define GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET
#define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_STOP
Ask for next result of attestation iteration for the given operation.
Definition: reclaim.h:261
#define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT
struct GNUNET_CRYPTO_EcdsaPrivateKey identity
Identity.
static int check_consume_ticket_message(void *cls, const struct ConsumeTicketMessage *cm)
Check a consume ticket message.
#define GNUNET_YES
Definition: gnunet_common.h:85
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
QueueEntry.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
static void cleanup_adh(struct AttributeDeleteHandle *adh)
Cleanup attribute delete handle.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:360
static void attest_iter_cb(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Got record.
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:923
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET.
Definition: reclaim.h:479
static void send_ticket_result(const struct IdpClient *client, uint32_t r_id, const struct GNUNET_RECLAIM_Ticket *ticket, uint32_t success)
Sends a ticket result message to the client.
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
static void do_shutdown(void *cls)
Shutdown task.
This expiration time of the record is a relative time (not an absolute time).
Attestation is returned from the idp.
Definition: reclaim.h:164
uint32_t request_id
The operation id fot the zone iteration in the response for the client.
#define GNUNET_RECLAIM_id_generate(id)
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *server)
Main function that will be run.
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_var_size(attestation_store_message, GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_STORE, struct AttributeStoreMessage, NULL), GNUNET_MQ_hd_var_size(attribute_delete_message, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE, struct AttributeDeleteMessage, NULL), GNUNET_MQ_hd_var_size(attestation_delete_message, GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_DELETE, struct AttributeDeleteMessage, 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_fixed_size(attestation_iteration_start, GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_ITERATION_START, struct AttestationIterationStartMessage, NULL), GNUNET_MQ_hd_fixed_size(attestation_iteration_next, GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_ITERATION_NEXT, struct AttestationIterationNextMessage, NULL), GNUNET_MQ_hd_fixed_size(attestation_iteration_stop, GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_ITERATION_STOP, struct AttestationIterationStopMessage, 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())
Define "main" method using service macro.
struct IdpClient * next
DLL.
struct TicketIssueOperation * next
DLL.
static int check_revoke_ticket_message(void *cls, const struct RevokeTicketMessage *im)
Check revocation message format.
static void attest_iter_finished(void *cls)
Done iterating over attestations.
static void attr_iter_finished(void *cls)
Done iterating over attributes.
uint32_t data
The data value.
struct Iterator * attr_iter_tail
Tail of the DLL of Attribute iteration operations in progress initiated by this client.
struct GNUNET_RECLAIM_Attribute * claim
The attribute to store.
struct GNUNET_RECLAIM_Attribute * claim
The attribute to delete.
size_t GNUNET_RECLAIM_attestation_list_serialize_get_size(const struct GNUNET_RECLAIM_AttestationList *attestations)
Get required size for serialization buffer.
static void ticket_iter_cb(void *cls, struct GNUNET_RECLAIM_Ticket *ticket)
Got a ticket.
int RECLAIM_TICKETS_init(const struct GNUNET_CONFIGURATION_Handle *c)
Initialize tickets component.
static void attest_store_task(void *cls)
Add a new attestation.
uint32_t success
Revocation result.
Definition: reclaim.h:446
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2240
static int check_attribute_delete_message(void *cls, const struct AttributeDeleteMessage *dam)
Check attribute delete message format.
struct ConsumeTicketOperation * prev
DLL.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:484
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
static struct IdpClient * client_list_tail
Client list.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE
#define GNUNET_malloc(size)
Wrapper around malloc.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:113
static int check_issue_ticket_message(void *cls, const struct IssueTicketMessage *im)
Check issue ticket message.
#define GNUNET_free(ptr)
Wrapper around free.
static void handle_iteration_stop(void *cls, const struct AttributeIterationStopMessage *ais_msg)
Handle iteration stop message from client.
Ticket revoke message.
Definition: reclaim.h:400
Time for relative time used by GNUnet, in microseconds.
#define GNUNET_RECLAIM_id_is_zero(a)
#define GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:974