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 minimum 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_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. 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_ConsumeHandle *	RECLAIM_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_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. 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_Handle *	nsh
static struct GNUNET_GNS_Handle *	gns
static struct GNUNET_STATISTICS_Handle *	stats

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 minimum 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

rh	the ticket revocation handle

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

{
  struct RevokedAttributeEntry *ae;
  struct TicketRecordsEntry *le;
 
  if (NULL != rh->ns_qe)
    GNUNET_NAMESTORE_cancel (rh->ns_qe);
  if (NULL != rh->ns_it)
    GNUNET_NAMESTORE_zone_iteration_stop (rh->ns_it);
  while (NULL != (ae = rh->attrs_head))
  {
    GNUNET_CONTAINER_DLL_remove (rh->attrs_head, rh->attrs_tail, ae);
    GNUNET_free (ae);
  }
  while (NULL != (le = rh->tickets_to_update_head))
  {
    GNUNET_CONTAINER_DLL_remove (rh->tickets_to_update_head,
                                 rh->tickets_to_update_head,
                                 le);
    if (NULL != le->data)
      GNUNET_free (le->data);
    if (NULL != le->label)
      GNUNET_free (le->label);
    GNUNET_free (le);
  }
  GNUNET_free (rh);
}

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

cls	handle to the operation

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

{
  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
  struct TicketRecordsEntry *le;
  struct RevokedAttributeEntry *ae;
 
  if (NULL == rvk->tickets_to_update_head)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Finished updatding tickets, success\n");
    rvk->cb (rvk->cb_cls, GNUNET_OK);
    cleanup_rvk (rvk);
    return;
  }
  le = rvk->tickets_to_update_head;
  GNUNET_CONTAINER_DLL_remove (rvk->tickets_to_update_head,
                               rvk->tickets_to_update_tail,
                               le);
  struct GNUNET_GNSRECORD_Data rd[le->rd_count];
  if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize (le->data_size,
                                                         le->data,
                                                         le->rd_count,
                                                         rd))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Unable to deserialize ticket record(s)\n");
    rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
    cleanup_rvk (rvk);
    return;
  }
  for (int i = 0; i < le->rd_count; i++)
  {
    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF != rd[i].record_type)
      continue;
    for (ae = rvk->attrs_head; NULL != ae; ae = ae->next)
    {
      if (0 != memcmp (rd[i].data, &ae->old_id, sizeof(ae->old_id)))
        continue;
      rd[i].data = &ae->new_id;
    }
  }
  rvk->ns_qe = GNUNET_NAMESTORE_record_set_store (nsh,
                                                  &rvk->identity,
                                                  le->label,
                                                  le->rd_count,
                                                  rd,
                                                  &ticket_processed,
                                                  rvk);
  GNUNET_free (le->label);
  GNUNET_free (le->data);
  GNUNET_free (le);
}

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

cls	handle to the operation
success	result of namestore operation
emsg	(NULL on success)

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

{
  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
 
  rvk->ns_qe = NULL;
  GNUNET_SCHEDULER_add_now (&process_tickets, rvk);
}

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

cls	handle to the operation

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

{
  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
 
  rvk->ns_it = NULL;
  GNUNET_SCHEDULER_add_now (&process_tickets, rvk);
}

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

cls	handle to the operation
zone	ticket issuer private key
label	ticket rnd
rd_count	size of record set
rd	record set

Let everything point to the old record

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

{
  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
  struct TicketRecordsEntry *le;
  struct RevokedAttributeEntry *ae;
  int has_changed = GNUNET_NO;
 
  for (int i = 0; i < rd_count; i++)
  {
    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF != rd[i].record_type)
      continue;
    for (ae = rvk->attrs_head; NULL != ae; ae = ae->next)
    {
      if (0 != memcmp (rd[i].data, &ae->old_id, sizeof(ae->old_id)))
        continue;
      has_changed = GNUNET_YES;
      break;
    }
    if (GNUNET_YES == has_changed)
      break;
  }
  if (GNUNET_YES == has_changed)
  {
    le = GNUNET_new (struct TicketRecordsEntry);
    le->data_size = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
    le->data = GNUNET_malloc (le->data_size);
    le->rd_count = rd_count;
    le->label = GNUNET_strdup (label);
    GNUNET_GNSRECORD_records_serialize (rd_count, rd, le->data_size, le->data);
    GNUNET_CONTAINER_DLL_insert (rvk->tickets_to_update_head,
                                 rvk->tickets_to_update_tail,
                                 le);
  }
  GNUNET_NAMESTORE_zone_iterator_next (rvk->ns_it, 1);
}

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

cls	handle to the operation

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

{
  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
 
  rvk->ns_it = NULL;
  rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
  cleanup_rvk (rvk);
}

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

cls	handle to the operation

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

{
  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
 
  rvk->ns_qe = NULL;
  rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
  cleanup_rvk (rvk);
}

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

