GNUnet 0.21.1
gnunet-service-reclaim_tickets.c File Reference
#include "gnunet-service-reclaim_tickets.h"
#include "gnunet_common.h"
#include "gnunet_gns_service.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_reclaim_service.h"
#include <string.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_CRYPTO_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_CRYPTO_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_CRYPTO_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_CRYPTO_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)
 
static void abort_parallel_lookups (void *cls)
 Cancel the lookups for attribute records. More...
 
static void lookup_authz_cb (void *cls, int is_gns, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 
struct RECLAIM_TICKETS_ConsumeHandleRECLAIM_TICKETS_consume (const struct GNUNET_RECLAIM_Ticket *ticket, const char *rp_uri, 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_CRYPTO_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_CRYPTO_PrivateKey *identity, const struct GNUNET_RECLAIM_AttributeList *attrs, const char *rp, 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_CRYPTO_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_CRYPTO_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
 

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 39 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 362 of file gnunet-service-reclaim_tickets.c.

363{
364 struct RevokedAttributeEntry *ae;
365 struct TicketRecordsEntry *le;
366
367 if (NULL != rh->ns_qe)
369 if (NULL != rh->ns_it)
371 while (NULL != (ae = rh->attrs_head))
372 {
374 GNUNET_free (ae);
375 }
376 while (NULL != (le = rh->tickets_to_update_head))
377 {
380 le);
381 if (NULL != le->data)
382 GNUNET_free (le->data);
383 if (NULL != le->label)
384 GNUNET_free (le->label);
385 GNUNET_free (le);
386 }
387 GNUNET_free (rh);
388}
#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 425 of file gnunet-service-reclaim_tickets.c.

426{
427 struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
428 struct TicketRecordsEntry *le;
429 struct RevokedAttributeEntry *ae;
430
431 if (NULL == rvk->tickets_to_update_head)
432 {
434 "Finished updatding tickets, success\n");
435 rvk->cb (rvk->cb_cls, GNUNET_OK);
436 cleanup_rvk (rvk);
437 return;
438 }
439 le = rvk->tickets_to_update_head;
442 le);
445 le->data,
446 le->rd_count,
447 rd))
448 {
450 "Unable to deserialize ticket record(s)\n");
451 rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
452 cleanup_rvk (rvk);
453 return;
454 }
455 for (int i = 0; i < le->rd_count; i++)
456 {
458 continue;
459 for (ae = rvk->attrs_head; NULL != ae; ae = ae->next)
460 {
461 if (0 != memcmp (rd[i].data, &ae->old_id, sizeof(ae->old_id)))
462 continue;
463 rd[i].data = &ae->new_id;
464 }
465 }
467 &rvk->identity,
468 le->label,
469 le->rd_count,
470 rd,
472 rvk);
473 GNUNET_free (le->label);
474 GNUNET_free (le->data);
475 GNUNET_free (le);
476}
static char * data
The data to insert into the dht.
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_record_set_store(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_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.
#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF
for reclaim records
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.
RECLAIM_TICKETS_RevokeCallback cb
Callback.
struct GNUNET_CRYPTO_PrivateKey identity
Issuer Key.
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(), data, GNUNET_GNSRECORD_Data::data, TicketRecordsEntry::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_record_set_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 410 of file gnunet-service-reclaim_tickets.c.

411{
412 struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
413
414 rvk->ns_qe = NULL;
416}
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:1305

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 485 of file gnunet-service-reclaim_tickets.c.

486{
487 struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
488
489 rvk->ns_it = NULL;
491}

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_CRYPTO_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 505 of file gnunet-service-reclaim_tickets.c.

510{
511 struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
512 struct TicketRecordsEntry *le;
513 struct RevokedAttributeEntry *ae;
514 int has_changed = GNUNET_NO;
515
517 for (int i = 0; i < rd_count; i++)
518 {
520 continue;
521 for (ae = rvk->attrs_head; NULL != ae; ae = ae->next)
522 {
523 if (0 != memcmp (rd[i].data, &ae->old_id, sizeof(ae->old_id)))
524 continue;
525 has_changed = GNUNET_YES;
526 break;
527 }
528 if (GNUNET_YES == has_changed)
529 break;
530 }
531 if (GNUNET_YES == has_changed)
532 {
533 le = GNUNET_new (struct TicketRecordsEntry);
535 le->data = GNUNET_malloc (le->data_size);
536 le->rd_count = rd_count;
537 le->label = GNUNET_strdup (label);
541 le);
542 }
544}
#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.
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, data, TicketRecordsEntry::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 553 of file gnunet-service-reclaim_tickets.c.

554{
555 struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
556
557 rvk->ns_it = NULL;
558 rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
559 cleanup_rvk (rvk);
560}

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 569 of file gnunet-service-reclaim_tickets.c.

570{
571 struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
572
573 rvk->ns_qe = NULL;
574 rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
575 cleanup_rvk (rvk);
576}

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 777 of file gnunet-service-reclaim_tickets.c.

