GNUnet  0.20.0
gnunet-service-reclaim_tickets.c File Reference

reclaim tickets More...

#include "platform.h"
#include <inttypes.h>
#include "gnunet-service-reclaim_tickets.h"
Include dependency graph for gnunet-service-reclaim_tickets.c:

Go to the source code of this file.

Data Structures

struct  TicketReference
 A reference to a ticket stored in GNS. More...
 
struct  RECLAIM_TICKETS_ConsumeHandle
 Handle to a consume operation. More...
 
struct  ParallelLookup
 Handle for a parallel GNS lookup job. More...
 
struct  TicketIssueHandle
 Ticket issue request handle. More...
 
struct  RECLAIM_TICKETS_Iterator
 Ticket iterator. More...
 
struct  RevokedAttributeEntry
 
struct  RECLAIM_TICKETS_RevokeHandle
 Ticket revocation request handle. More...
 

Macros

#define DEFAULT_TICKET_REFRESH_INTERVAL   GNUNET_TIME_UNIT_HOURS
 FIXME: the default ticket iteration interval should probably be the minimim attribute expiration. More...
 

Functions

static void cleanup_rvk (struct RECLAIM_TICKETS_RevokeHandle *rh)
 Cleanup revoke handle. More...
 
static void process_tickets (void *cls)
 For each ticket, store new, updated attribute references (Implementation further below) More...
 
static void ticket_processed (void *cls, enum GNUNET_ErrorCode ec)
 Finished storing updated attribute references. More...
 
static void rvk_ticket_update_finished (void *cls)
 Done collecting tickets. More...
 