rh	handle to the operation

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

{
  char *label;
 
  if (NULL == rvk->move_attr)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished moving attributes\n");
    rvk->ns_it =
      GNUNET_NAMESTORE_zone_iteration_start (nsh,
                                             &rvk->identity,
                                             &rvk_ns_iter_err,
                                             rvk,
                                             &rvk_ticket_update,
                                             rvk,
                                             &rvk_ticket_update_finished,
                                             rvk);
    return;
  }
  label = GNUNET_STRINGS_data_to_string_alloc (&rvk->move_attr->old_id,
                                               sizeof (rvk->move_attr->old_id));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Moving claim %s\n", label);
 
  rvk->ns_qe = GNUNET_NAMESTORE_records_lookup (nsh,
                                                &rvk->identity,
                                                label,
                                                &rvk_ns_err,
                                                rvk,
                                                &rvk_move_attr_cb,
                                                rvk);
  GNUNET_free (label);
}

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

cls	handle to the operation.

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

{
  move_attrs ((struct RECLAIM_TICKETS_RevokeHandle *) cls);
}

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

cls	handle to the operation
success	result of the namestore operation
emsg	error message (NULL on success)

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

{
  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
 
  rvk->ns_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Error removing attribute: %s\n",
                GNUNET_ErrorCode_get_hint (ec));
    rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
    cleanup_rvk (rvk);
    return;
  }
  rvk->move_attr = rvk->move_attr->next;
  GNUNET_SCHEDULER_add_now (&move_attrs_cont, rvk);
}

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

cls	handle to the operation
success	result of the store operation
emsg	error message (NULL on success)

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

{
  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
  char *label;
 
  rvk->ns_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Error moving attribute: %s\n",
                GNUNET_ErrorCode_get_hint (ec));
    rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
    cleanup_rvk (rvk);
    return;
  }
  label = GNUNET_STRINGS_data_to_string_alloc (&rvk->move_attr->old_id,
                                               sizeof(rvk->move_attr->old_id));
  GNUNET_assert (NULL != label);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Removing attribute %s\n", label);
  rvk->ns_qe = GNUNET_NAMESTORE_record_set_store (nsh,
                                                  &rvk->identity,
                                                  label,
                                                  0,
                                                  NULL,
                                                  &del_attr_finished,
                                                  rvk);
  GNUNET_free (label);
}

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

cls	handle to the operation
zone	issuer identity
label	attribute ID
rd_count	size of record set (should be 1)
rd	record set (the attribute)

find a new place for this attribute

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

{
  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
  struct GNUNET_GNSRECORD_Data new_rd[rd_count];
  struct RevokedAttributeEntry *le;
  char *new_label;
  char *attr_data;
 
  rvk->ns_qe = NULL;
  if (0 == rd_count)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "The claim %s no longer exists!\n",
                label);
    le = rvk->move_attr;
    rvk->move_attr = le->next;
    GNUNET_CONTAINER_DLL_remove (rvk->attrs_head, rvk->attrs_tail, le);
    GNUNET_free (le);
    GNUNET_SCHEDULER_add_now (&move_attrs_cont, rvk);
    return;
  }
  GNUNET_RECLAIM_id_generate (&rvk->move_attr->new_id);
  new_label =
    GNUNET_STRINGS_data_to_string_alloc (&rvk->move_attr->new_id,
                                         sizeof (rvk->move_attr->new_id));
 
  attr_data = NULL;
  // new_rd = *rd;
  for (int i = 0; i < rd_count; i++)
  {
    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE == rd[i].record_type)
    {
      struct GNUNET_RECLAIM_Attribute *claim;
      GNUNET_RECLAIM_attribute_deserialize (rd[i].data,
                                            rd[i].data_size,
                                            &claim);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Attribute to update: Name=%s\n",
                  claim->name);
      claim->id = rvk->move_attr->new_id;
      new_rd[i].data_size = GNUNET_RECLAIM_attribute_serialize_get_size (claim);
      attr_data = GNUNET_malloc (rd[i].data_size);
      new_rd[i].data_size = GNUNET_RECLAIM_attribute_serialize (claim,
                                                                attr_data);
      new_rd[i].data = attr_data;
      new_rd[i].record_type = rd[i].record_type;
      new_rd[i].flags = rd[i].flags;
      new_rd[i].expiration_time = rd[i].expiration_time;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute %s\n", new_label);
      GNUNET_free (claim);
    }
    else if (GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL == rd[i].record_type)
    {
      struct GNUNET_RECLAIM_Credential *credential;
      credential = GNUNET_RECLAIM_credential_deserialize (rd[i].data,
                                                          rd[i].data_size);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Credential to update: Name=%s\n",
                  credential->name);
      credential->id = rvk->move_attr->new_id;
      new_rd[i].data_size =
        GNUNET_RECLAIM_credential_serialize_get_size (credential);
      attr_data = GNUNET_malloc (rd[i].data_size);
      new_rd[i].data_size = GNUNET_RECLAIM_credential_serialize (credential,
                                                                 attr_data);
      new_rd[i].data = attr_data;
      new_rd[i].record_type = rd[i].record_type;
      new_rd[i].flags = rd[i].flags;
      new_rd[i].expiration_time = rd[i].expiration_time;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding credential %s\n",
                  new_label);
      GNUNET_free (credential);
    }
    else
    {
      memcpy (&new_rd[i], &rd[i], sizeof (struct GNUNET_GNSRECORD_Data));
    }
  }
  rvk->ns_qe = GNUNET_NAMESTORE_record_set_store (nsh,
                                                  &rvk->identity,
                                                  new_label,
                                                  rd_count,
                                                  new_rd,
                                                  &move_attr_finished,
                                                  rvk);
  GNUNET_free (new_label);
  GNUNET_free (attr_data);
}

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