778{
779 char *label;
780
781 if (NULL == rvk->move_attr)
782 {
783 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished moving attributes\n");
784 rvk->ns_it =
786 &rvk->identity,
788 rvk,
790 rvk,
792 rvk);
793 return;
794 }
795 label = GNUNET_STRINGS_data_to_string_alloc (&rvk->move_attr->old_id,
796 sizeof (rvk->move_attr->old_id));
797 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Moving claim %s\n", label);
798
800 &rvk->identity,
801 label,
802 &rvk_ns_err,
803 rvk,
805 rvk);
806 GNUNET_free (label);
807}
static void rvk_ticket_update_finished(void *cls)
Done collecting tickets.
static void rvk_ticket_update(void *cls, const struct GNUNET_CRYPTO_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_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_CRYPTO_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Got the referenced attribute.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_lookup(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_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.
struct GNUNET_NAMESTORE_ZoneIterator * GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_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)
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:764

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 597 of file gnunet-service-reclaim_tickets.c.

598{
600}
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 612 of file gnunet-service-reclaim_tickets.c.

613{
614 struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
615
616 rvk->ns_qe = NULL;
617 if (GNUNET_EC_NONE != ec)
618 {
620 "Error removing attribute: %s\n",
622 rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
623 cleanup_rvk (rvk);
624 return;
625 }
626 rvk->move_attr = rvk->move_attr->next;
628}
static void move_attrs_cont(void *cls)
Delayed continuation for move_attrs.
const char * GNUNET_ErrorCode_get_hint(enum GNUNET_ErrorCode ec)
Returns a hint for a given error code.
@ GNUNET_EC_NONE
No error (success).
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 641 of file gnunet-service-reclaim_tickets.c.

642{
643 struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
644 char *label;
645
646 rvk->ns_qe = NULL;
647 if (GNUNET_EC_NONE != ec)
648 {
650 "Error moving attribute: %s\n",
652 rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
653 cleanup_rvk (rvk);
654 return;
655 }
657 sizeof(rvk->move_attr->old_id));
658 GNUNET_assert (NULL != label);
659 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Removing attribute %s\n", label);
661 &rvk->identity,
662 label,
663 0,
664 NULL,
666 rvk);
667 GNUNET_free (label);
668}
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_record_set_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_CRYPTO_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 681 of file gnunet-service-reclaim_tickets.c.

686{
687 struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
688 struct GNUNET_GNSRECORD_Data new_rd[rd_count];
689 struct RevokedAttributeEntry *le;
690 char *new_label;
691 char *attr_data;
692
693 rvk->ns_qe = NULL;
694 if (0 == rd_count)
695 {
697 "The claim %s no longer exists!\n",
698 label);
699 le = rvk->move_attr;
700 rvk->move_attr = le->next;
702 GNUNET_free (le);
704 return;
705 }
707 new_label =
709 sizeof (rvk->move_attr->new_id));
710
711 attr_data = NULL;
712 // new_rd = *rd;
713 for (int i = 0; i < rd_count; i++)
714 {
715 if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE == rd[i].record_type)
716 {
720 rd[i].data_size,
721 &claim);
723 "Attribute to update: Name=%s\n",
724 claim->name);
725 claim->id = rvk->move_attr->new_id;
727 attr_data = GNUNET_malloc (rd[i].data_size);
728 new_rd[i].data_size = GNUNET_RECLAIM_attribute_serialize (claim,
729 attr_data);
730 new_rd[i].data = attr_data;
731 new_rd[i].record_type = rd[i].record_type;
732 new_rd[i].flags = rd[i].flags;
733 new_rd[i].expiration_time = rd[i].expiration_time;
734 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute %s\n", new_label);
736 }
737 else if (GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL == rd[i].record_type)
738 {
741 rd[i].data_size);
743 "Credential to update: Name=%s\n",
744 credential->name);
745 credential->id = rvk->move_attr->new_id;
746 new_rd[i].data_size =
748 attr_data = GNUNET_malloc (rd[i].data_size);
749 new_rd[i].data_size = GNUNET_RECLAIM_credential_serialize (credential,
750 attr_data);
751 new_rd[i].data = attr_data;
752 new_rd[i].record_type = rd[i].record_type;
753 new_rd[i].flags = rd[i].flags;
754 new_rd[i].expiration_time = rd[i].expiration_time;
755 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding credential %s\n",
756 new_label);
758 }
759 else
760 {
761 memcpy (&new_rd[i], &rd[i], sizeof (struct GNUNET_GNSRECORD_Data));
762 }
763 }
765 &rvk->identity,
766 new_label,
767 rd_count,
768 new_rd,
770 rvk);
771 GNUNET_free (new_label);
772 GNUNET_free (attr_data);
773}
static size_t data_size
Number of bytes in data.
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
#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.
struct GNUNET_RECLAIM_Credential * GNUNET_RECLAIM_credential_deserialize(const char *data, size_t data_size)
Deserialize 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.
#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE
identity attribute
#define GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL
Record type for an attribute attestation (e.g.
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, data, GNUNET_GNSRECORD_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_record_set_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_Identifier::id, GNUNET_RECLAIM_Attribute::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 822 of file gnunet-service-reclaim_tickets.c.

823{
824 struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
825
826 rvk->ns_qe = NULL;
827 if (GNUNET_EC_NONE != ec)
828 {
831 rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
832 cleanup_rvk (rvk);
833 return;
834 }
835 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleted ticket\n");
836 if (0 == rvk->ticket_attrs)
837 {
839 "No attributes to move... strange\n");
840 rvk->cb (rvk->cb_cls, GNUNET_OK);
841 cleanup_rvk (rvk);
842 return;
843 }
844 rvk->move_attr = rvk->attrs_head;
845 move_attrs (rvk);
846}
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_CRYPTO_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 860 of file gnunet-service-reclaim_tickets.c.

