gnunet-reclaim.c File Reference

Identity Provider utility. More...

#include "platform.h"
#include <inttypes.h>
#include "gnunet_util_lib.h"
#include "gnunet_identity_service.h"
#include "gnunet_namestore_service.h"
#include "gnunet_reclaim_service.h"
#include "gnunet_signatures.h"

Include dependency graph for gnunet-reclaim.c:

Go to the source code of this file.

Functions
static void	do_cleanup (void *cls)
static void	ticket_issue_cb (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket, const struct GNUNET_RECLAIM_PresentationList *presentations)
static void	store_cont (void *cls, int32_t success, const char *emsg)
static void	process_attrs (void *cls, const struct GNUNET_IDENTITY_PublicKey *identity, const struct GNUNET_RECLAIM_Attribute *attr, const struct GNUNET_RECLAIM_Presentation *presentation)
static void	ticket_iter_err (void *cls)
static void	ticket_iter_fin (void *cls)
static void	ticket_iter (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
static void	iter_error (void *cls)
static void	timeout_task (void *cls)
static void	process_rvk (void *cls, int success, const char *msg)
static void	process_delete (void *cls, int success, const char *msg)
static void	iter_finished (void *cls)
static void	iter_cb (void *cls, const struct GNUNET_IDENTITY_PublicKey *identity, const struct GNUNET_RECLAIM_Attribute *attr)
static void	cred_iter_finished (void *cls)
static void	cred_iter_cb (void *cls, const struct GNUNET_IDENTITY_PublicKey *identity, const struct GNUNET_RECLAIM_Credential *cred)
static void	start_process ()
static void	ego_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
int	main (int argc, char *const argv[])

Variables
static int	ret
	return value More...
static int	list
	List attribute flag. More...
static int	list_credentials
	List credentials flag. More...
static char *	credential_id
	Credential ID string. More...
static struct GNUNET_RECLAIM_Identifier	credential
	Credential ID. More...
static char *	credential_name
	Credential name. More...
static char *	credential_type
	Credential type. More...
static int	credential_exists
	Credential exists. More...
static char *	rp
	Relying party. More...
static char *	attr_name
	The attribute. More...
static char *	attr_value
	Attribute value. More...
static char *	issue_attrs
	Attributes to issue. More...
static char *	consume_ticket
	Ticket to consume. More...
static char *	type_str
	Attribute type. More...
static char *	revoke_ticket
	Ticket to revoke. More...
static int	list_tickets
	Ticket listing. More...
static char *	ego_name
	Ego name. More...
static struct GNUNET_IDENTITY_Handle *	identity_handle
	Identity handle. More...
static struct GNUNET_RECLAIM_Handle *	reclaim_handle
	reclaim handle More...
static struct GNUNET_RECLAIM_Operation *	reclaim_op
	reclaim operation More...
static struct GNUNET_RECLAIM_AttributeIterator *	attr_iterator
	Attribute iterator. More...
static struct GNUNET_RECLAIM_CredentialIterator *	cred_iterator
	Credential iterator. More...
static struct GNUNET_RECLAIM_TicketIterator *	ticket_iterator
	Ticket iterator. More...
static const struct GNUNET_IDENTITY_PrivateKey *	pkey
	ego private key More...
static struct GNUNET_IDENTITY_PublicKey	rp_key
	rp public key More...
static struct GNUNET_RECLAIM_Ticket	ticket
	Ticket to consume. More...
static struct GNUNET_RECLAIM_AttributeList *	attr_list
	Attribute list. More...
static struct GNUNET_TIME_Relative	exp_interval
	Attribute expiration interval. More...
static struct GNUNET_SCHEDULER_Task *	timeout
	Timeout task. More...
static struct GNUNET_SCHEDULER_Task *	cleanup_task
	Cleanup task. More...
struct GNUNET_RECLAIM_Attribute *	claim
	Claim to store. More...
static char *	attr_delete
	Claim to delete. More...
static struct GNUNET_RECLAIM_Attribute *	attr_to_delete
	Claim object to delete. More...
static int	init = GNUNET_YES

Detailed Description

Identity Provider utility.

Author

Martin Schanzenbach

Definition in file gnunet-reclaim.c.

Function Documentation

do_cleanup()

static void do_cleanup ( void *  cls )

static

Definition at line 203 of file gnunet-reclaim.c.

{
  cleanup_task = NULL;
  if (NULL != timeout)
    GNUNET_SCHEDULER_cancel (timeout);
  if (NULL != reclaim_op)
    GNUNET_RECLAIM_cancel (reclaim_op);
  if (NULL != attr_iterator)
    GNUNET_RECLAIM_get_attributes_stop (attr_iterator);
  if (NULL != cred_iterator)
    GNUNET_RECLAIM_get_credentials_stop (cred_iterator);
  if (NULL != ticket_iterator)
    GNUNET_RECLAIM_ticket_iteration_stop (ticket_iterator);
  if (NULL != reclaim_handle)
    GNUNET_RECLAIM_disconnect (reclaim_handle);
  if (NULL != identity_handle)
    GNUNET_IDENTITY_disconnect (identity_handle);
  if (NULL != attr_list)
  {
    GNUNET_RECLAIM_attribute_list_destroy (attr_list);
    attr_list = NULL;
  }
  if (NULL != attr_to_delete)
    GNUNET_free (attr_to_delete);
  if (NULL == credential_type)
    GNUNET_free (credential_type);
}

References attr_iterator, attr_list, attr_to_delete, cleanup_task, cred_iterator, credential_type, GNUNET_free, GNUNET_IDENTITY_disconnect(), GNUNET_RECLAIM_attribute_list_destroy(), GNUNET_RECLAIM_cancel(), GNUNET_RECLAIM_disconnect(), GNUNET_RECLAIM_get_attributes_stop(), GNUNET_RECLAIM_get_credentials_stop(), GNUNET_RECLAIM_ticket_iteration_stop(), GNUNET_SCHEDULER_cancel(), identity_handle, reclaim_handle, reclaim_op, ticket_iterator, and timeout.

Referenced by cred_iter_finished(), iter_error(), iter_finished(), process_attrs(), process_delete(), process_rvk(), start_process(), store_cont(), ticket_issue_cb(), ticket_iter_err(), ticket_iter_fin(), and timeout_task().

Here is the call graph for this function:

Here is the caller graph for this function:

ticket_issue_cb()

static void ticket_issue_cb ( void *  cls, const struct GNUNET_RECLAIM_Ticket *  ticket, const struct GNUNET_RECLAIM_PresentationList *  presentations  )

static

Definition at line 233 of file gnunet-reclaim.c.

{
  char *ticket_str;
 
  reclaim_op = NULL;
  if (NULL != ticket)
  {
    ticket_str =
      GNUNET_STRINGS_data_to_string_alloc (ticket,
                                           sizeof(
                                             struct GNUNET_RECLAIM_Ticket));
    printf ("%s\n", ticket_str);
    GNUNET_free (ticket_str);
  }
  cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
}

References cleanup_task, do_cleanup(), GNUNET_free, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_data_to_string_alloc(), reclaim_op, and ticket.

Referenced by iter_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

store_cont()

static void store_cont ( void *  cls, int32_t  success, const char *  emsg  )

static

Definition at line 254 of file gnunet-reclaim.c.

{
  reclaim_op = NULL;
  if (GNUNET_SYSERR == success)
  {
    fprintf (stderr, "%s\n", emsg);
  }
  cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
}

References cleanup_task, do_cleanup(), GNUNET_SCHEDULER_add_now(), GNUNET_SYSERR, and reclaim_op.

Referenced by cred_iter_finished(), and iter_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

process_attrs()

static void process_attrs ( void *  cls, const struct GNUNET_IDENTITY_PublicKey *  identity, const struct GNUNET_RECLAIM_Attribute *  attr, const struct GNUNET_RECLAIM_Presentation *  presentation  )

static

Definition at line 266 of file gnunet-reclaim.c.

{
  char *value_str;
  char *id;
  const char *attr_type;
 
  if (NULL == identity)
  {
    reclaim_op = NULL;
    cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
    return;
  }
  if (NULL == attr)
  {
    ret = 1;
    return;
  }
  attr_type = GNUNET_RECLAIM_attribute_number_to_typename (attr->type);
  id = GNUNET_STRINGS_data_to_string_alloc (&attr->id, sizeof(attr->id));
  value_str = NULL;
  if (NULL == presentation)
  {
    value_str = GNUNET_RECLAIM_attribute_value_to_string (attr->type,
                                                          attr->data,
                                                          attr->data_size);
  }
  else
  {
    struct GNUNET_RECLAIM_AttributeListEntry *ale;
    struct GNUNET_RECLAIM_AttributeList *al
      = GNUNET_RECLAIM_presentation_get_attributes (presentation);
 
    for (ale = al->list_head; NULL != ale; ale = ale->next)
    {
      if (0 != strncmp (attr->data, ale->attribute->name, attr->data_size))
        continue;
      value_str
        = GNUNET_RECLAIM_attribute_value_to_string (ale->attribute->type,
                                                    ale->attribute->data,
                                                    ale->attribute->data_size);
      break;
    }
  }
  fprintf (stdout,
           "Name: %s; Value: %s (%s); Flag %u; ID: %s %s\n",
           attr->name,
           (NULL != value_str) ? value_str : "???",
           attr_type,
           attr->flag,
           id,
           (NULL == presentation) ? "" : "(ATTESTED)");
  GNUNET_free (value_str);
  GNUNET_free (id);
}

References GNUNET_RECLAIM_AttributeListEntry::attribute, cleanup_task, GNUNET_RECLAIM_Attribute::data, GNUNET_RECLAIM_Attribute::data_size, do_cleanup(), GNUNET_RECLAIM_Attribute::flag, GNUNET_free, GNUNET_RECLAIM_attribute_number_to_typename(), GNUNET_RECLAIM_attribute_value_to_string(), GNUNET_RECLAIM_presentation_get_attributes(), GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_data_to_string_alloc(), id, GNUNET_RECLAIM_Attribute::id, identity, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_Attribute::name, GNUNET_RECLAIM_AttributeListEntry::next, reclaim_op, ret, and GNUNET_RECLAIM_Attribute::type.

Referenced by iter_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

ticket_iter_err()

static void ticket_iter_err ( void *  cls )

static

Definition at line 326 of file gnunet-reclaim.c.

{
  ticket_iterator = NULL;
  fprintf (stderr, "Failed to iterate over tickets\n");
  cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
}

References cleanup_task, do_cleanup(), GNUNET_SCHEDULER_add_now(), and ticket_iterator.

Referenced by start_process().

Here is the call graph for this function:

Here is the caller graph for this function:

ticket_iter_fin()

static void ticket_iter_fin ( void *  cls )

static

Definition at line 335 of file gnunet-reclaim.c.

{
  ticket_iterator = NULL;
  cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
}

References cleanup_task, do_cleanup(), GNUNET_SCHEDULER_add_now(), and ticket_iterator.

Referenced by start_process().

Here is the call graph for this function:

Here is the caller graph for this function:

ticket_iter()

static void ticket_iter ( void *  cls, const struct GNUNET_RECLAIM_Ticket *  ticket  )

static

Definition at line 343 of file gnunet-reclaim.c.

{
  char *aud;
  char *ref;
  char *tkt;
 
  aud =
    GNUNET_STRINGS_data_to_string_alloc (&ticket->audience,
                                         sizeof(struct
                                                GNUNET_IDENTITY_PublicKey));
  ref = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd, sizeof(ticket->rnd));
  tkt =
    GNUNET_STRINGS_data_to_string_alloc (ticket,
                                         sizeof(struct GNUNET_RECLAIM_Ticket));
  fprintf (stdout, "Ticket: %s | ID: %s | Audience: %s\n", tkt, ref, aud);
  GNUNET_free (aud);
  GNUNET_free (ref);
  GNUNET_free (tkt);
  GNUNET_RECLAIM_ticket_iteration_next (ticket_iterator);
}

