GNUnet  0.19.3
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 
306 
311 
315  char *label;
316 
320  uint32_t r_id;
321 };
322 
323 
328 {
333 
338 
342  struct IdpClient *client;
343 
348 
353 
358 
363 
368 
372  struct GNUNET_TIME_Relative exp;
373 
377  uint32_t r_id;
378 };
379 
380 
385 {
390 
395 
399  struct IdpClient *client;
400 
404  uint32_t r_id;
405 
410 };
411 
412 
417 {
422 
427 
431  struct IdpClient *client;
432 
437 
441  uint32_t r_id;
442 };
443 
444 
449 {
454 
459 
463  struct IdpClient *client;
464 
468  uint32_t r_id;
469 };
470 
471 
475 static struct IdpClient *client_list_head = NULL;
476 
480 static struct IdpClient *client_list_tail = NULL;
481 
482 
488 static void
490 {
491  struct TicketRecordsEntry *le;
492 
493  if (NULL != adh->ns_it)
495  if (NULL != adh->ns_qe)
497  if (NULL != adh->label)
498  GNUNET_free (adh->label);
499  if (NULL != adh->claim)
500  GNUNET_free (adh->claim);
501  if (NULL != adh->credential)
502  GNUNET_free (adh->credential);
503  if (NULL != adh->existing_credentials)
505  if (NULL != adh->existing_attributes)
507  while (NULL != (le = adh->tickets_to_update_head))
508  {
511  le);
512  if (NULL != le->label)
513  GNUNET_free (le->label);
514  if (NULL != le->data)
515  GNUNET_free (le->data);
516  GNUNET_free (le);
517  }
518  GNUNET_free (adh);
519 }
520 
521 
527 static void
529 {
530  if (NULL != ash->ns_qe)
532  if (NULL != ash->claim)
533  GNUNET_free (ash->claim);
534  if (NULL != ash->credential)
535  GNUNET_free (ash->credential);
536  GNUNET_free (ash);
537 }
538 
539 
545 static void
547 {
548  struct Iterator *ai;
549  struct TicketIteration *ti;
550  struct TicketRevocationOperation *rop;
551  struct TicketIssueOperation *iss;
552  struct ConsumeTicketOperation *ct;
553  struct AttributeStoreHandle *as;
554  struct AttributeDeleteHandle *adh;
555 
556  while (NULL != (iss = idp->issue_op_head))
557  {
558  GNUNET_CONTAINER_DLL_remove (idp->issue_op_head, idp->issue_op_tail, iss);
559  GNUNET_free (iss);
560  }
561  while (NULL != (ct = idp->consume_op_head))
562  {
563  GNUNET_CONTAINER_DLL_remove (idp->consume_op_head,
564  idp->consume_op_tail,
565  ct);
566  if (NULL != ct->ch)
568  GNUNET_free (ct);
569  }
570  while (NULL != (as = idp->store_op_head))
571  {
572  GNUNET_CONTAINER_DLL_remove (idp->store_op_head, idp->store_op_tail, as);
573  cleanup_as_handle (as);
574  }
575  while (NULL != (adh = idp->delete_op_head))
576  {
577  GNUNET_CONTAINER_DLL_remove (idp->delete_op_head, idp->delete_op_tail, adh);
578  cleanup_adh (adh);
579  }
580 
581  while (NULL != (ai = idp->attr_iter_head))
582  {
583  GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai);
584  GNUNET_free (ai);
585  }
586  while (NULL != (ai = idp->cred_iter_head))
587  {
588  GNUNET_CONTAINER_DLL_remove (idp->cred_iter_head, idp->cred_iter_tail,
589  ai);
590  GNUNET_free (ai);
591  }
592 
593  while (NULL != (rop = idp->revoke_op_head))
594  {
595  GNUNET_CONTAINER_DLL_remove (idp->revoke_op_head, idp->revoke_op_tail, rop);
596  if (NULL != rop->rh)
598  GNUNET_free (rop);
599  }
600  while (NULL != (ti = idp->ticket_iter_head))
601  {
602  GNUNET_CONTAINER_DLL_remove (idp->ticket_iter_head,
603  idp->ticket_iter_tail,
604  ti);
605  if (NULL != ti->iter)
607  GNUNET_free (ti);
608  }
609  GNUNET_free (idp);
610 }
611 
612 
616 static void
618 {
619  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
620 
622  if (NULL != timeout_task)
624  if (NULL != nsh)
626 }
627 
628 
634 static void
635 do_shutdown (void *cls)
636 {
637  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down...\n");
638  cleanup ();
639 }
640 
641 
650 static void
652  uint32_t r_id,
653  const struct GNUNET_RECLAIM_Ticket *ticket,
654  const struct GNUNET_RECLAIM_PresentationList *presentations,
655  uint32_t success)
656 {
657  struct TicketResultMessage *irm;
658  struct GNUNET_MQ_Envelope *env;
659  size_t pres_len = 0;
660  size_t tkt_len = 0;
661  ssize_t written;
662  char *buf;
663 
664  if (NULL != presentations)
665  {
666  pres_len =
668  }
669  if (NULL != ticket)
671  env = GNUNET_MQ_msg_extra (irm,
672  pres_len + tkt_len,
674  buf = (char*) &irm[1];
675  if (NULL != ticket)
676  {
677  irm->tkt_len = htons (tkt_len);
678  written = GNUNET_RECLAIM_write_ticket_to_buffer (ticket, buf, tkt_len);
679  GNUNET_assert (0 <= written);
680  buf += written;
681  }
682  // TODO add success member
683  irm->id = htonl (r_id);
684  irm->presentations_len = htons (pres_len);
685  if (NULL != presentations)
686  {
688  buf);
689  }
690  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
691  GNUNET_MQ_send (client->mq, env);
692 }
693 
694 
704 static void
707  struct GNUNET_RECLAIM_PresentationList *presentations,
708  int32_t success,
709  const char *emsg)
710 {
711  struct TicketIssueOperation *tio = cls;
712 
713  if (GNUNET_OK != success)
714  {
715  send_ticket_result (tio->client, tio->r_id, NULL, NULL, GNUNET_SYSERR);
716  GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head,
717  tio->client->issue_op_tail,
718  tio);
719  GNUNET_free (tio);
720  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error issuing ticket: %s\n", emsg);
721  return;
722  }
723  send_ticket_result (tio->client, tio->r_id,
724  ticket, presentations, GNUNET_SYSERR);
725  GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head,
726  tio->client->issue_op_tail,
727  tio);
728  GNUNET_free (tio);
729 }
730 
731 
739 static int
740 check_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
741 {
742  uint16_t size;
743  size_t attrs_len;
744  size_t key_len;
745  size_t pkey_len;
746 
747  size = ntohs (im->header.size);
748  attrs_len = ntohs (im->attr_len);
749  key_len = ntohs (im->key_len);
750  pkey_len = ntohs (im->pkey_len);
751  if (size != attrs_len + key_len + pkey_len + sizeof(struct
753  {
754  GNUNET_break (0);
755  return GNUNET_SYSERR;
756  }
757  return GNUNET_OK;
758 }
759 
760 
767 static void
768 handle_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
769 {
770  struct TicketIssueOperation *tio;
771  struct IdpClient *idp = cls;
772  struct GNUNET_RECLAIM_AttributeList *attrs;
776  size_t attrs_len;
777  size_t key_len;
778  size_t pkey_len;
779  size_t read;
780  char *buf;
781 
782  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ISSUE_TICKET message\n");
783  key_len = ntohs (im->key_len);
784  buf = (char *) &im[1];
785  if ((GNUNET_SYSERR ==
787  &identity, &read)) ||
788  (read != key_len))
789  {
791  "Failed to read private key\n");
793  return;
794  }
795  buf += read;
796  pkey_len = ntohs (im->pkey_len);
797  if ((GNUNET_SYSERR ==
799  &rp, &read)) ||
800  (read != pkey_len))
801  {
803  "Failed to read public key\n");
805  return;
806  }
807  buf += read;
809  attrs_len = ntohs (im->attr_len);
811  attrs_len);
812  for (le = attrs->list_head; NULL != le; le = le->next)
814  "List entry: %s\n", le->attribute->name);
815 
816  tio->r_id = ntohl (im->id);
817  tio->client = idp;
818  GNUNET_CONTAINER_DLL_insert (idp->issue_op_head, idp->issue_op_tail, tio);
820  attrs,
821  &rp,
823  tio);
826 }
827 
828 
829 /**********************************************************
830 * Revocation
831 **********************************************************/
832 
839 static void
840 revoke_result_cb (void *cls, int32_t success)
841 {
842  struct TicketRevocationOperation *rop = cls;
843  struct GNUNET_MQ_Envelope *env;
844  struct RevokeTicketResultMessage *trm;
845 
847  "Sending REVOKE_TICKET_RESULT message\n");
848  rop->rh = NULL;
850  trm->id = htonl (rop->r_id);
851  trm->success = htonl (success);
852  GNUNET_MQ_send (rop->client->mq, env);
854  rop->client->revoke_op_tail,
855  rop);
856  GNUNET_free (rop);
857 }
858 
859 
867 static int
869 {
870  uint16_t size;
871 
872  size = ntohs (im->header.size);
873  if (size != sizeof(struct RevokeTicketMessage))
874  {
875  GNUNET_break (0);
876  return GNUNET_SYSERR;
877  }
878  return GNUNET_OK;
879 }
880 
881 
888 static void
890 {
891  struct TicketRevocationOperation *rop;
892  struct IdpClient *idp = cls;
895  size_t key_len;
896  size_t tkt_len;
897  size_t read;
898  char *buf;
899 
900  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received REVOKE_TICKET message\n");
901  key_len = ntohs (rm->key_len);
902  buf = (char *) &rm[1];
903  if ((GNUNET_SYSERR ==
905  &identity, &read)) ||
906  (read != key_len))
907  {
909  "Failed to read private key\n");
911  return;
912  }
913  buf += read;
914  tkt_len = ntohs (rm->tkt_len);
915  if ((GNUNET_SYSERR ==
917  &ticket, &read)) ||
918  (read != tkt_len))
919  {
921  "Failed to read ticket\n");
923  return;
924  }
925  rop = GNUNET_new (struct TicketRevocationOperation);
926  rop->r_id = ntohl (rm->id);
927  rop->client = idp;
928  GNUNET_CONTAINER_DLL_insert (idp->revoke_op_head, idp->revoke_op_tail, rop);
929  rop->rh
932 }
933 
934 
944 static void
945 consume_result_cb (void *cls,
946  const struct GNUNET_IDENTITY_PublicKey *identity,
947  const struct GNUNET_RECLAIM_AttributeList *attrs,
948  const struct GNUNET_RECLAIM_PresentationList *presentations,
949  int32_t success,
950  const char *emsg)
951 {
952  struct ConsumeTicketOperation *cop = cls;
953  struct ConsumeTicketResultMessage *crm;
954  struct GNUNET_MQ_Envelope *env;
955  char *data_tmp;
956  size_t attrs_len = 0;
957  size_t pres_len = 0;
958  size_t key_len;
959  ssize_t written;
960 
961  if (GNUNET_OK != success)
962  {
963  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error consuming ticket: %s\n", emsg);
964  }
967  presentations);
970  "Sending CONSUME_TICKET_RESULT message\n");
971  env = GNUNET_MQ_msg_extra (crm,
972  attrs_len + pres_len + key_len,
974  crm->id = htonl (cop->r_id);
975  crm->attrs_len = htons (attrs_len);
976  crm->presentations_len = htons (pres_len);
977  crm->key_len = htons (key_len);
978  crm->result = htons (success);
979  data_tmp = (char *) &crm[1];
981  data_tmp,
982  key_len);
983  GNUNET_assert (0 <= written);
984  data_tmp += written;
985  GNUNET_RECLAIM_attribute_list_serialize (attrs, data_tmp);
986  data_tmp += attrs_len;
987  GNUNET_RECLAIM_presentation_list_serialize (presentations, data_tmp);
988  GNUNET_MQ_send (cop->client->mq, env);
990  cop->client->consume_op_tail,
991  cop);
992  GNUNET_free (cop);
993 }
994 
995 
1002 static int
1004 {
1005  uint16_t size;
1006 
1007  size = ntohs (cm->header.size);
1008  if (size <= sizeof(struct ConsumeTicketMessage))
1009  {
1010  GNUNET_break (0);
1011  return GNUNET_SYSERR;
1012  }
1013  return GNUNET_OK;
1014 }
1015 
1016 
1023 static void
1025 {
1026  struct ConsumeTicketOperation *cop;
1027  struct IdpClient *idp = cls;
1030  size_t key_len;
1031  size_t tkt_len;
1032  size_t read;
1033  char *buf;
1034 
1035  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CONSUME_TICKET message\n");
1036  key_len = ntohs (cm->key_len);
1037  buf = (char *) &cm[1];
1038  if ((GNUNET_SYSERR ==
1040  &identity, &read)) ||
1041  (read != key_len))
1042  {
1044  "Failed to read private key\n");
1046  return;
1047  }
1048  buf += read;
1049  tkt_len = ntohs (cm->tkt_len);
1050  if ((GNUNET_SYSERR ==
1052  &ticket, &read)) ||
1053  (read != tkt_len))
1054  {
1056  "Failed to read ticket\n");
1058  return;
1059  }
1060  cop = GNUNET_new (struct ConsumeTicketOperation);
1061  cop->r_id = ntohl (cm->id);
1062  cop->client = idp;
1063  cop->ch
1065  cop);
1066  GNUNET_CONTAINER_DLL_insert (idp->consume_op_head, idp->consume_op_tail, cop);
1068 }
1069 
1070 
1071 /*****************************************
1072 * Attribute store
1073 *****************************************/
1074 
1075 
1083 static void
1084 attr_store_cont (void *cls, enum GNUNET_ErrorCode ec)
1085 {
1086  struct AttributeStoreHandle *ash = cls;
1087  struct GNUNET_MQ_Envelope *env;
1088  struct SuccessResultMessage *acr_msg;
1089 
1090  ash->ns_qe = NULL;
1092  ash->client->store_op_tail,
1093  ash);
1094 
1095  if (GNUNET_EC_NONE != ec)
1096  {
1098  "Failed to store attribute %s\n",
1100  cleanup_as_handle (ash);
1102  return;
1103  }
1104 
1105  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
1107  acr_msg->id = htonl (ash->r_id);
1108  acr_msg->op_result = htonl (GNUNET_OK);
1109  GNUNET_MQ_send (ash->client->mq, env);
1110  cleanup_as_handle (ash);
1111 }
1112 
1113 
1119 static void
1120 attr_store_task (void *cls)
1121 {
1122  struct AttributeStoreHandle *ash = cls;
1123  struct GNUNET_GNSRECORD_Data rd[1];
1124  char *buf;
1125  char *label;
1126  size_t buf_size;
1127 
1128  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing attribute\n");
1130  buf = GNUNET_malloc (buf_size);
1131  // Give the ash a new id if unset
1132  if (GNUNET_YES == GNUNET_RECLAIM_id_is_zero (&ash->claim->id))
1135  label
1137  sizeof (ash->claim->id));
1138  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypting with label %s\n", label);
1139 
1140  rd[0].data_size = buf_size;
1141  rd[0].data = buf;
1144  rd[0].expiration_time = ash->exp.rel_value_us;
1146  &ash->identity,
1147  label,
1148  1,
1149  rd,
1150  &attr_store_cont,
1151  ash);
1152  GNUNET_free (buf);
1153  GNUNET_free (label);
1154 }
1155 
1156 
1163 static int
1165  const struct AttributeStoreMessage *sam)
1166 {
1167  uint16_t size;
1168 
1169  size = ntohs (sam->header.size);
1170  if (size <= sizeof(struct AttributeStoreMessage))
1171  {
1172  GNUNET_break (0);
1173  return GNUNET_SYSERR;
1174  }
1175  return GNUNET_OK;
1176 }
1177 
1178 
1185 static void
1187  const struct AttributeStoreMessage *sam)
1188 {
1189  struct AttributeStoreHandle *ash;
1190  struct IdpClient *idp = cls;
1192  size_t data_len;
1193  size_t key_len;
1194  size_t read;
1195  char *buf;
1196 
1197  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_STORE message\n");
1198 
1199  data_len = ntohs (sam->attr_len);
1200  key_len = ntohs (sam->key_len);
1201  buf = (char *) &sam[1];
1202  if ((GNUNET_SYSERR ==
1204  &identity, &read)) ||
1205  (read != key_len))
1206  {
1208  "Failed to read private key\n");
1210  return;
1211  }
1212  buf += read;
1213  ash = GNUNET_new (struct AttributeStoreHandle);
1215  data_len,
1216  &ash->claim);
1217 
1218  ash->r_id = ntohl (sam->id);
1219  ash->identity = identity;
1220  ash->exp.rel_value_us = GNUNET_ntohll (sam->exp);
1222 
1224  ash->client = idp;
1225  GNUNET_CONTAINER_DLL_insert (idp->store_op_head, idp->store_op_tail, ash);
1227 }
1228 
1229 
1237 static void
1238 cred_store_cont (void *cls, enum GNUNET_ErrorCode ec)
1239 {
1240  struct AttributeStoreHandle *ash = cls;
1241  struct GNUNET_MQ_Envelope *env;
1242  struct SuccessResultMessage *acr_msg;
1243 
1244  ash->ns_qe = NULL;
1246  ash->client->store_op_tail,
1247  ash);
1248 
1249  if (GNUNET_EC_NONE != ec)
1250  {
1252  "Failed to store credential: %s\n",
1254  cleanup_as_handle (ash);
1256  return;
1257  }
1258 
1259  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
1261  acr_msg->id = htonl (ash->r_id);
1262  acr_msg->op_result = htonl (GNUNET_OK);
1263  GNUNET_MQ_send (ash->client->mq, env);
1264  cleanup_as_handle (ash);
1265 }
1266 
1267 
1273 static void
1274 cred_error (void *cls)
1275 {
1276  struct AttributeStoreHandle *ash = cls;
1278  "Failed to check for existing credential.\n");
1279  cleanup_as_handle (ash);
1281  return;
1282 }
1283 
1284 
1294 static void
1295 cred_add_cb (void *cls,
1296  const struct GNUNET_IDENTITY_PrivateKey *zone,
1297  const char *label,
1298  unsigned int rd_count,
1299  const struct GNUNET_GNSRECORD_Data *rd)
1300 {
1301  struct AttributeStoreHandle *ash = cls;
1302  struct GNUNET_GNSRECORD_Data rd_new[1];
1303  char *buf;
1304  size_t buf_size;
1305 
1307  buf = GNUNET_malloc (buf_size);
1310  "Storing new credential under `%s'.\n",
1311  label);
1312  rd_new[0].data_size = buf_size;
1313  rd_new[0].data = buf;
1316  rd_new[0].expiration_time = ash->exp.rel_value_us;
1318  &ash->identity,
1319  label,
1320  1,
1321  rd_new,
1322  &cred_store_cont,
1323  ash);
1324  GNUNET_free (buf);
1325  return;
1326 }
1327 
1328 
1334 static void
1335 cred_store_task (void *cls)
1336 {
1337  struct AttributeStoreHandle *ash = cls;
1338  char *label;
1339 
1340  // Give the ash a new id if unset
1344  sizeof (ash->credential->id));
1346  "Looking up existing data under label `%s'\n", label);
1348  &ash->identity,
1349  label,
1350  &cred_error,
1351  ash,
1352  &cred_add_cb,
1353  ash);
1354  GNUNET_free (label);
1355 }
1356 
1357 
1364 static int
1366  const struct AttributeStoreMessage *sam)
1367 {
1368  uint16_t size;
1369 
1370  size = ntohs (sam->header.size);
1371  if (size <= sizeof(struct AttributeStoreMessage))
1372  {
1373  GNUNET_break (0);
1374  return GNUNET_SYSERR;
1375  }
1376  return GNUNET_OK;
1377 }
1378 
1379 
1386 static void
1388  const struct AttributeStoreMessage *sam)
1389 {
1390  struct AttributeStoreHandle *ash;
1391  struct IdpClient *idp = cls;
1393  size_t data_len;
1394  size_t key_len;
1395  size_t read;
1396  char *buf;
1397 
1398  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREDENTIAL_STORE message\n");
1399 
1400  data_len = ntohs (sam->attr_len);
1401  key_len = ntohs (sam->key_len);
1402  buf = (char *) &sam[1];
1403  if ((GNUNET_SYSERR ==
1405  &identity, &read)) ||
1406  (read != key_len))
1407  {
1409  "Failed to read private key\n");
1411  return;
1412  }
1413  buf += read;
1414  ash = GNUNET_new (struct AttributeStoreHandle);
1416  data_len);
1417 
1418  ash->r_id = ntohl (sam->id);
1419  ash->identity = identity;
1420  ash->exp.rel_value_us = GNUNET_ntohll (sam->exp);
1422 
1424  ash->client = idp;
1425  GNUNET_CONTAINER_DLL_insert (idp->store_op_head, idp->store_op_tail, ash);
1427 }
1428 
1429 
1436 static void
1437 send_delete_response (struct AttributeDeleteHandle *adh, int32_t success)
1438 {
1439  struct GNUNET_MQ_Envelope *env;
1440  struct SuccessResultMessage *acr_msg;
1441 
1443  adh->client->delete_op_tail,
1444  adh);
1445 
1446  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
1448  acr_msg->id = htonl (adh->r_id);
1449  acr_msg->op_result = htonl (success);
1450  GNUNET_MQ_send (adh->client->mq, env);
1451 }
1452 
1453 
1464 static void
1465 consistency_iter (void *cls,
1466  const struct GNUNET_IDENTITY_PrivateKey *zone,
1467  const char *label,
1468  unsigned int rd_count,
1469  const struct GNUNET_GNSRECORD_Data *rd)
1470 {
1471  struct AttributeDeleteHandle *adh = cls;
1472  struct TicketRecordsEntry *le;
1475  int is_ticket = GNUNET_NO;
1476  for (int i = 0; i < rd_count; i++)
1477  {
1478  switch (rd[i].record_type)
1479  {
1483  rd[i].data_size,
1484  &ale->attribute);
1487  ale);
1488  break;
1492  rd[i].data_size);
1495  cle);
1496  break;
1499  "Ticket to delete found (%s)\n",
1500  label);
1501  is_ticket = GNUNET_YES;
1502  break;
1503  default:
1504  break;
1505  }
1506  if (GNUNET_YES == is_ticket)
1507  break;
1508  }
1509  if (GNUNET_YES == is_ticket)
1510  {
1511  le = GNUNET_new (struct TicketRecordsEntry);
1513  le->data = GNUNET_malloc (le->data_size);
1514  le->rd_count = rd_count;
1515  le->label = GNUNET_strdup (label);
1519  le);
1520  }
1522 }
1523 
1524 
1529 static void
1530 update_tickets (void *cls);
1531 
1532 
1540 static void
1541 ticket_updated (void *cls, enum GNUNET_ErrorCode ec)
1542 {
1543  struct AttributeDeleteHandle *adh = cls;
1544 
1545  adh->ns_qe = NULL;
1547 }
1548 
1549 
1557 static void
1558 update_tickets (void *cls)
1559 {
1560  struct AttributeDeleteHandle *adh = cls;
1561  struct TicketRecordsEntry *le;
1562 
1563  if (NULL == adh->tickets_to_update_head)
1564  {
1566  "Finished updating tickets, success\n");
1568  cleanup_adh (adh);
1569  return;
1570  }
1571  le = adh->tickets_to_update_head;
1574  le);
1575  struct GNUNET_GNSRECORD_Data rd[le->rd_count];
1576  struct GNUNET_GNSRECORD_Data rd_new[le->rd_count - 1];
1578  le->data,
1579  le->rd_count,
1580  rd))
1581  {
1583  "Unable to deserialize record data!\n");
1585  cleanup_adh (adh);
1586  return;
1587  }
1588  int j = 0;
1589  int i = 0;
1592  struct GNUNET_RECLAIM_Presentation *presentation;
1593  for (i = 0; i < le->rd_count; i++)
1594  {
1595  switch (rd[i].record_type)
1596  {
1598  for (ale = adh->existing_attributes->list_head; NULL != ale; ale =
1599  ale->next)
1600  {
1602  &ale->attribute->id))
1603  {
1605  "Found attribute %s, readding...\n",
1606  ale->attribute->name);
1607  rd_new[j] = rd[i];
1608  j++;
1609  break; // Found and added
1610  }
1611  }
1612  break;
1614  presentation = GNUNET_RECLAIM_presentation_deserialize (rd[i].data,
1615  rd[i].data_size);
1616  for (cle = adh->existing_credentials->list_head; NULL != cle; cle =
1617  cle->next)
1618  {
1620  &presentation->credential_id,
1621  &cle->credential->id))
1622  {
1624  "Found presentation for credential %s, readding...\n",
1625  cle->credential->name);
1626  rd_new[j] = rd[i];
1627  j++;
1628  break; // Found and added
1629  }
1630  }
1631  GNUNET_free (presentation);
1632  break;
1634  rd_new[j] = rd[i];
1635  j++;
1636  break; // Found and added
1637  default:
1638  GNUNET_break (0);
1639  }
1640  }
1642  "Updating ticket with %d entries (%d before)...\n",
1643  j, i);
1645  &adh->identity,
1646  le->label,
1647  j,
1648  rd_new,
1649  &ticket_updated,
1650  adh);
1651  GNUNET_free (le->label);
1652  GNUNET_free (le->data);
1653  GNUNET_free (le);
1654 }
1655 
1656 
1661 static void
1662 purge_attributes (void *cls);;
1663 
1664 static void
1666 {
1667  struct AttributeDeleteHandle *adh = cls;
1668 
1669  adh->ns_qe = NULL;
1670  if (GNUNET_EC_NONE != ec)
1671  {
1673  "Error deleting attribute %s\n",
1674  adh->label);
1676  cleanup_adh (adh);
1677  return;
1678  }
1679  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Continuing consistency check...\n");
1681 }
1682 
1683 
1688 static void
1689 purge_attributes (void *cls)
1690 {
1691  struct AttributeDeleteHandle *adh = cls;
1694 
1695  for (ale = adh->existing_attributes->list_head; NULL != ale; ale = ale->next)
1696  {
1697  if (GNUNET_YES ==
1699  continue;
1700 
1701  for (cle = adh->existing_credentials->list_head;
1702  NULL != cle; cle = cle->next)
1703  {
1704  if (GNUNET_YES !=
1706  &ale->attribute->credential))
1707  continue;
1708  break;
1709  }
1710  if (NULL == cle)
1711  {
1713  "Found attribute with missing credential\n");
1714  break;
1715  }
1716  }
1717  if (NULL == ale)
1718  {
1720  "Attributes consistent, updating tickets.\n");
1722  return;
1723  }
1725  "Attributes inconsistent, deleting offending attribute.\n");
1726  char *label
1728  sizeof(ale->attribute->id));
1729 
1731  &adh->identity,
1732  label,
1733  0,
1734  NULL,
1736  adh);
1739  ale);
1740  GNUNET_free (ale);
1741  GNUNET_free (label);
1742 }
1743 
1744 
1750 static void
1752 {
1753  struct AttributeDeleteHandle *adh = cls;
1754  adh->ns_it = NULL;
1756 }
1757 
1758 
1764 static void
1766 {
1767  struct AttributeDeleteHandle *adh = cls;
1768 
1769  adh->ns_it = NULL;
1771  "Namestore error on consistency check\n");
1773  cleanup_adh (adh);
1774 }
1775 
1776 
1783 static void
1785 {
1786  struct AttributeDeleteHandle *adh = cls;
1787 
1790 
1792  &adh->identity,
1794  adh,
1796  adh,
1798  adh);
1799 }
1800 
1801 
1809 static void
1811 {
1812  struct AttributeDeleteHandle *adh = cls;
1813 
1814  adh->ns_qe = NULL;
1815  if (GNUNET_EC_NONE != ec)
1816  {
1818  "Error deleting attribute %s\n",
1819  adh->label);
1821  cleanup_adh (adh);
1822  return;
1823  }
1824  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating tickets...\n");
1826 }
1827 
1828 
1835 static int
1837  const struct AttributeDeleteMessage *dam)
1838 {
1839  uint16_t size;
1840 
1841  size = ntohs (dam->header.size);
1842  if (size <= sizeof(struct AttributeDeleteMessage))
1843  {
1844  GNUNET_break (0);
1845  return GNUNET_SYSERR;
1846  }
1847  return GNUNET_OK;
1848 }
1849 
1850 
1857 static void
1859  const struct AttributeDeleteMessage *dam)
1860 {
1861  struct AttributeDeleteHandle *adh;
1862  struct IdpClient *idp = cls;
1864  size_t data_len;
1865  size_t key_len;
1866  size_t read;
1867  char *buf;
1868 
1869  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_DELETE message\n");
1870 
1871  data_len = ntohs (dam->attr_len);
1872  key_len = ntohs (dam->key_len);
1873  buf = (char *) &dam[1];
1874  if ((GNUNET_SYSERR ==
1876  &identity, &read)) ||
1877  (read != key_len))
1878  {
1880  "Failed to read private key\n");
1882  return;
1883  }
1884  buf += read;
1885  adh = GNUNET_new (struct AttributeDeleteHandle);
1887  data_len,
1888  &adh->claim);
1889  adh->credential = NULL;
1890 
1891  adh->r_id = ntohl (dam->id);
1892  adh->identity = identity;
1893  adh->label
1895  sizeof(adh->claim->id));
1897  adh->client = idp;
1898  GNUNET_CONTAINER_DLL_insert (idp->delete_op_head, idp->delete_op_tail, adh);
1900  &adh->identity,
1901  adh->label,
1902  0,
1903  NULL,
1905  adh);
1906 }
1907 
1908 
1916 static void
1918 {
1919  struct AttributeDeleteHandle *adh = cls;
1920 
1921  adh->ns_qe = NULL;
1922  if (GNUNET_EC_NONE != ec)
1923  {
1925  "Error deleting credential `%s'\n",
1926  adh->label);
1928  cleanup_adh (adh);
1929  return;
1930  }
1931  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating tickets...\n");
1933 }
1934 
1935 
1942 static int
1944  const struct AttributeDeleteMessage *dam)
1945 {
1946  uint16_t size;
1947 
1948  size = ntohs (dam->header.size);
1949  if (size <= sizeof(struct AttributeDeleteMessage))
1950  {
1951  GNUNET_break (0);
1952  return GNUNET_SYSERR;
1953  }
1954  return GNUNET_OK;
1955 }
1956 
1957 
1964 static void
1966  const struct AttributeDeleteMessage *dam)
1967 {
1968  struct AttributeDeleteHandle *adh;
1969  struct IdpClient *idp = cls;
1971  size_t data_len;
1972  size_t key_len;
1973  size_t read;
1974  char *buf;
1975 
1976  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREDENTIAL_DELETE message\n");
1977 
1978  data_len = ntohs (dam->attr_len);
1979  key_len = ntohs (dam->key_len);
1980  buf = (char *) &dam[1];
1981  if ((GNUNET_SYSERR ==
1983  &identity, &read)) ||
1984  (read != key_len))
1985  {
1987  "Failed to read private key\n");
1989  return;
1990  }
1991  buf += read;
1992  adh = GNUNET_new (struct AttributeDeleteHandle);
1994  data_len);
1995  adh->claim = NULL;
1996 
1997  adh->r_id = ntohl (dam->id);
1998  adh->identity = identity;
1999  adh->label
2001  sizeof(adh->credential->id));
2003  adh->client = idp;
2004  GNUNET_CONTAINER_DLL_insert (idp->delete_op_head, idp->delete_op_tail, adh);
2006  &adh->identity,
2007  adh->label,
2008  0,
2009  NULL,
2011  adh);
2012 }
2013 
2014 
2015 /*************************************************
2016  * Attribute iteration
2017  *************************************************/
2018 
2019 
2025 static void
2027 {
2028  struct Iterator *ai = cls;
2029  struct GNUNET_MQ_Envelope *env;
2030  struct AttributeResultMessage *arm;
2031 
2032  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ATTRIBUTE_RESULT message\n");
2034  arm->id = htonl (ai->request_id);
2035  arm->attr_len = htons (0);
2036  arm->pkey_len = htons (0);
2037  GNUNET_MQ_send (ai->client->mq, env);
2038  GNUNET_CONTAINER_DLL_remove (ai->client->attr_iter_head,
2039  ai->client->attr_iter_tail,
2040  ai);
2041  GNUNET_free (ai);
2042 }
2043 
2044 
2050 static void
2051 attr_iter_error (void *cls)
2052 {
2053  struct Iterator *ai = cls;
2054 
2055  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over attributes\n");
2057 }
2058 
2059 
2069 static void
2070 attr_iter_cb (void *cls,
2071  const struct GNUNET_IDENTITY_PrivateKey *zone,
2072  const char *label,
2073  unsigned int rd_count,
2074  const struct GNUNET_GNSRECORD_Data *rd)
2075 {
2076  struct Iterator *ai = cls;
2077  struct GNUNET_MQ_Envelope *env;
2079  char *data_tmp;
2080  size_t key_len;
2081  ssize_t written;
2082 
2083  if ((rd_count != 1) ||
2085  {
2087  return;
2088  }
2089  struct AttributeResultMessage *arm;
2090  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found attribute under: %s\n",
2091  label);
2093  "Sending ATTRIBUTE_RESULT message\n");
2096  env = GNUNET_MQ_msg_extra (arm,
2097  rd->data_size + key_len,
2099  arm->id = htonl (ai->request_id);
2100  arm->attr_len = htons (rd->data_size);
2101  data_tmp = (char *) &arm[1];
2102  arm->pkey_len = htons (key_len);
2104  data_tmp,
2105  key_len);
2106  GNUNET_assert (0 <= written);
2107  data_tmp += written;
2108  GNUNET_memcpy (data_tmp, rd->data, rd->data_size);
2109  GNUNET_MQ_send (ai->client->mq, env);
2110 }
2111 
2112 
2113 static enum GNUNET_GenericReturnValue
2115  void *cls,
2116  const struct AttributeIterationStartMessage *ais_msg)
2117 {
2118  uint16_t size;
2119  size_t key_len;
2120 
2121  size = ntohs (ais_msg->header.size);
2122  key_len = ntohs (ais_msg->key_len);
2123 
2124  if (size < key_len + sizeof(*ais_msg))
2125  {
2126  GNUNET_break (0);
2127  return GNUNET_SYSERR;
2128  }
2129  return GNUNET_OK;
2130 }
2131 
2138 static void
2140  const struct AttributeIterationStartMessage *ais_msg)
2141 {
2142  struct IdpClient *idp = cls;
2143  struct Iterator *ai;
2145  size_t key_len;
2146  size_t read;
2147 
2149  "Received ATTRIBUTE_ITERATION_START message\n");
2150  key_len = ntohs (ais_msg->key_len);
2151  if ((GNUNET_SYSERR ==
2153  key_len,
2154  &identity,
2155  &read)) ||
2156  (read != key_len))
2157  {
2159  "Failed to read private key.\n");
2161  return;
2162  }
2163  ai = GNUNET_new (struct Iterator);
2164  ai->request_id = ntohl (ais_msg->id);
2165  ai->client = idp;
2166  ai->identity = identity;
2167 
2168  GNUNET_CONTAINER_DLL_insert (idp->attr_iter_head, idp->attr_iter_tail, ai);
2170  &ai->identity,
2171  &attr_iter_error,
2172  ai,
2173  &attr_iter_cb,
2174  ai,
2176  ai);
2178 }
2179 
2180 
2187 static void
2189  const struct AttributeIterationStopMessage *ais_msg)
2190 {
2191  struct IdpClient *idp = cls;
2192  struct Iterator *ai;
2193  uint32_t rid;
2194 
2196  "Received `%s' message\n",
2197  "ATTRIBUTE_ITERATION_STOP");
2198  rid = ntohl (ais_msg->id);
2199  for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
2200  if (ai->request_id == rid)
2201  break;
2202  if (NULL == ai)
2203  {
2204  GNUNET_break (0);
2206  return;
2207  }
2208  GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai);
2209  GNUNET_free (ai);
2211 }
2212 
2213 
2220 static void
2222  const struct AttributeIterationNextMessage *ais_msg)
2223 {
2224  struct IdpClient *idp = cls;
2225  struct Iterator *ai;
2226  uint32_t rid;
2227 
2229  "Received ATTRIBUTE_ITERATION_NEXT message\n");
2230  rid = ntohl (ais_msg->id);
2231  for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
2232  if (ai->request_id == rid)
2233  break;
2234  if (NULL == ai)
2235  {
2236  GNUNET_break (0);
2238  return;
2239  }
2242 }
2243 
2244 
2245 /*************************************************
2246  * Credential iteration
2247  *************************************************/
2248 
2249 
2255 static void
2257 {
2258  struct Iterator *ai = cls;
2259  struct GNUNET_MQ_Envelope *env;
2260  struct CredentialResultMessage *arm;
2261 
2262  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending CREDENTIAL_RESULT message\n");
2264  arm->id = htonl (ai->request_id);
2265  arm->credential_len = htons (0);
2266  arm->key_len = htons (0);
2267  GNUNET_MQ_send (ai->client->mq, env);
2268  GNUNET_CONTAINER_DLL_remove (ai->client->cred_iter_head,
2269  ai->client->cred_iter_tail,
2270  ai);
2271  GNUNET_free (ai);
2272 }
2273 
2274 
2280 static void
2281 cred_iter_error (void *cls)
2282 {
2283  struct Iterator *ai = cls;
2284 
2285  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over credentials\n");
2287 }
2288 
2289 
2299 static void
2300 cred_iter_cb (void *cls,
2301  const struct GNUNET_IDENTITY_PrivateKey *zone,
2302  const char *label,
2303  unsigned int rd_count,
2304  const struct GNUNET_GNSRECORD_Data *rd)
2305 {
2306  struct Iterator *ai = cls;
2307  struct GNUNET_MQ_Envelope *env;
2308  struct CredentialResultMessage *arm;
2310  char *data_tmp;
2311  size_t key_len;
2312  ssize_t written;
2313 
2314  if ((rd_count != 1) ||
2316  {
2318  return;
2319  }
2320  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found credential under: %s\n",
2321  label);
2323  "Sending CREDENTIAL_RESULT message\n");
2326  env = GNUNET_MQ_msg_extra (arm,
2327  rd->data_size + key_len,
2329  arm->id = htonl (ai->request_id);
2330  arm->credential_len = htons (rd->data_size);
2331  arm->key_len = htons (key_len);
2332  data_tmp = (char *) &arm[1];
2334  data_tmp,
2335  key_len);
2336  GNUNET_assert (written >= 0);
2337  data_tmp += written;
2338  GNUNET_memcpy (data_tmp, rd->data, rd->data_size);
2339  GNUNET_MQ_send (ai->client->mq, env);
2340 }
2341 
2342 static enum GNUNET_GenericReturnValue
2344  void *cls,
2345  const struct CredentialIterationStartMessage *cis_msg)
2346 {
2347  uint16_t size;
2348  size_t key_len;
2349 
2350  size = ntohs (cis_msg->header.size);
2351  key_len = ntohs (cis_msg->key_len);
2352 
2353  if (size < key_len + sizeof(*cis_msg))
2354  {
2355  GNUNET_break (0);
2356  return GNUNET_SYSERR;
2357  }
2358  return GNUNET_OK;
2359 }
2360 
2361 
2368 static void
2370  const struct
2372 {
2373  struct IdpClient *idp = cls;
2374  struct Iterator *ai;
2376  size_t key_len;
2377  size_t read;
2378 
2380  "Received CREDENTIAL_ITERATION_START message\n");
2381  key_len = ntohs (ais_msg->key_len);
2382  if ((GNUNET_SYSERR ==
2384  key_len,
2385  &identity,
2386  &read)) ||
2387  (read != key_len))
2388  {
2390  "Failed to read private key.\n");
2392  return;
2393  }
2394  ai = GNUNET_new (struct Iterator);
2395  ai->request_id = ntohl (ais_msg->id);
2396  ai->client = idp;
2397  ai->identity = identity;
2398 
2399  GNUNET_CONTAINER_DLL_insert (idp->cred_iter_head, idp->cred_iter_tail,
2400  ai);
2402  &ai->identity,
2403  &cred_iter_error,
2404  ai,
2405  &cred_iter_cb,
2406  ai,
2408  ai);
2410 }
2411 
2412 
2419 static void
2421  const struct
2423 {
2424  struct IdpClient *idp = cls;
2425  struct Iterator *ai;
2426  uint32_t rid;
2427 
2429  "Received `%s' message\n",
2430  "CREDENTIAL_ITERATION_STOP");
2431  rid = ntohl (ais_msg->id);
2432  for (ai = idp->cred_iter_head; NULL != ai; ai = ai->next)
2433  if (ai->request_id == rid)
2434  break;
2435  if (NULL == ai)
2436  {
2437  GNUNET_break (0);
2439  return;
2440  }
2441  GNUNET_CONTAINER_DLL_remove (idp->cred_iter_head, idp->cred_iter_tail,
2442  ai);
2443  GNUNET_free (ai);
2445 }
2446 
2447 
2454 static void
2456  const struct
2458 {
2459  struct IdpClient *idp = cls;
2460  struct Iterator *ai;
2461  uint32_t rid;
2462 
2464  "Received CREDENTIAL_ITERATION_NEXT message\n");
2465  rid = ntohl (ais_msg->id);
2466  for (ai = idp->cred_iter_head; NULL != ai; ai = ai->next)
2467  if (ai->request_id == rid)
2468  break;
2469  if (NULL == ai)
2470  {
2471  GNUNET_break (0);
2473  return;
2474  }
2477 }
2478 
2479 
2480 /******************************************************
2481  * Ticket iteration
2482  ******************************************************/
2483 
2490 static void
2492 {
2493  struct TicketIteration *ti = cls;
2494  struct GNUNET_MQ_Envelope *env;
2495  struct TicketResultMessage *trm;
2496  size_t tkt_len;
2497 
2498  if (NULL == ticket)
2499  tkt_len = 0;
2500  else
2502 
2503  env = GNUNET_MQ_msg_extra (trm,
2504  tkt_len,
2506  if (NULL == ticket)
2507  {
2508  /* send empty response to indicate end of list */
2510  ti->client->ticket_iter_tail,
2511  ti);
2512  }
2513  else
2514  {
2516  &trm[1],
2517  tkt_len);
2518  }
2519  trm->tkt_len = htons (tkt_len);
2520  trm->id = htonl (ti->r_id);
2521  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
2522  GNUNET_MQ_send (ti->client->mq, env);
2523  if (NULL == ticket)
2524  GNUNET_free (ti);
2525 }
2526 
2527 static enum GNUNET_GenericReturnValue
2529  void *cls,
2530  const struct TicketIterationStartMessage *tis_msg)
2531 {
2532  uint16_t size;
2533  size_t key_len;
2534 
2535  size = ntohs (tis_msg->header.size);
2536  key_len = ntohs (tis_msg->key_len);
2537 
2538  if (size < key_len + sizeof(*tis_msg))
2539  {
2540  GNUNET_break (0);
2541  return GNUNET_SYSERR;
2542  }
2543  return GNUNET_OK;
2544 }
2545 
2552 static void
2554  void *cls,
2555  const struct TicketIterationStartMessage *tis_msg)
2556 {
2558  struct IdpClient *client = cls;
2559  struct TicketIteration *ti;
2560  size_t key_len;
2561  size_t read;
2562 
2564  "Received TICKET_ITERATION_START message\n");
2565  key_len = ntohs (tis_msg->key_len);
2566  if ((GNUNET_SYSERR ==
2568  key_len,
2569  &identity,
2570  &read)) ||
2571  (read != key_len))
2572  {
2574  "Failed to read private key\n");
2576  return;
2577  }
2578  ti = GNUNET_new (struct TicketIteration);
2579  ti->r_id = ntohl (tis_msg->id);
2580  ti->client = client;
2583  ti);
2584  ti->iter
2587 }
2588 
2589 
2596 static void
2598  const struct TicketIterationStopMessage *tis_msg)
2599 {
2600  struct IdpClient *client = cls;
2601  struct TicketIteration *ti;
2602  uint32_t rid;
2603 
2605  "Received `%s' message\n",
2606  "TICKET_ITERATION_STOP");
2607  rid = ntohl (tis_msg->id);
2608  for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next)
2609  if (ti->r_id == rid)
2610  break;
2611  if (NULL == ti)
2612  {
2613  GNUNET_break (0);
2615  return;
2616  }
2620  ti);
2621  GNUNET_free (ti);
2623 }
2624 
2625 
2632 static void
2634  const struct TicketIterationNextMessage *tis_msg)
2635 {
2636  struct IdpClient *client = cls;
2637  struct TicketIteration *ti;
2638  uint32_t rid;
2639 
2641  "Received TICKET_ITERATION_NEXT message\n");
2642  rid = ntohl (tis_msg->id);
2643  for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next)
2644  if (ti->r_id == rid)
2645  break;
2646  if (NULL == ti)
2647  {
2648  GNUNET_break (0);
2650  return;
2651  }
2654 }
2655 
2656 
2664 static void
2665 run (void *cls,
2666  const struct GNUNET_CONFIGURATION_Handle *c,
2667  struct GNUNET_SERVICE_Handle *server)
2668 {
2669  cfg = c;
2670 
2672  {
2674  "Unable to initialize TICKETS subsystem.\n");
2676  return;
2677  }
2678  // Connect to identity and namestore services
2680  if (NULL == nsh)
2681  {
2683  "error connecting to namestore");
2684  }
2685 
2687 }
2688 
2689 
2697 static void
2699  struct GNUNET_SERVICE_Client *client,
2700  void *app_ctx)
2701 {
2702  struct IdpClient *idp = app_ctx;
2703 
2704  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p disconnected\n", client);
2707  idp);
2708  cleanup_client (idp);
2709 }
2710 
2711 
2720 static void *
2722  struct GNUNET_SERVICE_Client *client,
2723  struct GNUNET_MQ_Handle *mq)
2724 {
2725  struct IdpClient *idp;
2726 
2727  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
2728  idp = GNUNET_new (struct IdpClient);
2729  idp->client = client;
2730  idp->mq = mq;
2733  idp);
2734  return idp;
2735 }
2736 
2737 
2742  "reclaim",
2744  &run,
2747  NULL,
2748  GNUNET_MQ_hd_var_size (attribute_store_message,
2750  struct AttributeStoreMessage,
2751  NULL),
2752  GNUNET_MQ_hd_var_size (credential_store_message,
2754  struct AttributeStoreMessage,
2755  NULL),
2756  GNUNET_MQ_hd_var_size (attribute_delete_message,
2758  struct AttributeDeleteMessage,
2759  NULL),
2760  GNUNET_MQ_hd_var_size (credential_delete_message,
2762  struct AttributeDeleteMessage,
2763  NULL),
2767  NULL),
2768  GNUNET_MQ_hd_fixed_size (iteration_next,
2771  NULL),
2772  GNUNET_MQ_hd_fixed_size (iteration_stop,
2775  NULL),
2776  GNUNET_MQ_hd_var_size (credential_iteration_start,
2779  NULL),
2780  GNUNET_MQ_hd_fixed_size (credential_iteration_next,
2783  NULL),
2784  GNUNET_MQ_hd_fixed_size (credential_iteration_stop,
2787  NULL),
2788 
2789  GNUNET_MQ_hd_var_size (issue_ticket_message,
2791  struct IssueTicketMessage,
2792  NULL),
2793  GNUNET_MQ_hd_var_size (consume_ticket_message,
2795  struct ConsumeTicketMessage,
2796  NULL),
2797  GNUNET_MQ_hd_var_size (ticket_iteration_start,
2800  NULL),
2801  GNUNET_MQ_hd_fixed_size (ticket_iteration_next,
2804  NULL),
2805  GNUNET_MQ_hd_fixed_size (ticket_iteration_stop,
2808  NULL),
2809  GNUNET_MQ_hd_var_size (revoke_ticket_message,
2811  struct RevokeTicketMessage,
2812  NULL),
2814 /* end of gnunet-service-reclaim.c */
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE
identity attribute
#define GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION
Record type for a presentation of a credential.
#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF
for reclaim records
#define GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL
Record type for an attribute attestation (e.g.
#define GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET
local ticket reference
const char * GNUNET_ErrorCode_get_hint(enum GNUNET_ErrorCode ec)
Returns a hint for a given error code.
GNUNET_ErrorCode
Taler error codes.
@ GNUNET_EC_NONE
No error (success).
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
static struct GNUNET_CADET_ListTunnels * tio
Active tunnel listing operation.
Definition: gnunet-cadet.c:112
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
uint32_t data
The data value.
static char * zone
Name of the zone being managed.
static unsigned int rd_count
Number of records for currently parsed set.
static struct GNUNET_GNSRECORD_Data rd[50]
The record data under a single label.
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static struct GNUNET_RECLAIM_Ticket ticket
Ticket to consume.
static char * rp
Relying party.
static void handle_ticket_iteration_next(void *cls, const struct TicketIterationNextMessage *tis_msg)
Client requests next result.
static void cred_delete_cont(void *cls, enum GNUNET_ErrorCode ec)
Credential deleted callback.
static void attr_store_cont(void *cls, enum GNUNET_ErrorCode ec)
Attribute store result handler.
static void attr_iter_cb(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Got record.
static void consistency_iter(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Namestore iteration within attribute deletion.
static int check_consume_ticket_message(void *cls, const struct ConsumeTicketMessage *cm)
Check a consume ticket message.
static int check_issue_ticket_message(void *cls, const struct IssueTicketMessage *im)
Check issue ticket message.
static void cleanup_adh(struct AttributeDeleteHandle *adh)
Cleanup attribute delete handle.
static void handle_issue_ticket_message(void *cls, const struct IssueTicketMessage *im)
Handle ticket issue message.
static void update_tickets(void *cls)
Recursion prototype for function.
static void cred_store_task(void *cls)
Add a new credential.
static void attr_iter_finished(void *cls)
Done iterating over attributes.
static void handle_iteration_start(void *cls, const struct AttributeIterationStartMessage *ais_msg)
Iterate over zone to get attributes.
static int check_credential_store_message(void *cls, const struct AttributeStoreMessage *sam)
Check an credential store message.
static int check_revoke_ticket_message(void *cls, const struct RevokeTicketMessage *im)
Check revocation message format.
static void revoke_result_cb(void *cls, int32_t success)
Handles revocation result.
static void handle_credential_iteration_start(void *cls, const struct CredentialIterationStartMessage *ais_msg)
Iterate over zone to get attributes.
static int check_attribute_store_message(void *cls, const struct AttributeStoreMessage *sam)
Check an attribute store message.
static void cred_iter_error(void *cls)
Error iterating over credentials.
static struct IdpClient * client_list_tail
Client list.
static void handle_revoke_ticket_message(void *cls, const struct RevokeTicketMessage *rm)
Handle a revocation message to a ticket.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static void cleanup()
Cleanup task.
static void send_delete_response(struct AttributeDeleteHandle *adh, int32_t success)
Send a deletion success response.
static void offending_attr_delete_cont(void *cls, enum GNUNET_ErrorCode ec)
static void cred_store_cont(void *cls, enum GNUNET_ErrorCode ec)
Credential store result handler.
static void consistency_iter_err(void *cls)
Error collecting affected tickets.
static void cred_error(void *cls)
Error looking up potential credential.
static void handle_attribute_delete_message(void *cls, const struct AttributeDeleteMessage *dam)
Handle attribute deletion.
static void purge_attributes(void *cls)
Delete all attributes which reference credentials that no longer exist.
static void handle_credential_delete_message(void *cls, const struct AttributeDeleteMessage *dam)
Handle credential deletion.
static void handle_credential_iteration_next(void *cls, const struct CredentialIterationNextMessage *ais_msg)
Client requests next credential from iterator.
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *server)
Main function that will be run.
static void handle_ticket_iteration_start(void *cls, const struct TicketIterationStartMessage *tis_msg)
Client requests a ticket iteration.
static void do_shutdown(void *cls)
Shutdown task.
static void start_consistency_update(void *cls)
Start processing tickets which may still contain reference to deleted attribute.
static void consistency_iter_fin(void *cls)
Done collecting affected tickets, start updating.
static void ticket_iter_cb(void *cls, struct GNUNET_RECLAIM_Ticket *ticket)
Got a ticket.
static void ticket_updated(void *cls, enum GNUNET_ErrorCode ec)
Callback called when a ticket was updated.
static void handle_credential_store_message(void *cls, const struct AttributeStoreMessage *sam)
Handle a credential store message.
static void attr_delete_cont(void *cls, enum GNUNET_ErrorCode ec)
Attribute deleted callback.
static void issue_ticket_result_cb(void *cls, struct GNUNET_RECLAIM_Ticket *ticket, struct GNUNET_RECLAIM_PresentationList *presentations, int32_t success, const char *emsg)
Issue ticket result.
static void handle_consume_ticket_message(void *cls, const struct ConsumeTicketMessage *cm)
Handle a consume ticket message.
static struct GNUNET_NAMESTORE_Handle * nsh
Namestore handle.
static int check_credential_delete_message(void *cls, const struct AttributeDeleteMessage *dam)
Check credential delete message format.
static void handle_attribute_store_message(void *cls, const struct AttributeStoreMessage *sam)
Handle an attribute store message.
static void cred_iter_cb(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Got record.
static void cred_iter_finished(void *cls)
Done iterating over credentials.
static struct IdpClient * client_list_head
Client list.
static struct GNUNET_SCHEDULER_Task * timeout_task
Timeout task.
static void attr_iter_error(void *cls)
Error iterating over attributes.
static void send_ticket_result(const struct IdpClient *client, uint32_t r_id, const struct GNUNET_RECLAIM_Ticket *ticket, const struct GNUNET_RECLAIM_PresentationList *presentations, uint32_t success)
Sends a ticket result message to the client.
static int check_attribute_delete_message(void *cls, const struct AttributeDeleteMessage *dam)
Check attribute delete message format.
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.
static void cred_add_cb(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Check for existing record before storing credential.
static void handle_iteration_stop(void *cls, const struct AttributeIterationStopMessage *ais_msg)
Handle iteration stop message from client.
static void attr_store_task(void *cls)
Add a new attribute.
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(credential_store_message, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_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(credential_delete_message, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_DELETE, struct AttributeDeleteMessage, NULL), GNUNET_MQ_hd_var_size(iteration_start, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START, struct AttributeIterationStartMessage, NULL), GNUNET_MQ_hd_fixed_size(iteration_next, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT, struct AttributeIterationNextMessage, NULL), GNUNET_MQ_hd_fixed_size(iteration_stop, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP, struct AttributeIterationStopMessage, NULL), GNUNET_MQ_hd_var_size(credential_iteration_start, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START, struct CredentialIterationStartMessage, NULL), GNUNET_MQ_hd_fixed_size(credential_iteration_next, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_NEXT, struct CredentialIterationNextMessage, NULL), GNUNET_MQ_hd_fixed_size(credential_iteration_stop, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_STOP, struct CredentialIterationStopMessage, 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_var_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.
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
Called whenever a client is disconnected.
static void consume_result_cb(void *cls, const struct GNUNET_IDENTITY_PublicKey *identity, const struct GNUNET_RECLAIM_AttributeList *attrs, const struct GNUNET_RECLAIM_PresentationList *presentations, int32_t success, const char *emsg)
Handle a ticket consume result.
static enum GNUNET_GenericReturnValue check_iteration_start(void *cls, const struct AttributeIterationStartMessage *ais_msg)
static void handle_credential_iteration_stop(void *cls, const struct CredentialIterationStopMessage *ais_msg)
Handle iteration stop message from client.
static void cleanup_client(struct IdpClient *idp)
Cleanup client.
static void cleanup_as_handle(struct AttributeStoreHandle *ash)
Cleanup attribute store handle.
static enum GNUNET_GenericReturnValue check_credential_iteration_start(void *cls, const struct CredentialIterationStartMessage *cis_msg)
static void handle_iteration_next(void *cls, const struct AttributeIterationNextMessage *ais_msg)
Client requests next attribute from iterator.
static void handle_ticket_iteration_stop(void *cls, const struct TicketIterationStopMessage *tis_msg)
Client has had enough tickets.
static enum GNUNET_GenericReturnValue check_ticket_iteration_start(void *cls, const struct TicketIterationStartMessage *tis_msg)
void RECLAIM_TICKETS_iteration_stop(struct RECLAIM_TICKETS_Iterator *iter)
Stop a running ticket iteration.
void RECLAIM_TICKETS_consume_cancel(struct RECLAIM_TICKETS_ConsumeHandle *cth)
Cancel a consume operation.
struct RECLAIM_TICKETS_Iterator * RECLAIM_TICKETS_iteration_start(const struct GNUNET_IDENTITY_PrivateKey *identity, RECLAIM_TICKETS_TicketIter cb, void *cb_cls)
Iterate over all tickets issued by an identity.
void RECLAIM_TICKETS_revoke_cancel(struct RECLAIM_TICKETS_RevokeHandle *rh)
Cancel a revocation.
struct RECLAIM_TICKETS_ConsumeHandle * RECLAIM_TICKETS_consume(const struct GNUNET_IDENTITY_PrivateKey *id, const struct GNUNET_RECLAIM_Ticket *ticket, RECLAIM_TICKETS_ConsumeCallback cb, void *cb_cls)
Consume a ticket.
int RECLAIM_TICKETS_init(const struct GNUNET_CONFIGURATION_Handle *c)
Initialize tickets component.
void RECLAIM_TICKETS_iteration_next(struct RECLAIM_TICKETS_Iterator *iter)
Continue ticket iteration.
void RECLAIM_TICKETS_issue(const struct GNUNET_IDENTITY_PrivateKey *identity, const struct GNUNET_RECLAIM_AttributeList *attrs, const struct GNUNET_IDENTITY_PublicKey *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 RECLAIM_TICKETS_RevokeHandle * RECLAIM_TICKETS_revoke(const struct GNUNET_RECLAIM_Ticket *ticket, const struct GNUNET_IDENTITY_PrivateKey *identity, RECLAIM_TICKETS_RevokeCallback cb, void *cb_cls)
Revoke a ticket.
void RECLAIM_TICKETS_deinit(void)
Close handles and clean up.
static char buf[2048]
static void iteration_start()
API that can be used to manipulate GNS record data.
Constants for network protocols.
Identity attribute definitions.
reclaim service; implements identity and personal data sharing for GNUnet
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
@ GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION
This expiration time of the record is a relative time (not an absolute time).
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.
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.
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.
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_key_get_public(const struct GNUNET_IDENTITY_PrivateKey *privkey, struct GNUNET_IDENTITY_PublicKey *key)
Retrieves the public key representation of a private key.
Definition: identity_api.c:179
ssize_t GNUNET_IDENTITY_write_public_key_to_buffer(const struct GNUNET_IDENTITY_PublicKey *key, void *buffer, size_t len)
Writes a GNUNET_IDENTITY_PublicKey to a compact buffer.
Definition: identity_api.c:890
ssize_t GNUNET_IDENTITY_public_key_get_length(const struct GNUNET_IDENTITY_PublicKey *key)
Get the compacted length of a GNUNET_IDENTITY_PublicKey.
Definition: identity_api.c:830
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_read_public_key_from_buffer(const void *buffer, size_t len, struct GNUNET_IDENTITY_PublicKey *key, size_t *kb_read)
Reads a GNUNET_IDENTITY_PublicKey from a compact buffer.
Definition: identity_api.c:865
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_read_private_key_from_buffer(const void *buffer, size_t len, struct GNUNET_IDENTITY_PrivateKey *key, size_t *kb_read)
Reads a GNUNET_IDENTITY_PrivateKey from a compact buffer.
Definition: identity_api.c:908
#define GNUNET_log(kind,...)
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_GenericReturnValue
Named constants for return values.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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:304
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#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:62
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:77
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
struct GNUNET_NAMESTORE_ZoneIterator * GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *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)
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_lookup(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *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.
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.
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_IDENTITY_PrivateKey *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 GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
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_CONSUME_TICKET_RESULT
#define GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT
#define GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_DELETE
#define GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_STOP
#define GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE
#define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT
#define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START
#define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_STOP
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT
#define GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT
#define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT
#define GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_NEXT
#define GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET
#define GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE
#define GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START
#define GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_STORE
#define GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT
#define GNUNET_RECLAIM_id_is_equal(a, b)
void GNUNET_RECLAIM_attribute_list_destroy(struct GNUNET_RECLAIM_AttributeList *attrs)
Destroy claim list.
void GNUNET_RECLAIM_credential_list_destroy(struct GNUNET_RECLAIM_CredentialList *credentials)
Destroy credential list.
struct GNUNET_RECLAIM_Credential * GNUNET_RECLAIM_credential_deserialize(const char *data, size_t data_size)
Deserialize an credential.
#define GNUNET_RECLAIM_id_is_zero(a)
struct GNUNET_RECLAIM_Presentation * GNUNET_RECLAIM_presentation_deserialize(const char *data, size_t data_size)
Deserialize a presentation.
struct GNUNET_RECLAIM_AttributeList * GNUNET_RECLAIM_attribute_list_deserialize(const char *data, size_t data_size)
Deserialize an attribute list.
#define GNUNET_RECLAIM_id_generate(id)
size_t GNUNET_RECLAIM_attribute_serialize_get_size(const struct GNUNET_RECLAIM_Attribute *attr)
Get required size for serialization buffer.
size_t GNUNET_RECLAIM_attribute_list_serialize(const struct GNUNET_RECLAIM_AttributeList *attrs, char *result)
Serialize an attribute list.
ssize_t GNUNET_RECLAIM_attribute_deserialize(const char *data, size_t data_size, struct GNUNET_RECLAIM_Attribute **attr)
Deserialize an attribute.
size_t GNUNET_RECLAIM_presentation_list_serialize(const struct GNUNET_RECLAIM_PresentationList *presentations, char *result)
Serialize a presentation list.
size_t GNUNET_RECLAIM_credential_serialize(const struct GNUNET_RECLAIM_Credential *credential, char *result)
Serialize an credential.
size_t GNUNET_RECLAIM_presentation_list_serialize_get_size(const struct GNUNET_RECLAIM_PresentationList *presentations)
Get required size for serialization buffer.
size_t GNUNET_RECLAIM_attribute_list_serialize_get_size(const struct GNUNET_RECLAIM_AttributeList *attrs)
Get required size for serialization buffer.
size_t GNUNET_RECLAIM_credential_serialize_get_size(const struct GNUNET_RECLAIM_Credential *credential)
Get required size for serialization buffer.
size_t GNUNET_RECLAIM_attribute_serialize(const struct GNUNET_RECLAIM_Attribute *attr, char *result)
Serialize an attribute.
enum GNUNET_GenericReturnValue GNUNET_RECLAIM_read_ticket_from_buffer(const void *buffer, size_t len, struct GNUNET_RECLAIM_Ticket *tkt, size_t *tb_read)
Deserializes a ticket.
Definition: reclaim_api.c:1750
ssize_t GNUNET_RECLAIM_write_ticket_to_buffer(const struct GNUNET_RECLAIM_Ticket *tkt, void *buffer, size_t len)
Serializes a ticket.
Definition: reclaim_api.c:1783
size_t GNUNET_RECLAIM_ticket_serialize_get_size(const struct GNUNET_RECLAIM_Ticket *tkt)
Get serialized ticket size.
Definition: reclaim_api.c:1740
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:562
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:1299
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,...
Definition: scheduler.c:1334
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2330
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2249
@ GNUNET_SERVICE_OPTION_NONE
Use defaults.
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:763
static unsigned int size
Size of the "table".
Definition: peer.c:68
static struct GNUNET_RECLAIM_Handle * idp
Identity Provider.
Common type definitions for the identity provider service and API.
Handle for attribute deletion request.
struct GNUNET_RECLAIM_CredentialList * existing_credentials
Existing credentials.
struct TicketRecordsEntry * tickets_to_update_tail
Tickets to update.
struct GNUNET_RECLAIM_Attribute * claim
The attribute to delete.
struct AttributeDeleteHandle * next
DLL.
struct IdpClient * client
Client connection.
char * label
Attribute label.
struct GNUNET_NAMESTORE_ZoneIterator * ns_it
Iterator.
struct GNUNET_RECLAIM_AttributeList * existing_attributes
Existing attributes.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
QueueEntry.
struct AttributeDeleteHandle * prev
DLL.
struct GNUNET_IDENTITY_PrivateKey identity
Identity.
struct GNUNET_RECLAIM_Credential * credential
The credential to delete.
struct TicketRecordsEntry * tickets_to_update_head
Tickets to update.
Use to delete an identity attribute.
Definition: reclaim.h:77
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT.
Definition: reclaim.h:81
uint16_t key_len
The length of the private key.
Definition: reclaim.h:96
uint16_t attr_len
The length of the attribute.
Definition: reclaim.h:91
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:86
Ask for next result of attribute iteration for the given operation.
Definition: reclaim.h:233
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:242
Start a attribute iteration for the given identity.
Definition: reclaim.h:202
uint16_t key_len
The length of the private key.
Definition: reclaim.h:221
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:211
struct GNUNET_MessageHeader header
Message.
Definition: reclaim.h:206
Stop attribute iteration for the given operation.
Definition: reclaim.h:315
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:324
Attribute is returned from the idp.
Definition: reclaim.h:127
uint16_t attr_len
Length of serialized attribute data.
Definition: reclaim.h:146
uint16_t pkey_len
The length of the public key.
Definition: reclaim.h:156
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:136
Handle for attribute store request.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
QueueEntry.
struct IdpClient * client
Client connection.
struct GNUNET_RECLAIM_Credential * credential
The credential to store.
struct GNUNET_IDENTITY_PrivateKey identity
Identity.
struct GNUNET_TIME_Relative exp
The attribute expiration interval.
struct AttributeStoreHandle * prev
DLL.
struct GNUNET_IDENTITY_PublicKey identity_pkey
Identity pubkey.
struct AttributeStoreHandle * next
DLL.
struct GNUNET_RECLAIM_Attribute * claim
The attribute to store.
Use to store an identity attribute.
Definition: reclaim.h:41
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT.
Definition: reclaim.h:45
uint64_t exp
The expiration interval of the attribute.
Definition: reclaim.h:50
uint16_t key_len
The length of the private key.
Definition: reclaim.h:65
uint16_t attr_len
The length of the attribute.
Definition: reclaim.h:60
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:55
Ticket consume message.
Definition: reclaim.h:523
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:532
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET.
Definition: reclaim.h:527
uint16_t key_len
The length of the private key.
Definition: reclaim.h:537
uint16_t tkt_len
The length of the ticket.
Definition: reclaim.h:542
Handle for ticket consume request.
struct ConsumeTicketOperation * next
DLL.
struct IdpClient * client
Client connection.
struct ConsumeTicketOperation * prev
DLL.
struct RECLAIM_TICKETS_ConsumeHandle * ch
Ticket consume handle.
Attribute list is returned from the idp.
Definition: reclaim.h:554
uint16_t attrs_len
Length of serialized attribute data.
Definition: reclaim.h:578
uint16_t presentations_len
Length of presentation data.
Definition: reclaim.h:583
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:563
uint16_t key_len
The length of the private key.
Definition: reclaim.h:588
uint32_t result
Result.
Definition: reclaim.h:568
Ask for next result of credential iteration for the given operation.
Definition: reclaim.h:281
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:290
Start a credential iteration for the given identity.
Definition: reclaim.h:250
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:259
struct GNUNET_MessageHeader header
Message.
Definition: reclaim.h:254
uint16_t key_len
The length of the private key.
Definition: reclaim.h:269
Stop credential iteration for the given operation.
Definition: reclaim.h:298
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:307
Credential is returned from the idp.
Definition: reclaim.h:169
uint16_t credential_len
Length of serialized attribute data.
Definition: reclaim.h:183
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:178
uint16_t key_len
The length of the public key.
Definition: reclaim.h:188
uint32_t record_type
Type of the GNS/DNS record.
const void * data
Binary value stored in the DNS record.
size_t data_size
Number of bytes in data.
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
uint64_t expiration_time
Expiration time for the DNS record.
A private key for an identity as per LSD0001.
An identity key as per LSD0001.
Handle to a message queue.
Definition: mq.c:87
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Connection to the NAMESTORE service.
An QueueEntry used to store information for a pending NAMESTORE record operation.
Definition: namestore_api.c:53
Handle for a zone iterator operation.
struct GNUNET_RECLAIM_Attribute * attribute
The attribute claim.
struct GNUNET_RECLAIM_AttributeListEntry * next
DLL.
A list of GNUNET_RECLAIM_Attribute structures.
struct GNUNET_RECLAIM_AttributeListEntry * list_tail
List tail.
struct GNUNET_RECLAIM_AttributeListEntry * list_head
List head.
const char * name
The name of the attribute.
struct GNUNET_RECLAIM_Identifier credential
Referenced ID of credential (may be GNUNET_RECLAIM_ID_ZERO if self-creded)
struct GNUNET_RECLAIM_Identifier id
ID.
struct GNUNET_RECLAIM_CredentialListEntry * next
DLL.
struct GNUNET_RECLAIM_Credential * credential
The credential.
A list of GNUNET_RECLAIM_Credential structures.
struct GNUNET_RECLAIM_CredentialListEntry * list_head
List head.
struct GNUNET_RECLAIM_CredentialListEntry * list_tail
List tail.
const char * name
The name of the credential.
struct GNUNET_RECLAIM_Identifier id
ID.
struct GNUNET_CLIENT_Connection * client
Socket (if available).
Definition: reclaim_api.c:326
struct GNUNET_MQ_Handle * mq
Connection to service (if available).
Definition: reclaim_api.c:391
A list of GNUNET_RECLAIM_Presentation structures.
A credential presentation.
struct GNUNET_RECLAIM_Identifier credential_id
The credential id of which this is a presentation.
The authorization ticket.
Entry in list of pending tasks.
Definition: scheduler.c:136
Handle to a client that is connected to a service.
Definition: service.c:252
Handle to a service.
Definition: service.c:118
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
struct GNUNET_TRANSPORT_AddressIdentifier * next
Kept in a DLL.
An idp client.
struct IdpClient * next
DLL.
struct TicketIteration * ticket_iter_tail
Tail of DLL of ticket iteration ops.
struct GNUNET_SERVICE_Client * client
The client.
struct Iterator * attr_iter_tail
Tail of the DLL of Attribute iteration operations in progress initiated by this client.
struct IdpClient * prev
DLL.
struct TicketRevocationOperation * revoke_op_head
Head of DLL of ticket revocation ops.
struct AttributeStoreHandle * store_op_head
Head of DLL of attribute store ops.
struct TicketIssueOperation * issue_op_tail
Tail of DLL of ticket issue ops.
struct Iterator * cred_iter_tail
Tail of the DLL of Credential iteration operations in progress initiated by this client.
struct AttributeDeleteHandle * delete_op_tail
Tail of DLL of attribute delete ops.
struct TicketRevocationOperation * revoke_op_tail
Tail of DLL of ticket revocation ops.
struct TicketIssueOperation * issue_op_head
Head of DLL of ticket issue ops.
struct AttributeDeleteHandle * delete_op_head
Head of DLL of attribute delete ops.
struct Iterator * cred_iter_head
Head of the DLL of Credential iteration operations in progress initiated by this client.
struct GNUNET_MQ_Handle * mq
Message queue for transmission to client.
struct AttributeStoreHandle * store_op_tail
Tail of DLL of attribute store ops.
struct ConsumeTicketOperation * consume_op_head
Head of DLL of ticket consume ops.
struct ConsumeTicketOperation * consume_op_tail
Tail of DLL of ticket consume ops.
struct TicketIteration * ticket_iter_head
Head of DLL of ticket iteration ops.
struct Iterator * attr_iter_head
Head of the DLL of Attribute iteration operations in progress initiated by this client.
Ticket issue message.
Definition: reclaim.h:396
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:405
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET.
Definition: reclaim.h:400
uint16_t pkey_len
The length of the relying party public key.
Definition: reclaim.h:425
uint16_t key_len
The length of the identity private key.
Definition: reclaim.h:420
uint16_t attr_len
length of serialized attribute list
Definition: reclaim.h:415
An attribute iteration operation.
struct Iterator * prev
Previous element in the DLL.
struct GNUNET_NAMESTORE_ZoneIterator * ns_it
Namestore iterator.
struct GNUNET_IDENTITY_PrivateKey identity
Key of the zone we are iterating over.
struct IdpClient * client
IDP client which intiated this zone iteration.
void * ctx
Context.
struct Iterator * next
Next element in the DLL.
uint32_t request_id
The operation id for the zone iteration in the response for the client.
Ticket revocation request handle.
Ticket revoke message.
Definition: reclaim.h:438
uint16_t key_len
The length of the private key.
Definition: reclaim.h:452
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:447
uint16_t tkt_len
The length of the ticket.
Definition: reclaim.h:457
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET.
Definition: reclaim.h:442
Ticket revoke message.
Definition: reclaim.h:470
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:479
uint32_t success
Revocation result.
Definition: reclaim.h:484
Attribute store/delete response message.
Definition: reclaim.h:106
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:115
int32_t op_result
GNUNET_SYSERR on failure, GNUNET_OK on success
Definition: reclaim.h:120
Ticket issue operation handle.
struct TicketIssueOperation * next
DLL.
struct IdpClient * client
Client connection.
struct TicketIssueOperation * prev
DLL.
Ask for next result of ticket iteration for the given operation.
Definition: reclaim.h:362
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:371
Start a ticket iteration for the given identity.
Definition: reclaim.h:331
uint16_t key_len
The length of the private key.
Definition: reclaim.h:350
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:340
struct GNUNET_MessageHeader header
Message.
Definition: reclaim.h:335
Stop ticket iteration for the given operation.
Definition: reclaim.h:379
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:388
A ticket iteration operation.
struct TicketIteration * next
DLL.
struct IdpClient * client
Client which intiated this zone iteration.
uint32_t r_id
The operation id for the iteration in the response for the client.
struct RECLAIM_TICKETS_Iterator * iter
The ticket iterator.
struct TicketIteration * prev
DLL.
unsigned int rd_count
Record count.
Ticket result message.
Definition: reclaim.h:492
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:501
uint16_t presentations_len
Length of new presentations created.
Definition: reclaim.h:511
uint16_t tkt_len
Ticket length.
Definition: reclaim.h:506
Ticket revocation request handle.
struct TicketRevocationOperation * next
DLL.
struct RECLAIM_TICKETS_RevokeHandle * rh
Revocation handle.
struct TicketRevocationOperation * prev
DLL.
struct IdpClient * client
Client connection.