866{
867 struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
868 struct RevokedAttributeEntry *le;
869
870 rvk->ns_qe = NULL;
875 for (int i = 0; i < rd_count; i++)
876 {
878 continue;
879 le = GNUNET_new (struct RevokedAttributeEntry);
880 le->old_id = *((struct GNUNET_RECLAIM_Identifier *) rd[i].data);
882 rvk->ticket_attrs++;
883 }
884
887 &rvk->identity,
888 label,
889 0,
890 NULL,
892 rvk);
893}
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_record_set_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 902 of file gnunet-service-reclaim_tickets.c.

903{
904 struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
905
906 rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
907 cleanup_rvk (rvk);
908}

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_CRYPTO_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 923 of file gnunet-service-reclaim_tickets.c.

927{
929 char *label;
930 char *tmp;
931
933 rvk->cb = cb;
934 rvk->cb_cls = cb_cls;
935 rvk->identity = *identity;
936 rvk->ticket = *ticket;
938 label = strtok (tmp, ".");
939 GNUNET_assert (NULL != label);
942 identity,
943 label,
945 rvk,
947 rvk);
948 GNUNET_free (tmp);
949 return rvk;
950}
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_CRYPTO_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.
char gns_name[63 *2+2]
The ticket.
struct GNUNET_RECLAIM_Ticket ticket
Ticket to issue.

References RECLAIM_TICKETS_RevokeHandle::cb, RECLAIM_TICKETS_RevokeHandle::cb_cls, GNUNET_RECLAIM_Ticket::gns_name, GNUNET_assert, GNUNET_free, GNUNET_NAMESTORE_records_lookup(), GNUNET_new, GNUNET_strdup, identity, RECLAIM_TICKETS_RevokeHandle::identity, RECLAIM_TICKETS_RevokeHandle::ns_qe, nsh, revoke_attrs_cb(), 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 959 of file gnunet-service-reclaim_tickets.c.

960{
961 GNUNET_assert (NULL != rh);
962 cleanup_rvk (rh);
963}

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 976 of file gnunet-service-reclaim_tickets.c.

977{
978 struct ParallelLookup *lu;
979
980 if (NULL != cth->lookup_request)
982 if (NULL != cth->kill_task)
984 while (NULL != (lu = cth->parallel_lookups_head))
985 {
986 if (NULL != lu->lookup_request)
988 GNUNET_free (lu->label);
991 lu);
992 GNUNET_free (lu);
993 }
994
995 if (NULL != cth->attrs)
997 if (NULL != cth->presentations)
999 GNUNET_free (cth);
1000}
void * GNUNET_GNS_lookup_with_tld_cancel(struct GNUNET_GNS_LookupWithTldRequest *ltr)
Cancel pending lookup request.
Definition: gns_tld_api.c:331
void * GNUNET_GNS_lookup_cancel(struct GNUNET_GNS_LookupRequest *lr)
Cancel pending lookup request.
Definition: gns_api.c:313
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:981
Handle for a parallel GNS lookup job.
struct GNUNET_GNS_LookupRequest * lookup_request
struct GNUNET_RECLAIM_AttributeList * attrs
Attributes.
struct ParallelLookup * parallel_lookups_tail
Lookup DLL.
struct ParallelLookup * parallel_lookups_head
Lookup DLL.
struct GNUNET_GNS_LookupWithTldRequest * lookup_request
LookupRequest.
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_GNS_lookup_with_tld_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

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