References GNUNET_RECLAIM_Ticket::audience, GNUNET_free, GNUNET_RECLAIM_ticket_iteration_next(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_RECLAIM_Ticket::rnd, ticket, and ticket_iterator.

Referenced by start_process().

Here is the call graph for this function:

Here is the caller graph for this function:

iter_error()

static void iter_error ( void *  cls )

static

Definition at line 366 of file gnunet-reclaim.c.

{
  attr_iterator = NULL;
  cred_iterator = NULL;
  fprintf (stderr, "Failed\n");
 
  cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
}

References attr_iterator, cleanup_task, cred_iterator, do_cleanup(), and GNUNET_SCHEDULER_add_now().

Referenced by cred_iter_finished(), and start_process().

Here is the call graph for this function:

Here is the caller graph for this function:

timeout_task()

static void timeout_task ( void *  cls )

static

Definition at line 377 of file gnunet-reclaim.c.

{
  timeout = NULL;
  ret = 1;
  fprintf (stderr, "Timeout\n");
  if (NULL == cleanup_task)
    cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
}

References cleanup_task, do_cleanup(), GNUNET_SCHEDULER_add_now(), ret, and timeout.

Referenced by iter_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

process_rvk()

static void process_rvk ( void *  cls, int  success, const char *  msg  )

static

Definition at line 388 of file gnunet-reclaim.c.

{
  reclaim_op = NULL;
  if (GNUNET_OK != success)
  {
    fprintf (stderr, "Revocation failed.\n");
    ret = 1;
  }
  cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
}

References cleanup_task, do_cleanup(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), reclaim_op, and ret.

Referenced by iter_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

process_delete()

static void process_delete ( void *  cls, int  success, const char *  msg  )

static

Definition at line 401 of file gnunet-reclaim.c.

{
  reclaim_op = NULL;
  if (GNUNET_OK != success)
  {
    fprintf (stderr, "Deletion failed.\n");
    ret = 1;
  }
  cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
}

References cleanup_task, do_cleanup(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), reclaim_op, and ret.

Referenced by iter_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

iter_finished()

static void iter_finished ( void *  cls )

static

Definition at line 414 of file gnunet-reclaim.c.

{
  char *data;
  size_t data_size;
  int type;
 
  attr_iterator = NULL;
  if (list)
  {
    cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
    return;
  }
 
  if (issue_attrs)
  {
    reclaim_op = GNUNET_RECLAIM_ticket_issue (reclaim_handle,
                                              pkey,
                                              &rp_key,
                                              attr_list,
                                              &ticket_issue_cb,
                                              NULL);
    return;
  }
  if (consume_ticket)
  {
    reclaim_op = GNUNET_RECLAIM_ticket_consume (reclaim_handle,
                                                pkey,
                                                &ticket,
                                                &process_attrs,
                                                NULL);
    timeout = GNUNET_SCHEDULER_add_delayed (
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10),
      &timeout_task,
      NULL);
    return;
  }
  if (revoke_ticket)
  {
    reclaim_op = GNUNET_RECLAIM_ticket_revoke (reclaim_handle,
                                               pkey,
                                               &ticket,
                                               &process_rvk,
                                               NULL);
    return;
  }
  if (attr_delete)
  {
    if (NULL == attr_to_delete)
    {
      fprintf (stdout, "No such attribute ``%s''\n", attr_delete);
      GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
      return;
    }
    reclaim_op = GNUNET_RECLAIM_attribute_delete (reclaim_handle,
                                                  pkey,
                                                  attr_to_delete,
                                                  &process_delete,
                                                  NULL);
    return;
  }
  if (attr_name)
  {
    if (NULL == type_str)
      type = GNUNET_RECLAIM_ATTRIBUTE_TYPE_STRING;
    else
      type = GNUNET_RECLAIM_attribute_typename_to_number (type_str);
 
    GNUNET_assert (GNUNET_SYSERR !=
                   GNUNET_RECLAIM_attribute_string_to_value (type,
                                                             attr_value,
                                                             (void **) &data,
                                                             &data_size));
    if (NULL != claim)
    {
      claim->type = type;
      claim->data = data;
      claim->data_size = data_size;
    }
    else
    {
      claim =
        GNUNET_RECLAIM_attribute_new (attr_name, NULL, type, data, data_size);
    }
    if (NULL != credential_id)
    {
      claim->credential = credential;
    }
    reclaim_op = GNUNET_RECLAIM_attribute_store (reclaim_handle,
                                                 pkey,
                                                 claim,
                                                 &exp_interval,
                                                 &store_cont,
                                                 NULL);
    GNUNET_free (data);
    GNUNET_free (claim);
    return;
  }
  cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
}