static void rvk_ticket_update (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 We need to update all other tickets with the new attribute IDs. More...
 
static void rvk_ns_iter_err (void *cls)
 Error iterating namestore. More...
 
static void rvk_ns_err (void *cls)
 Error storing new attribute in namestore. More...
 
static void move_attrs (struct RECLAIM_TICKETS_RevokeHandle *rh)
 We change every attribute ID of the ticket attributes we want to revoke. More...
 
static void move_attrs_cont (void *cls)
 Delayed continuation for move_attrs. More...
 
static void del_attr_finished (void *cls, enum GNUNET_ErrorCode ec)
 Done deleting the old record. More...
 
static void move_attr_finished (void *cls, enum GNUNET_ErrorCode ec)
 Updated an attribute ID. More...
 
static void rvk_move_attr_cb (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 Got the referenced attribute. More...
 
static void remove_ticket_cont (void *cls, enum GNUNET_ErrorCode ec)
 Finished deleting ticket and attribute references. More...
 
static void revoke_attrs_cb (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 We found the attribute references. More...
 
static void rvk_attrs_err_cb (void *cls)
 Failed to query namestore. More...
 
struct RECLAIM_TICKETS_RevokeHandleRECLAIM_TICKETS_revoke (const struct GNUNET_RECLAIM_Ticket *ticket, const struct GNUNET_IDENTITY_PrivateKey *identity, RECLAIM_TICKETS_RevokeCallback cb, void *cb_cls)
 Revoke a ticket. More...
 
void RECLAIM_TICKETS_revoke_cancel (struct RECLAIM_TICKETS_RevokeHandle *rh)
 Cancel a revocation. More...
 
static void cleanup_cth (struct RECLAIM_TICKETS_ConsumeHandle *cth)
 Cleanup ticket consume handle. More...
 
static void process_parallel_lookup_result (void *cls, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 We found an attribute record. More...
 
static void abort_parallel_lookups (void *cls)
 Cancel the lookups for attribute records. More...
 
static void lookup_authz_cb (void *cls, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 GNS result with attribute references. More...
 
struct RECLAIM_TICKETS_ConsumeHandleRECLAIM_TICKETS_consume (const struct GNUNET_IDENTITY_PrivateKey *id, const struct GNUNET_RECLAIM_Ticket *ticket, RECLAIM_TICKETS_ConsumeCallback cb, void *cb_cls)
 Consume a ticket. More...
 
void RECLAIM_TICKETS_consume_cancel (struct RECLAIM_TICKETS_ConsumeHandle *cth)
 Cancel a consume operation. More...
 
static void cleanup_issue_handle (struct TicketIssueHandle *handle)
 Cleanup ticket consume handle. More...
 
static void store_ticket_issue_cont (void *cls, enum GNUNET_ErrorCode ec)
 Store finished, abort on error. More...
 
static void issue_ticket (struct TicketIssueHandle *ih)
 Issue a new ticket. More...
 
static void filter_tickets_error_cb (void *cls)
 Namestore error on issue. More...
 
static void filter_tickets_cb (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 Iterator over records. More...
 
static void filter_tickets_finished_cb (void *cls)
 Done iterating over tickets and we apparently did not find an existing, matching ticket. More...
 
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. More...
 
static void cleanup_iter (struct RECLAIM_TICKETS_Iterator *iter)
 Cleanup ticket iterator. More...
 
static void collect_tickets_cb (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 Return each record of type GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET to the caller and proceed with the iteration. More...
 
static void collect_tickets_finished_cb (void *cls)
 Signal ticket iteration has finished. More...
 
static void collect_tickets_error_cb (void *cls)
 Cancel ticket iteration on namestore error. More...
 
void RECLAIM_TICKETS_iteration_next (struct RECLAIM_TICKETS_Iterator *iter)
 Continue ticket iteration. More...
 
void RECLAIM_TICKETS_iteration_stop (struct RECLAIM_TICKETS_Iterator *iter)
 Stop a running ticket iteration. More...
 
struct RECLAIM_TICKETS_IteratorRECLAIM_TICKETS_iteration_start (const struct GNUNET_IDENTITY_PrivateKey *identity, RECLAIM_TICKETS_TicketIter cb, void *cb_cls)
 Iterate over all tickets issued by an identity. More...
 
int RECLAIM_TICKETS_init (const struct GNUNET_CONFIGURATION_Handle *c)
 Initialize tickets component. More...
 
void RECLAIM_TICKETS_deinit (void)
 Close handles and clean up. More...
 

Variables

static struct GNUNET_TIME_Relative ticket_refresh_interval
 Ticket expiration interval. More...
 
static struct GNUNET_NAMESTORE_Handlensh
 
static struct GNUNET_GNS_Handlegns
 
static struct GNUNET_STATISTICS_Handlestats
 

Detailed Description

reclaim tickets

Author
Martin Schanzenbach

Definition in file gnunet-service-reclaim_tickets.c.

Macro Definition Documentation

◆ DEFAULT_TICKET_REFRESH_INTERVAL

#define DEFAULT_TICKET_REFRESH_INTERVAL   GNUNET_TIME_UNIT_HOURS

FIXME: the default ticket iteration interval should probably be the minimim attribute expiration.

Definition at line 36 of file gnunet-service-reclaim_tickets.c.

Function Documentation

◆ cleanup_rvk()

static void cleanup_rvk ( struct RECLAIM_TICKETS_RevokeHandle rh)
static

Cleanup revoke handle.

Parameters
rhthe ticket revocation handle

Definition at line 350 of file gnunet-service-reclaim_tickets.c.

351 {
352  struct RevokedAttributeEntry *ae;
353  struct TicketRecordsEntry *le;
354 
355  if (NULL != rh->ns_qe)
357  if (NULL != rh->ns_it)
359  while (NULL != (ae = rh->attrs_head))
360  {
362  GNUNET_free (ae);
363  }
364  while (NULL != (le = rh->tickets_to_update_head))
365  {
368  le);
369  if (NULL != le->data)
370  GNUNET_free (le->data);
371  if (NULL != le->label)
372  GNUNET_free (le->label);
373  GNUNET_free (le);
374  }
375  GNUNET_free (rh);
376 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_NAMESTORE_cancel(struct GNUNET_NAMESTORE_QueueEntry *qe)
Cancel a namestore operation.
void GNUNET_NAMESTORE_zone_iteration_stop(struct GNUNET_NAMESTORE_ZoneIterator *it)
Stops iteration and releases the namestore handle for further calls.
struct TicketRecordsEntry * tickets_to_update_head
Tickets to update.
struct RevokedAttributeEntry * attrs_tail
Revoked attributes.
struct GNUNET_NAMESTORE_ZoneIterator * ns_it
Namestore iterator.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
QueueEntry.
struct RevokedAttributeEntry * attrs_head
Revoked attributes.

References RECLAIM_TICKETS_RevokeHandle::attrs_head, RECLAIM_TICKETS_RevokeHandle::attrs_tail, TicketRecordsEntry::data, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_zone_iteration_stop(), TicketRecordsEntry::label, RECLAIM_TICKETS_RevokeHandle::ns_it, RECLAIM_TICKETS_RevokeHandle::ns_qe, and RECLAIM_TICKETS_RevokeHandle::tickets_to_update_head.

Referenced by del_attr_finished(), move_attr_finished(), process_tickets(), RECLAIM_TICKETS_revoke_cancel(), remove_ticket_cont(), rvk_attrs_err_cb(), rvk_ns_err(), and rvk_ns_iter_err().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_tickets()

static void process_tickets ( void *  cls)
static

For each ticket, store new, updated attribute references (Implementation further below)

For each ticket, store new, updated attribute references.

Parameters
clshandle to the operation

Definition at line 413 of file gnunet-service-reclaim_tickets.c.

414 {
415  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
416  struct TicketRecordsEntry *le;
417  struct RevokedAttributeEntry *ae;
418 
419  if (NULL == rvk->tickets_to_update_head)
420  {
422  "Finished updatding tickets, success\n");
423  rvk->cb (rvk->cb_cls, GNUNET_OK);
424  cleanup_rvk (rvk);
425  return;
426  }
427  le = rvk->tickets_to_update_head;
430  le);
431  struct GNUNET_GNSRECORD_Data rd[le->rd_count];
433  le->data,
434  le->rd_count,
435  rd))
436  {
438  "Unable to deserialize ticket record(s)\n");
439  rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
440  cleanup_rvk (rvk);
441  return;
442  }
443  for (int i = 0; i < le->rd_count; i++)
444  {
446  continue;
447  for (ae = rvk->attrs_head; NULL != ae; ae = ae->next)
448  {
449  if (0 != memcmp (rd[i].data, &ae->old_id, sizeof(ae->old_id)))
450  continue;
451  rd[i].data = &ae->new_id;
452  }
453  }
455  &rvk->identity,
456  le->label,
457  le->rd_count,
458  rd,
460  rvk);
461  GNUNET_free (le->label);
462  GNUNET_free (le->data);
463  GNUNET_free (le);
464 }
#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF
for reclaim records
uint32_t data
The data value.
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 void cleanup_rvk(struct RECLAIM_TICKETS_RevokeHandle *rh)
Cleanup revoke handle.
static struct GNUNET_NAMESTORE_Handle * nsh
static void ticket_processed(void *cls, enum GNUNET_ErrorCode ec)
Finished storing updated attribute references.
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.
#define GNUNET_log(kind,...)
@ GNUNET_OK
@ GNUNET_SYSERR
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
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.
uint32_t record_type
Type of the GNS/DNS record.
const void * data
Binary value stored in the DNS record.
Ticket revocation request handle.
struct TicketRecordsEntry * tickets_to_update_tail
Tickets to update.
struct GNUNET_IDENTITY_PrivateKey identity
Issuer Key.
RECLAIM_TICKETS_RevokeCallback cb
Callback.
struct GNUNET_RECLAIM_Identifier old_id
Old ID of the attribute.
struct RevokedAttributeEntry * next
DLL.
struct GNUNET_RECLAIM_Identifier new_id
New ID of the attribute.
unsigned int rd_count
Record count.

References RECLAIM_TICKETS_RevokeHandle::attrs_head, RECLAIM_TICKETS_RevokeHandle::cb, RECLAIM_TICKETS_RevokeHandle::cb_cls, cleanup_rvk(), GNUNET_GNSRECORD_Data::data, TicketRecordsEntry::data, data, TicketRecordsEntry::data_size, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNSRECORD_records_deserialize(), GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF, GNUNET_log, GNUNET_NAMESTORE_records_store(), GNUNET_OK, GNUNET_SYSERR, RECLAIM_TICKETS_RevokeHandle::identity, TicketRecordsEntry::label, RevokedAttributeEntry::new_id, RevokedAttributeEntry::next, RECLAIM_TICKETS_RevokeHandle::ns_qe, nsh, RevokedAttributeEntry::old_id, rd, rd_count, TicketRecordsEntry::rd_count, GNUNET_GNSRECORD_Data::record_type, ticket_processed(), RECLAIM_TICKETS_RevokeHandle::tickets_to_update_head, and RECLAIM_TICKETS_RevokeHandle::tickets_to_update_tail.

Referenced by rvk_ticket_update_finished(), and ticket_processed().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ticket_processed()

static void ticket_processed ( void *  cls,
enum GNUNET_ErrorCode  ec 
)
static

Finished storing updated attribute references.

Abort on error, else continue processing tickets

Parameters
clshandle to the operation
successresult of namestore operation
emsg(NULL on success)

Definition at line 398 of file gnunet-service-reclaim_tickets.c.

399 {
400  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
401 
402  rvk->ns_qe = NULL;
404 }
static void process_tickets(void *cls)
For each ticket, store new, updated attribute references (Implementation further below)
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

References GNUNET_SCHEDULER_add_now(), RECLAIM_TICKETS_RevokeHandle::ns_qe, and process_tickets().

Referenced by process_tickets().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ rvk_ticket_update_finished()

static void rvk_ticket_update_finished ( void *  cls)
static

Done collecting tickets.

Start processing.

Parameters
clshandle to the operation

Definition at line 473 of file gnunet-service-reclaim_tickets.c.

474 {
475  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
476 
477  rvk->ns_it = NULL;
479 }

References GNUNET_SCHEDULER_add_now(), RECLAIM_TICKETS_RevokeHandle::ns_it, and process_tickets().

Referenced by move_attrs().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ rvk_ticket_update()

static void rvk_ticket_update ( void *  cls,
const struct GNUNET_IDENTITY_PrivateKey zone,
const char *  label,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

We need to update all other tickets with the new attribute IDs.

We first collect them all. Processing after.

Parameters
clshandle to the operation
zoneticket issuer private key
labelticket rnd
rd_countsize of record set
rdrecord set

Let everything point to the old record

Definition at line 493 of file gnunet-service-reclaim_tickets.c.

498 {
499  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
500  struct TicketRecordsEntry *le;
501  struct RevokedAttributeEntry *ae;
502  int has_changed = GNUNET_NO;
503 
505  for (int i = 0; i < rd_count; i++)
506  {
507  if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF != rd[i].record_type)
508  continue;
509  for (ae = rvk->attrs_head; NULL != ae; ae = ae->next)
510  {
511  if (0 != memcmp (rd[i].data, &ae->old_id, sizeof(ae->old_id)))
512  continue;
513  has_changed = GNUNET_YES;
514  break;
515  }
516  if (GNUNET_YES == has_changed)
517  break;
518  }
519  if (GNUNET_YES == has_changed)
520  {
521  le = GNUNET_new (struct TicketRecordsEntry);
523  le->data = GNUNET_malloc (le->data_size);
524  le->rd_count = rd_count;
525  le->label = GNUNET_strdup (label);
529  le);
530  }
532 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
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.
@ GNUNET_YES
@ GNUNET_NO
#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.
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.

References RECLAIM_TICKETS_RevokeHandle::attrs_head, TicketRecordsEntry::data, data, TicketRecordsEntry::data_size, GNUNET_CONTAINER_DLL_insert, GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF, GNUNET_malloc, GNUNET_NAMESTORE_zone_iterator_next(), GNUNET_new, GNUNET_NO, GNUNET_strdup, GNUNET_YES, TicketRecordsEntry::label, RevokedAttributeEntry::next, RECLAIM_TICKETS_RevokeHandle::ns_it, RevokedAttributeEntry::old_id, rd, rd_count, TicketRecordsEntry::rd_count, RECLAIM_TICKETS_RevokeHandle::tickets_to_update_head, and RECLAIM_TICKETS_RevokeHandle::tickets_to_update_tail.

Referenced by move_attrs().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ rvk_ns_iter_err()

static void rvk_ns_iter_err ( void *  cls)
static

Error iterating namestore.

Abort.

Parameters
clshandle to the operation

Definition at line 541 of file gnunet-service-reclaim_tickets.c.

542 {
543  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
544 
545  rvk->ns_it = NULL;
546  rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
547  cleanup_rvk (rvk);
548 }

References RECLAIM_TICKETS_RevokeHandle::cb, RECLAIM_TICKETS_RevokeHandle::cb_cls, cleanup_rvk(), GNUNET_SYSERR, and RECLAIM_TICKETS_RevokeHandle::ns_it.

Referenced by move_attrs().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ rvk_ns_err()

static void rvk_ns_err ( void *  cls)
static

Error storing new attribute in namestore.

Abort

Parameters
clshandle to the operation

Definition at line 557 of file gnunet-service-reclaim_tickets.c.

558 {
559  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
560 
561  rvk->ns_qe = NULL;
562  rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
563  cleanup_rvk (rvk);
564 }

References RECLAIM_TICKETS_RevokeHandle::cb, RECLAIM_TICKETS_RevokeHandle::cb_cls, cleanup_rvk(), GNUNET_SYSERR, and RECLAIM_TICKETS_RevokeHandle::ns_qe.

Referenced by move_attrs().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ move_attrs()

static void move_attrs ( struct RECLAIM_TICKETS_RevokeHandle rh)
static

We change every attribute ID of the ticket attributes we want to revoke.

When we are done, we need to update any other ticket which included references to any of the changed attributes.

Parameters
rhhandle to the operation

Definition at line 764 of file gnunet-service-reclaim_tickets.c.

765 {
766  char *label;
767 
768  if (NULL == rvk->move_attr)
769  {
770  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished moving attributes\n");
771  rvk->ns_it =
773  &rvk->identity,
775  rvk,
777  rvk,
779  rvk);
780  return;
781  }
782  label = GNUNET_STRINGS_data_to_string_alloc (&rvk->move_attr->old_id,
783  sizeof (rvk->move_attr->old_id));
784  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Moving claim %s\n", label);
785 
786  rvk->ns_qe = GNUNET_NAMESTORE_records_lookup (nsh,
787  &rvk->identity,
788  label,
789  &rvk_ns_err,
790  rvk,
792  rvk);
793  GNUNET_free (label);
794 }
static void rvk_ticket_update(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
We need to update all other tickets with the new attribute IDs.
static void rvk_ticket_update_finished(void *cls)
Done collecting tickets.
static void rvk_ns_err(void *cls)
Error storing new attribute in namestore.
static void rvk_ns_iter_err(void *cls)
Error iterating namestore.
static void rvk_move_attr_cb(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Got the referenced attribute.
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.
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

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NAMESTORE_records_lookup(), GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_STRINGS_data_to_string_alloc(), RECLAIM_TICKETS_RevokeHandle::identity, RECLAIM_TICKETS_RevokeHandle::move_attr, RECLAIM_TICKETS_RevokeHandle::ns_it, RECLAIM_TICKETS_RevokeHandle::ns_qe, nsh, RevokedAttributeEntry::old_id, rvk_move_attr_cb(), rvk_ns_err(), rvk_ns_iter_err(), rvk_ticket_update(), and rvk_ticket_update_finished().

Referenced by move_attrs_cont(), and remove_ticket_cont().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ move_attrs_cont()

static void move_attrs_cont ( void *  cls)
static

Delayed continuation for move_attrs.

Parameters
clshandle to the operation.

Definition at line 585 of file gnunet-service-reclaim_tickets.c.

586 {
587  move_attrs ((struct RECLAIM_TICKETS_RevokeHandle *) cls);
588 }
static void move_attrs(struct RECLAIM_TICKETS_RevokeHandle *rh)
We change every attribute ID of the ticket attributes we want to revoke.

References move_attrs().

Referenced by del_attr_finished(), and rvk_move_attr_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ del_attr_finished()

static void del_attr_finished ( void *  cls,
enum GNUNET_ErrorCode  ec 
)
static

Done deleting the old record.

Abort on error. Else, continue updating attribute IDs.

Parameters
clshandle to the operation
successresult of the namestore operation
emsgerror message (NULL on success)

Definition at line 600 of file gnunet-service-reclaim_tickets.c.

601 {
602  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
603 
604  rvk->ns_qe = NULL;
605  if (GNUNET_EC_NONE != ec)
606  {
608  "Error removing attribute: %s\n",
610  rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
611  cleanup_rvk (rvk);
612  return;
613  }
614  rvk->move_attr = rvk->move_attr->next;
616 }
const char * GNUNET_ErrorCode_get_hint(enum GNUNET_ErrorCode ec)
Returns a hint for a given error code.
@ GNUNET_EC_NONE
No error (success).
static void move_attrs_cont(void *cls)
Delayed continuation for move_attrs.
struct RevokedAttributeEntry * move_attr
Current attribute to move.

References RECLAIM_TICKETS_RevokeHandle::cb, RECLAIM_TICKETS_RevokeHandle::cb_cls, cleanup_rvk(), GNUNET_EC_NONE, GNUNET_ERROR_TYPE_ERROR, GNUNET_ErrorCode_get_hint(), GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SYSERR, RECLAIM_TICKETS_RevokeHandle::move_attr, move_attrs_cont(), RevokedAttributeEntry::next, and RECLAIM_TICKETS_RevokeHandle::ns_qe.

Referenced by move_attr_finished().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ move_attr_finished()

static void move_attr_finished ( void *  cls,
enum GNUNET_ErrorCode  ec 
)
static

Updated an attribute ID.

Abort on error if namestore operation failed. Else, we have to delete the old record.

Parameters
clshandle to the operation
successresult of the store operation
emsgerror message (NULL on success)

Definition at line 629 of file gnunet-service-reclaim_tickets.c.

630 {
631  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
632  char *label;
633 
634  rvk->ns_qe = NULL;
635  if (GNUNET_EC_NONE != ec)
636  {
638  "Error moving attribute: %s\n",
640  rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
641  cleanup_rvk (rvk);
642  return;
643  }
645  sizeof(rvk->move_attr->old_id));
646  GNUNET_assert (NULL != label);
647  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Removing attribute %s\n", label);
649  &rvk->identity,
650  label,
651  0,
652  NULL,
654  rvk);
655  GNUNET_free (label);
656 }
static void del_attr_finished(void *cls, enum GNUNET_ErrorCode ec)
Done deleting the old record.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.