1007{
1008 struct ParallelLookup *parallel_lookup = cls;
1009 struct RECLAIM_TICKETS_ConsumeHandle *cth = parallel_lookup->handle;
1010 struct GNUNET_RECLAIM_AttributeListEntry *attr_le;
1011 struct GNUNET_CRYPTO_PublicKey iss;
1012
1014 "Parallel lookup finished (count=%u)\n",
1015 rd_count);
1016
1019 parallel_lookup);
1020 GNUNET_free (parallel_lookup->label);
1021
1023 "attribute_lookup_time_total",
1025 parallel_lookup->lookup_start_time)
1026 .rel_value_us,
1027 GNUNET_YES);
1028 GNUNET_STATISTICS_update (stats, "attribute_lookups_count", 1, GNUNET_YES);
1029
1030
1031 GNUNET_free (parallel_lookup);
1032 if (0 == rd_count)
1033 GNUNET_break (0);
1034 // REMARK: It is possible now to find rd_count > 1
1035 for (int i = 0; i < rd_count; i++)
1036 {
1037 if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE != rd[i].record_type)
1038 continue;
1041 &attr_le->attribute);
1043 cth->attrs->list_tail,
1044 attr_le);
1045 }
1046 if (NULL != cth->parallel_lookups_head)
1047 return; // Wait for more
1048 /* Else we are done */
1050 );
1051 cth->cb (cth->cb_cls, &iss,
1052 cth->attrs, cth->presentations, GNUNET_OK, NULL);
1053 cleanup_cth (cth);
1054}
static struct GNUNET_STATISTICS_Handle * stats
static void cleanup_cth(struct RECLAIM_TICKETS_ConsumeHandle *cth)
Cleanup ticket consume handle.
enum GNUNET_GenericReturnValue GNUNET_GNS_parse_ztld(const char *name, struct GNUNET_CRYPTO_PublicKey *ztld_key)
Try to parse the zTLD into a public key.
Definition: gns_tld_api.c:228
#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
An identity key as per LSD0001.
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_RECLAIM_Ticket::gns_name, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNS_parse_ztld(), 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, 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 1063 of file gnunet-service-reclaim_tickets.c.

1064{
1065 struct RECLAIM_TICKETS_ConsumeHandle *cth = cls;
1066 struct ParallelLookup *lu;
1067 struct ParallelLookup *tmp;
1068
1069 cth->kill_task = NULL;
1070 for (lu = cth->parallel_lookups_head; NULL != lu;)
1071 {
1073 GNUNET_free (lu->label);
1074 tmp = lu->next;
1077 lu);
1078 GNUNET_free (lu);
1079 lu = tmp;
1080 }
1081 cth->cb (cth->cb_cls, NULL, NULL, NULL, GNUNET_SYSERR, "Aborted");
1082}
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,
int  is_gns,
uint32_t  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

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

Return error

Return error

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.