References attr_delete, attr_iterator, attr_list, attr_name, attr_to_delete, attr_value, claim, cleanup_task, consume_ticket, GNUNET_RECLAIM_Attribute::credential, credential, credential_id, GNUNET_RECLAIM_Attribute::data, data, data_size, GNUNET_RECLAIM_Attribute::data_size, do_cleanup(), exp_interval, GNUNET_assert, GNUNET_free, GNUNET_RECLAIM_attribute_delete(), GNUNET_RECLAIM_attribute_new(), GNUNET_RECLAIM_attribute_store(), GNUNET_RECLAIM_attribute_string_to_value(), GNUNET_RECLAIM_ATTRIBUTE_TYPE_STRING, GNUNET_RECLAIM_attribute_typename_to_number(), GNUNET_RECLAIM_ticket_consume(), GNUNET_RECLAIM_ticket_issue(), GNUNET_RECLAIM_ticket_revoke(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SYSERR, GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_SECONDS, issue_attrs, list, pkey, process_attrs(), process_delete(), process_rvk(), reclaim_handle, reclaim_op, revoke_ticket, rp_key, store_cont(), ticket, ticket_issue_cb(), timeout, timeout_task(), GNUNET_RECLAIM_Attribute::type, type, and type_str.

Referenced by cred_iter_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

iter_cb()

static void iter_cb ( void *  cls, const struct GNUNET_IDENTITY_PublicKey *  identity, const struct GNUNET_RECLAIM_Attribute *  attr  )

static

Definition at line 516 of file gnunet-reclaim.c.

{
  struct GNUNET_RECLAIM_AttributeListEntry *le;
  char *attrs_tmp;
  char *attr_str;
  char *label;
  char *id;
  const char *attr_type;
 
  if ((NULL != attr_name) && (NULL == claim))
  {
    if (0 == strcasecmp (attr_name, attr->name))
    {
      claim = GNUNET_RECLAIM_attribute_new (attr->name,
                                            &attr->credential,
                                            attr->type,
                                            attr->data,
                                            attr->data_size);
      claim->id = attr->id;
    }
  }
  else if (issue_attrs)
  {
    attrs_tmp = GNUNET_strdup (issue_attrs);
    attr_str = strtok (attrs_tmp, ",");
    while (NULL != attr_str)
    {
      if (0 != strcasecmp (attr_str, attr->name))
      {
        attr_str = strtok (NULL, ",");
        continue;
      }
      le = GNUNET_new (struct GNUNET_RECLAIM_AttributeListEntry);
      le->attribute = GNUNET_RECLAIM_attribute_new (attr->name,
                                                    &attr->credential,
                                                    attr->type,
                                                    attr->data,
                                                    attr->data_size);
      le->attribute->flag = attr->flag;
      le->attribute->id = attr->id;
      GNUNET_CONTAINER_DLL_insert (attr_list->list_head,
                                   attr_list->list_tail,
                                   le);
      break;
    }
    GNUNET_free (attrs_tmp);
  }
  else if (attr_delete && (NULL == attr_to_delete))
  {
    label = GNUNET_STRINGS_data_to_string_alloc (&attr->id, sizeof(attr->id));
    if (0 == strcasecmp (attr_delete, label))
    {
      attr_to_delete = GNUNET_RECLAIM_attribute_new (attr->name,
                                                     &attr->credential,
                                                     attr->type,
                                                     attr->data,
                                                     attr->data_size);
      attr_to_delete->id = attr->id;
    }
    GNUNET_free (label);
  }
  else if (list)
  {
    attr_str = GNUNET_RECLAIM_attribute_value_to_string (attr->type,
                                                         attr->data,
                                                         attr->data_size);
    attr_type = GNUNET_RECLAIM_attribute_number_to_typename (attr->type);
    id = GNUNET_STRINGS_data_to_string_alloc (&attr->id, sizeof(attr->id));
    if (GNUNET_YES == GNUNET_RECLAIM_id_is_zero (&attr->credential))
    {
      fprintf (stdout,
               "%s: ``%s'' (%s); ID: %s\n",
               attr->name,
               attr_str,
               attr_type,
               id);
    }
    else
    {
      char *cred_id =
        GNUNET_STRINGS_data_to_string_alloc (&attr->credential,
                                             sizeof(attr->credential));
      fprintf (stdout,
               "%s: ``%s'' in credential presentation `%s' (%s); ID: %s\n",
               attr->name,
               attr_str,
               cred_id,
               attr_type,
               id);
      GNUNET_free (cred_id);
 
    }
    GNUNET_free (id);
  }
  GNUNET_RECLAIM_get_attributes_next (attr_iterator);
}

References attr_delete, attr_iterator, attr_list, attr_name, attr_to_delete, GNUNET_RECLAIM_AttributeListEntry::attribute, claim, GNUNET_RECLAIM_Attribute::credential, GNUNET_RECLAIM_Attribute::data, GNUNET_RECLAIM_Attribute::data_size, GNUNET_RECLAIM_Attribute::flag, GNUNET_CONTAINER_DLL_insert, GNUNET_free, GNUNET_new, GNUNET_RECLAIM_attribute_new(), GNUNET_RECLAIM_attribute_number_to_typename(), GNUNET_RECLAIM_attribute_value_to_string(), GNUNET_RECLAIM_get_attributes_next(), GNUNET_RECLAIM_id_is_zero, GNUNET_strdup, GNUNET_STRINGS_data_to_string_alloc(), GNUNET_YES, id, GNUNET_RECLAIM_Attribute::id, issue_attrs, list, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_AttributeList::list_tail, GNUNET_RECLAIM_Attribute::name, and GNUNET_RECLAIM_Attribute::type.

Referenced by cred_iter_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

cred_iter_finished()

static void cred_iter_finished ( void *  cls )

static

Definition at line 617 of file gnunet-reclaim.c.

{
  cred_iterator = NULL;
 
  // Add new credential
  if ((NULL != credential_name) &&
      (NULL != attr_value))
  {
    enum GNUNET_RECLAIM_CredentialType ctype =
      GNUNET_RECLAIM_credential_typename_to_number (credential_type);
    struct GNUNET_RECLAIM_Credential *credential =
      GNUNET_RECLAIM_credential_new (credential_name,
                                     ctype,
                                     attr_value,
                                     strlen (attr_value));
    reclaim_op = GNUNET_RECLAIM_credential_store (reclaim_handle,
                                                  pkey,
                                                  credential,
                                                  &exp_interval,
                                                  store_cont,
                                                  NULL);
    return;
 
  }
  if (list_credentials)
  {
    cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
    return;
  }
  attr_iterator = GNUNET_RECLAIM_get_attributes_start (reclaim_handle,
                                                       pkey,
                                                       &iter_error,
                                                       NULL,
                                                       &iter_cb,
                                                       NULL,
                                                       &iter_finished,
                                                       NULL);
 
}

References attr_iterator, attr_value, cleanup_task, cred_iterator, credential, credential_name, credential_type, do_cleanup(), exp_interval, GNUNET_RECLAIM_credential_new(), GNUNET_RECLAIM_credential_store(), GNUNET_RECLAIM_credential_typename_to_number(), GNUNET_RECLAIM_get_attributes_start(), GNUNET_SCHEDULER_add_now(), iter_cb(), iter_error(), iter_finished(), list_credentials, pkey, reclaim_handle, reclaim_op, and store_cont().

Referenced by start_process().

Here is the call graph for this function:

Here is the caller graph for this function:

cred_iter_cb()

static void cred_iter_cb ( void *  cls, const struct GNUNET_IDENTITY_PublicKey *  identity, const struct GNUNET_RECLAIM_Credential *  cred  )

static

Definition at line 659 of file gnunet-reclaim.c.

{
  char *cred_str;
  char *attr_str;
  char *id;
  const char *cred_type;
  struct GNUNET_RECLAIM_AttributeListEntry *ale;
 
  if (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (&credential,
                                                &cred->id))
    credential_exists = GNUNET_YES;
  if (list_credentials)
  {
    cred_str = GNUNET_RECLAIM_credential_value_to_string (cred->type,
                                                          cred->data,
                                                          cred->data_size);
    cred_type = GNUNET_RECLAIM_credential_number_to_typename (cred->type);
    id = GNUNET_STRINGS_data_to_string_alloc (&cred->id, sizeof(cred->id));
    fprintf (stdout,
             "%s: ``%s'' (%s); ID: %s\n",
             cred->name,
             cred_str,
             cred_type,
             id);
    struct GNUNET_RECLAIM_AttributeList *attrs =
      GNUNET_RECLAIM_credential_get_attributes (cred);
    if (NULL != attrs)
    {
      fprintf (stdout,
               "\t Attributes:\n");
      for (ale = attrs->list_head; NULL != ale; ale = ale->next)
      {
        attr_str = GNUNET_RECLAIM_attribute_value_to_string (
          ale->attribute->type,
          ale->attribute->data,
          ale->attribute->data_size);
        fprintf (stdout,
                 "\t %s: %s\n", ale->attribute->name, attr_str);
        GNUNET_free (attr_str);
      }
      GNUNET_RECLAIM_attribute_list_destroy (attrs);
    }
    GNUNET_free (id);
  }
  GNUNET_RECLAIM_get_credentials_next (cred_iterator);
}

References GNUNET_RECLAIM_AttributeListEntry::attribute, cred_iterator, credential, credential_exists, GNUNET_RECLAIM_Attribute::data, GNUNET_RECLAIM_Credential::data, GNUNET_RECLAIM_Attribute::data_size, GNUNET_RECLAIM_Credential::data_size, GNUNET_free, GNUNET_RECLAIM_attribute_list_destroy(), GNUNET_RECLAIM_attribute_value_to_string(), GNUNET_RECLAIM_credential_get_attributes(), GNUNET_RECLAIM_credential_number_to_typename(), GNUNET_RECLAIM_credential_value_to_string(), GNUNET_RECLAIM_get_credentials_next(), GNUNET_RECLAIM_id_is_equal, GNUNET_STRINGS_data_to_string_alloc(), GNUNET_YES, id, GNUNET_RECLAIM_Credential::id, list_credentials, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_Attribute::name, GNUNET_RECLAIM_Credential::name, GNUNET_RECLAIM_AttributeListEntry::next, GNUNET_RECLAIM_Attribute::type, and GNUNET_RECLAIM_Credential::type.

Referenced by start_process().

Here is the call graph for this function:

Here is the caller graph for this function:

start_process()

static void start_process ( )

static

Definition at line 710 of file gnunet-reclaim.c.

{
  if (NULL == pkey)
  {
    fprintf (stderr, "Ego %s not found\n", ego_name);
    cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
    return;
  }
  if (NULL == credential_type)
    credential_type = GNUNET_strdup ("JWT");
  credential = GNUNET_RECLAIM_ID_ZERO;
  if (NULL != credential_id)
    GNUNET_STRINGS_string_to_data (credential_id,
                                   strlen (credential_id),
                                   &credential, sizeof(credential));
  credential_exists = GNUNET_NO;
  if (list_tickets)
  {
    ticket_iterator = GNUNET_RECLAIM_ticket_iteration_start (reclaim_handle,
                                                             pkey,
                                                             &ticket_iter_err,
                                                             NULL,
                                                             &ticket_iter,
                                                             NULL,
                                                             &ticket_iter_fin,
                                                             NULL);
    return;
  }
 
  if ((NULL != rp) &&
      (GNUNET_OK !=
       GNUNET_IDENTITY_public_key_from_string (rp, &rp_key)) )
  {
    fprintf (stderr, "%s is not a public key!\n", rp);
    cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
    return;
  }
  if (NULL != consume_ticket)
    GNUNET_STRINGS_string_to_data (consume_ticket,
                                   strlen (consume_ticket),
                                   &ticket,
                                   sizeof(struct GNUNET_RECLAIM_Ticket));
  if (NULL != revoke_ticket)
    GNUNET_STRINGS_string_to_data (revoke_ticket,
                                   strlen (revoke_ticket),
                                   &ticket,
                                   sizeof(struct GNUNET_RECLAIM_Ticket));
 
  attr_list = GNUNET_new (struct GNUNET_RECLAIM_AttributeList);
  claim = NULL;
  cred_iterator = GNUNET_RECLAIM_get_credentials_start (reclaim_handle,
                                                        pkey,
                                                        &iter_error,
                                                        NULL,
                                                        &cred_iter_cb,
                                                        NULL,
                                                        &cred_iter_finished,
                                                        NULL);
 
}

References attr_list, claim, cleanup_task, consume_ticket, cred_iter_cb(), cred_iter_finished(), cred_iterator, credential, credential_exists, credential_id, credential_type, do_cleanup(), ego_name, GNUNET_IDENTITY_public_key_from_string(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_RECLAIM_get_credentials_start(), GNUNET_RECLAIM_ID_ZERO, GNUNET_RECLAIM_ticket_iteration_start(), GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNUNET_STRINGS_string_to_data(), iter_error(), list_tickets, pkey, reclaim_handle, revoke_ticket, rp, rp_key, ticket, ticket_iter(), ticket_iter_err(), ticket_iter_fin(), and ticket_iterator.

Referenced by ego_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

ego_cb()

static void ego_cb ( void *  cls, struct GNUNET_IDENTITY_Ego *  ego, void **  ctx, const char *  name  )

static

Definition at line 775 of file gnunet-reclaim.c.

{
  if (NULL == name)
  {
    if (GNUNET_YES == init)
    {
      init = GNUNET_NO;
      start_process ();
    }
    return;
  }
  if (0 != strcmp (name, ego_name))
    return;
  pkey = GNUNET_IDENTITY_ego_get_private_key (ego);
}

References ego_name, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_NO, GNUNET_YES, init, name, pkey, and start_process().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  c  )

static

Definition at line 796 of file gnunet-reclaim.c.

{
  ret = 0;
  if (NULL == ego_name)
  {
    ret = 1;
    fprintf (stderr, _ ("Ego is required\n"));
    return;
  }
 
  if ((NULL == attr_value) && (NULL != attr_name))
  {
    ret = 1;
    fprintf (stderr, _ ("Attribute value missing!\n"));
    return;
  }
 
  if ((NULL == rp) && (NULL != issue_attrs))
  {
    ret = 1;
    fprintf (stderr, _ ("Requesting party key is required!\n"));
    return;
  }
 
  reclaim_handle = GNUNET_RECLAIM_connect (c);
  // Get Ego
  identity_handle = GNUNET_IDENTITY_connect (c, &ego_cb, NULL);
}

References _, attr_name, attr_value, ego_cb(), ego_name, GNUNET_IDENTITY_connect(), GNUNET_RECLAIM_connect(), identity_handle, issue_attrs, reclaim_handle, ret, and rp.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const	argv[]
	)