References RECLAIM_TICKETS_RevokeHandle::cb, RECLAIM_TICKETS_RevokeHandle::cb_cls, cleanup_rvk(), del_attr_finished(), GNUNET_assert, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ErrorCode_get_hint(), GNUNET_free, GNUNET_log, GNUNET_NAMESTORE_records_store(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_SYSERR, RECLAIM_TICKETS_RevokeHandle::identity, RECLAIM_TICKETS_RevokeHandle::move_attr, RECLAIM_TICKETS_RevokeHandle::ns_qe, nsh, and RevokedAttributeEntry::old_id.

Referenced by rvk_move_attr_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ rvk_move_attr_cb()

static void rvk_move_attr_cb ( void *  cls,
const struct GNUNET_IDENTITY_PrivateKey zone,
const char *  label,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

Got the referenced attribute.

Updating the ID

Parameters
clshandle to the operation
zoneissuer identity
labelattribute ID
rd_countsize of record set (should be 1)
rdrecord set (the attribute)

find a new place for this attribute

Definition at line 669 of file gnunet-service-reclaim_tickets.c.

674 {
675  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
676  struct GNUNET_GNSRECORD_Data new_rd[rd_count];
677  struct RevokedAttributeEntry *le;
678  char *new_label;
679  char *attr_data;
680 
681  rvk->ns_qe = NULL;
682  if (0 == rd_count)
683  {
685  "The claim %s no longer exists!\n",
686  label);
687  le = rvk->move_attr;
688  rvk->move_attr = le->next;
690  GNUNET_free (le);
692  return;
693  }
695  new_label =
697  sizeof (rvk->move_attr->new_id));
698 
699  attr_data = NULL;
700  // new_rd = *rd;
701  for (int i = 0; i < rd_count; i++)
702  {
703  if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE == rd[i].record_type)
704  {
708  rd[i].data_size,
709  &claim);
711  "Attribute to update: Name=%s\n",
712  claim->name);
713  claim->id = rvk->move_attr->new_id;
714  new_rd[i].data_size = GNUNET_RECLAIM_attribute_serialize_get_size (claim);
715  attr_data = GNUNET_malloc (rd[i].data_size);
716  new_rd[i].data_size = GNUNET_RECLAIM_attribute_serialize (claim,
717  attr_data);
718  new_rd[i].data = attr_data;
719  new_rd[i].record_type = rd[i].record_type;
720  new_rd[i].flags = rd[i].flags;
721  new_rd[i].expiration_time = rd[i].expiration_time;
722  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute %s\n", new_label);
723  GNUNET_free (claim);
724  }
725  else if (GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL == rd[i].record_type)
726  {
729  rd[i].data_size);
731  "Credential to update: Name=%s\n",
732  credential->name);
733  credential->id = rvk->move_attr->new_id;
734  new_rd[i].data_size =
736  attr_data = GNUNET_malloc (rd[i].data_size);
737  new_rd[i].data_size = GNUNET_RECLAIM_credential_serialize (credential,
738  attr_data);
739  new_rd[i].data = attr_data;
740  new_rd[i].record_type = rd[i].record_type;
741  new_rd[i].flags = rd[i].flags;
742  new_rd[i].expiration_time = rd[i].expiration_time;
743  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding credential %s\n",
744  new_label);
746  }
747  else {
748  memcpy (&new_rd[i], &rd[i], sizeof (struct GNUNET_GNSRECORD_Data));
749  }
750  }
752  &rvk->identity,
753  new_label,
754  rd_count,
755  new_rd,
757  rvk);
758  GNUNET_free (new_label);
759  GNUNET_free (attr_data);
760 }
#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE
identity attribute
#define GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL
Record type for an attribute attestation (e.g.
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
struct GNUNET_RECLAIM_Attribute * claim
Claim to store.
static struct GNUNET_RECLAIM_Identifier credential
Credential ID.
static void move_attr_finished(void *cls, enum GNUNET_ErrorCode ec)
Updated an attribute ID.
@ GNUNET_ERROR_TYPE_WARNING
struct GNUNET_RECLAIM_Credential * GNUNET_RECLAIM_credential_deserialize(const char *data, size_t data_size)
Deserialize an credential.
#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.
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_credential_serialize(const struct GNUNET_RECLAIM_Credential *credential, char *result)
Serialize an credential.
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_GNSRECORD_Flags flags
Flags for the record.
uint64_t expiration_time
Expiration time for the DNS record.
const char * name
The name of the attribute.
struct GNUNET_RECLAIM_Identifier id
ID.

References RECLAIM_TICKETS_RevokeHandle::attrs_head, RECLAIM_TICKETS_RevokeHandle::attrs_tail, claim, credential, GNUNET_GNSRECORD_Data::data, data, data_size, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE, GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL, GNUNET_log, GNUNET_malloc, GNUNET_NAMESTORE_records_store(), GNUNET_RECLAIM_attribute_deserialize(), GNUNET_RECLAIM_attribute_serialize(), GNUNET_RECLAIM_attribute_serialize_get_size(), GNUNET_RECLAIM_credential_deserialize(), GNUNET_RECLAIM_credential_serialize(), GNUNET_RECLAIM_credential_serialize_get_size(), GNUNET_RECLAIM_id_generate, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_RECLAIM_Attribute::id, GNUNET_RECLAIM_Identifier::id, RECLAIM_TICKETS_RevokeHandle::identity, RECLAIM_TICKETS_RevokeHandle::move_attr, move_attr_finished(), move_attrs_cont(), GNUNET_RECLAIM_Attribute::name, RevokedAttributeEntry::new_id, RevokedAttributeEntry::next, RECLAIM_TICKETS_RevokeHandle::ns_qe, nsh, rd, rd_count, and GNUNET_GNSRECORD_Data::record_type.

Referenced by move_attrs().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ remove_ticket_cont()

static void remove_ticket_cont ( void *  cls,
enum GNUNET_ErrorCode  ec 
)
static

Finished deleting ticket and attribute references.

Abort on failure. Else, we start changing every attribute ID in the found attribute references so that access is no longer possible.

Parameters
clshandle to the operation
successNamestore operation return value
emsgerror message (NULL on success)

Definition at line 809 of file gnunet-service-reclaim_tickets.c.

810 {
811  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
812 
813  rvk->ns_qe = NULL;
814  if (GNUNET_EC_NONE != ec)
815  {
818  rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
819  cleanup_rvk (rvk);
820  return;
821  }
822  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleted ticket\n");
823  if (0 == rvk->ticket_attrs)
824  {
826  "No attributes to move... strange\n");
827  rvk->cb (rvk->cb_cls, GNUNET_OK);
828  cleanup_rvk (rvk);
829  return;
830  }
831  rvk->move_attr = rvk->attrs_head;
832  move_attrs (rvk);
833 }
unsigned int ticket_attrs
Number of attributes in ticket.

References RECLAIM_TICKETS_RevokeHandle::attrs_head, RECLAIM_TICKETS_RevokeHandle::cb, RECLAIM_TICKETS_RevokeHandle::cb_cls, cleanup_rvk(), GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_ErrorCode_get_hint(), GNUNET_log, GNUNET_OK, GNUNET_SYSERR, RECLAIM_TICKETS_RevokeHandle::move_attr, move_attrs(), RECLAIM_TICKETS_RevokeHandle::ns_qe, and RECLAIM_TICKETS_RevokeHandle::ticket_attrs.