cls	handle to the operation
success	Namestore operation return value
emsg	error message (NULL on success)

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

{
  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
 
  rvk->ns_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s\n",
                GNUNET_ErrorCode_get_hint (ec));
    rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
    cleanup_rvk (rvk);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleted ticket\n");
  if (0 == rvk->ticket_attrs)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "No attributes to move... strange\n");
    rvk->cb (rvk->cb_cls, GNUNET_OK);
    cleanup_rvk (rvk);
    return;
  }
  rvk->move_attr = rvk->attrs_head;
  move_attrs (rvk);
}

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

cls	handle to the operation
zone	the issuer key
label	ticket rnd
rd_count	size of record set
rd	record set

Temporarily store attribute references. We need it later.

Remove attribute references

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

{
  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
  struct RevokedAttributeEntry *le;
 
  rvk->ns_qe = NULL;
  for (int i = 0; i < rd_count; i++)
  {
    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF != rd[i].record_type)
      continue;
    le = GNUNET_new (struct RevokedAttributeEntry);
    le->old_id = *((struct GNUNET_RECLAIM_Identifier *) rd[i].data);
    GNUNET_CONTAINER_DLL_insert (rvk->attrs_head, rvk->attrs_tail, le);
    rvk->ticket_attrs++;
  }
 
  rvk->ns_qe = GNUNET_NAMESTORE_record_set_store (nsh,
                                                  &rvk->identity,
                                                  label,
                                                  0,
                                                  NULL,
                                                  &remove_ticket_cont,
                                                  rvk);
}

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

cls	handle to the operation

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

{
  struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
 
  rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
  cleanup_rvk (rvk);
}

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

ticket	ticket to revoke
identity	private key of issuer
cb	revocation status callback
cb_cls	callback closure

Returns

handle to the operation

Get shared attributes

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

{
  struct RECLAIM_TICKETS_RevokeHandle *rvk;
  char *label;
  char *tmp;
 
  rvk = GNUNET_new (struct RECLAIM_TICKETS_RevokeHandle);
  rvk->cb = cb;
  rvk->cb_cls = cb_cls;
  rvk->identity = *identity;
  rvk->ticket = *ticket;
  tmp = GNUNET_strdup (ticket->gns_name);
  label = strtok (tmp, ".");
  GNUNET_assert (NULL != label);
  rvk->ns_qe = GNUNET_NAMESTORE_records_lookup (nsh,
                                                identity,
                                                label,
                                                &rvk_attrs_err_cb,
                                                rvk,
                                                &revoke_attrs_cb,
                                                rvk);
  GNUNET_free (tmp);
  return rvk;
}

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

rh	handle to the operation

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

{
  GNUNET_assert (NULL != rh);
  cleanup_rvk (rh);
}

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

cth	the handle to clean up

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

{
  struct ParallelLookup *lu;
 
  if (NULL != cth->lookup_request)
    GNUNET_GNS_lookup_with_tld_cancel (cth->lookup_request);
  if (NULL != cth->kill_task)
    GNUNET_SCHEDULER_cancel (cth->kill_task);
  while (NULL != (lu = cth->parallel_lookups_head))
  {
    if (NULL != lu->lookup_request)
      GNUNET_GNS_lookup_cancel (lu->lookup_request);
    GNUNET_free (lu->label);
    GNUNET_CONTAINER_DLL_remove (cth->parallel_lookups_head,
                                 cth->parallel_lookups_tail,
                                 lu);
    GNUNET_free (lu);
  }
 
  if (NULL != cth->attrs)
    GNUNET_RECLAIM_attribute_list_destroy (cth->attrs);
  if (NULL != cth->presentations)
    GNUNET_RECLAIM_presentation_list_destroy (cth->presentations);
  GNUNET_free (cth);
}

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.