1090{
1091 struct RECLAIM_TICKETS_ConsumeHandle *cth = cls;
1092 struct GNUNET_CRYPTO_PublicKey iss;
1093 struct ParallelLookup *parallel_lookup;
1094 const char *rp_uri = NULL;
1095 char *lbl;
1097
1098 cth->lookup_request = NULL;
1099
1100 GNUNET_assert (GNUNET_YES == is_gns);
1102 "reclaim_authz_lookup_time_total",
1104 cth->lookup_start_time)
1105 .rel_value_us,
1106 GNUNET_YES);
1108 "reclaim_authz_lookups_count",
1109 1,
1110 GNUNET_YES);
1111
1113 == GNUNET_GNS_parse_ztld (cth->ticket.gns_name, &iss));
1114 for (int i = 0; i < rd_count; i++)
1115 {
1120 switch (rd[i].record_type)
1121 {
1123 rp_uri = rd[i].data;
1124 break;
1127 ale->presentation =
1129 rd[i].data_size);
1132 ale);
1133 break;
1136 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ticket reference found %s\n", lbl);
1137 parallel_lookup = GNUNET_new (struct ParallelLookup);
1138 parallel_lookup->handle = cth;
1139 parallel_lookup->label = lbl;
1140 parallel_lookup->lookup_start_time = GNUNET_TIME_absolute_get ();
1141 parallel_lookup->lookup_request =
1143 lbl,
1144 &iss,
1148 parallel_lookup);
1151 parallel_lookup);
1152 break;
1153 default:
1155 "Ignoring unknown record type %d", rd[i].record_type);
1156 }
1157 }
1158 if (NULL == rp_uri)
1159 {
1161 "RP URI not found along references, ignoring...\n");
1165 cth->cb (cth->cb_cls, &iss,
1166 cth->attrs, NULL, GNUNET_NO, NULL);
1167 cleanup_cth (cth);
1168 return;
1169 }
1170 if (0 != strcmp (rp_uri, cth->rp_uri))
1171 {
1173 "RP URI does not match consume request: `%s' != `%s'\n",
1174 rp_uri, cth->rp_uri);
1178 cth->cb (cth->cb_cls, &iss,
1179 cth->attrs, NULL, GNUNET_NO, NULL);
1180 cleanup_cth (cth);
1181 return;
1182 }
1187 if (NULL != cth->parallel_lookups_head)
1188 {
1192 cth);
1193 return;
1194 }
1198 cth->cb (cth->cb_cls, &iss,
1199 cth->attrs, NULL, GNUNET_OK, NULL);
1200 cleanup_cth (cth);
1201}
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)
#define GNUNET_DNSPARSER_TYPE_TXT
struct GNUNET_GNS_LookupRequest * GNUNET_GNS_lookup(struct GNUNET_GNS_Handle *handle, const char *name, const struct GNUNET_CRYPTO_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:421
@ 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:1278
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
#define GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION
Record type for a presentation of a credential.
struct GNUNET_RECLAIM_Presentation * presentation
The credential.
struct GNUNET_RECLAIM_PresentationListEntry * list_head
List head.
struct GNUNET_RECLAIM_PresentationListEntry * list_tail
List tail.
char rp_uri[GNUNET_RECLAIM_TICKET_RP_URI_MAX_LEN]
The ticket audience (= relying party) URI.
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, GNUNET_GNSRECORD_Data::data, data_size, gns, GNUNET_RECLAIM_Ticket::gns_name, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_DNSPARSER_TYPE_TXT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_GNS_LO_DEFAULT, GNUNET_GNS_lookup(), GNUNET_GNS_parse_ztld(), GNUNET_GNSRECORD_TYPE_ANY, GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF, GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION, GNUNET_log, GNUNET_new, GNUNET_NO, 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, 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, RECLAIM_TICKETS_ConsumeHandle::rp_uri, 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_RECLAIM_Ticket ticket,
const char *  rp_uri,
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 1216 of file gnunet-service-reclaim_tickets.c.

1220{
1222
1224
1227 cth->ticket = *ticket;
1228 memcpy (cth->rp_uri, rp_uri, strlen (rp_uri) + 1);
1229 cth->cb = cb;
1230 cth->cb_cls = cb_cls;
1232 cth->lookup_request =
1238 cth);
1239 return cth;
1240}
static void lookup_authz_cb(void *cls, int is_gns, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
struct GNUNET_GNS_LookupWithTldRequest * GNUNET_GNS_lookup_with_tld(struct GNUNET_GNS_Handle *handle, const char *name, uint32_t type, enum GNUNET_GNS_LocalOptions options, GNUNET_GNS_LookupResultProcessor2 proc, void *proc_cls)
Perform an asynchronous lookup operation on the GNS, determining the zone using the TLD of the given ...
Definition: gns_tld_api.c:240
A list of GNUNET_RECLAIM_Attribute structures.
A list of GNUNET_RECLAIM_Presentation structures.

References RECLAIM_TICKETS_ConsumeHandle::attrs, RECLAIM_TICKETS_ConsumeHandle::cb, RECLAIM_TICKETS_ConsumeHandle::cb_cls, gns, GNUNET_RECLAIM_Ticket::gns_name, GNUNET_GNS_LO_DEFAULT, GNUNET_GNS_lookup_with_tld(), GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF, GNUNET_new, GNUNET_TIME_absolute_get(), lookup_authz_cb(), RECLAIM_TICKETS_ConsumeHandle::lookup_request, RECLAIM_TICKETS_ConsumeHandle::lookup_start_time, RECLAIM_TICKETS_ConsumeHandle::presentations, RECLAIM_TICKETS_ConsumeHandle::rp_uri, 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 1249 of file gnunet-service-reclaim_tickets.c.

1250{
1251 cleanup_cth (cth);
1252 return;
1253}

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 1265 of file gnunet-service-reclaim_tickets.c.

1266{
1267 if (NULL != handle->ns_qe)
1270}
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35

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 1282 of file gnunet-service-reclaim_tickets.c.

1283{
1284 struct TicketIssueHandle *handle = cls;
1285
1286 handle->ns_qe = NULL;
1287 if (GNUNET_EC_NONE != ec)
1288 {
1289 handle->cb (handle->cb_cls,
1290 &handle->ticket,
1291 NULL,
1293 "Error storing AuthZ ticket in GNS");
1294 return;
1295 }
1296 handle->cb (handle->cb_cls,
1297 &handle->ticket,
1298 handle->presentations,
1299 GNUNET_OK, NULL);
1301}
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 1312 of file gnunet-service-reclaim_tickets.c.

1313{
1316 struct GNUNET_GNSRECORD_Data *attrs_record;
1317 char *label;
1318 char *tkt_data;
1319 int i;
1320 int j;
1321 int attrs_count = 0;
1322
1323 for (le = ih->attrs->list_head; NULL != le; le = le->next)
1324 attrs_count++;
1325
1326 // Worst case we have one presentation per attribute plus the ticket
1327 // plus the RP URI record
1328 attrs_record =
1329 GNUNET_malloc ((2 * attrs_count + 2) * sizeof(struct GNUNET_GNSRECORD_Data))
1330 ;
1331 i = 0;
1332 for (le = ih->attrs->list_head; NULL != le; le = le->next)
1333 {
1335 "Adding list entry: %s\n", le->attribute->name);
1336
1337 attrs_record[i].data = &le->attribute->id;
1338 attrs_record[i].data_size = sizeof(le->attribute->id);
1342 i++;
1344 {
1346 "Attribute is backed by credential. Adding...\n");
1347 struct GNUNET_RECLAIM_Presentation *presentation = NULL;
1348 for (j = 0; j < i; j++)
1349 {
1350 if (attrs_record[j].record_type
1352 continue;
1354 attrs_record[j].data,
1355 attrs_record[j].
1356 data_size);
1357 if (NULL == presentation)
1358 {
1360 "Failed to deserialize presentation\n");
1361 continue;
1362 }
1363 if (0 == memcmp (&presentation->credential_id,
1364 &le->attribute->credential,
1365 sizeof (le->attribute->credential)))
1366 break;
1367 GNUNET_free (presentation);
1368 presentation = NULL;
1369 }
1370 if (NULL != presentation)
1371 {
1372 GNUNET_free (presentation);
1373 continue; // Skip as we have already added this credential presentation.
1374 }
1375 for (ple = ih->presentations->list_head; NULL != ple; ple = ple->next)
1376 {
1378 "Checking presentation....\n");
1379
1380 if (0 != memcmp (&le->attribute->credential,
1382 sizeof (le->attribute->credential)))
1383 {
1385 "Presentation does not match credential ID.\n");
1386 continue;
1387 }
1388 char *pres_buf;
1389 size_t pres_size;
1390
1391 pres_size =
1393 pres_buf = GNUNET_malloc (pres_size);
1395 pres_buf);
1396 attrs_record[i].data = pres_buf;
1397 attrs_record[i].data_size = pres_size;
1398 attrs_record[i].expiration_time =
1400 attrs_record[i].record_type =
1403 i++;
1404 break;
1405 }
1406 }
1407 }
1408
1409 label =
1411 sizeof(ih->rnd));
1414 &pub);
1417 "Storing AuthZ information under %s in %s\n", label, str);
1418 sprintf (ih->ticket.gns_name, "%s.%s", label, str);
1419 GNUNET_free (str);
1420
1421 attrs_record[i].data_size =
1422 strlen (ih->ticket.gns_name) + 1;
1423 tkt_data = GNUNET_malloc (attrs_record[i].data_size);
1424 memcpy (tkt_data, &ih->ticket, attrs_record[i].data_size);
1425 // The ticket: Could be removed?
1426 attrs_record[i].data = tkt_data;
1429 attrs_record[i].flags =
1431 i++;
1432 // The RP URI
1433 attrs_record[i].data_size = strlen (ih->rp_uri);
1434 attrs_record[i].data = ih->rp_uri;
1436 attrs_record[i].record_type = GNUNET_DNSPARSER_TYPE_TXT;
1437 attrs_record[i].flags =
1439 i++;
1440
1441 // Publish record
1443 &ih->identity,
1444 label,
1445 i,
1446 attrs_record,
1448 ih);
1449 for (j = 0; j < i; j++)
1450 {
1451 if (attrs_record[j].record_type
1453 continue;
1454 // Yes, we are allowed to do this because we allocated it above
1455 char *ptr = (char*) attrs_record[j].data;
1456 GNUNET_free (ptr);
1457 }
1458 GNUNET_free (tkt_data);
1459 GNUNET_free (attrs_record);
1460 GNUNET_free (label);
1461}
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.
char * GNUNET_CRYPTO_public_key_to_string(const struct GNUNET_CRYPTO_PublicKey *key)
Creates a (Base32) string representation of the public key.
Definition: crypto_pkey.c:568
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_key_get_public(const struct GNUNET_CRYPTO_PrivateKey *privkey, struct GNUNET_CRYPTO_PublicKey *key)
Retrieves the public key representation of a private key.
Definition: crypto_pkey.c:619
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.
#define GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET
local ticket reference
size_t data_size
Number of bytes in data.
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.
char rp_uri[GNUNET_RECLAIM_TICKET_RP_URI_MAX_LEN]
The ticket audience (= relying party) URI.
struct GNUNET_CRYPTO_PrivateKey identity
Issuer Key.
struct GNUNET_RECLAIM_Ticket ticket
Ticket to issue.
struct GNUNET_RECLAIM_Identifier rnd
The ticket random identifier.