Referenced by revoke_attrs_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ revoke_attrs_cb()

static void revoke_attrs_cb ( void *  cls,
const struct GNUNET_IDENTITY_PrivateKey zone,
const char *  label,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

We found the attribute references.

Store them for later and remove the record set.

Parameters
clshandle to the operation
zonethe issuer key
labelticket rnd
rd_countsize of record set
rdrecord set

Temporarily store attribute references. We need it later.

Remove attribute references

Definition at line 847 of file gnunet-service-reclaim_tickets.c.

853 {
854  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
855  struct RevokedAttributeEntry *le;
856 
857  rvk->ns_qe = NULL;
862  for (int i = 0; i < rd_count; i++)
863  {
864  if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF != rd[i].record_type)
865  continue;
866  le = GNUNET_new (struct RevokedAttributeEntry);
867  le->old_id = *((struct GNUNET_RECLAIM_Identifier *) rd[i].data);
869  rvk->ticket_attrs++;
870  }
871 
874  &rvk->identity,
875  label,
876  0,
877  NULL,
879  rvk);
880 }
static void remove_ticket_cont(void *cls, enum GNUNET_ErrorCode ec)
Finished deleting ticket and attribute references.
A reclaim identifier FIXME maybe put this in a different namespace.

References RECLAIM_TICKETS_RevokeHandle::attrs_head, RECLAIM_TICKETS_RevokeHandle::attrs_tail, data, GNUNET_CONTAINER_DLL_insert, GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF, GNUNET_NAMESTORE_records_store(), GNUNET_new, RECLAIM_TICKETS_RevokeHandle::identity, RECLAIM_TICKETS_RevokeHandle::ns_qe, nsh, RevokedAttributeEntry::old_id, rd, rd_count, remove_ticket_cont(), and RECLAIM_TICKETS_RevokeHandle::ticket_attrs.

Referenced by RECLAIM_TICKETS_revoke().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ rvk_attrs_err_cb()

static void rvk_attrs_err_cb ( void *  cls)
static

Failed to query namestore.

Abort operation

Parameters
clshandle to the operation

Definition at line 889 of file gnunet-service-reclaim_tickets.c.

890 {
891  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
892 
893  rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
894  cleanup_rvk (rvk);
895 }

References RECLAIM_TICKETS_RevokeHandle::cb, RECLAIM_TICKETS_RevokeHandle::cb_cls, cleanup_rvk(), and GNUNET_SYSERR.

Referenced by RECLAIM_TICKETS_revoke().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ RECLAIM_TICKETS_revoke()

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.

We start by looking up attribute references in order to change attribute IDs.

Parameters
ticketticket to revoke
identityprivate key of issuer
cbrevocation status callback
cb_clscallback closure
Returns
handle to the operation

Get shared attributes

Definition at line 910 of file gnunet-service-reclaim_tickets.c.

914 {
915  struct RECLAIM_TICKETS_RevokeHandle *rvk;
916  char *label;
917 
919  rvk->cb = cb;
920  rvk->cb_cls = cb_cls;
921  rvk->identity = *identity;
922  rvk->ticket = *ticket;
926  sizeof(ticket->rnd));
927  GNUNET_assert (NULL != label);
929  identity,
930  label,
932  rvk,
934  rvk);
935  GNUNET_free (label);
936  return rvk;
937 }
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 void revoke_attrs_cb(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
We found the attribute references.
static void rvk_attrs_err_cb(void *cls)
Failed to query namestore.
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
struct GNUNET_RECLAIM_Identifier rnd
The ticket random identifier.
struct GNUNET_IDENTITY_PublicKey identity
The ticket issuer (= the user)
struct GNUNET_RECLAIM_Ticket ticket
Ticket to issue.

References RECLAIM_TICKETS_RevokeHandle::cb, RECLAIM_TICKETS_RevokeHandle::cb_cls, GNUNET_assert, GNUNET_free, GNUNET_IDENTITY_key_get_public(), GNUNET_NAMESTORE_records_lookup(), GNUNET_new, GNUNET_STRINGS_data_to_string_alloc(), identity, GNUNET_RECLAIM_Ticket::identity, RECLAIM_TICKETS_RevokeHandle::identity, RECLAIM_TICKETS_RevokeHandle::ns_qe, nsh, revoke_attrs_cb(), GNUNET_RECLAIM_Ticket::rnd, rvk_attrs_err_cb(), ticket, and RECLAIM_TICKETS_RevokeHandle::ticket.

Referenced by handle_revoke_ticket_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ RECLAIM_TICKETS_revoke_cancel()

void RECLAIM_TICKETS_revoke_cancel ( struct RECLAIM_TICKETS_RevokeHandle rh)

Cancel a revocation.

Parameters
rhhandle to the operation

Definition at line 946 of file gnunet-service-reclaim_tickets.c.

947 {
948  GNUNET_assert (NULL != rh);
949  cleanup_rvk (rh);
950 }

References cleanup_rvk(), and GNUNET_assert.

Referenced by cleanup_client().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cleanup_cth()

static void cleanup_cth ( struct RECLAIM_TICKETS_ConsumeHandle cth)
static

Cleanup ticket consume handle.

Parameters
cththe handle to clean up

Definition at line 963 of file gnunet-service-reclaim_tickets.c.

964 {
965  struct ParallelLookup *lu;
966 
967  if (NULL != cth->lookup_request)
969  if (NULL != cth->kill_task)
971  while (NULL != (lu = cth->parallel_lookups_head))
972  {
973  if (NULL != lu->lookup_request)
975  GNUNET_free (lu->label);
978  lu);
979  GNUNET_free (lu);
980  }
981 
982  if (NULL != cth->attrs)
984  if (NULL != cth->presentations)
986  GNUNET_free (cth);
987 }
void * GNUNET_GNS_lookup_cancel(struct GNUNET_GNS_LookupRequest *lr)
Cancel pending lookup request.
Definition: gns_api.c:314
void GNUNET_RECLAIM_attribute_list_destroy(struct GNUNET_RECLAIM_AttributeList *attrs)
Destroy claim list.
void GNUNET_RECLAIM_presentation_list_destroy(struct GNUNET_RECLAIM_PresentationList *presentations)
Destroy presentations list.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
Handle for a parallel GNS lookup job.
struct GNUNET_GNS_LookupRequest * lookup_request
struct GNUNET_GNS_LookupRequest * lookup_request
LookupRequest.
struct GNUNET_RECLAIM_AttributeList * attrs
Attributes.
struct ParallelLookup * parallel_lookups_tail
Lookup DLL.
struct ParallelLookup * parallel_lookups_head
Lookup DLL.
struct GNUNET_RECLAIM_PresentationList * presentations
Presentations.
struct GNUNET_SCHEDULER_Task * kill_task
Kill task.

References RECLAIM_TICKETS_ConsumeHandle::attrs, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_GNS_lookup_cancel(), GNUNET_RECLAIM_attribute_list_destroy(), GNUNET_RECLAIM_presentation_list_destroy(), GNUNET_SCHEDULER_cancel(), RECLAIM_TICKETS_ConsumeHandle::kill_task, ParallelLookup::label, RECLAIM_TICKETS_ConsumeHandle::lookup_request, ParallelLookup::lookup_request, RECLAIM_TICKETS_ConsumeHandle::parallel_lookups_head, RECLAIM_TICKETS_ConsumeHandle::parallel_lookups_tail, and RECLAIM_TICKETS_ConsumeHandle::presentations.

Referenced by lookup_authz_cb(), process_parallel_lookup_result(), and RECLAIM_TICKETS_consume_cancel().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_parallel_lookup_result()

static void process_parallel_lookup_result ( void *  cls,
uint32_t  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

We found an attribute record.

Parameters
clshandle to the operation
rd_countsize of record set
rdrecord set

Definition at line 998 of file gnunet-service-reclaim_tickets.c.

1001 {
1002  struct ParallelLookup *parallel_lookup = cls;
1003  struct RECLAIM_TICKETS_ConsumeHandle *cth = parallel_lookup->handle;
1004  struct GNUNET_RECLAIM_AttributeListEntry *attr_le;
1005 
1007  "Parallel lookup finished (count=%u)\n",
1008  rd_count);
1009 
1011  cth->parallel_lookups_tail,
1012  parallel_lookup);
1013  GNUNET_free (parallel_lookup->label);
1014 
1016  "attribute_lookup_time_total",
1018  parallel_lookup->lookup_start_time)
1019  .rel_value_us,
1020  GNUNET_YES);
1021  GNUNET_STATISTICS_update (stats, "attribute_lookups_count", 1, GNUNET_YES);
1022 
1023 
1024  GNUNET_free (parallel_lookup);
1025  if (0 == rd_count)
1026  GNUNET_break (0);
1027  // REMARK: It is possible now to find rd_count > 1
1028  for (int i = 0; i < rd_count; i++)
1029  {
1030  if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE != rd[i].record_type)
1031  continue;
1032  attr_le = GNUNET_new (struct GNUNET_RECLAIM_AttributeListEntry);
1034  &attr_le->attribute);
1036  cth->attrs->list_tail,
1037  attr_le);
1038  }
1039  if (NULL != cth->parallel_lookups_head)
1040  return; // Wait for more
1041  /* Else we are done */
1042  cth->cb (cth->cb_cls, &cth->ticket.identity,
1043  cth->attrs, cth->presentations, GNUNET_OK, NULL);
1044  cleanup_cth (cth);
1045 }
static struct GNUNET_STATISTICS_Handle * stats
static void cleanup_cth(struct RECLAIM_TICKETS_ConsumeHandle *cth)
Cleanup ticket consume handle.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:436
struct GNUNET_RECLAIM_Attribute * attribute
The attribute claim.
struct GNUNET_RECLAIM_AttributeListEntry * list_tail
List tail.
struct GNUNET_RECLAIM_AttributeListEntry * list_head
List head.
uint64_t rel_value_us
The actual value.
struct GNUNET_TIME_Absolute lookup_start_time
Lookup time.
struct RECLAIM_TICKETS_ConsumeHandle * handle
RECLAIM_TICKETS_ConsumeCallback cb
Callback.
struct GNUNET_RECLAIM_Ticket ticket
Ticket.