{
  struct ParallelLookup *parallel_lookup = cls;
  struct RECLAIM_TICKETS_ConsumeHandle *cth = parallel_lookup->handle;
  struct GNUNET_RECLAIM_AttributeListEntry *attr_le;
  struct GNUNET_CRYPTO_PublicKey iss;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Parallel lookup finished (count=%u)\n",
              rd_count);
 
  GNUNET_CONTAINER_DLL_remove (cth->parallel_lookups_head,
                               cth->parallel_lookups_tail,
                               parallel_lookup);
  GNUNET_free (parallel_lookup->label);
 
  GNUNET_STATISTICS_update (stats,
                            "attribute_lookup_time_total",
                            GNUNET_TIME_absolute_get_duration (
                              parallel_lookup->lookup_start_time)
                            .rel_value_us,
                            GNUNET_YES);
  GNUNET_STATISTICS_update (stats, "attribute_lookups_count", 1, GNUNET_YES);
 
 
  GNUNET_free (parallel_lookup);
  if (0 == rd_count)
    GNUNET_break (0);
  // REMARK: It is possible now to find rd_count > 1
  for (int i = 0; i < rd_count; i++)
  {
    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE != rd[i].record_type)
      continue;
    attr_le = GNUNET_new (struct GNUNET_RECLAIM_AttributeListEntry);
    GNUNET_RECLAIM_attribute_deserialize (rd[i].data, rd[i].data_size,
                                          &attr_le->attribute);
    GNUNET_CONTAINER_DLL_insert (cth->attrs->list_head,
                                 cth->attrs->list_tail,
                                 attr_le);
  }
  if (NULL != cth->parallel_lookups_head)
    return; // Wait for more
  /* Else we are done */
  GNUNET_assert (GNUNET_OK == GNUNET_GNS_parse_ztld (cth->ticket.gns_name, &iss)
                 );
  cth->cb (cth->cb_cls, &iss,
           cth->attrs, cth->presentations, GNUNET_OK, NULL);
  cleanup_cth (cth);
}

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

cls	handle to the operation

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

{
  struct RECLAIM_TICKETS_ConsumeHandle *cth = cls;
  struct ParallelLookup *lu;
  struct ParallelLookup *tmp;
 
  cth->kill_task = NULL;
  for (lu = cth->parallel_lookups_head; NULL != lu;)
  {
    GNUNET_GNS_lookup_cancel (lu->lookup_request);
    GNUNET_free (lu->label);
    tmp = lu->next;
    GNUNET_CONTAINER_DLL_remove (cth->parallel_lookups_head,
                                 cth->parallel_lookups_tail,
                                 lu);
    GNUNET_free (lu);
    lu = tmp;
  }
  cth->cb (cth->cb_cls, NULL, NULL, NULL, GNUNET_SYSERR, "Aborted");
}

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.

{
  struct RECLAIM_TICKETS_ConsumeHandle *cth = cls;
  struct GNUNET_CRYPTO_PublicKey iss;
  struct ParallelLookup *parallel_lookup;
  const char *rp_uri = NULL;
  char *lbl;
  struct GNUNET_RECLAIM_PresentationListEntry *ale;
 
  cth->lookup_request = NULL;
 
  GNUNET_assert (GNUNET_YES == is_gns);
  GNUNET_STATISTICS_update (stats,
                            "reclaim_authz_lookup_time_total",
                            GNUNET_TIME_absolute_get_duration (
                              cth->lookup_start_time)
                            .rel_value_us,
                            GNUNET_YES);
  GNUNET_STATISTICS_update (stats,
                            "reclaim_authz_lookups_count",
                            1,
                            GNUNET_YES);
 
  GNUNET_assert (GNUNET_OK
                 == GNUNET_GNS_parse_ztld (cth->ticket.gns_name, &iss));
  for (int i = 0; i < rd_count; i++)
  {
    switch (rd[i].record_type)
    {
    case GNUNET_DNSPARSER_TYPE_TXT:
      rp_uri = rd[i].data;
      break;
    case GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION:
      ale = GNUNET_new (struct GNUNET_RECLAIM_PresentationListEntry);
      ale->presentation =
        GNUNET_RECLAIM_presentation_deserialize (rd[i].data,
                                                 rd[i].data_size);
      GNUNET_CONTAINER_DLL_insert (cth->presentations->list_head,
                                   cth->presentations->list_tail,
                                   ale);
      break;
    case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF:
      lbl = GNUNET_STRINGS_data_to_string_alloc (rd[i].data, rd[i].data_size);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ticket reference found %s\n", lbl);
      parallel_lookup = GNUNET_new (struct ParallelLookup);
      parallel_lookup->handle = cth;
      parallel_lookup->label = lbl;
      parallel_lookup->lookup_start_time = GNUNET_TIME_absolute_get ();
      parallel_lookup->lookup_request =
        GNUNET_GNS_lookup (gns,
                           lbl,
                           &iss,
                           GNUNET_GNSRECORD_TYPE_ANY,
                           GNUNET_GNS_LO_DEFAULT,
                           &process_parallel_lookup_result,
                           parallel_lookup);
      GNUNET_CONTAINER_DLL_insert (cth->parallel_lookups_head,
                                   cth->parallel_lookups_tail,
                                   parallel_lookup);
      break;
    default:
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Ignoring unknown record type %d", rd[i].record_type);
    }
  }
  if (NULL == rp_uri)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "RP URI not found along references, ignoring...\n");
    cth->cb (cth->cb_cls, &iss,
             cth->attrs, NULL, GNUNET_NO, NULL);
    cleanup_cth (cth);
    return;
  }
  if (0 != strcmp (rp_uri, cth->rp_uri))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "RP URI does not match consume request: `%s' != `%s'\n",
                rp_uri, cth->rp_uri);
    cth->cb (cth->cb_cls, &iss,
             cth->attrs, NULL, GNUNET_NO, NULL);
    cleanup_cth (cth);
    return;
  }
  if (NULL != cth->parallel_lookups_head)
  {
    cth->kill_task = GNUNET_SCHEDULER_add_delayed (
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 3),
      &abort_parallel_lookups,
      cth);
    return;
  }
  cth->cb (cth->cb_cls, &iss,
           cth->attrs, NULL, GNUNET_OK, NULL);
  cleanup_cth (cth);
}

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