References GNUNET_RECLAIM_AttributeListEntry::attribute, TicketIssueHandle::attrs, GNUNET_RECLAIM_Attribute::credential, GNUNET_RECLAIM_Presentation::credential_id, data, GNUNET_GNSRECORD_Data::data, data_size, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_RECLAIM_Ticket::gns_name, GNUNET_CRYPTO_key_get_public(), GNUNET_CRYPTO_public_key_to_string(), GNUNET_DNSPARSER_TYPE_TXT, 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_log, GNUNET_malloc, GNUNET_NAMESTORE_record_set_store(), GNUNET_NO, GNUNET_RECLAIM_id_is_zero, GNUNET_RECLAIM_presentation_deserialize(), GNUNET_RECLAIM_presentation_serialize(), GNUNET_RECLAIM_presentation_serialize_get_size(), 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, TicketIssueHandle::rnd, TicketIssueHandle::rp_uri, 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 1475 of file gnunet-service-reclaim_tickets.c.

1476{
1477 struct TicketIssueHandle *tih = cls;
1478
1479 tih->ns_it = NULL;
1480 tih->cb (tih->cb_cls,
1481 &tih->ticket,
1482 NULL,
1484 "Error storing AuthZ ticket in GNS");
1486}
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_CRYPTO_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 1502 of file gnunet-service-reclaim_tickets.c.