References GNUNET_RECLAIM_AttributeListEntry::attribute, RECLAIM_TICKETS_ConsumeHandle::attrs, RECLAIM_TICKETS_ConsumeHandle::cb, RECLAIM_TICKETS_ConsumeHandle::cb_cls, cleanup_cth(), data, data_size, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_RECLAIM_attribute_deserialize(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, ParallelLookup::handle, GNUNET_RECLAIM_Ticket::identity, ParallelLookup::label, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_AttributeList::list_tail, ParallelLookup::lookup_start_time, RECLAIM_TICKETS_ConsumeHandle::parallel_lookups_head, RECLAIM_TICKETS_ConsumeHandle::parallel_lookups_tail, RECLAIM_TICKETS_ConsumeHandle::presentations, rd, rd_count, GNUNET_TIME_Relative::rel_value_us, stats, and RECLAIM_TICKETS_ConsumeHandle::ticket.

Referenced by lookup_authz_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ abort_parallel_lookups()

static void abort_parallel_lookups ( void *  cls)
static

Cancel the lookups for attribute records.

Parameters
clshandle to the operation

Definition at line 1054 of file gnunet-service-reclaim_tickets.c.

1055 {
1056  struct RECLAIM_TICKETS_ConsumeHandle *cth = cls;
1057  struct ParallelLookup *lu;
1058  struct ParallelLookup *tmp;
1059 
1060  cth->kill_task = NULL;
1061  for (lu = cth->parallel_lookups_head; NULL != lu;)
1062  {
1064  GNUNET_free (lu->label);
1065  tmp = lu->next;
1067  cth->parallel_lookups_tail,
1068  lu);
1069  GNUNET_free (lu);
1070  lu = tmp;
1071  }
1072  cth->cb (cth->cb_cls, NULL, NULL, NULL, GNUNET_SYSERR, "Aborted");
1073 }
struct ParallelLookup * next

References RECLAIM_TICKETS_ConsumeHandle::cb, RECLAIM_TICKETS_ConsumeHandle::cb_cls, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_GNS_lookup_cancel(), GNUNET_SYSERR, RECLAIM_TICKETS_ConsumeHandle::kill_task, ParallelLookup::label, ParallelLookup::lookup_request, ParallelLookup::next, RECLAIM_TICKETS_ConsumeHandle::parallel_lookups_head, and RECLAIM_TICKETS_ConsumeHandle::parallel_lookups_tail.

Referenced by lookup_authz_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ lookup_authz_cb()