id	the audience of the ticket
ticket	the ticket to consume
cb	callback to call with attributes of ticket
cb_cls	callback closure

Returns

handle to the operation

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

{
  struct RECLAIM_TICKETS_ConsumeHandle *cth;
 
  cth = GNUNET_new (struct RECLAIM_TICKETS_ConsumeHandle);
 
  cth->attrs = GNUNET_new (struct GNUNET_RECLAIM_AttributeList);
  cth->presentations = GNUNET_new (struct GNUNET_RECLAIM_PresentationList);
  cth->ticket = *ticket;
  memcpy (cth->rp_uri, rp_uri, strlen (rp_uri) + 1);
  cth->cb = cb;
  cth->cb_cls = cb_cls;
  cth->lookup_start_time = GNUNET_TIME_absolute_get ();
  cth->lookup_request =
    GNUNET_GNS_lookup_with_tld (gns,
                                ticket->gns_name,
                                GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF,
                                GNUNET_GNS_LO_DEFAULT,
                                &lookup_authz_cb,
                                cth);
  return cth;
}

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

cth	the operation to cancel

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

{
  cleanup_cth (cth);
  return;
}

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

handle

the handle to clean up

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

{
  if (NULL != handle->ns_qe)
    GNUNET_NAMESTORE_cancel (handle->ns_qe);
  GNUNET_free (handle);
}

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

cls	handle to the operation
success	store operation result
emsg	error message (or NULL on success)

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