Definition at line 830 of file gnunet-reclaim.c.

{
  exp_interval = GNUNET_TIME_UNIT_HOURS;
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_string ('a',
                                 "add",
                                 "NAME",
                                 gettext_noop ("Add or update an attribute NAME"),
                                 &attr_name),
    GNUNET_GETOPT_option_string ('d',
                                 "delete",
                                 "ID",
                                 gettext_noop ("Delete the attribute with ID"),
                                 &attr_delete),
    GNUNET_GETOPT_option_string ('V',
                                 "value",
                                 "VALUE",
                                 gettext_noop ("The attribute VALUE"),
                                 &attr_value),
    GNUNET_GETOPT_option_string ('e',
                                 "ego",
                                 "EGO",
                                 gettext_noop ("The EGO to use"),
                                 &ego_name),
    GNUNET_GETOPT_option_string ('r',
                                 "rp",
                                 "RP",
                                 gettext_noop (
                                   "Specify the relying party for issue"),
                                 &rp),
    GNUNET_GETOPT_option_flag ('D',
                               "dump",
                               gettext_noop ("List attributes for EGO"),
                               &list),
    GNUNET_GETOPT_option_flag ('A',
                               "credentials",
                               gettext_noop ("List credentials for EGO"),
                               &list_credentials),
    GNUNET_GETOPT_option_string ('I',
                                 "credential-id",
                                 "CREDENTIAL_ID",
                                 gettext_noop (
                                   "Credential to use for attribute"),
                                 &credential_id),
    GNUNET_GETOPT_option_string ('N',
                                 "credential-name",
                                 "NAME",
                                 gettext_noop ("Credential name"),
                                 &credential_name),
    GNUNET_GETOPT_option_string ('i',
                                 "issue",
                                 "A1,A2,...",
                                 gettext_noop (
                                   "Issue a ticket for a set of attributes separated by comma"),
                                 &issue_attrs),
    GNUNET_GETOPT_option_string ('C',
                                 "consume",
                                 "TICKET",
                                 gettext_noop ("Consume a ticket"),
                                 &consume_ticket),
    GNUNET_GETOPT_option_string ('R',
                                 "revoke",
                                 "TICKET",
                                 gettext_noop ("Revoke a ticket"),
                                 &revoke_ticket),
    GNUNET_GETOPT_option_string ('t',
                                 "type",
                                 "TYPE",
                                 gettext_noop ("Type of attribute"),
                                 &type_str),
    GNUNET_GETOPT_option_string ('u',
                                 "credential-type",
                                 "TYPE",
                                 gettext_noop ("Type of credential"),
                                 &credential_type),
    GNUNET_GETOPT_option_flag ('T',
                               "tickets",
                               gettext_noop ("List tickets of ego"),
                               &list_tickets),
    GNUNET_GETOPT_option_relative_time ('E',
                                        "expiration",
                                        "INTERVAL",
                                        gettext_noop (
                                          "Expiration interval of the attribute"),
                                        &exp_interval),
 
    GNUNET_GETOPT_OPTION_END
  };
  if (GNUNET_OK != GNUNET_PROGRAM_run (argc,
                                       argv,
                                       "gnunet-reclaim",
                                       _ ("re:claimID command line tool"),
                                       options,
                                       &run,
                                       NULL))
    return 1;
  else
    return ret;
}