static void lookup_authz_cb ( void *  cls,
uint32_t  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

GNS result with attribute references.

For each result, we start a (parallel) lookup of the actual attribute record under the referenced label.

Parameters
clshandle to the operation
rd_countsize of the record set
rdrecord set

Check if record is a credential presentation or an attribute reference.

We started lookups. Add a timeout task. FIXME: Really needed here?

No references found, return empty attribute list

Definition at line 1086 of file gnunet-service-reclaim_tickets.c.

1089 {
1090  struct RECLAIM_TICKETS_ConsumeHandle *cth = cls;
1091  struct ParallelLookup *parallel_lookup;
1092  char *lbl;
1094 
1095  cth->lookup_request = NULL;
1096 
1098  "reclaim_authz_lookup_time_total",
1100  cth->lookup_start_time)
1101  .rel_value_us,
1102  GNUNET_YES);
1104  "reclaim_authz_lookups_count",
1105  1,
1106  GNUNET_YES);
1107 
1108  for (int i = 0; i < rd_count; i++)
1109  {
1114  switch (rd[i].record_type)
1115  {
1118  ale->presentation =
1120  rd[i].data_size);
1122  cth->presentations->list_tail,
1123  ale);
1124  break;
1127  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ticket reference found %s\n", lbl);
1128  parallel_lookup = GNUNET_new (struct ParallelLookup);
1129  parallel_lookup->handle = cth;
1130  parallel_lookup->label = lbl;
1131  parallel_lookup->lookup_start_time = GNUNET_TIME_absolute_get ();
1132  parallel_lookup->lookup_request =
1134  lbl,
1135  &cth->ticket.identity,
1139  parallel_lookup);
1141  cth->parallel_lookups_tail,
1142  parallel_lookup);
1143  break;
1144  default:
1146  "Ignoring unknown record type %d", rd[i].record_type);
1147  }
1148  }
1153  if (NULL != cth->parallel_lookups_head)
1154  {
1158  cth);
1159  return;
1160  }
1164  cth->cb (cth->cb_cls, &cth->ticket.identity,
1165  cth->attrs, NULL, GNUNET_OK, NULL);
1166  cleanup_cth (cth);
1167 }
#define GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION
Record type for a presentation of a credential.
static struct GNUNET_GNS_Handle * gns
static void abort_parallel_lookups(void *cls)
Cancel the lookups for attribute records.
static void process_parallel_lookup_result(void *cls, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
We found an attribute record.
struct GNUNET_GNS_LookupRequest * GNUNET_GNS_lookup(struct GNUNET_GNS_Handle *handle, const char *name, const struct GNUNET_IDENTITY_PublicKey *zone, uint32_t type, enum GNUNET_GNS_LocalOptions options, GNUNET_GNS_LookupResultProcessor proc, void *proc_cls)
Perform an asynchronous lookup operation on the GNS.
Definition: gns_api.c:422
@ GNUNET_GNS_LO_DEFAULT
Defaults, look in cache, then in DHT.
#define GNUNET_GNSRECORD_TYPE_ANY
Record type indicating any record/'*'.
struct GNUNET_RECLAIM_Presentation * GNUNET_RECLAIM_presentation_deserialize(const char *data, size_t data_size)
Deserialize a presentation.
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:1272
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
#define GNUNET_TIME_UNIT_MINUTES
One minute.
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:484
struct GNUNET_RECLAIM_Presentation * presentation
The credential.
struct GNUNET_RECLAIM_PresentationListEntry * list_head
List head.
struct GNUNET_RECLAIM_PresentationListEntry * list_tail
List tail.
struct GNUNET_TIME_Absolute lookup_start_time
Lookup time.

References abort_parallel_lookups(), RECLAIM_TICKETS_ConsumeHandle::attrs, RECLAIM_TICKETS_ConsumeHandle::cb, RECLAIM_TICKETS_ConsumeHandle::cb_cls, cleanup_cth(), data, data_size, gns, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNS_LO_DEFAULT, GNUNET_GNS_lookup(), GNUNET_GNSRECORD_TYPE_ANY, GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF, GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_RECLAIM_presentation_deserialize(), GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, ParallelLookup::handle, GNUNET_RECLAIM_Ticket::identity, RECLAIM_TICKETS_ConsumeHandle::kill_task, ParallelLookup::label, GNUNET_RECLAIM_PresentationList::list_head, GNUNET_RECLAIM_PresentationList::list_tail, RECLAIM_TICKETS_ConsumeHandle::lookup_request, ParallelLookup::lookup_request, RECLAIM_TICKETS_ConsumeHandle::lookup_start_time, ParallelLookup::lookup_start_time, RECLAIM_TICKETS_ConsumeHandle::parallel_lookups_head, RECLAIM_TICKETS_ConsumeHandle::parallel_lookups_tail, GNUNET_RECLAIM_PresentationListEntry::presentation, RECLAIM_TICKETS_ConsumeHandle::presentations, process_parallel_lookup_result(), rd, rd_count, GNUNET_TIME_Relative::rel_value_us, stats, and RECLAIM_TICKETS_ConsumeHandle::ticket.

Referenced by RECLAIM_TICKETS_consume().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ RECLAIM_TICKETS_consume()

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.

We first looking attribute references under the label ticket.rnd in GNS.

Parameters
idthe audience of the ticket
ticketthe ticket to consume
cbcallback to call with attributes of ticket
cb_clscallback closure
Returns
handle to the operation

Definition at line 1182 of file gnunet-service-reclaim_tickets.c.

1186 {
1187  struct RECLAIM_TICKETS_ConsumeHandle *cth;
1188  char *label;
1189 
1191 
1192  cth->identity = *id;
1196  cth->ticket = *ticket;
1197  cth->cb = cb;
1198  cth->cb_cls = cb_cls;
1199  label =
1201  sizeof(cth->ticket.rnd));
1204  "Looking for AuthZ info under %s in %s\n",
1205  label, str);
1206  GNUNET_free (str);
1208  cth->lookup_request =
1210  label,
1211  &cth->ticket.identity,
1214  &lookup_authz_cb,
1215  cth);
1216  GNUNET_free (label);
1217  return cth;
1218 }
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
static void lookup_authz_cb(void *cls, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
GNS result with attribute references.
char * GNUNET_IDENTITY_public_key_to_string(const struct GNUNET_IDENTITY_PublicKey *key)
Creates a (Base32) string representation of the public key.
A list of GNUNET_RECLAIM_Attribute structures.
A list of GNUNET_RECLAIM_Presentation structures.
struct GNUNET_IDENTITY_PublicKey identity_pub
Audience Key.
struct GNUNET_IDENTITY_PrivateKey identity
Audience Key.

References RECLAIM_TICKETS_ConsumeHandle::attrs, RECLAIM_TICKETS_ConsumeHandle::cb, RECLAIM_TICKETS_ConsumeHandle::cb_cls, gns, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNS_LO_DEFAULT, GNUNET_GNS_lookup(), GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF, GNUNET_IDENTITY_key_get_public(), GNUNET_IDENTITY_public_key_to_string(), GNUNET_log, GNUNET_new, GNUNET_STRINGS_data_to_string_alloc(), GNUNET_TIME_absolute_get(), id, GNUNET_RECLAIM_Ticket::identity, RECLAIM_TICKETS_ConsumeHandle::identity, RECLAIM_TICKETS_ConsumeHandle::identity_pub, lookup_authz_cb(), RECLAIM_TICKETS_ConsumeHandle::lookup_request, RECLAIM_TICKETS_ConsumeHandle::lookup_start_time, RECLAIM_TICKETS_ConsumeHandle::presentations, GNUNET_RECLAIM_Ticket::rnd, ticket, and RECLAIM_TICKETS_ConsumeHandle::ticket.

Referenced by handle_consume_ticket_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ RECLAIM_TICKETS_consume_cancel()

void RECLAIM_TICKETS_consume_cancel ( struct RECLAIM_TICKETS_ConsumeHandle cth)

Cancel a consume operation.

Parameters
cththe operation to cancel

Definition at line 1227 of file gnunet-service-reclaim_tickets.c.

1228 {
1229  cleanup_cth (cth);
1230  return;
1231 }

References cleanup_cth().

Referenced by cleanup_client().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cleanup_issue_handle()

static void cleanup_issue_handle ( struct TicketIssueHandle handle)
static

Cleanup ticket consume handle.

Parameters
handlethe handle to clean up

Definition at line 1243 of file gnunet-service-reclaim_tickets.c.

1244 {
1245  if (NULL != handle->ns_qe)
1247  GNUNET_free (handle);
1248 }
static struct GNUNET_DNS_Handle * handle
Handle to transport service.

References GNUNET_free, GNUNET_NAMESTORE_cancel(), and handle.

Referenced by filter_tickets_cb(), filter_tickets_error_cb(), and store_ticket_issue_cont().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ store_ticket_issue_cont()

static void store_ticket_issue_cont ( void *  cls,
enum GNUNET_ErrorCode  ec 
)
static

Store finished, abort on error.

Else, return new ticket to caller.

Parameters
clshandle to the operation
successstore operation result
emsgerror message (or NULL on success)

Definition at line 1260 of file gnunet-service-reclaim_tickets.c.

1261 {
1262  struct TicketIssueHandle *handle = cls;
1263 
1264  handle->ns_qe = NULL;
1265  if (GNUNET_EC_NONE != ec)
1266  {
1267  handle->cb (handle->cb_cls,
1268  &handle->ticket,
1269  NULL,
1270  GNUNET_SYSERR,
1271  "Error storing AuthZ ticket in GNS");
1272  return;
1273  }
1274  handle->cb (handle->cb_cls,
1275  &handle->ticket,
1276  handle->presentations,
1277  GNUNET_OK, NULL);
1279 }
static void cleanup_issue_handle(struct TicketIssueHandle *handle)
Cleanup ticket consume handle.
Ticket issue request handle.

References cleanup_issue_handle(), GNUNET_EC_NONE, GNUNET_OK, GNUNET_SYSERR, and handle.

Referenced by issue_ticket().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ issue_ticket()

static void issue_ticket ( struct TicketIssueHandle ih)
static

Issue a new ticket.

We store references to attribute record labels and the ticket itself under the label base64(ticket.rnd).

Parameters
ihhandle to the operation containing relevant metadata

Definition at line 1290 of file gnunet-service-reclaim_tickets.c.

1291 {
1294  struct GNUNET_GNSRECORD_Data *attrs_record;
1295  char *label;
1296  char *tkt_data;
1297  int i;
1298  int j;
1299  int attrs_count = 0;
1300 
1301  for (le = ih->attrs->list_head; NULL != le; le = le->next)
1302  attrs_count++;
1303 
1304  // Worst case we have one presentation per attribute
1305  attrs_record =
1306  GNUNET_malloc (2 * attrs_count * sizeof(struct GNUNET_GNSRECORD_Data));
1307  i = 0;
1308  for (le = ih->attrs->list_head; NULL != le; le = le->next)
1309  {
1311  "Adding list entry: %s\n", le->attribute->name);
1312 
1313  attrs_record[i].data = &le->attribute->id;
1314  attrs_record[i].data_size = sizeof(le->attribute->id);
1318  i++;
1320  {
1322  "Attribute is backed by credential. Adding...\n");
1323  struct GNUNET_RECLAIM_Presentation *presentation = NULL;
1324  for (j = 0; j < i; j++)
1325  {
1326  if (attrs_record[j].record_type
1328  continue;
1330  attrs_record[j].data,
1331  attrs_record[j].
1332  data_size);
1333  if (NULL == presentation)
1334  {
1336  "Failed to deserialize presentation\n");
1337  continue;
1338  }
1339  if (0 == memcmp (&presentation->credential_id,
1340  &le->attribute->credential,
1341  sizeof (le->attribute->credential)))
1342  break;
1343  GNUNET_free (presentation);
1344  presentation = NULL;
1345  }
1346  if (NULL != presentation)
1347  {
1348  GNUNET_free (presentation);
1349  continue; // Skip as we have already added this credential presentation.
1350  }
1351  for (ple = ih->presentations->list_head; NULL != ple; ple = ple->next)
1352  {
1354  "Checking presentation....\n");
1355 
1356  if (0 != memcmp (&le->attribute->credential,
1357  &ple->presentation->credential_id,
1358  sizeof (le->attribute->credential)))
1359  {
1361  "Presentation does not match credential ID.\n");
1362  continue;
1363  }
1364  char *pres_buf;
1365  size_t pres_size;
1366 
1367  pres_size =
1369  pres_buf = GNUNET_malloc (pres_size);
1371  pres_buf);
1372  attrs_record[i].data = pres_buf;
1373  attrs_record[i].data_size = pres_size;
1374  attrs_record[i].expiration_time =
1376  attrs_record[i].record_type =
1379  i++;
1380  break;
1381  }
1382  }
1383  }
1384  attrs_record[i].data_size =
1386  tkt_data = GNUNET_malloc (attrs_record[i].data_size);
1388  tkt_data,
1389  attrs_record[i].data_size);
1390  attrs_record[i].data = tkt_data;
1393  attrs_record[i].flags =
1395  i++;
1396 
1397  label =
1399  sizeof(ih->ticket.rnd));
1402  &pub);
1405  "Storing AuthZ information under %s in %s\n", label, str);
1406  GNUNET_free (str);
1407  // Publish record
1409  &ih->identity,
1410  label,
1411  i,
1412  attrs_record,
1414  ih);
1415  for (j = 0; j < i; j++)
1416  {
1417  if (attrs_record[j].record_type
1419  continue;
1420  // Yes, we are allowed to do this because we allocated it above
1421  char *ptr = (char*) attrs_record[j].data;
1422  GNUNET_free (ptr);
1423  }
1424  GNUNET_free (tkt_data);
1425  GNUNET_free (attrs_record);
1426  GNUNET_free (label);
1427 }
#define GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET
local ticket reference
static struct GNUNET_CRYPTO_EddsaPublicKey pub
Definition: gnunet-scrypt.c:47
static struct GNUNET_TIME_Relative ticket_refresh_interval
Ticket expiration interval.
static void store_ticket_issue_cont(void *cls, enum GNUNET_ErrorCode ec)
Store finished, abort on error.
@ GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION
This expiration time of the record is a relative time (not an absolute time).
@ GNUNET_GNSRECORD_RF_PRIVATE
This is a private record of this peer and it should thus not be published.
size_t GNUNET_RECLAIM_presentation_serialize_get_size(const struct GNUNET_RECLAIM_Presentation *presentation)
Get required size for serialization buffer.
#define GNUNET_RECLAIM_id_is_zero(a)
size_t GNUNET_RECLAIM_presentation_serialize(const struct GNUNET_RECLAIM_Presentation *presentation, char *result)
Serialize a presentation.
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
size_t data_size
Number of bytes in data.
An identity key as per LSD0001.
struct GNUNET_RECLAIM_AttributeListEntry * next
DLL.
struct GNUNET_RECLAIM_Identifier credential
Referenced ID of credential (may be GNUNET_RECLAIM_ID_ZERO if self-creded)
struct GNUNET_RECLAIM_PresentationListEntry * next
DLL.
A credential presentation.
struct GNUNET_RECLAIM_Identifier credential_id
The credential id of which this is a presentation.
struct GNUNET_RECLAIM_AttributeList * attrs
Attributes to issue.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
QueueEntry.
struct GNUNET_RECLAIM_PresentationList * presentations
Presentations to add.
struct GNUNET_IDENTITY_PrivateKey identity
Issuer Key.
struct GNUNET_RECLAIM_Ticket ticket
Ticket to issue.