1507{
1508 struct TicketIssueHandle *tih = cls;
1510 struct GNUNET_RECLAIM_Presentation *presentation;
1511 struct GNUNET_RECLAIM_PresentationList *ticket_presentations;
1512 struct GNUNET_RECLAIM_Credential *cred;
1515 unsigned int attr_cnt = 0;
1516 unsigned int pres_cnt = 0;
1517 int ticket_found = GNUNET_NO;
1518 int rp_uri_matches = GNUNET_NO;
1519
1520 for (le = tih->attrs->list_head; NULL != le; le = le->next)
1521 {
1522 attr_cnt++;
1524 pres_cnt++;
1525 }
1526
1527 // ticket search
1528 unsigned int found_attrs_cnt = 0;
1529 unsigned int found_pres_cnt = 0;
1530 ticket_presentations = GNUNET_new (struct GNUNET_RECLAIM_PresentationList);
1531
1532 for (int i = 0; i < rd_count; i++)
1533 {
1534 // found ticket
1535 if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET == rd[i].record_type)
1536 {
1537 ticket = (struct GNUNET_RECLAIM_Ticket *) rd[i].data;
1538 tih->ticket = *ticket;
1539 ticket_found = GNUNET_YES;
1540 }
1541 if (GNUNET_DNSPARSER_TYPE_TXT == rd[i].record_type)
1542 {
1543 // cmp audience
1544 if (0 != strncmp (tih->rp_uri,
1545 rd[i].data,
1546 rd[i].data_size))
1547 continue;
1548 rp_uri_matches = GNUNET_YES;
1549 }
1550 // cmp requested attributes with ticket attributes
1551 if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF == rd[i].record_type)
1552 {
1553 for (le = tih->attrs->list_head; NULL != le; le = le->next)
1554 {
1556 &le->attribute->id))
1557 found_attrs_cnt++;
1558 }
1559 }
1560 if (GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL == rd[i].record_type)
1561 {
1563 "Found credential...\n");
1564
1565 for (le = tih->attrs->list_head; NULL != le; le = le->next)
1566 {
1568 rd[i].data_size);
1570 &le->attribute->credential
1571 ))
1572 {
1574 "No match.\n");
1575 GNUNET_free (cred);
1576 continue;
1577 }
1579 "Match, creating presentation...\n");
1581 cred,
1582 tih->attrs,
1583 &presentation))
1584 {
1586 "Unable to retrieve presentation from credential\n");
1587 GNUNET_free (cred);
1588 continue;
1589 }
1591 ple->presentation = presentation;
1594 ple);
1595 GNUNET_free (cred);
1596 break;
1597 }
1598 }
1599 if (GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION == rd[i].record_type)
1600 {
1601 for (le = tih->attrs->list_head; NULL != le; le = le->next)
1602 {
1604 rd[i].data_size)
1605 ;
1606 if (NULL == presentation)
1607 {
1609 "Failed to deserialize presentation\n");
1610 continue;
1611 }
1613 &presentation->credential_id,
1614 &le->attribute->credential))
1615 {
1616 found_pres_cnt++;
1618 ple->presentation = presentation;
1619 GNUNET_CONTAINER_DLL_insert (ticket_presentations->list_head,
1620 ticket_presentations->list_tail,
1621 ple);
1622 }
1623 }
1624 }
1625 }
1626
1631 if ((attr_cnt == found_attrs_cnt) &&
1632 (pres_cnt == found_pres_cnt) &&
1633 (GNUNET_YES == ticket_found) &&
1634 (GNUNET_YES == rp_uri_matches))
1635 {
1637 tih->cb (tih->cb_cls, &tih->ticket, ticket_presentations, GNUNET_OK, NULL);
1638 GNUNET_RECLAIM_presentation_list_destroy (ticket_presentations);
1640 return;
1641 }
1642 GNUNET_RECLAIM_presentation_list_destroy (ticket_presentations);
1643 // ticket not found in current record, checking next record set
1645}
#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.
struct GNUNET_RECLAIM_Identifier id
ID.
The authorization ticket.

References GNUNET_RECLAIM_AttributeListEntry::attribute, TicketIssueHandle::attrs, TicketIssueHandle::cb, TicketIssueHandle::cb_cls, cleanup_issue_handle(), GNUNET_RECLAIM_Attribute::credential, GNUNET_RECLAIM_Presentation::credential_id, data, GNUNET_GNSRECORD_Data::data, data_size, GNUNET_GNSRECORD_Data::data_size, GNUNET_CONTAINER_DLL_insert, GNUNET_DNSPARSER_TYPE_TXT, 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_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, TicketIssueHandle::rp_uri, 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 1656 of file gnunet-service-reclaim_tickets.c.

1657{
1658 struct TicketIssueHandle *tih = cls;
1659
1661 issue_ticket (tih);
1662}
static void issue_ticket(struct TicketIssueHandle *ih)
Issue a new ticket.

References GNUNET_RECLAIM_id_generate, issue_ticket(), and TicketIssueHandle::rnd.

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_CRYPTO_PrivateKey identity,
const struct GNUNET_RECLAIM_AttributeList attrs,
const char *  rp,
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 1677 of file gnunet-service-reclaim_tickets.c.