{
  struct TicketIssueHandle *handle = cls;
 
  handle->ns_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    handle->cb (handle->cb_cls,
                &handle->ticket,
                NULL,
                GNUNET_SYSERR,
                "Error storing AuthZ ticket in GNS");
    return;
  }
  handle->cb (handle->cb_cls,
              &handle->ticket,
              handle->presentations,
              GNUNET_OK, NULL);
  cleanup_issue_handle (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

ih	handle to the operation containing relevant metadata

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

{
  struct GNUNET_RECLAIM_AttributeListEntry *le;
  struct GNUNET_RECLAIM_PresentationListEntry *ple;
  struct GNUNET_GNSRECORD_Data *attrs_record;
  char *label;
  char *tkt_data;
  int i;
  int j;
  int attrs_count = 0;
 
  for (le = ih->attrs->list_head; NULL != le; le = le->next)
    attrs_count++;
 
  // Worst case we have one presentation per attribute plus the ticket
  // plus the RP URI record
  attrs_record =
    GNUNET_malloc ((2 * attrs_count + 2) * sizeof(struct GNUNET_GNSRECORD_Data))
  ;
  i = 0;
  for (le = ih->attrs->list_head; NULL != le; le = le->next)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Adding list entry: %s\n", le->attribute->name);
 
    attrs_record[i].data = &le->attribute->id;
    attrs_record[i].data_size = sizeof(le->attribute->id);
    attrs_record[i].expiration_time = ticket_refresh_interval.rel_value_us;
    attrs_record[i].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF;
    attrs_record[i].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
    i++;
    if (GNUNET_NO == GNUNET_RECLAIM_id_is_zero (&le->attribute->credential))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Attribute is backed by credential. Adding...\n");
      struct GNUNET_RECLAIM_Presentation *presentation = NULL;
      for (j = 0; j < i; j++)
      {
        if (attrs_record[j].record_type
            != GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION)
          continue;
        presentation = GNUNET_RECLAIM_presentation_deserialize (
          attrs_record[j].data,
          attrs_record[j].
          data_size);
        if (NULL == presentation)
        {
          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                      "Failed to deserialize presentation\n");
          continue;
        }
        if (0 == memcmp (&presentation->credential_id,
                         &le->attribute->credential,
                         sizeof (le->attribute->credential)))
          break;
        GNUNET_free (presentation);
        presentation = NULL;
      }
      if (NULL != presentation)
      {
        GNUNET_free (presentation);
        continue; // Skip as we have already added this credential presentation.
      }
      for (ple = ih->presentations->list_head; NULL != ple; ple = ple->next)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Checking presentation....\n");
 
        if (0 != memcmp (&le->attribute->credential,
                         &ple->presentation->credential_id,
                         sizeof (le->attribute->credential)))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Presentation does not match credential ID.\n");
          continue;
        }
        char *pres_buf;
        size_t pres_size;
 
        pres_size =
          GNUNET_RECLAIM_presentation_serialize_get_size (ple->presentation);
        pres_buf = GNUNET_malloc (pres_size);
        GNUNET_RECLAIM_presentation_serialize (ple->presentation,
                                               pres_buf);
        attrs_record[i].data = pres_buf;
        attrs_record[i].data_size = pres_size;
        attrs_record[i].expiration_time =
          ticket_refresh_interval.rel_value_us;
        attrs_record[i].record_type =
          GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION;
        attrs_record[i].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
        i++;
        break;
      }
    }
  }
 
  label =
    GNUNET_STRINGS_data_to_string_alloc (&ih->rnd,
                                         sizeof(ih->rnd));
  struct GNUNET_CRYPTO_PublicKey pub;
  GNUNET_CRYPTO_key_get_public (&ih->identity,
                                &pub);
  char *str = GNUNET_CRYPTO_public_key_to_string (&pub);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Storing AuthZ information under %s in %s\n", label, str);
  sprintf (ih->ticket.gns_name, "%s.%s", label, str);
  GNUNET_free (str);
 
  attrs_record[i].data_size =
    strlen (ih->ticket.gns_name) + 1;
  tkt_data = GNUNET_malloc (attrs_record[i].data_size);
  memcpy (tkt_data, &ih->ticket, attrs_record[i].data_size);
  // The ticket: Could be removed?
  attrs_record[i].data = tkt_data;
  attrs_record[i].expiration_time = ticket_refresh_interval.rel_value_us;
  attrs_record[i].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET;
  attrs_record[i].flags =
    GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION | GNUNET_GNSRECORD_RF_PRIVATE;
  i++;
  // The RP URI
  attrs_record[i].data_size = strlen (ih->rp_uri);
  attrs_record[i].data = ih->rp_uri;
  attrs_record[i].expiration_time = ticket_refresh_interval.rel_value_us;
  attrs_record[i].record_type = GNUNET_DNSPARSER_TYPE_TXT;
  attrs_record[i].flags =
    GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
  i++;
 
  // Publish record
  ih->ns_qe = GNUNET_NAMESTORE_record_set_store (nsh,
                                                 &ih->identity,
                                                 label,
                                                 i,
                                                 attrs_record,
                                                 &store_ticket_issue_cont,
                                                 ih);
  for (j = 0; j < i; j++)
  {
    if (attrs_record[j].record_type
        != GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION)
      continue;
    // Yes, we are allowed to do this because we allocated it above
    char *ptr = (char*) attrs_record[j].data;
    GNUNET_free (ptr);
  }
  GNUNET_free (tkt_data);
  GNUNET_free (attrs_record);
  GNUNET_free (label);
}

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

cls	handle to the operation

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

{
  struct TicketIssueHandle *tih = cls;
 
  tih->ns_it = NULL;
  tih->cb (tih->cb_cls,
           &tih->ticket,
           NULL,
           GNUNET_SYSERR,
           "Error storing AuthZ ticket in GNS");
  cleanup_issue_handle (tih);
}

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

cls	handle to the operation
zone	issuer identity
label	ticket rnd
rd_count	size of record set
rd	record 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.