References _, attr_delete, attr_name, attr_value, consume_ticket, credential_id, credential_name, credential_type, ego_name, exp_interval, gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_relative_time(), GNUNET_GETOPT_option_string(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_TIME_UNIT_HOURS, issue_attrs, list, list_credentials, list_tickets, options, ret, revoke_ticket, rp, run(), and type_str.

Here is the call graph for this function:

Variable Documentation

ret

int ret

static

return value

Definition at line 38 of file gnunet-reclaim.c.

Referenced by main(), process_attrs(), process_delete(), process_rvk(), run(), and timeout_task().

list

int list

static

List attribute flag.

Definition at line 43 of file gnunet-reclaim.c.

Referenced by iter_cb(), iter_finished(), and main().

list_credentials

int list_credentials

static

List credentials flag.

Definition at line 48 of file gnunet-reclaim.c.

Referenced by cred_iter_cb(), cred_iter_finished(), and main().

credential_id

char* credential_id

static

Credential ID string.

Definition at line 53 of file gnunet-reclaim.c.

Referenced by iter_finished(), main(), and start_process().

credential

struct GNUNET_RECLAIM_Identifier credential

static

Credential ID.

Definition at line 53 of file gnunet-reclaim.c.

Referenced by attribute_list_merge(), cred_iter_cb(), cred_iter_finished(), GNUNET_RECLAIM_attribute_list_add(), GNUNET_RECLAIM_attribute_new(), GNUNET_RECLAIM_credential_deserialize(), GNUNET_RECLAIM_credential_get_attributes(), GNUNET_RECLAIM_credential_get_expiration(), GNUNET_RECLAIM_credential_get_issuer(), GNUNET_RECLAIM_credential_serialize(), GNUNET_RECLAIM_credential_serialize_get_size(), GNUNET_RECLAIM_credential_store(), iter_finished(), pabc_create_presentation(), rvk_move_attr_cb(), and start_process().

credential_name

char* credential_name

static

Credential name.

Definition at line 63 of file gnunet-reclaim.c.

Referenced by cred_iter_finished(), and main().

credential_type

char* credential_type

static

Credential type.

Definition at line 68 of file gnunet-reclaim.c.

Referenced by cred_iter_finished(), do_cleanup(), main(), and start_process().

credential_exists

int credential_exists

static

Credential exists.

Definition at line 73 of file gnunet-reclaim.c.

Referenced by cred_iter_cb(), and start_process().

rp

char* rp

static

Relying party.

Definition at line 78 of file gnunet-reclaim.c.

Referenced by do_shutdown(), for_all_records(), free_peer(), GAS_preference_get_by_peer(), get_latest(), get_rp_key(), GNUNET_CURL_gnunet_rc_create_with_parser(), GNUNET_CURL_perform2(), GNUNET_RECLAIM_ticket_issue(), GSF_plan_add_(), GSF_plan_notify_peer_disconnect_(), GSF_plan_notify_request_done_(), handle_issue_ticket_message(), main(), merge_pr(), plan(), resolver_lookup_get_next_label(), run(), schedule_peer_transmission(), start_process(), and update_relative_values_for_peer().

attr_name

char* attr_name

static

The attribute.

Definition at line 83 of file gnunet-reclaim.c.

Referenced by attr_in_claims_request(), attr_in_idtoken_request(), attr_in_userinfo_request(), GNUNET_RECLAIM_attribute_list_add(), GNUNET_RECLAIM_attribute_new(), GNUNET_RECLAIM_credential_new(), iter_cb(), iter_finished(), main(), and run().

attr_value

char* attr_value

static

Attribute value.

Definition at line 88 of file gnunet-reclaim.c.

Referenced by cred_iter_finished(), iter_finished(), main(), and run().

issue_attrs

char* issue_attrs

static

Attributes to issue.

Definition at line 93 of file gnunet-reclaim.c.

Referenced by iter_cb(), iter_finished(), main(), and run().

consume_ticket

char* consume_ticket

static

Ticket to consume.

Definition at line 98 of file gnunet-reclaim.c.

Referenced by iter_finished(), main(), and start_process().

type_str

char* type_str

static

Attribute type.

Definition at line 103 of file gnunet-reclaim.c.

Referenced by iter_finished(), main(), parse_attr(), parse_credential(), and parse_jwt().

revoke_ticket

char* revoke_ticket

static

Ticket to revoke.

Definition at line 108 of file gnunet-reclaim.c.

Referenced by iter_finished(), main(), and start_process().

list_tickets

int list_tickets

static

Ticket listing.

Definition at line 113 of file gnunet-reclaim.c.

Referenced by main(), and start_process().

ego_name

char* ego_name

static

Ego name.

Definition at line 118 of file gnunet-reclaim.c.

Referenced by ego_cb(), main(), run(), and start_process().

identity_handle

struct GNUNET_IDENTITY_Handle* identity_handle

static

Identity handle.

Definition at line 123 of file gnunet-reclaim.c.

Referenced by do_cleanup(), and run().

reclaim_handle

struct GNUNET_RECLAIM_Handle* reclaim_handle

static

reclaim handle

Definition at line 128 of file gnunet-reclaim.c.

Referenced by cred_iter_finished(), do_cleanup(), iter_finished(), run(), and start_process().

reclaim_op

struct GNUNET_RECLAIM_Operation* reclaim_op

static

reclaim operation

Definition at line 133 of file gnunet-reclaim.c.

Referenced by cred_iter_finished(), do_cleanup(), iter_finished(), process_attrs(), process_delete(), process_rvk(), store_cont(), and ticket_issue_cb().

attr_iterator

struct GNUNET_RECLAIM_AttributeIterator* attr_iterator

static

Attribute iterator.

Definition at line 138 of file gnunet-reclaim.c.

Referenced by cred_iter_finished(), do_cleanup(), iter_cb(), iter_error(), and iter_finished().

cred_iterator

struct GNUNET_RECLAIM_CredentialIterator* cred_iterator

static

Credential iterator.

Definition at line 143 of file gnunet-reclaim.c.

Referenced by cred_iter_cb(), cred_iter_finished(), do_cleanup(), iter_error(), and start_process().

ticket_iterator

struct GNUNET_RECLAIM_TicketIterator* ticket_iterator

static

Ticket iterator.

Definition at line 149 of file gnunet-reclaim.c.

Referenced by do_cleanup(), start_process(), ticket_iter(), ticket_iter_err(), and ticket_iter_fin().

pkey

const struct GNUNET_IDENTITY_PrivateKey* pkey

static

ego private key

Definition at line 155 of file gnunet-reclaim.c.

Referenced by cred_iter_finished(), ego_cb(), iter_finished(), and start_process().

rp_key

struct GNUNET_IDENTITY_PublicKey rp_key

static

rp public key

Definition at line 155 of file gnunet-reclaim.c.

Referenced by iter_finished(), and start_process().

ticket

struct GNUNET_RECLAIM_Ticket ticket

static

Ticket to consume.

Definition at line 155 of file gnunet-reclaim.c.

Referenced by check_code_challenge(), check_ticket_iteration_start(), clean_ticket(), collect_tickets_cb(), consume_fail(), consume_ticket_cont(), filter_tickets_cb(), GNUNET_RECLAIM_ticket_consume(), GNUNET_RECLAIM_ticket_revoke(), handle_consume_ticket_message(), handle_revoke_ticket_message(), handle_ticket_result(), issue_ticket_result_cb(), iter_finished(), OIDC_access_token_new(), OIDC_parse_authz_code(), oidc_ticket_issue_cb(), parse_ticket(), RECLAIM_TICKETS_consume(), RECLAIM_TICKETS_revoke(), revoke_ticket_cont(), send_ticket_result(), start_process(), ticket_collect(), ticket_issue_cb(), ticket_iter(), token_endpoint(), and userinfo_endpoint().

attr_list

struct GNUNET_RECLAIM_AttributeList* attr_list

static

Attribute list.

Definition at line 170 of file gnunet-reclaim.c.

Referenced by do_cleanup(), iter_cb(), iter_finished(), and start_process().

exp_interval

struct GNUNET_TIME_Relative exp_interval

static

Attribute expiration interval.

Definition at line 170 of file gnunet-reclaim.c.

Referenced by cred_iter_finished(), GNUNET_RECLAIM_attribute_store(), GNUNET_RECLAIM_credential_store(), iter_finished(), and main().

timeout

struct GNUNET_SCHEDULER_Task* timeout

static

Timeout task.

Definition at line 180 of file gnunet-reclaim.c.

Referenced by do_cleanup(), iter_finished(), and timeout_task().

cleanup_task

struct GNUNET_SCHEDULER_Task* cleanup_task

static

Cleanup task.

Definition at line 185 of file gnunet-reclaim.c.

Referenced by cred_iter_finished(), do_cleanup(), GST_neighbour_get_connection_cancel(), iter_error(), iter_finished(), process_attrs(), process_delete(), process_rvk(), start_process(), store_cont(), ticket_issue_cb(), ticket_iter_err(), ticket_iter_fin(), and timeout_task().

claim

struct GNUNET_RECLAIM_Attribute* claim

Claim to store.

Definition at line 190 of file gnunet-reclaim.c.

Referenced by iter_cb(), iter_finished(), parse_jwt(), rvk_move_attr_cb(), and start_process().

attr_delete

char* attr_delete

static

Claim to delete.

Definition at line 195 of file gnunet-reclaim.c.

Referenced by iter_cb(), iter_finished(), and main().

attr_to_delete

struct GNUNET_RECLAIM_Attribute* attr_to_delete

static

Claim object to delete.

Definition at line 200 of file gnunet-reclaim.c.

Referenced by do_cleanup(), iter_cb(), and iter_finished().

init

int init = GNUNET_YES

static

Definition at line 772 of file gnunet-reclaim.c.

Referenced by ego_cb().