GNUnet  0.10.x
gnunet-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 <inttypes.h>
28 
29 #include "gnunet_util_lib.h"
30 
33 #include "gnunet_reclaim_service.h"
34 #include "gnunet_signatures.h"
38 static int ret;
39 
43 static int list;
44 
48 static char *rp;
49 
53 static char *attr_name;
54 
58 static char *attr_value;
59 
63 static char *issue_attrs;
64 
68 static char *consume_ticket;
69 
73 static char *type_str;
74 
78 static char *revoke_ticket;
79 
83 static int list_tickets;
84 
88 static char *ego_name;
89 
94 
99 
104 
109 
114 
119 
123 static const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey;
124 
129 
134 
139 
144 
149 
154 
159 
163 static char *attr_delete;
164 
169 
170 static void
171 do_cleanup(void *cls)
172 {
173  cleanup_task = NULL;
174  if (NULL != timeout)
175  GNUNET_SCHEDULER_cancel(timeout);
176  if (NULL != reclaim_op)
177  GNUNET_RECLAIM_cancel(reclaim_op);
178  if (NULL != attr_iterator)
179  GNUNET_RECLAIM_get_attributes_stop(attr_iterator);
180  if (NULL != ticket_iterator)
181  GNUNET_RECLAIM_ticket_iteration_stop(ticket_iterator);
182  if (NULL != reclaim_handle)
183  GNUNET_RECLAIM_disconnect(reclaim_handle);
184  if (NULL != identity_handle)
185  GNUNET_IDENTITY_disconnect(identity_handle);
186  if (NULL != abe_key)
187  GNUNET_free(abe_key);
188  if (NULL != attr_list)
189  GNUNET_free(attr_list);
190  if (NULL != attr_to_delete)
191  GNUNET_free(attr_to_delete);
192 }
193 
194 static void
196 {
197  char *ticket_str;
198 
199  reclaim_op = NULL;
200  if (NULL != ticket)
201  {
202  ticket_str =
204  sizeof(
205  struct GNUNET_RECLAIM_Ticket));
206  printf("%s\n", ticket_str);
207  GNUNET_free(ticket_str);
208  }
209  cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
210 }
211 
212 static void
213 store_attr_cont(void *cls, int32_t success, const char *emsg)
214 {
215  reclaim_op = NULL;
216  if (GNUNET_SYSERR == success)
217  {
218  fprintf(stderr, "%s\n", emsg);
219  }
220  cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
221 }
222 
223 static void
224 process_attrs(void *cls,
226  const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
227 {
228  char *value_str;
229  char *id;
230  const char *attr_type;
231 
232  if (NULL == identity)
233  {
234  reclaim_op = NULL;
235  cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
236  return;
237  }
238  if (NULL == attr)
239  {
240  ret = 1;
241  return;
242  }
244  attr->data,
245  attr->data_size);
247  id = GNUNET_STRINGS_data_to_string_alloc(&attr->id, sizeof(uint64_t));
248  fprintf(stdout,
249  "Name: %s; Value: %s (%s); Version %u; ID: %s\n",
250  attr->name,
251  value_str,
252  attr_type,
253  attr->version,
254  id);
255  GNUNET_free(id);
256 }
257 
258 static void
259 ticket_iter_err(void *cls)
260 {
261  ticket_iterator = NULL;
262  fprintf(stderr, "Failed to iterate over tickets\n");
263  cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
264 }
265 
266 static void
267 ticket_iter_fin(void *cls)
268 {
269  ticket_iterator = NULL;
270  cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
271 }
272 
273 static void
274 ticket_iter(void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
275 {
276  char *aud;
277  char *ref;
278  char *tkt;
279 
280  aud =
282  sizeof(struct
284  ref = GNUNET_STRINGS_data_to_string_alloc(&ticket->rnd, sizeof(uint64_t));
285  tkt =
287  sizeof(struct GNUNET_RECLAIM_Ticket));
288  fprintf(stdout, "Ticket: %s | ID: %s | Audience: %s\n", tkt, ref, aud);
289  GNUNET_free(aud);
290  GNUNET_free(ref);
291  GNUNET_free(tkt);
292  GNUNET_RECLAIM_ticket_iteration_next(ticket_iterator);
293 }
294 
295 static void
296 iter_error(void *cls)
297 {
298  attr_iterator = NULL;
299  fprintf(stderr, "Failed to iterate over attributes\n");
300  cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
301 }
302 
303 static void
304 timeout_task(void *cls)
305 {
306  timeout = NULL;
307  ret = 1;
308  fprintf(stderr, "Timeout\n");
309  if (NULL == cleanup_task)
310  cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
311 }
312 
313 static void
314 process_rvk(void *cls, int success, const char *msg)
315 {
316  reclaim_op = NULL;
317  if (GNUNET_OK != success)
318  {
319  fprintf(stderr, "Revocation failed.\n");
320  ret = 1;
321  }
322  cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
323 }
324 
325 
326 static void
327 process_delete(void *cls, int success, const char *msg)
328 {
329  reclaim_op = NULL;
330  if (GNUNET_OK != success)
331  {
332  fprintf(stderr, "Deletion failed.\n");
333  ret = 1;
334  }
335  cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
336 }
337 
338 
339 static void
340 iter_finished(void *cls)
341 {
342  char *data;
343  size_t data_size;
344  int type;
345 
346  attr_iterator = NULL;
347  if (list)
348  {
349  cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
350  return;
351  }
352 
353  if (issue_attrs)
354  {
355  reclaim_op = GNUNET_RECLAIM_ticket_issue(reclaim_handle,
356  pkey,
357  &rp_key,
358  attr_list,
360  NULL);
361  return;
362  }
363  if (consume_ticket)
364  {
365  reclaim_op = GNUNET_RECLAIM_ticket_consume(reclaim_handle,
366  pkey,
367  &ticket,
368  &process_attrs,
369  NULL);
372  &timeout_task,
373  NULL);
374  return;
375  }
376  if (revoke_ticket)
377  {
378  reclaim_op = GNUNET_RECLAIM_ticket_revoke(reclaim_handle,
379  pkey,
380  &ticket,
381  &process_rvk,
382  NULL);
383  return;
384  }
385  if (attr_delete)
386  {
387  if (NULL == attr_to_delete)
388  {
389  fprintf(stdout, "No such attribute ``%s''\n", attr_delete);
390  return;
391  }
392  reclaim_op = GNUNET_RECLAIM_attribute_delete(reclaim_handle,
393  pkey,
394  attr_to_delete,
396  NULL);
397  return;
398  }
399  if (attr_name)
400  {
401  if (NULL == type_str)
403  else
405 
408  attr_value,
409  (void **)&data,
410  &data_size));
411  if (NULL != claim)
412  {
413  claim->type = type;
414  claim->data = data;
415  claim->data_size = data_size;
416  }
417  else
418  {
419  claim =
420  GNUNET_RECLAIM_ATTRIBUTE_claim_new(attr_name, type, data, data_size);
421  }
422  reclaim_op = GNUNET_RECLAIM_attribute_store(reclaim_handle,
423  pkey,
424  claim,
425  &exp_interval,
427  NULL);
428  GNUNET_free(data);
429  GNUNET_free(claim);
430  return;
431  }
432  cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
433 }
434 
435 static void
436 iter_cb(void *cls,
438  const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
439 {
441  char *attrs_tmp;
442  char *attr_str;
443  char *label;
444  char *id;
445  const char *attr_type;
446 
447  if ((NULL != attr_name) && (NULL != claim))
448  {
449  if (0 == strcasecmp(attr_name, attr->name))
450  {
452  attr->type,
453  attr->data,
454  attr->data_size);
455  }
456  }
457  else if (issue_attrs)
458  {
459  attrs_tmp = GNUNET_strdup(issue_attrs);
460  attr_str = strtok(attrs_tmp, ",");
461  while (NULL != attr_str)
462  {
463  if (0 != strcasecmp(attr_str, attr->name))
464  {
465  attr_str = strtok(NULL, ",");
466  continue;
467  }
470  attr->type,
471  attr->data,
472  attr->data_size);
473  le->claim->version = attr->version;
474  le->claim->id = attr->id;
476  attr_list->list_tail,
477  le);
478  break;
479  }
480  GNUNET_free(attrs_tmp);
481  }
482  else if (attr_delete && (NULL == attr_to_delete))
483  {
484  label = GNUNET_STRINGS_data_to_string_alloc(&attr->id, sizeof(uint64_t));
485  if (0 == strcasecmp(attr_delete, label))
486  {
487  attr_to_delete = GNUNET_RECLAIM_ATTRIBUTE_claim_new(attr->name,
488  attr->type,
489  attr->data,
490  attr->data_size);
491  attr_to_delete->id = attr->id;
492  }
493  GNUNET_free(label);
494  }
495  else if (list)
496  {
498  attr->data,
499  attr->data_size);
501  id = GNUNET_STRINGS_data_to_string_alloc(&attr->id, sizeof(uint64_t));
502  fprintf(stdout,
503  "Name: %s; Value: %s (%s); Version %u; ID: %s\n",
504  attr->name,
505  attr_str,
506  attr_type,
507  attr->version,
508  id);
509  GNUNET_free(id);
510  }
511  GNUNET_RECLAIM_get_attributes_next(attr_iterator);
512 }
513 
514 static void
516 {
517  if (NULL == pkey)
518  {
519  fprintf(stderr, "Ego %s not found\n", ego_name);
520  cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
521  return;
522  }
523 
524  if (list_tickets)
525  {
526  ticket_iterator = GNUNET_RECLAIM_ticket_iteration_start(reclaim_handle,
527  pkey,
529  NULL,
530  &ticket_iter,
531  NULL,
533  NULL);
534  return;
535  }
536 
537  if ((NULL != rp) &&
538  GNUNET_OK !=
540  {
541  fprintf(stderr, "%s is not a public key!\n", rp);
542  cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup, NULL);
543  return;
544  }
545  if (NULL != consume_ticket)
547  strlen(consume_ticket),
548  &ticket,
549  sizeof(struct GNUNET_RECLAIM_Ticket));
550  if (NULL != revoke_ticket)
552  strlen(revoke_ticket),
553  &ticket,
554  sizeof(struct GNUNET_RECLAIM_Ticket));
555 
557  claim = NULL;
558  attr_iterator = GNUNET_RECLAIM_get_attributes_start(reclaim_handle,
559  pkey,
560  &iter_error,
561  NULL,
562  &iter_cb,
563  NULL,
564  &iter_finished,
565  NULL);
566 }
567 
568 static int init = GNUNET_YES;
569 
570 static void
571 ego_cb(void *cls,
572  struct GNUNET_IDENTITY_Ego *ego,
573  void **ctx,
574  const char *name)
575 {
576  if (NULL == name)
577  {
578  if (GNUNET_YES == init)
579  {
580  init = GNUNET_NO;
581  start_process();
582  }
583  return;
584  }
585  if (0 != strcmp(name, ego_name))
586  return;
588 }
589 
590 
591 static void
592 run(void *cls,
593  char *const *args,
594  const char *cfgfile,
595  const struct GNUNET_CONFIGURATION_Handle *c)
596 {
597  ret = 0;
598  if (NULL == ego_name)
599  {
600  ret = 1;
601  fprintf(stderr, _("Ego is required\n"));
602  return;
603  }
604 
605  if ((NULL == attr_value) && (NULL != attr_name))
606  {
607  ret = 1;
608  fprintf(stderr, _("Attribute value missing!\n"));
609  return;
610  }
611 
612  if ((NULL == rp) && (NULL != issue_attrs))
613  {
614  ret = 1;
615  fprintf(stderr, _("Requesting party key is required!\n"));
616  return;
617  }
618 
619  reclaim_handle = GNUNET_RECLAIM_connect(c);
620  // Get Ego
621  identity_handle = GNUNET_IDENTITY_connect(c, &ego_cb, NULL);
622 }
623 
624 
625 int
626 main(int argc, char *const argv[])
627 {
629  struct GNUNET_GETOPT_CommandLineOption options[] = {
631  "add",
632  "NAME",
633  gettext_noop("Add an attribute NAME"),
634  &attr_name),
636  "delete",
637  "ID",
638  gettext_noop("Delete the attribute with ID"),
639  &attr_delete),
641  "value",
642  "VALUE",
643  gettext_noop("The attribute VALUE"),
644  &attr_value),
646  "ego",
647  "EGO",
648  gettext_noop("The EGO to use"),
649  &ego_name),
651  "rp",
652  "RP",
653  gettext_noop(
654  "Specify the relying party for issue"),
655  &rp),
657  "dump",
658  gettext_noop("List attributes for EGO"),
659  &list),
661  'i',
662  "issue",
663  "A1,A2,...",
664  gettext_noop(
665  "Issue a ticket for a set of attributes separated by comma"),
666  &issue_attrs),
668  "consume",
669  "TICKET",
670  gettext_noop("Consume a ticket"),
671  &consume_ticket),
673  "revoke",
674  "TICKET",
675  gettext_noop("Revoke a ticket"),
676  &revoke_ticket),
678  "type",
679  "TYPE",
680  gettext_noop("Type of attribute"),
681  &type_str),
683  "tickets",
684  gettext_noop("List tickets of ego"),
685  &list_tickets),
687  "expiration",
688  "INTERVAL",
689  gettext_noop(
690  "Expiration interval of the attribute"),
691  &exp_interval),
692 
694  };
695  if (GNUNET_OK != GNUNET_PROGRAM_run(argc,
696  argv,
697  "gnunet-reclaim",
698  _("re:claimID command line tool"),
699  options,
700  &run,
701  NULL))
702  return 1;
703  else
704  return ret;
705 }
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_relative_time(char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_TIME_Relative *val)
Allow user to specify a struct GNUNET_TIME_Relative (using human-readable "fancy" time)...
struct GNUNET_IDENTITY_Handle * GNUNET_IDENTITY_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
Connect to the identity service.
Definition: identity_api.c:525
const char * name
The name of the attribute.
struct GNUNET_RECLAIM_ATTRIBUTE_Claim * claim
The attribute claim.
static char * consume_ticket
Ticket to consume.
char * GNUNET_RECLAIM_ATTRIBUTE_value_to_string(uint32_t type, const void *data, size_t data_size)
Convert the &#39;claim&#39; of an attribute to a string.
Handle to the service.
Definition: reclaim_api.c:232
The authorization ticket.
struct GNUNET_RECLAIM_AttributeIterator * GNUNET_RECLAIM_get_attributes_start(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_RECLAIM_AttributeResult proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
List all attributes for a local identity.
Definition: reclaim_api.c:948
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_TIME_UNIT_HOURS
One hour.
static int init
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static void do_cleanup(void *cls)
struct GNUNET_RECLAIM_Operation * GNUNET_RECLAIM_attribute_store(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr, const struct GNUNET_TIME_Relative *exp_interval, GNUNET_RECLAIM_ContinuationWithStatus cont, void *cont_cls)
Store an attribute.
Definition: reclaim_api.c:844
static void ticket_iter_fin(void *cls)
struct GNUNET_RECLAIM_TicketIterator * GNUNET_RECLAIM_ticket_iteration_start(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_RECLAIM_TicketCallback proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
Lists all tickets that have been issued to remote identites (relying parties)
Definition: reclaim_api.c:1139
static int list_tickets
Ticket listing.
size_t data_size
Number of bytes in data.
static void iter_finished(void *cls)
static void process_attrs(void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry * list_tail
List tail.
static struct GNUNET_SCHEDULER_Task * cleanup_task
Cleanup task.
static char * attr_delete
Claim to delete.
static struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList * attr_list
Attribute list.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_TIME_UNIT_SECONDS
One second.
uint32_t GNUNET_RECLAIM_ATTRIBUTE_typename_to_number(const char *typename)
Convert a type name to the corresponding number.
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:553
void GNUNET_RECLAIM_disconnect(struct GNUNET_RECLAIM_Handle *h)
Disconnect from identity provider service.
Definition: reclaim_api.c:814
void GNUNET_RECLAIM_cancel(struct GNUNET_RECLAIM_Operation *op)
Cancel an identity provider operation.
Definition: reclaim_api.c:799
void GNUNET_RECLAIM_ticket_iteration_next(struct GNUNET_RECLAIM_TicketIterator *it)
Calls the ticket processor specified in GNUNET_RECLAIM_ticket_iteration_start for the next record...
Definition: reclaim_api.c:1183
#define GNUNET_NO
Definition: gnunet_common.h:78
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
void GNUNET_RECLAIM_ticket_iteration_stop(struct GNUNET_RECLAIM_TicketIterator *it)
Stops iteration and releases the handle for further calls.
Definition: reclaim_api.c:1203
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static void start_process()
int GNUNET_RECLAIM_ATTRIBUTE_string_to_value(uint32_t type, const char *s, void **data, size_t *data_size)
Convert human-readable version of a &#39;claim&#39; of an attribute to the binary representation.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition of a command line option.
Private ECC key encoded for transmission.
void GNUNET_RECLAIM_get_attributes_next(struct GNUNET_RECLAIM_AttributeIterator *it)
Calls the record processor specified in GNUNET_RECLAIM_get_attributes_start for the next record...
Definition: reclaim_api.c:994
static struct GNUNET_TIME_Relative exp_interval
Attribute expiration interval.
static struct GNUNET_RECLAIM_Handle * reclaim_handle
reclaim handle
Handle for an operation with the service.
Definition: reclaim_api.c:41
static struct GNUNET_RECLAIM_AttributeIterator * attr_iterator
Attribute iterator.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
static struct GNUNET_RECLAIM_TicketIterator * ticket_iterator
Ticket iterator.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
const void * data
Binary value stored as attribute value.
static char * ego_name
Ego name.
static struct GNUNET_RECLAIM_Ticket ticket
Ticket to consume.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1237
Handle for an ego.
Definition: identity.h:237
static void ticket_issue_cb(void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
struct GNUNET_RECLAIM_Operation * GNUNET_RECLAIM_ticket_revoke(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, const struct GNUNET_RECLAIM_Ticket *ticket, GNUNET_RECLAIM_ContinuationWithStatus cb, void *cb_cls)
Revoked an issued ticket.
Definition: reclaim_api.c:1234
Handle for a attribute iterator operation.
Definition: reclaim_api.c:165
static char * attr_value
Attribute value.
const char * GNUNET_RECLAIM_ATTRIBUTE_number_to_typename(uint32_t type)
Convert a type number to the corresponding type string.
struct GNUNET_RECLAIM_Operation * GNUNET_RECLAIM_attribute_delete(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr, GNUNET_RECLAIM_ContinuationWithStatus cont, void *cont_cls)
Delete an attribute.
Definition: reclaim_api.c:891
static char * attr_name
The attribute.
#define GNUNET_RECLAIM_ATTRIBUTE_TYPE_STRING
String attribute.
Handle for the service.
Definition: identity_api.c:94
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:1264
struct GNUNET_RECLAIM_Operation * GNUNET_RECLAIM_ticket_issue(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *iss, const struct GNUNET_CRYPTO_EcdsaPublicKey *rp, const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs, GNUNET_RECLAIM_TicketCallback cb, void *cb_cls)
Issues a ticket to a relying party.
Definition: reclaim_api.c:1046
static struct GNUNET_SCHEDULER_Task * timeout
Timeout task.
static struct GNUNET_IDENTITY_Handle * identity_handle
Identity handle.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:440
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:835
static char * issue_attrs
Attributes to issue.
static struct GNUNET_CRYPTO_EcdsaPublicKey rp_key
rp public key
static void iter_error(void *cls)
static void ticket_iter(void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
uint64_t rnd
The ticket random (NBO)
const char * name
static char * type_str
Attribute type.
static void ticket_iter_err(void *cls)
static void process_delete(void *cls, int success, const char *msg)
static void iter_cb(void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
static const struct GNUNET_CRYPTO_EcdsaPrivateKey * pkey
ego private key
int GNUNET_CRYPTO_ecdsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:468
static struct GNUNET_RECLAIM_Operation * reclaim_op
reclaim operation
configuration data
Definition: configuration.c:83
void GNUNET_RECLAIM_get_attributes_stop(struct GNUNET_RECLAIM_AttributeIterator *it)
Stops iteration and releases the handle for further calls.
Definition: reclaim_api.c:1015
static void ego_cb(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
struct GNUNET_RECLAIM_ATTRIBUTE_Claim * GNUNET_RECLAIM_ATTRIBUTE_claim_new(const char *attr_name, uint32_t type, const void *data, size_t data_size)
Create a new attribute claim.
struct GNUNET_CRYPTO_EcdsaPublicKey audience
The ticket audience (= relying party)
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
static void process_rvk(void *cls, int success, const char *msg)
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
A list of GNUNET_RECLAIM_ATTRIBUTE_Claim structures.
Handle for a ticket iterator operation.
Definition: reclaim_api.c:103
Entry in list of pending tasks.
Definition: scheduler.c:131
static char * rp
Relying party.
int GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).
Definition: program.c:367
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
static struct GNUNET_CRYPTO_AbeMasterKey * abe_key
Master ABE key.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
struct GNUNET_RECLAIM_Operation * GNUNET_RECLAIM_ticket_consume(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, const struct GNUNET_RECLAIM_Ticket *ticket, GNUNET_RECLAIM_AttributeResult cb, void *cb_cls)
Consumes an issued ticket.
Definition: reclaim_api.c:1095
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_RECLAIM_ATTRIBUTE_Claim * claim
Claim to store.
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:921
static int list
List attribute flag.
static char * revoke_ticket
Ticket to revoke.
int main(int argc, char *const argv[])
static int ret
return value
struct GNUNET_RECLAIM_Handle * GNUNET_RECLAIM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the re:claimID service.
Definition: reclaim_api.c:774
uint32_t data
The data value.
static size_t data_size
Number of bytes in data.
static struct GNUNET_RECLAIM_ATTRIBUTE_Claim * attr_to_delete
Claim object to delete.
struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry * list_head
List head.
static void timeout_task(void *cls)
int GNUNET_STRINGS_string_to_data(const char *enc, size_t enclen, void *out, size_t out_size)
Convert CrockfordBase32 encoding back to data.
Definition: strings.c:953
static void store_attr_cont(void *cls, int32_t success, const char *emsg)
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
#define gettext_noop(String)
Definition: gettext.h:69
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956