{
  struct TicketIssueHandle *tih = cls;
  struct GNUNET_RECLAIM_Ticket *ticket;
  struct GNUNET_RECLAIM_Presentation *presentation;
  struct GNUNET_RECLAIM_PresentationList *ticket_presentations;
  struct GNUNET_RECLAIM_Credential *cred;
  struct GNUNET_RECLAIM_PresentationListEntry *ple;
  struct GNUNET_RECLAIM_AttributeListEntry *le;
  unsigned int attr_cnt = 0;
  unsigned int pres_cnt = 0;
  int ticket_found = GNUNET_NO;
  int rp_uri_matches = GNUNET_NO;
 
  for (le = tih->attrs->list_head; NULL != le; le = le->next)
  {
    attr_cnt++;
    if (GNUNET_NO == GNUNET_RECLAIM_id_is_zero (&le->attribute->credential))
      pres_cnt++;
  }
 
  // ticket search
  unsigned int found_attrs_cnt = 0;
  unsigned int found_pres_cnt = 0;
  ticket_presentations = GNUNET_new (struct GNUNET_RECLAIM_PresentationList);
 
  for (int i = 0; i < rd_count; i++)
  {
    // found ticket
    if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET == rd[i].record_type)
    {
      ticket = (struct GNUNET_RECLAIM_Ticket *) rd[i].data;
      tih->ticket = *ticket;
      ticket_found = GNUNET_YES;
    }
    if (GNUNET_DNSPARSER_TYPE_TXT == rd[i].record_type)
    {
      // cmp audience
      if (0 != strncmp (tih->rp_uri,
                        rd[i].data,
                        rd[i].data_size))
        continue;
      rp_uri_matches = GNUNET_YES;
    }
    // cmp requested attributes with ticket attributes
    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF == rd[i].record_type)
    {
      for (le = tih->attrs->list_head; NULL != le; le = le->next)
      {
        if (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (rd[i].data,
                                                      &le->attribute->id))
          found_attrs_cnt++;
      }
    }
    if (GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL == rd[i].record_type)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Found credential...\n");
 
      for (le = tih->attrs->list_head; NULL != le; le = le->next)
      {
        cred = GNUNET_RECLAIM_credential_deserialize (rd[i].data,
                                                      rd[i].data_size);
        if (GNUNET_YES != GNUNET_RECLAIM_id_is_equal (&cred->id,
                                                      &le->attribute->credential
                                                      ))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "No match.\n");
          GNUNET_free (cred);
          continue;
        }
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Match, creating presentation...\n");
        if (GNUNET_OK != GNUNET_RECLAIM_credential_get_presentation (
              cred,
              tih->attrs,
              &presentation))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                      "Unable to retrieve presentation from credential\n");
          GNUNET_free (cred);
          continue;
        }
        ple = GNUNET_new (struct GNUNET_RECLAIM_PresentationListEntry);
        ple->presentation = presentation;
        GNUNET_CONTAINER_DLL_insert (tih->presentations->list_head,
                                     tih->presentations->list_tail,
                                     ple);
        GNUNET_free (cred);
        break;
      }
    }
    if (GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION == rd[i].record_type)
    {
      for (le = tih->attrs->list_head; NULL != le; le = le->next)
      {
        presentation = GNUNET_RECLAIM_presentation_deserialize (rd[i].data,
                                                                rd[i].data_size)
        ;
        if (NULL == presentation)
        {
          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                      "Failed to deserialize presentation\n");
          continue;
        }
        if (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (
              &presentation->credential_id,
              &le->attribute->credential))
        {
          found_pres_cnt++;
          ple = GNUNET_new (struct GNUNET_RECLAIM_PresentationListEntry);
          ple->presentation = presentation;
          GNUNET_CONTAINER_DLL_insert (ticket_presentations->list_head,
                                       ticket_presentations->list_tail,
                                       ple);
        }
      }
    }
  }
 
  if ((attr_cnt == found_attrs_cnt) &&
      (pres_cnt == found_pres_cnt) &&
      (GNUNET_YES == ticket_found) &&
      (GNUNET_YES == rp_uri_matches))
  {
    GNUNET_NAMESTORE_zone_iteration_stop (tih->ns_it);
    tih->cb (tih->cb_cls, &tih->ticket, ticket_presentations, GNUNET_OK, NULL);
    GNUNET_RECLAIM_presentation_list_destroy (ticket_presentations);
    cleanup_issue_handle (tih);
    return;
  }
  GNUNET_RECLAIM_presentation_list_destroy (ticket_presentations);
  // ticket not found in current record, checking next record set
  GNUNET_NAMESTORE_zone_iterator_next (tih->ns_it, 1);
}

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

cls	handle to the operation

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

{
  struct TicketIssueHandle *tih = cls;
 
  GNUNET_RECLAIM_id_generate (&tih->rnd);
  issue_ticket (tih);
}

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

identity	the issuer
attrs	the attributes to share
audience	the audience to share the attributes with
cb	the callback to call with the ticket result
cb_cls	the callback closure FIXME: Return handle??

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

{
  struct TicketIssueHandle *tih;
 
  tih = GNUNET_new (struct TicketIssueHandle);
  tih->cb = cb;
  tih->cb_cls = cb_cls;
  tih->attrs = GNUNET_RECLAIM_attribute_list_dup (attrs);
  tih->presentations = GNUNET_new (struct GNUNET_RECLAIM_PresentationList);
  tih->identity = *identity;
  memcpy (tih->rp_uri, rp, strlen (rp) + 1);
 
  // First check whether the ticket has already been issued
  tih->ns_it =
    GNUNET_NAMESTORE_zone_iteration_start (nsh,
                                           &tih->identity,
                                           &filter_tickets_error_cb,
                                           tih,
                                           &filter_tickets_cb,
                                           tih,
                                           &filter_tickets_finished_cb,
                                           tih);
}

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

iter	handle to the iteration

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

{
  if (NULL != iter->ns_it)
    GNUNET_NAMESTORE_zone_iteration_stop (iter->ns_it);
  GNUNET_free (iter);
}

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