1682{
1683 struct TicketIssueHandle *tih;
1684
1685 tih = GNUNET_new (struct TicketIssueHandle);
1686 tih->cb = cb;
1687 tih->cb_cls = cb_cls;
1690 tih->identity = *identity;
1691 memcpy (tih->rp_uri, rp, strlen (rp) + 1);
1692
1693 // First check whether the ticket has already been issued
1694 tih->ns_it =
1696 &tih->identity,
1698 tih,
1700 tih,
1702 tih);
1703}
static char * rp
Relying party.
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_cb(void *cls, const struct GNUNET_CRYPTO_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Iterator over records.
static void filter_tickets_error_cb(void *cls)
Namestore error on issue.
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, 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, rp, and TicketIssueHandle::rp_uri.

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 1716 of file gnunet-service-reclaim_tickets.c.

1717{
1718 if (NULL != iter->ns_it)
1720 GNUNET_free (iter);
1721}
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_CRYPTO_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 1736 of file gnunet-service-reclaim_tickets.c.

1741{
1742 struct RECLAIM_TICKETS_Iterator *iter = cls;
1744 int ticket_found = GNUNET_NO;
1745 const char *rp_uri = NULL;
1746
1747 for (int i = 0; i < rd_count; i++)
1748 {
1749 if (GNUNET_DNSPARSER_TYPE_TXT == rd[i].record_type)
1750 rp_uri = rd[i].data;
1751 if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET != rd[i].record_type)
1752 continue;
1753 if ((GNUNET_YES == ticket_found) && (NULL != rp_uri))
1754 break;
1755 ticket = (struct GNUNET_RECLAIM_Ticket *) rd[i].data;
1756 ticket_found = GNUNET_YES;
1757 }
1758 if ((GNUNET_YES == ticket_found) && (NULL != rp_uri))
1759 iter->cb (iter->cb_cls, ticket, rp_uri);
1761}
RECLAIM_TICKETS_TicketIter cb
Iter callback.

References RECLAIM_TICKETS_Iterator::cb, RECLAIM_TICKETS_Iterator::cb_cls, data, GNUNET_GNSRECORD_Data::data, GNUNET_DNSPARSER_TYPE_TXT, GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET, GNUNET_NAMESTORE_zone_iterator_next(), GNUNET_NO, GNUNET_YES, 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 1770 of file gnunet-service-reclaim_tickets.c.

1771{
1772 struct RECLAIM_TICKETS_Iterator *iter = cls;
1773
1774 iter->ns_it = NULL;
1775 iter->cb (iter->cb_cls, NULL, NULL);
1776 cleanup_iter (iter);
1777}
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 1786 of file gnunet-service-reclaim_tickets.c.

1787{
1788 struct RECLAIM_TICKETS_Iterator *iter = cls;
1789
1790 iter->ns_it = NULL;
1791 iter->cb (iter->cb_cls, NULL, NULL);
1792 cleanup_iter (iter);
1793}

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 1802 of file gnunet-service-reclaim_tickets.c.

1803{
1805}

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 1814 of file gnunet-service-reclaim_tickets.c.

1815{
1817 cleanup_iter (iter);
1818}

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_CRYPTO_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 1830 of file gnunet-service-reclaim_tickets.c.

1834{
1835 struct RECLAIM_TICKETS_Iterator *iter;
1836
1837 iter = GNUNET_new (struct RECLAIM_TICKETS_Iterator);
1838 iter->cb = cb;
1839 iter->cb_cls = cb_cls;
1840 iter->ns_it =
1842 identity,
1844 iter,
1846 iter,
1848 iter);
1849 return iter;
1850}
static void collect_tickets_finished_cb(void *cls)
Signal ticket iteration has finished.
static void collect_tickets_error_cb(void *cls)
Cancel ticket iteration on namestore error.
static void collect_tickets_cb(void *cls, const struct GNUNET_CRYPTO_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...

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 1860 of file gnunet-service-reclaim_tickets.c.

1861{
1862 // Get ticket expiration time (relative) from config
1863 if (GNUNET_OK ==
1865 "reclaim",
1866 "TICKET_REFRESH_INTERVAL",
1868 {
1870 "Configured refresh interval for tickets: %s\n",
1872 GNUNET_YES));
1873 }
1874 else
1875 {
1877 }
1878 // Connect to identity and namestore services
1880 if (NULL == nsh)
1881 {
1883 "error connecting to namestore");
1884 return GNUNET_SYSERR;
1885 }
1886 gns = GNUNET_GNS_connect (c);
1887 if (NULL == gns)
1888 {
1889 GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "error connecting to gns");
1890 return GNUNET_SYSERR;
1891 }
1892 stats = GNUNET_STATISTICS_create ("reclaim", c);
1893 return GNUNET_OK;
1894}
#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:267
#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:570

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 1902 of file gnunet-service-reclaim_tickets.c.

1903{
1904 if (NULL != nsh)
1906 nsh = NULL;
1907 if (NULL != gns)
1909 gns = NULL;
1910 if (NULL != stats)
1911 {
1913 stats = NULL;
1914 }
1915}
void GNUNET_GNS_disconnect(struct GNUNET_GNS_Handle *handle)
Shutdown connection with the GNS service.
Definition: gns_api.c:289
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 341 of file gnunet-service-reclaim_tickets.c.

Referenced by issue_ticket(), and RECLAIM_TICKETS_init().

◆ nsh

◆ gns

◆ stats