References GNUNET_RECLAIM_AttributeListEntry::attribute, TicketIssueHandle::attrs, GNUNET_RECLAIM_Attribute::credential, GNUNET_RECLAIM_Presentation::credential_id, GNUNET_GNSRECORD_Data::data, data, data_size, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF, GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION, GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET, GNUNET_IDENTITY_key_get_public(), GNUNET_IDENTITY_public_key_to_string(), GNUNET_log, GNUNET_malloc, GNUNET_NAMESTORE_records_store(), GNUNET_NO, GNUNET_RECLAIM_id_is_zero, GNUNET_RECLAIM_presentation_deserialize(), GNUNET_RECLAIM_presentation_serialize(), GNUNET_RECLAIM_presentation_serialize_get_size(), GNUNET_RECLAIM_ticket_serialize_get_size(), GNUNET_RECLAIM_write_ticket_to_buffer(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_RECLAIM_Attribute::id, TicketIssueHandle::identity, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_PresentationList::list_head, GNUNET_RECLAIM_Attribute::name, GNUNET_RECLAIM_AttributeListEntry::next, GNUNET_RECLAIM_PresentationListEntry::next, TicketIssueHandle::ns_qe, nsh, GNUNET_RECLAIM_PresentationListEntry::presentation, TicketIssueHandle::presentations, pub, GNUNET_GNSRECORD_Data::record_type, GNUNET_TIME_Relative::rel_value_us, GNUNET_RECLAIM_Ticket::rnd, store_ticket_issue_cont(), TicketIssueHandle::ticket, and ticket_refresh_interval.

Referenced by filter_tickets_finished_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ filter_tickets_error_cb()

static void filter_tickets_error_cb ( void *  cls)
static

Namestore error on issue.

Abort.

Parameters
clshandle to the operation

Definition at line 1441 of file gnunet-service-reclaim_tickets.c.

1442 {
1443  struct TicketIssueHandle *tih = cls;
1444 
1445  tih->ns_it = NULL;
1446  tih->cb (tih->cb_cls,
1447  &tih->ticket,
1448  NULL,
1449  GNUNET_SYSERR,
1450  "Error storing AuthZ ticket in GNS");
1451  cleanup_issue_handle (tih);
1452 }
struct GNUNET_NAMESTORE_ZoneIterator * ns_it
Namestore Iterator.
RECLAIM_TICKETS_TicketResult cb
Callback.

References TicketIssueHandle::cb, TicketIssueHandle::cb_cls, cleanup_issue_handle(), GNUNET_SYSERR, TicketIssueHandle::ns_it, and TicketIssueHandle::ticket.

Referenced by RECLAIM_TICKETS_issue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ filter_tickets_cb()

static void filter_tickets_cb ( void *  cls,
const struct GNUNET_IDENTITY_PrivateKey zone,
const char *  label,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

Iterator over records.

Check if any previously issued ticket already matches what we need to prevent duplicates and improve resolution synergy.

Parameters
clshandle to the operation
zoneissuer identity
labelticket rnd
rd_countsize of record set
rdrecord set

If we found a matching ticket, return that to the caller and we are done.

Definition at line 1468 of file gnunet-service-reclaim_tickets.c.

1473 {
1474  struct TicketIssueHandle *tih = cls;
1476  struct GNUNET_RECLAIM_Presentation *presentation;
1477  struct GNUNET_RECLAIM_PresentationList *ticket_presentations;
1478  struct GNUNET_RECLAIM_Credential *cred;
1481  unsigned int attr_cnt = 0;
1482  unsigned int pres_cnt = 0;
1483  int ticket_found = GNUNET_NO;
1484 
1485  for (le = tih->attrs->list_head; NULL != le; le = le->next)
1486  {
1487  attr_cnt++;
1489  pres_cnt++;
1490  }
1491 
1492  // ticket search
1493  unsigned int found_attrs_cnt = 0;
1494  unsigned int found_pres_cnt = 0;
1495  size_t read;
1496  ticket_presentations = GNUNET_new (struct GNUNET_RECLAIM_PresentationList);
1497 
1498  for (int i = 0; i < rd_count; i++)
1499  {
1500  // found ticket
1501  if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET == rd[i].record_type)
1502  {
1503  if ((GNUNET_SYSERR ==
1505  rd[i].data_size,
1506  &ticket,
1507  &read)) ||
1508  (read != rd[i].data_size))
1509  {
1511  "Failed to deserialize ticket from record\n");
1512  continue;
1513  }
1514  // cmp audience
1515  // FIXME this is ugly, GNUNET_IDENTITY_PublicKey cannot be compared
1516  // like this
1517  if (0 == memcmp (&tih->ticket.audience,
1518  &ticket.audience,
1519  sizeof(struct GNUNET_IDENTITY_PublicKey)))
1520  {
1521  tih->ticket = ticket;
1522  ticket_found = GNUNET_YES;
1523  continue;
1524  }
1525  }
1526 
1527  // cmp requested attributes with ticket attributes
1528  if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF == rd[i].record_type)
1529  {
1530  for (le = tih->attrs->list_head; NULL != le; le = le->next)
1531  {
1533  &le->attribute->id))
1534  found_attrs_cnt++;
1535  }
1536  }
1537  if (GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL == rd[i].record_type)
1538  {
1540  "Found credential...\n");
1541 
1542  for (le = tih->attrs->list_head; NULL != le; le = le->next)
1543  {
1545  rd[i].data_size);
1546  if (GNUNET_YES != GNUNET_RECLAIM_id_is_equal (&cred->id,
1547  &le->attribute->credential))
1548  {
1550  "No match.\n");
1551  GNUNET_free (cred);
1552  continue;
1553  }
1555  "Match, creating presentation...\n");
1557  cred,
1558  tih->attrs,
1559  &presentation))
1560  {
1562  "Unable to retrieve presentation from credential\n");
1563  GNUNET_free (cred);
1564  continue;
1565  }
1567  ple->presentation = presentation;
1569  tih->presentations->list_tail,
1570  ple);
1571  GNUNET_free (cred);
1572  break;
1573  }
1574  }
1575  if (GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION == rd[i].record_type)
1576  {
1577  for (le = tih->attrs->list_head; NULL != le; le = le->next)
1578  {
1579  presentation = GNUNET_RECLAIM_presentation_deserialize (rd[i].data,
1580  rd[i].data_size);
1581  if (NULL == presentation)
1582  {
1584  "Failed to deserialize presentation\n");
1585  continue;
1586  }
1588  &presentation->credential_id,
1589  &le->attribute->credential))
1590  {
1591  found_pres_cnt++;
1593  ple->presentation = presentation;
1594  GNUNET_CONTAINER_DLL_insert (ticket_presentations->list_head,
1595  ticket_presentations->list_tail,
1596  ple);
1597  }
1598  }
1599  }
1600  }
1601 
1606  if ((attr_cnt == found_attrs_cnt) &&
1607  (pres_cnt == found_pres_cnt) &&
1608  (GNUNET_YES == ticket_found))
1609  {
1611  tih->cb (tih->cb_cls, &tih->ticket, ticket_presentations, GNUNET_OK, NULL);
1612  GNUNET_RECLAIM_presentation_list_destroy (ticket_presentations);
1613  cleanup_issue_handle (tih);
1614  return;
1615  }
1616  GNUNET_RECLAIM_presentation_list_destroy (ticket_presentations);
1617  // ticket not found in current record, checking next record set
1619 }
#define GNUNET_RECLAIM_id_is_equal(a, b)
int GNUNET_RECLAIM_credential_get_presentation(const struct GNUNET_RECLAIM_Credential *cred, const struct GNUNET_RECLAIM_AttributeList *attrs, struct GNUNET_RECLAIM_Presentation **presentation)
Create a presentation from a credential and a lift of (selected) attributes in the credential.
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
struct GNUNET_RECLAIM_Identifier id
ID.
The authorization ticket.
struct GNUNET_IDENTITY_PublicKey audience
The ticket audience (= relying party)

References GNUNET_RECLAIM_AttributeListEntry::attribute, TicketIssueHandle::attrs, GNUNET_RECLAIM_Ticket::audience, TicketIssueHandle::cb, TicketIssueHandle::cb_cls, cleanup_issue_handle(), GNUNET_RECLAIM_Attribute::credential, GNUNET_RECLAIM_Presentation::credential_id, data, data_size, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF, GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL, GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION, GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET, GNUNET_log, GNUNET_NAMESTORE_zone_iteration_stop(), GNUNET_NAMESTORE_zone_iterator_next(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_RECLAIM_credential_deserialize(), GNUNET_RECLAIM_credential_get_presentation(), GNUNET_RECLAIM_id_is_equal, GNUNET_RECLAIM_id_is_zero, GNUNET_RECLAIM_presentation_deserialize(), GNUNET_RECLAIM_presentation_list_destroy(), GNUNET_RECLAIM_read_ticket_from_buffer(), GNUNET_SYSERR, GNUNET_YES, GNUNET_RECLAIM_Attribute::id, GNUNET_RECLAIM_Credential::id, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_PresentationList::list_head, GNUNET_RECLAIM_PresentationList::list_tail, GNUNET_RECLAIM_AttributeListEntry::next, TicketIssueHandle::ns_it, GNUNET_RECLAIM_PresentationListEntry::presentation, TicketIssueHandle::presentations, rd, rd_count, ticket, and TicketIssueHandle::ticket.

Referenced by RECLAIM_TICKETS_issue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ filter_tickets_finished_cb()

static void filter_tickets_finished_cb ( void *  cls)
static

Done iterating over tickets and we apparently did not find an existing, matching ticket.

Continue by issuing a new ticket.

Parameters
clshandle to the operation

Definition at line 1630 of file gnunet-service-reclaim_tickets.c.

1631 {
1632  struct TicketIssueHandle *tih = cls;
1633 
1636  issue_ticket (tih);
1637 }
static void issue_ticket(struct TicketIssueHandle *ih)
Issue a new ticket.

References GNUNET_IDENTITY_key_get_public(), GNUNET_RECLAIM_id_generate, GNUNET_RECLAIM_Ticket::identity, TicketIssueHandle::identity, issue_ticket(), GNUNET_RECLAIM_Ticket::rnd, and TicketIssueHandle::ticket.

Referenced by RECLAIM_TICKETS_issue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ RECLAIM_TICKETS_issue()

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.

Parameters
identitythe issuer
attrsthe attributes to share
audiencethe audience to share the attributes with
cbthe callback to call with the ticket result
cb_clsthe callback closure FIXME: Return handle??

Definition at line 1652 of file gnunet-service-reclaim_tickets.c.

1657 {
1658  struct TicketIssueHandle *tih;
1659 
1660  tih = GNUNET_new (struct TicketIssueHandle);
1661  tih->cb = cb;
1662  tih->cb_cls = cb_cls;
1665  tih->identity = *identity;
1666  tih->ticket.audience = *audience;
1667 
1668  // First check whether the ticket has already been issued
1669  tih->ns_it =
1671  &tih->identity,
1673  tih,
1675  tih,
1677  tih);
1678 }
static void filter_tickets_finished_cb(void *cls)
Done iterating over tickets and we apparently did not find an existing, matching ticket.
static void filter_tickets_error_cb(void *cls)
Namestore error on issue.
static void filter_tickets_cb(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Iterator over records.
struct GNUNET_RECLAIM_AttributeList * GNUNET_RECLAIM_attribute_list_dup(const struct GNUNET_RECLAIM_AttributeList *attrs)
Make a (deep) copy of a claim list.

References TicketIssueHandle::attrs, GNUNET_RECLAIM_Ticket::audience, TicketIssueHandle::cb, TicketIssueHandle::cb_cls, filter_tickets_cb(), filter_tickets_error_cb(), filter_tickets_finished_cb(), GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_new, GNUNET_RECLAIM_attribute_list_dup(), identity, TicketIssueHandle::identity, TicketIssueHandle::ns_it, nsh, TicketIssueHandle::presentations, and TicketIssueHandle::ticket.

Referenced by handle_issue_ticket_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cleanup_iter()

static void cleanup_iter ( struct RECLAIM_TICKETS_Iterator iter)
static

Cleanup ticket iterator.

Parameters
iterhandle to the iteration

Definition at line 1691 of file gnunet-service-reclaim_tickets.c.

1692 {
1693  if (NULL != iter->ns_it)
1695  GNUNET_free (iter);
1696 }
struct GNUNET_NAMESTORE_ZoneIterator * ns_it
Namestore queue entry.

References GNUNET_free, GNUNET_NAMESTORE_zone_iteration_stop(), and RECLAIM_TICKETS_Iterator::ns_it.

Referenced by collect_tickets_error_cb(), collect_tickets_finished_cb(), and RECLAIM_TICKETS_iteration_stop().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ collect_tickets_cb()

static void collect_tickets_cb ( void *  cls,
const struct GNUNET_IDENTITY_PrivateKey zone,
const char *  label,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

Return each record of type GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET to the caller and proceed with the iteration.

FIXME: Should we not proceed automatically here?

Parameters
clshandle to the iteration
zonethe ticket issuer
labelthe ticket rnd
rd_countnumber of records in record set
rdrecord set containing a ticket

Definition at line 1711 of file gnunet-service-reclaim_tickets.c.

1716 {
1717  struct RECLAIM_TICKETS_Iterator *iter = cls;
1719  size_t read;
1720 
1721  for (int i = 0; i < rd_count; i++)
1722  {
1723  if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET != rd[i].record_type)
1724  continue;
1725  if ((GNUNET_SYSERR ==
1727  rd[i].data_size,
1728  &ticket,
1729  &read)) ||
1730  (read != rd[i].data_size))
1731  {
1733  "Failed to deserialize ticket from record\n");
1734  continue;
1735  }
1736  iter->cb (iter->cb_cls, &ticket);
1737  return;
1738  }
1740 }
RECLAIM_TICKETS_TicketIter cb
Iter callback.