cls	handle to the iteration
zone	the ticket issuer
label	the ticket rnd
rd_count	number of records in record set
rd	record set containing a ticket

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

{
  struct RECLAIM_TICKETS_Iterator *iter = cls;
  struct GNUNET_RECLAIM_Ticket *ticket;
  int ticket_found = GNUNET_NO;
  const char *rp_uri = NULL;
 
  for (int i = 0; i < rd_count; i++)
  {
    if (GNUNET_DNSPARSER_TYPE_TXT == rd[i].record_type)
      rp_uri = rd[i].data;
    if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET != rd[i].record_type)
      continue;
    if ((GNUNET_YES == ticket_found) && (NULL != rp_uri))
      break;
    ticket = (struct GNUNET_RECLAIM_Ticket *) rd[i].data;
    ticket_found = GNUNET_YES;
  }
  if ((GNUNET_YES == ticket_found) && (NULL != rp_uri))
    iter->cb (iter->cb_cls, ticket, rp_uri);
  GNUNET_NAMESTORE_zone_iterator_next (iter->ns_it, 1);
}

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

cls	handle to the iteration

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

{
  struct RECLAIM_TICKETS_Iterator *iter = cls;
 
  iter->ns_it = NULL;
  iter->cb (iter->cb_cls, NULL, NULL);
  cleanup_iter (iter);
}

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

cls	the iteration handle

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

{
  struct RECLAIM_TICKETS_Iterator *iter = cls;
 
  iter->ns_it = NULL;
  iter->cb (iter->cb_cls, NULL, NULL);
  cleanup_iter (iter);
}

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

iter	the iteration to continue

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

{
  GNUNET_NAMESTORE_zone_iterator_next (iter->ns_it, 1);
}

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

iter	iteration to cancel

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

{
  GNUNET_NAMESTORE_zone_iteration_stop (iter->ns_it);
  cleanup_iter (iter);
}

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

identity	the issuing identity
cb	ticket callback function
cb_cls	callback closure

Returns

a handle to the iteration

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

{
  struct RECLAIM_TICKETS_Iterator *iter;
 
  iter = GNUNET_new (struct RECLAIM_TICKETS_Iterator);
  iter->cb = cb;
  iter->cb_cls = cb_cls;
  iter->ns_it =
    GNUNET_NAMESTORE_zone_iteration_start (nsh,
                                           identity,
                                           &collect_tickets_error_cb,
                                           iter,
                                           &collect_tickets_cb,
                                           iter,
                                           &collect_tickets_finished_cb,
                                           iter);
  return iter;
}

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

c	the configuration

Returns

GNUNET_SYSERR on error

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

{
  // Get ticket expiration time (relative) from config
  if (GNUNET_OK ==
      GNUNET_CONFIGURATION_get_value_time (c,
                                           "reclaim",
                                           "TICKET_REFRESH_INTERVAL",
                                           &ticket_refresh_interval))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Configured refresh interval for tickets: %s\n",
                GNUNET_STRINGS_relative_time_to_string (ticket_refresh_interval,
                                                        GNUNET_YES));
  }
  else
  {
    ticket_refresh_interval = DEFAULT_TICKET_REFRESH_INTERVAL;
  }
  // Connect to identity and namestore services
  nsh = GNUNET_NAMESTORE_connect (c);
  if (NULL == nsh)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                         "error connecting to namestore");
    return GNUNET_SYSERR;
  }
  gns = GNUNET_GNS_connect (c);
  if (NULL == gns)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "error connecting to gns");
    return GNUNET_SYSERR;
  }
  stats = GNUNET_STATISTICS_create ("reclaim", c);
  return GNUNET_OK;
}

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.

{
  if (NULL != nsh)
    GNUNET_NAMESTORE_disconnect (nsh);
  nsh = NULL;
  if (NULL != gns)
    GNUNET_GNS_disconnect (gns);
  gns = NULL;
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
    stats = NULL;
  }
}

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

struct GNUNET_NAMESTORE_Handle* nsh

static

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

Referenced by issue_ticket(), move_attr_finished(), move_attrs(), process_tickets(), RECLAIM_TICKETS_deinit(), RECLAIM_TICKETS_init(), RECLAIM_TICKETS_issue(), RECLAIM_TICKETS_iteration_start(), RECLAIM_TICKETS_revoke(), revoke_attrs_cb(), and rvk_move_attr_cb().

gns

struct GNUNET_GNS_Handle* gns

static

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

Referenced by lookup_authz_cb(), RECLAIM_TICKETS_consume(), RECLAIM_TICKETS_deinit(), and RECLAIM_TICKETS_init().

stats

struct GNUNET_STATISTICS_Handle* stats

static

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

Referenced by lookup_authz_cb(), process_parallel_lookup_result(), RECLAIM_TICKETS_deinit(), and RECLAIM_TICKETS_init().