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"
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 
94 {
99 
104 
108  struct IdpClient *client;
109 
114 
119 
123  uint32_t request_id;
124 };
125 
126 
130 struct IdpClient
131 {
135  struct IdpClient *prev;
136 
140  struct IdpClient *next;
141 
146 
151 
158 
165 
170 
175 
180 
185 
190 
195 
200 
205 
210 
219 
224 };
225 
226 
231 {
236 
241 
245  struct IdpClient *client;
246 
251 
252 
257 
262 
267 
272 
277 
281  char *label;
282 
286  uint32_t r_id;
287 };
288 
289 
294 {
299 
304 
308  struct IdpClient *client;
309 
314 
318  struct GNUNET_CRYPTO_EcdsaPublicKey identity_pkey;
319 
324 
329 
334 
338  uint32_t r_id;
339 };
340 
341 
346 {
351 
356 
360  struct IdpClient *client;
361 
365  uint32_t r_id;
366 
371 };
372 
373 
378 {
383 
388 
392  struct IdpClient *client;
393 
398 
402  uint32_t r_id;
403 };
404 
405 
410 {
415 
420 
424  struct IdpClient *client;
425 
429  uint32_t r_id;
430 };
431 
432 
436 static struct IdpClient *client_list_head = NULL;
437 
441 static struct IdpClient *client_list_tail = NULL;
442 
443 
449 static void
451 {
452  struct TicketRecordsEntry *le;
453 
454  if (NULL != adh->ns_it)
456  if (NULL != adh->ns_qe)
458  if (NULL != adh->label)
459  GNUNET_free (adh->label);
460  if (NULL != adh->claim)
461  GNUNET_free (adh->claim);
462  while (NULL != (le = adh->tickets_to_update_head))
463  {
466  le);
467  if (NULL != le->label)
468  GNUNET_free (le->label);
469  if (NULL != le->data)
470  GNUNET_free (le->data);
471  GNUNET_free (le);
472  }
473  GNUNET_free (adh);
474 }
475 
476 
482 static void
484 {
485  if (NULL != ash->ns_qe)
487  if (NULL != ash->claim)
488  GNUNET_free (ash->claim);
489  GNUNET_free (ash);
490 }
491 
492 
498 static void
500 {
501  struct AttributeIterator *ai;
502  struct TicketIteration *ti;
503  struct TicketRevocationOperation *rop;
504  struct TicketIssueOperation *iss;
505  struct ConsumeTicketOperation *ct;
506  struct AttributeStoreHandle *as;
507  struct AttributeDeleteHandle *adh;
508 
509  while (NULL != (iss = idp->issue_op_head))
510  {
512  GNUNET_free (iss);
513  }
514  while (NULL != (ct = idp->consume_op_head))
515  {
517  idp->consume_op_tail,
518  ct);
519  if (NULL != ct->ch)
521  GNUNET_free (ct);
522  }
523  while (NULL != (as = idp->store_op_head))
524  {
526  cleanup_as_handle (as);
527  }
528  while (NULL != (adh = idp->delete_op_head))
529  {
531  cleanup_adh (adh);
532  }
533 
534  while (NULL != (ai = idp->attr_iter_head))
535  {
537  GNUNET_free (ai);
538  }
539  while (NULL != (rop = idp->revoke_op_head))
540  {
542  if (NULL != rop->rh)
544  GNUNET_free (rop);
545  }
546  while (NULL != (ti = idp->ticket_iter_head))
547  {
549  idp->ticket_iter_tail,
550  ti);
551  if (NULL != ti->iter)
553  GNUNET_free (ti);
554  }
555  GNUNET_free (idp);
556 }
557 
558 
562 static void
564 {
565  struct IdpClient *cl;
566 
567  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
568 
569  while (NULL != (cl = client_list_head))
570  {
571  GNUNET_CONTAINER_DLL_remove (client_list_head,
572  client_list_tail,
573  cl);
574  cleanup_client (cl);
575  }
577  if (NULL != timeout_task)
578  GNUNET_SCHEDULER_cancel (timeout_task);
579  if (NULL != nsh)
581 }
582 
583 
589 static void
590 do_shutdown (void *cls)
591 {
592  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down...\n");
593  cleanup ();
594 }
595 
596 
605 static void
607  uint32_t r_id,
608  const struct GNUNET_RECLAIM_Ticket *ticket,
609  uint32_t success)
610 {
611  struct TicketResultMessage *irm;
612  struct GNUNET_MQ_Envelope *env;
613 
614  env = GNUNET_MQ_msg (irm,
616  if (NULL != ticket)
617  {
618  irm->ticket = *ticket;
619  }
620  // TODO add success member
621  irm->id = htonl (r_id);
622  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
623  GNUNET_MQ_send (client->mq, env);
624 }
625 
626 
635 static void
638  int32_t success,
639  const char *emsg)
640 {
641  struct TicketIssueOperation *tio = cls;
642 
643  if (GNUNET_OK != success)
644  {
645  send_ticket_result (tio->client, tio->r_id, NULL, GNUNET_SYSERR);
647  tio->client->issue_op_tail,
648  tio);
649  GNUNET_free (tio);
650  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error issuing ticket: %s\n", emsg);
651  return;
652  }
653  send_ticket_result (tio->client, tio->r_id, ticket, GNUNET_SYSERR);
655  tio->client->issue_op_tail,
656  tio);
657  GNUNET_free (tio);
658 }
659 
660 
668 static int
669 check_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
670 {
671  uint16_t size;
672 
673  size = ntohs (im->header.size);
674  if (size <= sizeof(struct IssueTicketMessage))
675  {
676  GNUNET_break (0);
677  return GNUNET_SYSERR;
678  }
679  return GNUNET_OK;
680 }
681 
682 
689 static void
690 handle_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
691 {
692  struct TicketIssueOperation *tio;
693  struct IdpClient *idp = cls;
695  size_t attrs_len;
696 
697  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ISSUE_TICKET message\n");
698  tio = GNUNET_new (struct TicketIssueOperation);
699  attrs_len = ntohs (im->attr_len);
700  attrs = GNUNET_RECLAIM_ATTRIBUTE_list_deserialize ((char *) &im[1],
701  attrs_len);
702  tio->r_id = ntohl (im->id);
703  tio->client = idp;
705  RECLAIM_TICKETS_issue (&im->identity,
706  attrs,
707  &im->rp,
709  tio);
712 }
713 
714 
715 /**********************************************************
716 * Revocation
717 **********************************************************/
718 
725 static void
726 revoke_result_cb (void *cls, int32_t success)
727 {
728  struct TicketRevocationOperation *rop = cls;
729  struct GNUNET_MQ_Envelope *env;
730  struct RevokeTicketResultMessage *trm;
731 
733  "Sending REVOKE_TICKET_RESULT message\n");
734  rop->rh = NULL;
736  trm->id = htonl (rop->r_id);
737  trm->success = htonl (success);
738  GNUNET_MQ_send (rop->client->mq, env);
740  rop->client->revoke_op_tail,
741  rop);
742  GNUNET_free (rop);
743 }
744 
745 
753 static int
755 {
756  uint16_t size;
757 
758  size = ntohs (im->header.size);
759  if (size != sizeof(struct RevokeTicketMessage))
760  {
761  GNUNET_break (0);
762  return GNUNET_SYSERR;
763  }
764  return GNUNET_OK;
765 }
766 
767 
774 static void
776 {
777  struct TicketRevocationOperation *rop;
778  struct IdpClient *idp = cls;
779 
780  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received REVOKE_TICKET message\n");
781  rop = GNUNET_new (struct TicketRevocationOperation);
782  rop->r_id = ntohl (rm->id);
783  rop->client = idp;
785  rop->rh
787  rop);
789 }
790 
791 
801 static void
802 consume_result_cb (void *cls,
804  const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs,
805  int32_t success,
806  const char *emsg)
807 {
808  struct ConsumeTicketOperation *cop = cls;
809  struct ConsumeTicketResultMessage *crm;
810  struct GNUNET_MQ_Envelope *env;
811  char *data_tmp;
812  size_t attrs_len;
813 
814  if (GNUNET_OK != success)
815  {
816  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error consuming ticket: %s\n", emsg);
817  }
820  "Sending CONSUME_TICKET_RESULT message\n");
821  env = GNUNET_MQ_msg_extra (crm,
822  attrs_len,
824  crm->id = htonl (cop->r_id);
825  crm->attrs_len = htons (attrs_len);
826  crm->identity = *identity;
827  crm->result = htonl (success);
828  data_tmp = (char *) &crm[1];
829  GNUNET_RECLAIM_ATTRIBUTE_list_serialize (attrs, data_tmp);
830  GNUNET_MQ_send (cop->client->mq, env);
832  cop->client->consume_op_tail,
833  cop);
834  GNUNET_free (cop);
835 }
836 
837 
844 static int
846 {
847  uint16_t size;
848 
849  size = ntohs (cm->header.size);
850  if (size != sizeof(struct ConsumeTicketMessage))
851  {
852  GNUNET_break (0);
853  return GNUNET_SYSERR;
854  }
855  return GNUNET_OK;
856 }
857 
858 
865 static void
867 {
868  struct ConsumeTicketOperation *cop;
869  struct IdpClient *idp = cls;
870 
871  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CONSUME_TICKET message\n");
872  cop = GNUNET_new (struct ConsumeTicketOperation);
873  cop->r_id = ntohl (cm->id);
874  cop->client = idp;
875  cop->ch
877  cop);
880 }
881 
882 
883 /*****************************************
884 * Attribute store
885 *****************************************/
886 
887 
895 static void
896 attr_store_cont (void *cls, int32_t success, const char *emsg)
897 {
898  struct AttributeStoreHandle *ash = cls;
899  struct GNUNET_MQ_Envelope *env;
900  struct SuccessResultMessage *acr_msg;
901 
902  ash->ns_qe = NULL;
904  ash->client->store_op_tail,
905  ash);
906 
907  if (GNUNET_SYSERR == success)
908  {
910  "Failed to store attribute %s\n",
911  emsg);
912  cleanup_as_handle (ash);
914  return;
915  }
916 
917  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
919  acr_msg->id = htonl (ash->r_id);
920  acr_msg->op_result = htonl (GNUNET_OK);
921  GNUNET_MQ_send (ash->client->mq, env);
922  cleanup_as_handle (ash);
923 }
924 
925 
931 static void
932 attr_store_task (void *cls)
933 {
934  struct AttributeStoreHandle *ash = cls;
935  struct GNUNET_GNSRECORD_Data rd[1];
936  char *buf;
937  char *label;
938  size_t buf_size;
939 
940  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing attribute\n");
942  buf = GNUNET_malloc (buf_size);
943  // Give the ash a new id if unset
944  if (0 == ash->claim->id)
945  ash->claim->id
948  label
949  = GNUNET_STRINGS_data_to_string_alloc (&ash->claim->id, sizeof(uint64_t));
950  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypting with label %s\n", label);
951 
952  rd[0].data_size = buf_size;
953  rd[0].data = buf;
956  rd[0].expiration_time = ash->exp.rel_value_us;
958  &ash->identity,
959  label,
960  1,
961  rd,
963  ash);
964  GNUNET_free (buf);
965  GNUNET_free (label);
966 }
967 
968 
975 static int
977  const struct AttributeStoreMessage *sam)
978 {
979  uint16_t size;
980 
981  size = ntohs (sam->header.size);
982  if (size <= sizeof(struct AttributeStoreMessage))
983  {
984  GNUNET_break (0);
985  return GNUNET_SYSERR;
986  }
987  return GNUNET_OK;
988 }
989 
990 
997 static void
999  const struct AttributeStoreMessage *sam)
1000 {
1001  struct AttributeStoreHandle *ash;
1002  struct IdpClient *idp = cls;
1003  size_t data_len;
1004 
1005  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_STORE message\n");
1006 
1007  data_len = ntohs (sam->attr_len);
1008 
1009  ash = GNUNET_new (struct AttributeStoreHandle);
1010  ash->claim = GNUNET_RECLAIM_ATTRIBUTE_deserialize ((char *) &sam[1],
1011  data_len);
1012 
1013  ash->r_id = ntohl (sam->id);
1014  ash->identity = sam->identity;
1015  ash->exp.rel_value_us = GNUNET_ntohll (sam->exp);
1016  GNUNET_CRYPTO_ecdsa_key_get_public (&sam->identity, &ash->identity_pkey);
1017 
1019  ash->client = idp;
1022 }
1023 
1024 
1031 static void
1032 send_delete_response (struct AttributeDeleteHandle *adh, int32_t success)
1033 {
1034  struct GNUNET_MQ_Envelope *env;
1035  struct SuccessResultMessage *acr_msg;
1036 
1038  adh->client->delete_op_tail,
1039  adh);
1040 
1041  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
1043  acr_msg->id = htonl (adh->r_id);
1044  acr_msg->op_result = htonl (success);
1045  GNUNET_MQ_send (adh->client->mq, env);
1046 }
1047 
1048 
1059 static void
1060 ticket_iter (void *cls,
1061  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
1062  const char *label,
1063  unsigned int rd_count,
1064  const struct GNUNET_GNSRECORD_Data *rd)
1065 {
1066  struct AttributeDeleteHandle *adh = cls;
1067  struct TicketRecordsEntry *le;
1068  int has_changed = GNUNET_NO;
1069 
1070  for (int i = 0; i < rd_count; i++)
1071  {
1072  if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
1073  continue;
1074  if (0 != memcmp (rd[i].data, &adh->claim->id, sizeof(uint64_t)))
1075  continue;
1077  "Attribute to delete found (%s)\n",
1078  adh->label);
1079  has_changed = GNUNET_YES;
1080  break;
1081  }
1082  if (GNUNET_YES == has_changed)
1083  {
1084  le = GNUNET_new (struct TicketRecordsEntry);
1085  le->data_size = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
1086  le->data = GNUNET_malloc (le->data_size);
1087  le->rd_count = rd_count;
1088  le->label = GNUNET_strdup (label);
1089  GNUNET_GNSRECORD_records_serialize (rd_count, rd, le->data_size, le->data);
1092  le);
1093  }
1095 }
1096 
1097 
1102 static void
1103 update_tickets (void *cls);
1104 
1105 
1113 static void
1114 ticket_updated (void *cls, int32_t success, const char *emsg)
1115 {
1116  struct AttributeDeleteHandle *adh = cls;
1117 
1118  adh->ns_qe = NULL;
1120 }
1121 
1122 
1130 static void
1131 update_tickets (void *cls)
1132 {
1133  struct AttributeDeleteHandle *adh = cls;
1134  struct TicketRecordsEntry *le;
1135 
1136  if (NULL == adh->tickets_to_update_head)
1137  {
1139  "Finished updatding tickets, success\n");
1141  cleanup_adh (adh);
1142  return;
1143  }
1145  "Updating %s\n",
1147  le = adh->tickets_to_update_head;
1150  le);
1151  struct GNUNET_GNSRECORD_Data rd[le->rd_count];
1152  struct GNUNET_GNSRECORD_Data rd_new[le->rd_count - 1];
1154  le->data,
1155  le->rd_count,
1156  rd))
1157  {
1159  "Unable to deserialize record data!\n");
1161  cleanup_adh (adh);
1162  return;
1163  }
1164  int j = 0;
1165  for (int i = 0; i < le->rd_count; i++)
1166  {
1168  && (0 == memcmp (rd[i].data, &adh->claim->id, sizeof(uint64_t))))
1169  continue;
1170  rd_new[j] = rd[i];
1171  j++;
1172  }
1174  &adh->identity,
1175  le->label,
1176  j,
1177  rd_new,
1178  &ticket_updated,
1179  adh);
1180  GNUNET_free (le->label);
1181  GNUNET_free (le->data);
1182  GNUNET_free (le);
1183 }
1184 
1185 
1191 static void
1192 ticket_iter_fin (void *cls)
1193 {
1194  struct AttributeDeleteHandle *adh = cls;
1195 
1196  adh->ns_it = NULL;
1198 }
1199 
1200 
1206 static void
1207 ticket_iter_err (void *cls)
1208 {
1209  struct AttributeDeleteHandle *adh = cls;
1210 
1211  adh->ns_it = NULL;
1213  "Namestore error on delete %s\n",
1214  adh->label);
1216  cleanup_adh (adh);
1217 }
1218 
1219 
1226 static void
1228 {
1229  struct AttributeDeleteHandle *adh = cls;
1230 
1232  &adh->identity,
1233  &ticket_iter_err,
1234  adh,
1235  &ticket_iter,
1236  adh,
1237  &ticket_iter_fin,
1238  adh);
1239 }
1240 
1241 
1249 static void
1250 attr_delete_cont (void *cls, int32_t success, const char *emsg)
1251 {
1252  struct AttributeDeleteHandle *adh = cls;
1253 
1254  adh->ns_qe = NULL;
1255  if (GNUNET_SYSERR == success)
1256  {
1258  "Error deleting attribute %s\n",
1259  adh->label);
1261  cleanup_adh (adh);
1262  return;
1263  }
1264  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating tickets...\n");
1266 }
1267 
1268 
1275 static int
1277  const struct AttributeDeleteMessage *dam)
1278 {
1279  uint16_t size;
1280 
1281  size = ntohs (dam->header.size);
1282  if (size <= sizeof(struct AttributeDeleteMessage))
1283  {
1284  GNUNET_break (0);
1285  return GNUNET_SYSERR;
1286  }
1287  return GNUNET_OK;
1288 }
1289 
1290 
1297 static void
1299  const struct AttributeDeleteMessage *dam)
1300 {
1301  struct AttributeDeleteHandle *adh;
1302  struct IdpClient *idp = cls;
1303  size_t data_len;
1304 
1305  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_DELETE message\n");
1306 
1307  data_len = ntohs (dam->attr_len);
1308 
1309  adh = GNUNET_new (struct AttributeDeleteHandle);
1310  adh->claim = GNUNET_RECLAIM_ATTRIBUTE_deserialize ((char *) &dam[1],
1311  data_len);
1312 
1313  adh->r_id = ntohl (dam->id);
1314  adh->identity = dam->identity;
1315  adh->label
1316  = GNUNET_STRINGS_data_to_string_alloc (&adh->claim->id, sizeof(uint64_t));
1318  adh->client = idp;
1321  &adh->identity,
1322  adh->label,
1323  0,
1324  NULL,
1326  adh);
1327 }
1328 
1329 
1330 /*************************************************
1331 * Attrubute iteration
1332 *************************************************/
1333 
1334 
1340 static void
1342 {
1343  struct AttributeIterator *ai = cls;
1344  struct GNUNET_MQ_Envelope *env;
1345  struct AttributeResultMessage *arm;
1346 
1347  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ATTRIBUTE_RESULT message\n");
1349  arm->id = htonl (ai->request_id);
1350  arm->attr_len = htons (0);
1351  GNUNET_MQ_send (ai->client->mq, env);
1353  ai->client->attr_iter_tail,
1354  ai);
1355  GNUNET_free (ai);
1356 }
1357 
1358 
1364 static void
1365 attr_iter_error (void *cls)
1366 {
1367  struct AttributeIterator *ai = cls;
1368 
1369  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over attributes\n");
1370  attr_iter_finished (ai);
1371 }
1372 
1373 
1383 static void
1384 attr_iter_cb (void *cls,
1385  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
1386  const char *label,
1387  unsigned int rd_count,
1388  const struct GNUNET_GNSRECORD_Data *rd)
1389 {
1390  struct AttributeIterator *ai = cls;
1391  struct AttributeResultMessage *arm;
1392  struct GNUNET_MQ_Envelope *env;
1393  char *data_tmp;
1394 
1395  if (rd_count != 1)
1396  {
1398  return;
1399  }
1400 
1402  {
1404  return;
1405  }
1406  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found attribute under: %s\n", label);
1407  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ATTRIBUTE_RESULT message\n");
1408  env = GNUNET_MQ_msg_extra (arm,
1409  rd->data_size,
1411  arm->id = htonl (ai->request_id);
1412  arm->attr_len = htons (rd->data_size);
1414  data_tmp = (char *) &arm[1];
1415  GNUNET_memcpy (data_tmp, rd->data, rd->data_size);
1416  GNUNET_MQ_send (ai->client->mq, env);
1417 }
1418 
1419 
1426 static void
1428  const struct AttributeIterationStartMessage *ais_msg)
1429 {
1430  struct IdpClient *idp = cls;
1431  struct AttributeIterator *ai;
1432 
1434  "Received ATTRIBUTE_ITERATION_START message\n");
1435  ai = GNUNET_new (struct AttributeIterator);
1436  ai->request_id = ntohl (ais_msg->id);
1437  ai->client = idp;
1438  ai->identity = ais_msg->identity;
1439 
1442  &ai->identity,
1443  &attr_iter_error,
1444  ai,
1445  &attr_iter_cb,
1446  ai,
1448  ai);
1450 }
1451 
1452 
1459 static void
1461  const struct AttributeIterationStopMessage *ais_msg)
1462 {
1463  struct IdpClient *idp = cls;
1464  struct AttributeIterator *ai;
1465  uint32_t rid;
1466 
1468  "Received `%s' message\n",
1469  "ATTRIBUTE_ITERATION_STOP");
1470  rid = ntohl (ais_msg->id);
1471  for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
1472  if (ai->request_id == rid)
1473  break;
1474  if (NULL == ai)
1475  {
1476  GNUNET_break (0);
1478  return;
1479  }
1481  GNUNET_free (ai);
1483 }
1484 
1485 
1492 static void
1494  const struct AttributeIterationNextMessage *ais_msg)
1495 {
1496  struct IdpClient *idp = cls;
1497  struct AttributeIterator *ai;
1498  uint32_t rid;
1499 
1501  "Received ATTRIBUTE_ITERATION_NEXT message\n");
1502  rid = ntohl (ais_msg->id);
1503  for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
1504  if (ai->request_id == rid)
1505  break;
1506  if (NULL == ai)
1507  {
1508  GNUNET_break (0);
1510  return;
1511  }
1514 }
1515 
1516 
1517 /******************************************************
1518 * Ticket iteration
1519 ******************************************************/
1520 
1527 static void
1529 {
1530  struct TicketIteration *ti = cls;
1531  struct GNUNET_MQ_Envelope *env;
1532  struct TicketResultMessage *trm;
1533 
1535  if (NULL == ticket)
1536  {
1537  /* send empty response to indicate end of list */
1539  ti->client->ticket_iter_tail,
1540  ti);
1541  }
1542  else
1543  {
1544  trm->ticket = *ticket;
1545  }
1546  trm->id = htonl (ti->r_id);
1547  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
1548  GNUNET_MQ_send (ti->client->mq, env);
1549  if (NULL == ticket)
1550  GNUNET_free (ti);
1551 }
1552 
1553 
1560 static void
1562  void *cls,
1563  const struct TicketIterationStartMessage *tis_msg)
1564 {
1565  struct IdpClient *client = cls;
1566  struct TicketIteration *ti;
1567 
1569  "Received TICKET_ITERATION_START message\n");
1570  ti = GNUNET_new (struct TicketIteration);
1571  ti->r_id = ntohl (tis_msg->id);
1572  ti->client = client;
1573 
1575  client->ticket_iter_tail,
1576  ti);
1577  ti->iter
1580 }
1581 
1582 
1589 static void
1591  const struct TicketIterationStopMessage *tis_msg)
1592 {
1593  struct IdpClient *client = cls;
1594  struct TicketIteration *ti;
1595  uint32_t rid;
1596 
1598  "Received `%s' message\n",
1599  "TICKET_ITERATION_STOP");
1600  rid = ntohl (tis_msg->id);
1601  for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next)
1602  if (ti->r_id == rid)
1603  break;
1604  if (NULL == ti)
1605  {
1606  GNUNET_break (0);
1608  return;
1609  }
1612  client->ticket_iter_tail,
1613  ti);
1614  GNUNET_free (ti);
1616 }
1617 
1618 
1625 static void
1627  const struct TicketIterationNextMessage *tis_msg)
1628 {
1629  struct IdpClient *client = cls;
1630  struct TicketIteration *ti;
1631  uint32_t rid;
1632 
1634  "Received TICKET_ITERATION_NEXT message\n");
1635  rid = ntohl (tis_msg->id);
1636  for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next)
1637  if (ti->r_id == rid)
1638  break;
1639  if (NULL == ti)
1640  {
1641  GNUNET_break (0);
1643  return;
1644  }
1647 }
1648 
1649 
1657 static void
1658 run (void *cls,
1659  const struct GNUNET_CONFIGURATION_Handle *c,
1660  struct GNUNET_SERVICE_Handle *server)
1661 {
1662  cfg = c;
1663 
1664  if (GNUNET_OK != RECLAIM_TICKETS_init (cfg))
1665  {
1667  "Unable to initialize TICKETS subsystem.\n");
1669  return;
1670  }
1671  // Connect to identity and namestore services
1672  nsh = GNUNET_NAMESTORE_connect (cfg);
1673  if (NULL == nsh)
1674  {
1676  "error connecting to namestore");
1677  }
1678 
1680 }
1681 
1682 
1690 static void
1692  struct GNUNET_SERVICE_Client *client,
1693  void *app_ctx)
1694 {
1695  struct IdpClient *idp = app_ctx;
1696 
1697  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p disconnected\n", client);
1698  GNUNET_CONTAINER_DLL_remove (client_list_head,
1699  client_list_tail,
1700  idp);
1701  cleanup_client (idp);
1702 }
1703 
1704 
1713 static void *
1715  struct GNUNET_SERVICE_Client *client,
1716  struct GNUNET_MQ_Handle *mq)
1717 {
1718  struct IdpClient *idp;
1719 
1720  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
1721  idp = GNUNET_new (struct IdpClient);
1722  idp->client = client;
1723  idp->mq = mq;
1724  GNUNET_CONTAINER_DLL_insert (client_list_head,
1725  client_list_tail,
1726  idp);
1727  return idp;
1728 }
1729 
1730 
1735  "reclaim",
1737  &run,
1740  NULL,
1741  GNUNET_MQ_hd_var_size (attribute_store_message,
1743  struct AttributeStoreMessage,
1744  NULL),
1745  GNUNET_MQ_hd_var_size (attribute_delete_message,
1747  struct AttributeDeleteMessage,
1748  NULL),
1753  NULL),
1754  GNUNET_MQ_hd_fixed_size (iteration_next,
1757  NULL),
1758  GNUNET_MQ_hd_fixed_size (iteration_stop,
1761  NULL),
1762  GNUNET_MQ_hd_var_size (issue_ticket_message,
1764  struct IssueTicketMessage,
1765  NULL),
1766  GNUNET_MQ_hd_var_size (consume_ticket_message,
1768  struct ConsumeTicketMessage,
1769  NULL),
1770  GNUNET_MQ_hd_fixed_size (ticket_iteration_start,
1773  NULL),
1774  GNUNET_MQ_hd_fixed_size (ticket_iteration_next,
1777  NULL),
1778  GNUNET_MQ_hd_fixed_size (ticket_iteration_stop,
1781  NULL),
1782  GNUNET_MQ_hd_var_size (revoke_ticket_message,
1784  struct RevokeTicketMessage,
1785  NULL),
1787 /* 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.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:367
static void attr_delete_cont(void *cls, int32_t success, const char *emsg)
Attribute deleted callback.
Ticket result message.
Definition: reclaim.h:357
struct GNUNET_CRYPTO_EcdsaPrivateKey identity
Identity.
Definition: reclaim.h:319
The authorization ticket.
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:372
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.
struct TicketIssueOperation * prev
DLL.
Attribute list is returned from the idp.
Definition: reclaim.h:404
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_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:309
#define GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT
static void consume_result_cb(void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs, int32_t success, const char *emsg)
Handle a ticket consume result.
struct GNUNET_CRYPTO_EcdsaPrivateKey identity
Identity.
Definition: reclaim.h:230
Ticket consume message.
Definition: reclaim.h:378
Handle to a service.
Definition: service.c:116
struct ConsumeTicketOperation * consume_op_head
Head of DLL of ticket consume ops.
An idp client.
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:160
struct AttributeIterator * attr_iter_tail
Tail of the DLL of Attribute iteration operations in progress initiated by this client.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Random on unsigned 64-bit values.
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:1300
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.
Stop attribute iteration for the given operation.
Definition: reclaim.h:199
int32_t op_result
GNUNET_SYSERR on failure, GNUNET_OK on success
Definition: reclaim.h:118
#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR
Record type for identity attributes (of RECLAIM).
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:314
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:414
struct AttributeIterator * prev
Previous element in the DLL.
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.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#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.
#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF
Record type for reclaim records.
#define GNUNET_NO
Definition: gnunet_common.h:78
static void handle_attribute_delete_message(void *cls, const struct AttributeDeleteMessage *dam)
Handle attribute deletion.
#define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
size_t data_size
Number of bytes in data.
#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.
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:419
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.
struct GNUNET_CRYPTO_EcdsaPrivateKey identity
Key of the zone we are iterating over.
uint32_t r_id
request id
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
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_.
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.
#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:276
struct IdpClient * client
Client which intiated this zone iteration.
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:237
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:247
struct GNUNET_MQ_Handle * mq
Message queue for transmission to client.
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).
#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...
void GNUNET_RECLAIM_ATTRIBUTE_list_destroy(struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs)
Destroy claim list.
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:209
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.
struct AttributeIterator * next
Next element in the DLL.
struct GNUNET_RECLAIM_ATTRIBUTE_Claim * claim
The attribute to store.
#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:393
Connection to the NAMESTORE service.
struct TicketIteration * prev
DLL.
Stop ticket iteration for the given operation.
Definition: reclaim.h:254
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:192
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:1280
struct GNUNET_RECLAIM_Ticket ticket
The ticket to revoke.
Definition: reclaim.h:329
unsigned int rd_count
Record count.
Handle to a consume operation.
static struct IdpClient * client_list_head
Client list.
Handle for attribute store request.
struct ConsumeTicketOperation * next
DLL.
static char buf[2048]
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.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT
struct GNUNET_CRYPTO_EcdsaPrivateKey identity
Identity.
Definition: reclaim.h:175
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.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:170
Ticket issue message.
Definition: reclaim.h:271
struct IdpClient * prev
DLL.
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
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
struct GNUNET_CRYPTO_EcdsaPublicKey identity_pkey
Identity pubkey.
struct IdpClient * client
Client connection.
struct TicketRevocationOperation * next
DLL.
struct TicketIteration * next
DLL.
Attribute store/delete response message.
Definition: reclaim.h:103
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.
uint32_t request_id
The operation id fot the zone iteration in the response for the client.
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:296
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.
char * label
Attribute label.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_RECLAIM_Ticket ticket
The ticket to consume.
Definition: reclaim.h:398
static unsigned int size
Size of the "table".
Definition: peer.c:67
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:239
An QueueEntry used to store information for a pending NAMESTORE record operation. ...
Definition: namestore_api.c:53
Ask for next result of attribute iteration for the given operation.
Definition: reclaim.h:182
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.
void RECLAIM_TICKETS_issue(const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs, const struct GNUNET_CRYPTO_EcdsaPublicKey *audience, RECLAIM_TICKETS_TicketResult cb, void *cb_cls)
Issue a new reclaim ticket, thereby authorizing the audience to access the set of provided attributes...
struct TicketRevocationOperation * revoke_op_head
Head of DLL of ticket revocation ops.
static void iteration_start()
struct TicketRevocationOperation * prev
DLL.
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(attribute_delete_message, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_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_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.
static void ticket_updated(void *cls, int32_t success, const char *emsg)
Callback called when a ticket was updated.
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
#define GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE
Handle to a message queue.
Definition: mq.c:85
#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:434
size_t GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size(const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
Get required size for serialization buffer.
#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:335
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:85
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:225
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:345
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
A list of GNUNET_RECLAIM_ATTRIBUTE_Claim structures.
Start a ticket iteration for the given identity.
Definition: reclaim.h:215
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:424
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:149
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
struct AttributeIterator * attr_iter_head
Head of the DLL of Attribute iteration operations in progress initiated by this client.
#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.
size_t GNUNET_RECLAIM_ATTRIBUTE_serialize(const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr, char *result)
Serialize an attribute.
#define GNUNET_YES
Definition: gnunet_common.h:77
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:264
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:920
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET.
Definition: reclaim.h:383
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 flag is currently unused; former RF_PENDING flag.
struct GNUNET_RECLAIM_ATTRIBUTE_Claim * claim
The attribute to delete.
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *server)
Main function that will be run.
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 attr_iter_finished(void *cls)
Done iterating over attributes.
struct IdpClient * client
IDP client which intiated this zone iteration.
uint32_t data
The data value.
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.
uint32_t success
Revocation result.
Definition: reclaim.h:350
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
size_t GNUNET_RECLAIM_ATTRIBUTE_list_serialize_get_size(const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs)
Get required size for serialization buffer.
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:388
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList * GNUNET_RECLAIM_ATTRIBUTE_list_deserialize(const char *data, size_t data_size)
Deserialize an attribute list.
static struct IdpClient * client_list_tail
Client list.
size_t GNUNET_RECLAIM_ATTRIBUTE_list_serialize(const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs, char *result)
Serialize an attribute list.
An attribute iteration operation.
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE
struct GNUNET_RECLAIM_ATTRIBUTE_Claim * GNUNET_RECLAIM_ATTRIBUTE_deserialize(const char *data, size_t data_size)
Deserialize an attribute.
#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:48
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.
struct GNUNET_NAMESTORE_ZoneIterator * ns_it
Namestore iterator.
static void handle_iteration_stop(void *cls, const struct AttributeIterationStopMessage *ais_msg)
Handle iteration stop message from client.
Ticket revoke message.
Definition: reclaim.h:304
Time for relative time used by GNUnet, in microseconds.
#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:966
High-quality operations are desired.