References RECLAIM_TICKETS_Iterator::cb, RECLAIM_TICKETS_Iterator::cb_cls, data, data_size, GNUNET_ERROR_TYPE_ERROR, GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET, GNUNET_log, GNUNET_NAMESTORE_zone_iterator_next(), GNUNET_RECLAIM_read_ticket_from_buffer(), GNUNET_SYSERR, RECLAIM_TICKETS_Iterator::ns_it, rd, rd_count, and ticket.

Referenced by RECLAIM_TICKETS_iteration_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ collect_tickets_finished_cb()

static void collect_tickets_finished_cb ( void *  cls)
static

Signal ticket iteration has finished.

Parameters
clshandle to the iteration

Definition at line 1749 of file gnunet-service-reclaim_tickets.c.

1750 {
1751  struct RECLAIM_TICKETS_Iterator *iter = cls;
1752 
1753  iter->ns_it = NULL;
1754  iter->cb (iter->cb_cls, NULL);
1755  cleanup_iter (iter);
1756 }
static void cleanup_iter(struct RECLAIM_TICKETS_Iterator *iter)
Cleanup ticket iterator.

References RECLAIM_TICKETS_Iterator::cb, RECLAIM_TICKETS_Iterator::cb_cls, cleanup_iter(), and RECLAIM_TICKETS_Iterator::ns_it.

Referenced by RECLAIM_TICKETS_iteration_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ collect_tickets_error_cb()

static void collect_tickets_error_cb ( void *  cls)
static

Cancel ticket iteration on namestore error.

Parameters
clsthe iteration handle

Definition at line 1765 of file gnunet-service-reclaim_tickets.c.

1766 {
1767  struct RECLAIM_TICKETS_Iterator *iter = cls;
1768 
1769  iter->ns_it = NULL;
1770  iter->cb (iter->cb_cls, NULL);
1771  cleanup_iter (iter);
1772 }

References RECLAIM_TICKETS_Iterator::cb, RECLAIM_TICKETS_Iterator::cb_cls, cleanup_iter(), and RECLAIM_TICKETS_Iterator::ns_it.

Referenced by RECLAIM_TICKETS_iteration_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ RECLAIM_TICKETS_iteration_next()

void RECLAIM_TICKETS_iteration_next ( struct RECLAIM_TICKETS_Iterator iter)

Continue ticket iteration.

Parameters
iterthe iteration to continue

Definition at line 1781 of file gnunet-service-reclaim_tickets.c.

1782 {
1784 }

References GNUNET_NAMESTORE_zone_iterator_next(), and RECLAIM_TICKETS_Iterator::ns_it.

Referenced by handle_ticket_iteration_next().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ RECLAIM_TICKETS_iteration_stop()

void RECLAIM_TICKETS_iteration_stop ( struct RECLAIM_TICKETS_Iterator iter)

Stop a running ticket iteration.

Parameters
iteriteration to cancel

Definition at line 1793 of file gnunet-service-reclaim_tickets.c.

1794 {
1796  cleanup_iter (iter);
1797 }

References cleanup_iter(), GNUNET_NAMESTORE_zone_iteration_stop(), and RECLAIM_TICKETS_Iterator::ns_it.

Referenced by cleanup_client(), and handle_ticket_iteration_stop().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ RECLAIM_TICKETS_iteration_start()

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.

Parameters
identitythe issuing identity
cbticket callback function
cb_clscallback closure
Returns
a handle to the iteration

Definition at line 1809 of file gnunet-service-reclaim_tickets.c.

1813 {
1814  struct RECLAIM_TICKETS_Iterator *iter;
1815 
1816  iter = GNUNET_new (struct RECLAIM_TICKETS_Iterator);
1817  iter->cb = cb;
1818  iter->cb_cls = cb_cls;
1819  iter->ns_it =
1821  identity,
1823  iter,
1825  iter,
1827  iter);
1828  return iter;
1829 }
static void collect_tickets_finished_cb(void *cls)
Signal ticket iteration has finished.
static void collect_tickets_cb(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Return each record of type GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET to the caller and proceed with the it...
static void collect_tickets_error_cb(void *cls)
Cancel ticket iteration on namestore error.

References RECLAIM_TICKETS_Iterator::cb, RECLAIM_TICKETS_Iterator::cb_cls, collect_tickets_cb(), collect_tickets_error_cb(), collect_tickets_finished_cb(), GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_new, identity, RECLAIM_TICKETS_Iterator::ns_it, and nsh.

Referenced by handle_ticket_iteration_start().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ RECLAIM_TICKETS_init()

int RECLAIM_TICKETS_init ( const struct GNUNET_CONFIGURATION_Handle c)

Initialize tickets component.

Parameters
cthe configuration
Returns
GNUNET_SYSERR on error

Definition at line 1839 of file gnunet-service-reclaim_tickets.c.

1840 {
1841  // Get ticket expiration time (relative) from config
1842  if (GNUNET_OK ==
1844  "reclaim",
1845  "TICKET_REFRESH_INTERVAL",
1847  {
1849  "Configured refresh interval for tickets: %s\n",
1851  GNUNET_YES));
1852  }
1853  else
1854  {
1856  }
1857  // Connect to identity and namestore services
1859  if (NULL == nsh)
1860  {
1862  "error connecting to namestore");
1863  return GNUNET_SYSERR;
1864  }
1865  gns = GNUNET_GNS_connect (c);
1866  if (NULL == gns)
1867  {
1868  GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "error connecting to gns");
1869  return GNUNET_SYSERR;
1870  }
1871  stats = GNUNET_STATISTICS_create ("reclaim", c);
1872  return GNUNET_OK;
1873 }
#define DEFAULT_TICKET_REFRESH_INTERVAL
FIXME: the default ticket iteration interval should probably be the minimim attribute expiration.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
struct GNUNET_GNS_Handle * GNUNET_GNS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the connection with the GNS service.
Definition: gns_api.c:268
#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...
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:569

References DEFAULT_TICKET_REFRESH_INTERVAL, gns, GNUNET_CONFIGURATION_get_value_time(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_GNS_connect(), GNUNET_log, GNUNET_log_strerror, GNUNET_NAMESTORE_connect(), GNUNET_OK, GNUNET_STATISTICS_create(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_YES, nsh, stats, and ticket_refresh_interval.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ RECLAIM_TICKETS_deinit()

void RECLAIM_TICKETS_deinit ( void  )

Close handles and clean up.

FIXME: cancel all pending operations (gns, ns etc)

Definition at line 1881 of file gnunet-service-reclaim_tickets.c.

1882 {
1883  if (NULL != nsh)
1885  nsh = NULL;
1886  if (NULL != gns)
1888  gns = NULL;
1889  if (NULL != stats)
1890  {
1892  stats = NULL;
1893  }
1894 }
void GNUNET_GNS_disconnect(struct GNUNET_GNS_Handle *handle)
Shutdown connection with the GNS service.
Definition: gns_api.c:290
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).

References gns, GNUNET_GNS_disconnect(), GNUNET_NAMESTORE_disconnect(), GNUNET_NO, GNUNET_STATISTICS_destroy(), nsh, and stats.

Referenced by cleanup().

Here is the call graph for this function:
Here is the caller graph for this function:

Variable Documentation

◆ ticket_refresh_interval

struct GNUNET_TIME_Relative ticket_refresh_interval
static

Ticket expiration interval.

Definition at line 1 of file gnunet-service-reclaim_tickets.c.

Referenced by issue_ticket(), and RECLAIM_TICKETS_init().

◆ nsh

◆ gns

◆ stats