#include "platform.h"
#include "microhttpd.h"
#include <inttypes.h>
#include <jansson.h>
#include "gnunet_gns_service.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_identity_service.h"
#include "gnunet_reclaim_lib.h"
#include "gnunet_reclaim_service.h"
#include "gnunet_rest_lib.h"
#include "gnunet_rest_plugin.h"
#include "gnunet_signatures.h"
#include "json_reclaim.h"

Include dependency graph for reclaim_plugin.c:

Data Structures
struct	Plugin
	Handle for a plugin. More...

struct	EgoEntry
	The default namestore ego. More...

struct	RequestHandle
	The request handle. More...

Macros
#define	GNUNET_REST_API_NS_RECLAIM "/reclaim"
	REST root namespace. More...

#define	GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES "/reclaim/attributes"
	Attribute namespace. More...

#define	GNUNET_REST_API_NS_RECLAIM_CREDENTIAL "/reclaim/credential"
	Credential namespace. More...

#define	GNUNET_REST_API_NS_IDENTITY_TICKETS "/reclaim/tickets"
	Ticket namespace. More...

#define	GNUNET_REST_API_NS_IDENTITY_REVOKE "/reclaim/revoke"
	Revoke namespace. More...

#define	GNUNET_REST_API_NS_IDENTITY_CONSUME "/reclaim/consume"
	Revoke namespace. More...

#define	ID_REST_STATE_INIT 0
	State while collecting all egos. More...

#define	ID_REST_STATE_POST_INIT 1
	Done collecting egos. More...

Functions
static void	cleanup_handle (void *cls)
	Cleanup lookup handle. More...

static void	do_error (void *cls)
	Task run on error, sends error message. More...

static void	do_timeout (void *cls)
	Task run on timeout, sends error message. More...

static void	collect_error_cb (void *cls)

static void	finished_cont (void cls, int32_t success, const char emsg)

static void	delete_finished_cb (void cls, int32_t success, const char emsg)

static void	return_response (void *cls)
	Return attributes for identity. More...

static void	collect_finished_cb (void *cls)

static void	ticket_collect (void cls, const struct GNUNET_RECLAIM_Ticket ticket, const char *rp_uri)
	Collect all attributes for an ego. More...

static void	add_credential_cont (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)

static void	cred_collect (void cls, const struct GNUNET_CRYPTO_PublicKey identity, const struct GNUNET_RECLAIM_Credential *cred)
	Collect all credentials for an ego. More...

static void	list_credential_cont (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	Lists credential for identity request. More...

static void	delete_credential_cont (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	Deletes credential from an identity. More...

static void	list_tickets_cont (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	List tickets for identity request. More...

static void	add_attribute_cont (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)

struct GNUNET_RECLAIM_Attribute *	parse_jwt (const struct GNUNET_RECLAIM_Credential cred, const char claim)
	Parse a JWT and return the respective claim value as Attribute. More...

static void	attr_collect (void cls, const struct GNUNET_CRYPTO_PublicKey identity, const struct GNUNET_RECLAIM_Attribute *attr)
	Collect all attributes for an ego. More...

static void	list_attribute_cont (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	List attributes for identity request. More...

static void	delete_attribute_cont (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	List attributes for identity request. More...

static void	revoke_ticket_cont (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)

static void	consume_cont (void cls, const struct GNUNET_CRYPTO_PublicKey identity, const struct GNUNET_RECLAIM_Attribute attr, const struct GNUNET_RECLAIM_Presentation presentation)

static void	consume_ticket_cont (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)

static void	options_cont (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	Respond to OPTIONS request. More...

static void	list_ego (void cls, struct GNUNET_IDENTITY_Ego ego, void *ctx, const char identifier)
	If listing is enabled, prints information about the egos. More...

enum GNUNET_GenericReturnValue	REST_reclaim_process_request (void plugin, struct GNUNET_REST_RequestHandle rest_handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
	Function processing the REST call. More...

void *	REST_reclaim_init (struct GNUNET_CONFIGURATION_Handle *c)
	Entry point for the plugin. More...

void *	REST_reclaim_done (struct GNUNET_REST_Plugin *api)
	Exit point from the plugin. More...

Variables
const struct GNUNET_CONFIGURATION_Handle *	rcfg
	The configuration handle. More...

static char *	allow_methods
	HTTP methods allows for this plugin. More...

static struct EgoEntry *	ego_head
	Ego list. More...

static struct EgoEntry *	ego_tail
	Ego list. More...

static int	state
	The processing state. More...

static struct GNUNET_IDENTITY_Handle *	identity_handle
	Handle to Identity service. More...

static struct GNUNET_RECLAIM_Handle *	idp
	Identity Provider. More...

static struct RequestHandle *	requests_head
	DLL. More...

static struct RequestHandle *	requests_tail
	DLL. More...

Macro Definition Documentation

◆ GNUNET_REST_API_NS_RECLAIM

#define GNUNET_REST_API_NS_RECLAIM "/reclaim"

REST root namespace.

Definition at line 43 of file reclaim_plugin.c.

◆ GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES

#define GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES "/reclaim/attributes"

Attribute namespace.

Definition at line 48 of file reclaim_plugin.c.

◆ GNUNET_REST_API_NS_RECLAIM_CREDENTIAL

#define GNUNET_REST_API_NS_RECLAIM_CREDENTIAL "/reclaim/credential"

Credential namespace.

Definition at line 53 of file reclaim_plugin.c.

◆ GNUNET_REST_API_NS_IDENTITY_TICKETS

#define GNUNET_REST_API_NS_IDENTITY_TICKETS "/reclaim/tickets"

Ticket namespace.

Definition at line 58 of file reclaim_plugin.c.

◆ GNUNET_REST_API_NS_IDENTITY_REVOKE

#define GNUNET_REST_API_NS_IDENTITY_REVOKE "/reclaim/revoke"

Revoke namespace.

Definition at line 63 of file reclaim_plugin.c.

◆ GNUNET_REST_API_NS_IDENTITY_CONSUME

#define GNUNET_REST_API_NS_IDENTITY_CONSUME "/reclaim/consume"

Revoke namespace.

Definition at line 68 of file reclaim_plugin.c.

◆ ID_REST_STATE_INIT

#define ID_REST_STATE_INIT 0

State while collecting all egos.

Definition at line 73 of file reclaim_plugin.c.

◆ ID_REST_STATE_POST_INIT

#define ID_REST_STATE_POST_INIT 1

Done collecting egos.

Definition at line 78 of file reclaim_plugin.c.

Function Documentation

◆ cleanup_handle()

static void cleanup_handle ( void * cls )

static

Cleanup lookup handle.

Parameters

handle Handle to clean up

Definition at line 274 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
  if (NULL != handle->resp_object)
    json_decref (handle->resp_object);
  if (NULL != handle->timeout_task)
    GNUNET_SCHEDULER_cancel (handle->timeout_task);
  if (NULL != handle->attr_it)
    GNUNET_RECLAIM_get_attributes_stop (handle->attr_it);
  if (NULL != handle->cred_it)
    GNUNET_RECLAIM_get_credentials_stop (handle->cred_it);
  if (NULL != handle->ticket_it)
    GNUNET_RECLAIM_ticket_iteration_stop (handle->ticket_it);
  if (NULL != handle->url)
    GNUNET_free (handle->url);
  if (NULL != handle->emsg)
    GNUNET_free (handle->emsg);
  if (NULL != handle->attr_list)
    GNUNET_RECLAIM_attribute_list_destroy (handle->attr_list);
  GNUNET_CONTAINER_DLL_remove (requests_head,
                               requests_tail,
                               handle);
  GNUNET_free (handle);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_RECLAIM_attribute_list_destroy(), GNUNET_RECLAIM_get_attributes_stop(), GNUNET_RECLAIM_get_credentials_stop(), GNUNET_RECLAIM_ticket_iteration_stop(), GNUNET_SCHEDULER_cancel(), handle, requests_head, and requests_tail.

Referenced by delete_finished_cb(), do_error(), finished_cont(), options_cont(), REST_reclaim_process_request(), and return_response().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_error()

static void do_error ( void * cls )

static

Task run on error, sends error message.

Cleans up everything.

Parameters

cls	the `struct RequestHandle`

Definition at line 308 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct MHD_Response *resp;
  char *json_error;
 
  GNUNET_asprintf (&json_error, "{ \"error\" : \"%s\" }", handle->emsg);
  if (0 == handle->response_code)
  {
    handle->response_code = MHD_HTTP_BAD_REQUEST;
  }
  resp = GNUNET_REST_create_response (json_error);
  GNUNET_assert (MHD_NO != MHD_add_response_header (resp, "Content-Type",
                                                    "application/json"));
  handle->proc (handle->proc_cls, resp, handle->response_code);
  cleanup_handle (handle);
  GNUNET_free (json_error);
}

References cleanup_handle(), GNUNET_asprintf(), GNUNET_assert, GNUNET_free, GNUNET_REST_create_response(), handle, and MHD_HTTP_BAD_REQUEST.

Referenced by add_attribute_cont(), add_credential_cont(), collect_error_cb(), consume_ticket_cont(), delete_attribute_cont(), delete_credential_cont(), delete_finished_cb(), do_timeout(), finished_cont(), list_attribute_cont(), list_credential_cont(), list_tickets_cont(), REST_reclaim_done(), and revoke_ticket_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_timeout()

static void do_timeout ( void * cls )

static

Task run on timeout, sends error message.

Cleans up everything.

Parameters

cls	the `struct RequestHandle`

Definition at line 334 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = cls;
 
  handle->timeout_task = NULL;
  do_error (handle);
}

References do_error(), and handle.

Referenced by REST_reclaim_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collect_error_cb()

static void collect_error_cb ( void * cls )

static

Definition at line 344 of file reclaim_plugin.c.

{
  GNUNET_SCHEDULER_add_now (&do_error, cls);
}

References do_error(), and GNUNET_SCHEDULER_add_now().

Referenced by list_attribute_cont(), list_credential_cont(), and list_tickets_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finished_cont()

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

static

Definition at line 351 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct MHD_Response *resp;
 
  handle->idp_op = NULL;
  if (GNUNET_OK != success)
  {
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  resp = GNUNET_REST_create_response (emsg);
  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
                                                    "Content-Type",
                                                    "application/json"));
  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
                                                    "Access-Control-Allow-Methods",
                                                    allow_methods));
  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}

References allow_methods, cleanup_handle(), do_error(), GNUNET_assert, GNUNET_OK, GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), handle, and MHD_HTTP_OK.

Referenced by add_attribute_cont(), add_credential_cont(), and revoke_ticket_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_finished_cb()

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

static

Definition at line 375 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct MHD_Response *resp;
 
  if (GNUNET_OK != success)
  {
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  resp = GNUNET_REST_create_response (emsg);
  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
                                                    "Access-Control-Allow-Methods",
                                                    allow_methods));
  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}

References allow_methods, cleanup_handle(), do_error(), GNUNET_assert, GNUNET_OK, GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), handle, and MHD_HTTP_OK.

Referenced by delete_attribute_cont(), and delete_credential_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ return_response()

static void return_response ( void * cls )

static

Return attributes for identity.

Parameters

cls	the request handle

Definition at line 400 of file reclaim_plugin.c.

{
  char *result_str;
  struct RequestHandle *handle = cls;
  struct MHD_Response *resp;
 
  result_str = json_dumps (handle->resp_object, 0);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
  resp = GNUNET_REST_create_response (result_str);
  GNUNET_assert (MHD_NO !=
                 MHD_add_response_header (resp,
                                          "Access-Control-Allow-Methods",
                                          allow_methods));
  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
  GNUNET_free (result_str);
  cleanup_handle (handle);
}

References allow_methods, cleanup_handle(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_REST_create_response(), handle, and MHD_HTTP_OK.

Referenced by collect_finished_cb(), consume_cont(), delete_attribute_cont(), delete_credential_cont(), list_attribute_cont(), list_credential_cont(), and list_tickets_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collect_finished_cb()

static void collect_finished_cb ( void * cls )

static

Definition at line 420 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = cls;
 
  // Done
  handle->attr_it = NULL;
  handle->cred_it = NULL;
  handle->ticket_it = NULL;
  GNUNET_SCHEDULER_add_now (&return_response, handle);
}

References GNUNET_SCHEDULER_add_now(), handle, and return_response().

Referenced by list_attribute_cont(), list_credential_cont(), and list_tickets_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ticket_collect()

static void ticket_collect	(	void *	cls,
		const struct GNUNET_RECLAIM_Ticket *	ticket,
		const char *	rp_uri
	)

static

Collect all attributes for an ego.

Definition at line 437 of file reclaim_plugin.c.

{
  json_t *json_resource;
  struct RequestHandle *handle = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding ticket\n");
  json_resource = json_object ();
  json_array_append (handle->resp_object, json_resource);
 
  json_object_set_new (json_resource, "gns_name", json_string (ticket->gns_name)
                       );
  json_object_set_new (json_resource, "rp_uri", json_string (rp_uri));
  GNUNET_RECLAIM_ticket_iteration_next (handle->ticket_it);
}

References GNUNET_RECLAIM_Ticket::gns_name, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_RECLAIM_ticket_iteration_next(), handle, and ticket.

Referenced by list_tickets_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_credential_cont()

static void add_credential_cont	(	struct GNUNET_REST_RequestHandle *	con_handle,
		const char *	url,
		void *	cls
	)

static

New ID for attribute

Definition at line 455 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = cls;
  const struct GNUNET_CRYPTO_PrivateKey *identity_priv;
  const char *identity;
  struct EgoEntry *ego_entry;
  struct GNUNET_RECLAIM_Credential *attribute;
  struct GNUNET_TIME_Relative exp;
  char term_data[handle->rest_handle->data_size + 1];
  json_t *data_json;
  json_error_t err;
  struct GNUNET_JSON_Specification attrspec[] =
  { GNUNET_RECLAIM_JSON_spec_credential (&attribute),
    GNUNET_JSON_spec_end () };
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Adding an credential for %s.\n",
              handle->url);
  if (strlen (GNUNET_REST_API_NS_RECLAIM_CREDENTIAL) >= strlen (
        handle->url))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  identity = handle->url + strlen (
    GNUNET_REST_API_NS_RECLAIM_CREDENTIAL) + 1;
 
  for (ego_entry = ego_head; NULL != ego_entry;
       ego_entry = ego_entry->next)
    if (0 == strcmp (identity, ego_entry->identifier))
      break;
 
  if (NULL == ego_entry)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Identity unknown (%s)\n", identity);
    return;
  }
  identity_priv = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
 
  if (0 >= handle->rest_handle->data_size)
  {
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  term_data[handle->rest_handle->data_size] = '\0';
  GNUNET_memcpy (term_data,
                 handle->rest_handle->data,
                 handle->rest_handle->data_size);
  data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
  if (GNUNET_OK != GNUNET_JSON_parse (data_json, attrspec, NULL, NULL))
  {
    json_decref (data_json);
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Unable to parse JSON from %s\n",
                term_data);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  json_decref (data_json);
  if (NULL == attribute)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Unable to parse credential from %s\n",
                term_data);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  if (GNUNET_YES == GNUNET_RECLAIM_id_is_zero (&attribute->id))
    GNUNET_RECLAIM_id_generate (&attribute->id);
  exp = GNUNET_TIME_UNIT_HOURS;
  handle->idp_op = GNUNET_RECLAIM_credential_store (idp,
                                                    identity_priv,
                                                    attribute,
                                                    &exp,
                                                    &finished_cont,
                                                    handle);
  GNUNET_JSON_parse_free (attrspec);
}

References do_error(), EgoEntry::ego, ego_head, finished_cont(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_JSON_parse(), GNUNET_JSON_parse_free(), GNUNET_JSON_spec_end(), GNUNET_log, GNUNET_memcpy, GNUNET_OK, GNUNET_RECLAIM_credential_store(), GNUNET_RECLAIM_id_generate, GNUNET_RECLAIM_id_is_zero, GNUNET_RECLAIM_JSON_spec_credential(), GNUNET_REST_API_NS_RECLAIM_CREDENTIAL, GNUNET_SCHEDULER_add_now(), GNUNET_TIME_UNIT_HOURS, GNUNET_YES, handle, GNUNET_RECLAIM_Credential::id, EgoEntry::identifier, identity, idp, and EgoEntry::next.

Referenced by REST_reclaim_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cred_collect()

static void cred_collect	(	void *	cls,
		const struct GNUNET_CRYPTO_PublicKey *	identity,
		const struct GNUNET_RECLAIM_Credential *	cred
	)

static

Collect all credentials for an ego.

Definition at line 547 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct GNUNET_RECLAIM_AttributeList *attrs;
  struct GNUNET_RECLAIM_AttributeListEntry *ale;
  struct GNUNET_TIME_Absolute exp;
  json_t *attr_obj;
  json_t *cred_obj;
  const char *type;
  char *tmp_value;
  char *id_str;
  char *issuer;
 
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding credential: %s\n",
              cred->name);
  attrs = GNUNET_RECLAIM_credential_get_attributes (cred);
  issuer = GNUNET_RECLAIM_credential_get_issuer (cred);
  tmp_value = GNUNET_RECLAIM_credential_value_to_string (cred->type,
                                                         cred->data,
                                                         cred->data_size);
  cred_obj = json_object ();
  json_object_set_new (cred_obj, "value", json_string (tmp_value));
  json_object_set_new (cred_obj, "name", json_string (cred->name));
  type = GNUNET_RECLAIM_credential_number_to_typename (cred->type);
  json_object_set_new (cred_obj, "type", json_string (type));
  if (NULL != issuer)
  {
    json_object_set_new (cred_obj, "issuer", json_string (issuer));
    GNUNET_free (issuer);
  }
  if (GNUNET_OK == GNUNET_RECLAIM_credential_get_expiration (cred,
                                                             &exp))
  {
    json_object_set_new (cred_obj, "expiration", json_integer (
                           exp.abs_value_us));
  }
  id_str = GNUNET_STRINGS_data_to_string_alloc (&cred->id,
                                                sizeof(cred->id));
  json_object_set_new (cred_obj, "id", json_string (id_str));
  GNUNET_free (tmp_value);
  GNUNET_free (id_str);
  if (NULL != attrs)
  {
    json_t *attr_arr = json_array ();
    for (ale = attrs->list_head; NULL != ale; ale = ale->next)
    {
      tmp_value =
        GNUNET_RECLAIM_attribute_value_to_string (ale->attribute->type,
                                                  ale->attribute->data,
                                                  ale->attribute->data_size);
      attr_obj = json_object ();
      json_object_set_new (attr_obj, "value", json_string (tmp_value));
      json_object_set_new (attr_obj, "name", json_string (
                             ale->attribute->name));
 
      json_object_set_new (attr_obj, "flag", json_string ("1")); // FIXME
      type = GNUNET_RECLAIM_attribute_number_to_typename (ale->attribute->type);
      json_object_set_new (attr_obj, "type", json_string (type));
      json_object_set_new (attr_obj, "id", json_string (""));
      json_object_set_new (attr_obj, "credential", json_string (""));
      json_array_append_new (attr_arr, attr_obj);
      GNUNET_free (tmp_value);
    }
    json_object_set_new (cred_obj, "attributes", attr_arr);
  }
  json_array_append_new (handle->resp_object, cred_obj);
  if (NULL != attrs)
    GNUNET_RECLAIM_attribute_list_destroy (attrs);
  GNUNET_RECLAIM_get_credentials_next (handle->cred_it);
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_RECLAIM_AttributeListEntry::attribute, GNUNET_RECLAIM_Attribute::data, GNUNET_RECLAIM_Credential::data, GNUNET_RECLAIM_Attribute::data_size, GNUNET_RECLAIM_Credential::data_size, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_RECLAIM_attribute_list_destroy(), GNUNET_RECLAIM_attribute_number_to_typename(), GNUNET_RECLAIM_attribute_value_to_string(), GNUNET_RECLAIM_credential_get_attributes(), GNUNET_RECLAIM_credential_get_expiration(), GNUNET_RECLAIM_credential_get_issuer(), GNUNET_RECLAIM_credential_number_to_typename(), GNUNET_RECLAIM_credential_value_to_string(), GNUNET_RECLAIM_get_credentials_next(), GNUNET_STRINGS_data_to_string_alloc(), handle, GNUNET_RECLAIM_Credential::id, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_Attribute::name, GNUNET_RECLAIM_Credential::name, GNUNET_RECLAIM_AttributeListEntry::next, type, GNUNET_RECLAIM_Attribute::type, and GNUNET_RECLAIM_Credential::type.

Referenced by list_credential_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ list_credential_cont()

static void list_credential_cont	(	struct GNUNET_REST_RequestHandle *	con_handle,
		const char *	url,
		void *	cls
	)

static

Lists credential for identity request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 630 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = cls;
  const struct GNUNET_CRYPTO_PrivateKey *priv_key;
  struct EgoEntry *ego_entry;
  char *identity;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Getting credentials for %s.\n",
              handle->url);
  if (strlen (GNUNET_REST_API_NS_RECLAIM_CREDENTIAL) >= strlen (
        handle->url))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  identity = handle->url + strlen (
    GNUNET_REST_API_NS_RECLAIM_CREDENTIAL) + 1;
 
  for (ego_entry = ego_head; NULL != ego_entry;
       ego_entry = ego_entry->next)
    if (0 == strcmp (identity, ego_entry->identifier))
      break;
  handle->resp_object = json_array ();
 
 
  if (NULL == ego_entry)
  {
    // Done
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
    GNUNET_SCHEDULER_add_now (&return_response, handle);
    return;
  }
  priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
  handle->cred_it = GNUNET_RECLAIM_get_credentials_start (idp,
                                                          priv_key,
                                                          &collect_error_cb,
                                                          handle,
                                                          &cred_collect,
                                                          handle,
                                                          &
                                                          collect_finished_cb,
                                                          handle);
}

References collect_error_cb(), collect_finished_cb(), cred_collect(), do_error(), EgoEntry::ego, ego_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_RECLAIM_get_credentials_start(), GNUNET_REST_API_NS_RECLAIM_CREDENTIAL, GNUNET_SCHEDULER_add_now(), handle, EgoEntry::identifier, identity, idp, EgoEntry::next, and return_response().

Referenced by REST_reclaim_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_credential_cont()

static void delete_credential_cont	(	struct GNUNET_REST_RequestHandle *	con_handle,
		const char *	url,
		void *	cls
	)

static

Deletes credential from an identity.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 687 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = cls;
  const struct GNUNET_CRYPTO_PrivateKey *priv_key;
  struct GNUNET_RECLAIM_Credential attr;
  struct EgoEntry *ego_entry;
  char *identity_id_str;
  char *identity;
  char *id;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleting credential.\n");
  if (strlen (GNUNET_REST_API_NS_RECLAIM_CREDENTIAL) >= strlen (
        handle->url))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  identity_id_str =
    strdup (handle->url + strlen (
              GNUNET_REST_API_NS_RECLAIM_CREDENTIAL) + 1);
  identity = strtok (identity_id_str, "/");
  id = strtok (NULL, "/");
  if ((NULL == identity) || (NULL == id))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Malformed request.\n");
    GNUNET_free (identity_id_str);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  for (ego_entry = ego_head; NULL != ego_entry;
       ego_entry = ego_entry->next)
    if (0 == strcmp (identity, ego_entry->identifier))
      break;
  handle->resp_object = json_array ();
  if (NULL == ego_entry)
  {
    // Done
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
    GNUNET_free (identity_id_str);
    GNUNET_SCHEDULER_add_now (&return_response, handle);
    return;
  }
  priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
  memset (&attr, 0, sizeof(struct GNUNET_RECLAIM_Credential));
  GNUNET_STRINGS_string_to_data (id, strlen (id), &attr.id, sizeof(attr.id));
  attr.name = "";
  handle->idp_op = GNUNET_RECLAIM_credential_delete (idp,
                                                     priv_key,
                                                     &attr,
                                                     &delete_finished_cb,
                                                     handle);
  GNUNET_free (identity_id_str);
}

References delete_finished_cb(), do_error(), EgoEntry::ego, ego_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_RECLAIM_credential_delete(), GNUNET_REST_API_NS_RECLAIM_CREDENTIAL, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_string_to_data(), handle, id, GNUNET_RECLAIM_Credential::id, EgoEntry::identifier, identity, idp, GNUNET_RECLAIM_Credential::name, EgoEntry::next, and return_response().

Referenced by REST_reclaim_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ list_tickets_cont()

static void list_tickets_cont	(	struct GNUNET_REST_RequestHandle *	con_handle,
		const char *	url,
		void *	cls
	)

static

List tickets for identity request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 754 of file reclaim_plugin.c.

{
  const struct GNUNET_CRYPTO_PrivateKey *priv_key;
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *identity;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Getting tickets for %s.\n",
              handle->url);
  if (strlen (GNUNET_REST_API_NS_IDENTITY_TICKETS) >= strlen (handle->url))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  identity = handle->url + strlen (GNUNET_REST_API_NS_IDENTITY_TICKETS) + 1;
 
  for (ego_entry = ego_head; NULL != ego_entry;
       ego_entry = ego_entry->next)
    if (0 == strcmp (identity, ego_entry->identifier))
      break;
  handle->resp_object = json_array ();
 
  if (NULL == ego_entry)
  {
    // Done
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
    GNUNET_SCHEDULER_add_now (&return_response, handle);
    return;
  }
  priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
  handle->ticket_it =
    GNUNET_RECLAIM_ticket_iteration_start (idp,
                                           priv_key,
                                           &collect_error_cb,
                                           handle,
                                           &ticket_collect,
                                           handle,
                                           &collect_finished_cb,
                                           handle);
}

References collect_error_cb(), collect_finished_cb(), do_error(), EgoEntry::ego, ego_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_RECLAIM_ticket_iteration_start(), GNUNET_REST_API_NS_IDENTITY_TICKETS, GNUNET_SCHEDULER_add_now(), handle, EgoEntry::identifier, identity, idp, EgoEntry::next, return_response(), and ticket_collect().

Referenced by REST_reclaim_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_attribute_cont()

static void add_attribute_cont	(	struct GNUNET_REST_RequestHandle *	con_handle,
		const char *	url,
		void *	cls
	)

static

New ID for attribute

Definition at line 801 of file reclaim_plugin.c.

{
  const struct GNUNET_CRYPTO_PrivateKey *identity_priv;
  const char *identity;
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  struct GNUNET_RECLAIM_Attribute *attribute;
  struct GNUNET_TIME_Relative exp;
  char term_data[handle->rest_handle->data_size + 1];
  json_t *data_json;
  json_error_t err;
  struct GNUNET_JSON_Specification attrspec[] =
  { GNUNET_RECLAIM_JSON_spec_attribute (&attribute), GNUNET_JSON_spec_end () };
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Adding an attribute for %s.\n",
              handle->url);
  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >= strlen (handle->url))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  identity = handle->url + strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) + 1;
 
  for (ego_entry = ego_head; NULL != ego_entry;
       ego_entry = ego_entry->next)
    if (0 == strcmp (identity, ego_entry->identifier))
      break;
 
  if (NULL == ego_entry)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Identity unknown (%s)\n", identity);
    return;
  }
  identity_priv = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
 
  if (0 >= handle->rest_handle->data_size)
  {
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  term_data[handle->rest_handle->data_size] = '\0';
  GNUNET_memcpy (term_data,
                 handle->rest_handle->data,
                 handle->rest_handle->data_size);
  data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_JSON_parse (data_json, attrspec, NULL, NULL));
  json_decref (data_json);
  if (NULL == attribute)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Unable to parse attribute from %s\n",
                term_data);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  if (GNUNET_YES == GNUNET_RECLAIM_id_is_zero (&attribute->id))
    GNUNET_RECLAIM_id_generate (&attribute->id);
  exp = GNUNET_TIME_UNIT_HOURS;
  handle->idp_op = GNUNET_RECLAIM_attribute_store (idp,
                                                   identity_priv,
                                                   attribute,
                                                   &exp,
                                                   &finished_cont,
                                                   handle);
  GNUNET_JSON_parse_free (attrspec);
}

References do_error(), EgoEntry::ego, ego_head, finished_cont(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_JSON_parse(), GNUNET_JSON_parse_free(), GNUNET_JSON_spec_end(), GNUNET_log, GNUNET_memcpy, GNUNET_OK, GNUNET_RECLAIM_attribute_store(), GNUNET_RECLAIM_id_generate, GNUNET_RECLAIM_id_is_zero, GNUNET_RECLAIM_JSON_spec_attribute(), GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, GNUNET_SCHEDULER_add_now(), GNUNET_TIME_UNIT_HOURS, GNUNET_YES, handle, GNUNET_RECLAIM_Attribute::id, EgoEntry::identifier, identity, idp, and EgoEntry::next.

Referenced by REST_reclaim_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_jwt()

struct GNUNET_RECLAIM_Attribute * parse_jwt	(	const struct GNUNET_RECLAIM_Credential *	cred,
		const char *	claim
	)

Parse a JWT and return the respective claim value as Attribute.

Parameters

cred	the jwt credential
claim	the name of the claim in the JWT

Returns: a GNUNET_RECLAIM_Attribute, containing the new value

Definition at line 887 of file reclaim_plugin.c.

{
  char *jwt_string;
  struct GNUNET_RECLAIM_Attribute *attr;
  char delim[] = ".";
  const char *type_str = NULL;
  const char *val_str = NULL;
  char *data;
  size_t data_size;
  uint32_t type;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Parsing JWT attributes.\n");
  char *decoded_jwt;
  json_t *json_val;
  json_error_t *json_err = NULL;
 
  jwt_string = GNUNET_RECLAIM_credential_value_to_string (cred->type,
                                                          cred->data,
                                                          cred->data_size);
  char *jwt_body = strtok (jwt_string, delim);
  jwt_body = strtok (NULL, delim);
  GNUNET_STRINGS_base64_decode (jwt_body, strlen (jwt_body),
                                (void **) &decoded_jwt);
  json_val = json_loads (decoded_jwt, JSON_DECODE_ANY, json_err);
  const char *key;
  json_t *value;
  json_object_foreach (json_val, key, value) {
    if (0 == strcasecmp (key,claim))
    {
      val_str = json_dumps (value, JSON_ENCODE_ANY);
    }
  }
  type_str = "String";
  type = GNUNET_RECLAIM_attribute_typename_to_number (type_str);
  if (GNUNET_SYSERR == GNUNET_RECLAIM_attribute_string_to_value (type,val_str,
                                                                 (void **) &data
                                                                 ,
                                                                 &data_size))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Attribute value from JWT Parser invalid!\n");
    GNUNET_RECLAIM_attribute_string_to_value (type,
                                              "Error: Referenced Claim Name not Found",
                                              (void **) &data,
                                              &data_size);
    attr = GNUNET_RECLAIM_attribute_new (claim, &cred->id,
                                         type, data, data_size);
    attr->id = cred->id;
    attr->flag = 1;
  }
  else
  {
    attr = GNUNET_RECLAIM_attribute_new (claim, &cred->id,
                                         type, data, data_size);
    attr->id = cred->id;
    attr->flag = 1;
  }
  return attr;
}

References claim, data, GNUNET_RECLAIM_Credential::data, data_size, GNUNET_RECLAIM_Credential::data_size, GNUNET_RECLAIM_Attribute::flag, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_RECLAIM_attribute_new(), GNUNET_RECLAIM_attribute_string_to_value(), GNUNET_RECLAIM_attribute_typename_to_number(), GNUNET_RECLAIM_credential_value_to_string(), GNUNET_STRINGS_base64_decode(), GNUNET_SYSERR, GNUNET_RECLAIM_Attribute::id, GNUNET_RECLAIM_Credential::id, key, type, GNUNET_RECLAIM_Credential::type, type_str, and value.

Here is the call graph for this function:

◆ attr_collect()

static void attr_collect	(	void *	cls,
		const struct GNUNET_CRYPTO_PublicKey *	identity,
		const struct GNUNET_RECLAIM_Attribute *	attr
	)

static

Collect all attributes for an ego.

Definition at line 953 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = cls;
  json_t *attr_obj;
  const char *type;
  char *id_str;
 
  char *tmp_value;
  tmp_value = GNUNET_RECLAIM_attribute_value_to_string (attr->type,
                                                        attr->data,
                                                        attr->data_size);
  attr_obj = json_object ();
  json_object_set_new (attr_obj, "value", json_string (tmp_value));
  json_object_set_new (attr_obj, "name", json_string (attr->name));
 
  if (GNUNET_RECLAIM_id_is_zero (&attr->credential))
    json_object_set_new (attr_obj, "flag", json_string ("0"));
  else
    json_object_set_new (attr_obj, "flag", json_string ("1"));
  type = GNUNET_RECLAIM_attribute_number_to_typename (attr->type);
  json_object_set_new (attr_obj, "type", json_string (type));
  id_str = GNUNET_STRINGS_data_to_string_alloc (&attr->id,
                                                sizeof(attr->id));
  json_object_set_new (attr_obj, "id", json_string (id_str));
  GNUNET_free (id_str);
  id_str = GNUNET_STRINGS_data_to_string_alloc (&attr->credential,
                                                sizeof(attr->credential));
  json_object_set_new (attr_obj, "credential", json_string (id_str));
  GNUNET_free (id_str);
  json_array_append (handle->resp_object, attr_obj);
  json_decref (attr_obj);
  GNUNET_free (tmp_value);
  GNUNET_RECLAIM_get_attributes_next (handle->attr_it);
}

References GNUNET_RECLAIM_Attribute::credential, GNUNET_RECLAIM_Attribute::data, GNUNET_RECLAIM_Attribute::data_size, GNUNET_free, GNUNET_RECLAIM_attribute_number_to_typename(), GNUNET_RECLAIM_attribute_value_to_string(), GNUNET_RECLAIM_get_attributes_next(), GNUNET_RECLAIM_id_is_zero, GNUNET_STRINGS_data_to_string_alloc(), handle, GNUNET_RECLAIM_Attribute::id, GNUNET_RECLAIM_Attribute::name, type, and GNUNET_RECLAIM_Attribute::type.

Referenced by list_attribute_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ list_attribute_cont()

static void list_attribute_cont	(	struct GNUNET_REST_RequestHandle *	con_handle,
		const char *	url,
		void *	cls
	)

static

List attributes for identity request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 999 of file reclaim_plugin.c.

{
  const struct GNUNET_CRYPTO_PrivateKey *priv_key;
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *identity;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Getting attributes for %s.\n",
              handle->url);
  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >= strlen (handle->url))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  identity = handle->url + strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) + 1;
 
  for (ego_entry = ego_head; NULL != ego_entry;
       ego_entry = ego_entry->next)
    if (0 == strcmp (identity, ego_entry->identifier))
      break;
  handle->resp_object = json_array ();
 
 
  if (NULL == ego_entry)
  {
    // Done
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
    GNUNET_SCHEDULER_add_now (&return_response, handle);
    return;
  }
  priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
  handle->attr_it = GNUNET_RECLAIM_get_attributes_start (idp,
                                                         priv_key,
                                                         &collect_error_cb,
                                                         handle,
                                                         &attr_collect,
                                                         handle,
                                                         &collect_finished_cb,
                                                         handle);
}

References attr_collect(), collect_error_cb(), collect_finished_cb(), do_error(), EgoEntry::ego, ego_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_RECLAIM_get_attributes_start(), GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, GNUNET_SCHEDULER_add_now(), handle, EgoEntry::identifier, identity, idp, EgoEntry::next, and return_response().

Referenced by REST_reclaim_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_attribute_cont()

static void delete_attribute_cont	(	struct GNUNET_REST_RequestHandle *	con_handle,
		const char *	url,
		void *	cls
	)

static

List attributes for identity request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 1053 of file reclaim_plugin.c.

{
  const struct GNUNET_CRYPTO_PrivateKey *priv_key;
  struct RequestHandle *handle = cls;
  struct GNUNET_RECLAIM_Attribute attr;
  struct EgoEntry *ego_entry;
  char *identity_id_str;
  char *identity;
  char *id;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleting attributes.\n");
  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >= strlen (handle->url))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  identity_id_str =
    strdup (handle->url + strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) + 1);
  identity = strtok (identity_id_str, "/");
  id = strtok (NULL, "/");
  if ((NULL == identity) || (NULL == id))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Malformed request.\n");
    GNUNET_free (identity_id_str);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  for (ego_entry = ego_head; NULL != ego_entry;
       ego_entry = ego_entry->next)
    if (0 == strcmp (identity, ego_entry->identifier))
      break;
  handle->resp_object = json_array ();
  if (NULL == ego_entry)
  {
    // Done
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
    GNUNET_free (identity_id_str);
    GNUNET_SCHEDULER_add_now (&return_response, handle);
    return;
  }
  priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
  memset (&attr, 0, sizeof(struct GNUNET_RECLAIM_Attribute));
  GNUNET_STRINGS_string_to_data (id, strlen (id), &attr.id, sizeof(attr.id));
  attr.name = "";
  handle->idp_op = GNUNET_RECLAIM_attribute_delete (idp,
                                                    priv_key,
                                                    &attr,
                                                    &delete_finished_cb,
                                                    handle);
  GNUNET_free (identity_id_str);
}

References delete_finished_cb(), do_error(), EgoEntry::ego, ego_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_RECLAIM_attribute_delete(), GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_string_to_data(), handle, id, GNUNET_RECLAIM_Attribute::id, EgoEntry::identifier, identity, idp, GNUNET_RECLAIM_Attribute::name, EgoEntry::next, and return_response().

Referenced by REST_reclaim_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ revoke_ticket_cont()

static void revoke_ticket_cont	(	struct GNUNET_REST_RequestHandle *	con_handle,
		const char *	url,
		void *	cls
	)

static

Definition at line 1111 of file reclaim_plugin.c.

{
  const struct GNUNET_CRYPTO_PrivateKey *identity_priv;
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  struct GNUNET_RECLAIM_Ticket *ticket = NULL;
  struct GNUNET_CRYPTO_PublicKey iss;
  struct GNUNET_CRYPTO_PublicKey tmp_pk;
  char term_data[handle->rest_handle->data_size + 1];
  json_t *data_json;
  json_error_t err;
  struct GNUNET_JSON_Specification tktspec[] =
  { GNUNET_RECLAIM_JSON_spec_ticket (&ticket), GNUNET_JSON_spec_end () };
 
  if (0 >= handle->rest_handle->data_size)
  {
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  term_data[handle->rest_handle->data_size] = '\0';
  GNUNET_memcpy (term_data,
                 handle->rest_handle->data,
                 handle->rest_handle->data_size);
  data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
  if ((NULL == data_json) ||
      (GNUNET_OK != GNUNET_JSON_parse (data_json, tktspec, NULL, NULL)))
  {
    handle->emsg = GNUNET_strdup ("Not a ticket!\n");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    GNUNET_JSON_parse_free (tktspec);
    if (NULL != data_json)
      json_decref (data_json);
    return;
  }
  json_decref (data_json);
  if (NULL == ticket)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Unable to parse ticket from %s\n",
                term_data);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  GNUNET_assert (GNUNET_OK == GNUNET_GNS_parse_ztld (ticket->gns_name, &iss));
 
  for (ego_entry = ego_head; NULL != ego_entry;
       ego_entry = ego_entry->next)
  {
    GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego, &tmp_pk);
    if (0 == memcmp (&iss,
                     &tmp_pk,
                     sizeof(struct GNUNET_CRYPTO_PublicKey)))
      break;
  }
  if (NULL == ego_entry)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Identity unknown\n");
    GNUNET_JSON_parse_free (tktspec);
    return;
  }
  identity_priv = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
 
  handle->idp_op = GNUNET_RECLAIM_ticket_revoke (idp,
                                                 identity_priv,
                                                 ticket,
                                                 &finished_cont,
                                                 handle);
  GNUNET_JSON_parse_free (tktspec);
}

References do_error(), EgoEntry::ego, ego_head, finished_cont(), GNUNET_RECLAIM_Ticket::gns_name, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_GNS_parse_ztld(), GNUNET_IDENTITY_ego_get_private_key(), GNUNET_IDENTITY_ego_get_public_key(), GNUNET_JSON_parse(), GNUNET_JSON_parse_free(), GNUNET_JSON_spec_end(), GNUNET_log, GNUNET_memcpy, GNUNET_OK, GNUNET_RECLAIM_JSON_spec_ticket(), GNUNET_RECLAIM_ticket_revoke(), GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, idp, EgoEntry::next, and ticket.

Referenced by REST_reclaim_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ consume_cont()

static void consume_cont	(	void *	cls,
		const struct GNUNET_CRYPTO_PublicKey *	identity,
		const struct GNUNET_RECLAIM_Attribute *	attr,
		const struct GNUNET_RECLAIM_Presentation *	presentation
	)

static

Definition at line 1187 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = cls;
  char *val_str;
  json_t *value;
 
  if (NULL == identity)
  {
    GNUNET_SCHEDULER_add_now (&return_response, handle);
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n", attr->name);
  val_str = GNUNET_RECLAIM_attribute_value_to_string (attr->type,
                                                      attr->data,
                                                      attr->data_size);
  if (NULL == val_str)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to parse value for: %s\n",
                attr->name);
    return;
  }
  value = json_string (val_str);
  json_object_set_new (handle->resp_object, attr->name, value);
  json_decref (value);
  GNUNET_free (val_str);
}

References GNUNET_RECLAIM_Attribute::data, GNUNET_RECLAIM_Attribute::data_size, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_RECLAIM_attribute_value_to_string(), GNUNET_SCHEDULER_add_now(), handle, identity, GNUNET_RECLAIM_Attribute::name, return_response(), GNUNET_RECLAIM_Attribute::type, and value.

Referenced by consume_ticket_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ consume_ticket_cont()

static void consume_ticket_cont	(	struct GNUNET_REST_RequestHandle *	con_handle,
		const char *	url,
		void *	cls
	)

static

Definition at line 1221 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct GNUNET_RECLAIM_Ticket *ticket;
  char term_data[handle->rest_handle->data_size + 1];
  json_t *data_json;
  json_error_t err;
  struct GNUNET_JSON_Specification tktspec[] =
  { GNUNET_RECLAIM_JSON_spec_ticket (&ticket), GNUNET_JSON_spec_end () };
 
  if (0 >= handle->rest_handle->data_size)
  {
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  term_data[handle->rest_handle->data_size] = '\0';
  GNUNET_memcpy (term_data,
                 handle->rest_handle->data,
                 handle->rest_handle->data_size);
  data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
  if (NULL == data_json)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Unable to parse JSON Object from %s\n",
                term_data);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  if (GNUNET_OK != GNUNET_JSON_parse (data_json, tktspec, NULL, NULL))
  {
    handle->emsg = GNUNET_strdup ("Not a ticket!\n");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    GNUNET_JSON_parse_free (tktspec);
    json_decref (data_json);
    return;
  }
  handle->resp_object = json_object ();
  handle->idp_op = GNUNET_RECLAIM_ticket_consume (idp,
                                                  ticket,
                                                  &consume_cont,
                                                  handle);
  GNUNET_JSON_parse_free (tktspec);
}

References consume_cont(), do_error(), GNUNET_ERROR_TYPE_ERROR, GNUNET_JSON_parse(), GNUNET_JSON_parse_free(), GNUNET_JSON_spec_end(), GNUNET_log, GNUNET_memcpy, GNUNET_OK, GNUNET_RECLAIM_JSON_spec_ticket(), GNUNET_RECLAIM_ticket_consume(), GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, idp, and ticket.

Referenced by REST_reclaim_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ options_cont()

static void options_cont	(	struct GNUNET_REST_RequestHandle *	con_handle,
		const char *	url,
		void *	cls
	)

static

Respond to OPTIONS request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 1277 of file reclaim_plugin.c.

{
  struct MHD_Response *resp;
  struct RequestHandle *handle = cls;
 
  // For now, independent of path return all options
  resp = GNUNET_REST_create_response (NULL);
  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
                                                    "Access-Control-Allow-Methods",
                                                    allow_methods));
  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
  cleanup_handle (handle);
  return;
}

References allow_methods, cleanup_handle(), GNUNET_assert, GNUNET_REST_create_response(), handle, and MHD_HTTP_OK.

Referenced by REST_reclaim_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ list_ego()

static void list_ego	(	void *	cls,
		struct GNUNET_IDENTITY_Ego *	ego,
		void **	ctx,
		const char *	identifier
	)

static

If listing is enabled, prints information about the egos.

This function is initially called for all egos and then again whenever a ego's identifier changes or if it is deleted. At the end of the initial pass over all egos, the function is once called with 'NULL' for 'ego'. That does NOT mean that the callback won't be invoked in the future or that there was an error.

When used with 'GNUNET_IDENTITY_create' or 'GNUNET_IDENTITY_get', this function is only called ONCE, and 'NULL' being passed in 'ego' does indicate an error (for example because name is taken or no default value is known). If 'ego' is non-NULL and if '*ctx' is set in those callbacks, the value WILL be passed to a subsequent call to the identity callback of 'GNUNET_IDENTITY_connect' (if that one was not NULL).

When an identity is renamed, this function is called with the (known) ego but the NEW identifier.

When an identity is deleted, this function is called with the (known) ego and "NULL" for the 'identifier'. In this case, the 'ego' is henceforth invalid (and the 'ctx' should also be cleaned up).

Parameters

cls	closure
ego	ego handle
ctx	context for application to store data for this ego (during the lifetime of this process, initially NULL)
identifier	identifier assigned by the user for this ego, NULL if the user just deleted the ego and it must thus no longer be used

Definition at line 1328 of file reclaim_plugin.c.

{
  struct EgoEntry *ego_entry;
  struct GNUNET_CRYPTO_PublicKey pk;
 
  if (NULL == ego)
  {
    state = ID_REST_STATE_POST_INIT;
    return;
  }
  if (ID_REST_STATE_INIT == state)
  {
    ego_entry = GNUNET_new (struct EgoEntry);
    GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
    ego_entry->keystring = GNUNET_CRYPTO_public_key_to_string (&pk);
    ego_entry->ego = ego;
    ego_entry->identifier = GNUNET_strdup (identifier);
    GNUNET_CONTAINER_DLL_insert_tail (ego_head,
                                      ego_tail,
                                      ego_entry);
  }
  /* Ego renamed or added */
  if (identifier != NULL)
  {
    for (ego_entry = ego_head; NULL != ego_entry;
         ego_entry = ego_entry->next)
    {
      if (ego_entry->ego == ego)
      {
        /* Rename */
        GNUNET_free (ego_entry->identifier);
        ego_entry->identifier = GNUNET_strdup (identifier);
        break;
      }
    }
    if (NULL == ego_entry)
    {
      /* Add */
      ego_entry = GNUNET_new (struct EgoEntry);
      GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
      ego_entry->keystring = GNUNET_CRYPTO_public_key_to_string (&pk);
      ego_entry->ego = ego;
      ego_entry->identifier = GNUNET_strdup (identifier);
      GNUNET_CONTAINER_DLL_insert_tail (ego_head,
                                        ego_tail,
                                        ego_entry);
    }
  }
  else
  {
    /* Delete */
    for (ego_entry = ego_head; NULL != ego_entry;
         ego_entry = ego_entry->next)
    {
      if (ego_entry->ego == ego)
        break;
    }
    if (NULL == ego_entry)
      return; /* Not found */
 
    GNUNET_CONTAINER_DLL_remove (ego_head,
                                 ego_tail,
                                 ego_entry);
    GNUNET_free (ego_entry->identifier);
    GNUNET_free (ego_entry->keystring);
    GNUNET_free (ego_entry);
    return;
  }
 
}

References EgoEntry::ego, ego_head, ego_tail, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_CRYPTO_public_key_to_string(), GNUNET_free, GNUNET_IDENTITY_ego_get_public_key(), GNUNET_new, GNUNET_strdup, ID_REST_STATE_INIT, ID_REST_STATE_POST_INIT, EgoEntry::identifier, EgoEntry::keystring, EgoEntry::next, pk, and state.

Referenced by REST_reclaim_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ REST_reclaim_process_request()

enum GNUNET_GenericReturnValue REST_reclaim_process_request	(	void *	plugin,
		struct GNUNET_REST_RequestHandle *	conndata_handle,
		GNUNET_REST_ResultProcessor	proc,
		void *	proc_cls
	)

Function processing the REST call.

Parameters

method	HTTP method
url	URL of the HTTP request
data	body of the HTTP request (optional)
data_size	length of the body
proc	callback function for the result
proc_cls	closure for proc

Returns: GNUNET_OK if request accepted

Definition at line 1404 of file reclaim_plugin.c.

{
  struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
  struct GNUNET_REST_RequestHandlerError err;
  static const struct GNUNET_REST_RequestHandler handlers[] =
  { { MHD_HTTP_METHOD_GET,
      GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, &list_attribute_cont },
    { MHD_HTTP_METHOD_POST,
      GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, &add_attribute_cont },
    { MHD_HTTP_METHOD_DELETE,
      GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, &delete_attribute_cont },
    { MHD_HTTP_METHOD_GET,
      GNUNET_REST_API_NS_RECLAIM_CREDENTIAL, &list_credential_cont },
    { MHD_HTTP_METHOD_POST,
      GNUNET_REST_API_NS_RECLAIM_CREDENTIAL, &add_credential_cont },
    { MHD_HTTP_METHOD_DELETE,
      GNUNET_REST_API_NS_RECLAIM_CREDENTIAL, &delete_credential_cont },
    { MHD_HTTP_METHOD_GET,
      GNUNET_REST_API_NS_IDENTITY_TICKETS, &list_tickets_cont },
    { MHD_HTTP_METHOD_POST,
      GNUNET_REST_API_NS_IDENTITY_REVOKE, &revoke_ticket_cont },
    { MHD_HTTP_METHOD_POST,
      GNUNET_REST_API_NS_IDENTITY_CONSUME, &consume_ticket_cont },
    { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_RECLAIM, &options_cont },
    GNUNET_REST_HANDLER_END};
 
  handle->response_code = 0;
  handle->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
  handle->proc_cls = proc_cls;
  handle->proc = proc;
  handle->rest_handle = rest_handle;
 
  handle->url = GNUNET_strdup (rest_handle->url);
  if (handle->url[strlen (handle->url) - 1] == '/')
    handle->url[strlen (handle->url) - 1] = '\0';
  handle->timeout_task =
    GNUNET_SCHEDULER_add_delayed (handle->timeout, &do_timeout, handle);
  GNUNET_CONTAINER_DLL_insert (requests_head,
                               requests_tail,
                               handle);
  if (GNUNET_NO ==
      GNUNET_REST_handle_request (handle->rest_handle, handlers, &err, handle))
  {
    cleanup_handle (handle);
    return GNUNET_NO;
  }
 
  return GNUNET_YES;
}

References add_attribute_cont(), add_credential_cont(), cleanup_handle(), consume_ticket_cont(), delete_attribute_cont(), delete_credential_cont(), do_timeout(), GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_NO, GNUNET_REST_API_NS_IDENTITY_CONSUME, GNUNET_REST_API_NS_IDENTITY_REVOKE, GNUNET_REST_API_NS_IDENTITY_TICKETS, GNUNET_REST_API_NS_RECLAIM, GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, GNUNET_REST_API_NS_RECLAIM_CREDENTIAL, GNUNET_REST_handle_request(), GNUNET_REST_HANDLER_END, GNUNET_SCHEDULER_add_delayed(), GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, handle, handlers, list_attribute_cont(), list_credential_cont(), list_tickets_cont(), options_cont(), GNUNET_REST_RequestHandler::proc, requests_head, requests_tail, revoke_ticket_cont(), and GNUNET_REST_RequestHandle::url.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ REST_reclaim_init()

void * REST_reclaim_init ( struct GNUNET_CONFIGURATION_Handle * c )

Entry point for the plugin.

Parameters

cls	Config info

Returns: NULL on error, otherwise the plugin context

Definition at line 1465 of file reclaim_plugin.c.

{
  static struct Plugin plugin;
  struct GNUNET_REST_Plugin *api;
 
  rcfg = c;
  if (NULL != plugin.cfg)
    return NULL; /* can only initialize once! */
  memset (&plugin, 0, sizeof(struct Plugin));
  plugin.cfg = rcfg;
  api = GNUNET_new (struct GNUNET_REST_Plugin);
  api->cls = &plugin;
  api->name = GNUNET_REST_API_NS_RECLAIM;
  GNUNET_asprintf (&allow_methods,
                   "%s, %s, %s, %s, %s",
                   MHD_HTTP_METHOD_GET,
                   MHD_HTTP_METHOD_POST,
                   MHD_HTTP_METHOD_PUT,
                   MHD_HTTP_METHOD_DELETE,
                   MHD_HTTP_METHOD_OPTIONS);
  identity_handle = GNUNET_IDENTITY_connect (rcfg, &list_ego, NULL);
  state = ID_REST_STATE_INIT;
  idp = GNUNET_RECLAIM_connect (rcfg);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              _ ("Identity Provider REST API initialized\n"));
  return api;
}

References _, allow_methods, GNUNET_REST_Plugin::cls, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_IDENTITY_connect(), GNUNET_log, GNUNET_new, GNUNET_RECLAIM_connect(), GNUNET_REST_API_NS_RECLAIM, ID_REST_STATE_INIT, identity_handle, idp, list_ego(), GNUNET_REST_Plugin::name, plugin, rcfg, and state.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ REST_reclaim_done()

void * REST_reclaim_done ( struct GNUNET_REST_Plugin * api )

Exit point from the plugin.

Parameters

cls	the plugin context (as returned by "init")

Returns: always NULL

Definition at line 1501 of file reclaim_plugin.c.

{
  struct Plugin *plugin = api->cls;
  struct RequestHandle *request;
  struct EgoEntry *ego_entry;
  struct EgoEntry *ego_tmp;
 
  plugin->cfg = NULL;
  while (NULL != (request = requests_head))
    do_error (request);
  if (NULL != idp)
    GNUNET_RECLAIM_disconnect (idp);
  if (NULL != identity_handle)
    GNUNET_IDENTITY_disconnect (identity_handle);
  for (ego_entry = ego_head; NULL != ego_entry;)
  {
    ego_tmp = ego_entry;
    ego_entry = ego_entry->next;
    GNUNET_free (ego_tmp->identifier);
    GNUNET_free (ego_tmp->keystring);
    GNUNET_free (ego_tmp);
  }
 
  GNUNET_free (allow_methods);
  GNUNET_free (api);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Identity Provider REST plugin is finished\n");
  return NULL;
}

References allow_methods, Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, do_error(), ego_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_IDENTITY_disconnect(), GNUNET_log, GNUNET_RECLAIM_disconnect(), EgoEntry::identifier, identity_handle, idp, EgoEntry::keystring, EgoEntry::next, plugin, request, and requests_head.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ rcfg

const struct GNUNET_CONFIGURATION_Handle* rcfg

The configuration handle.

Definition at line 83 of file reclaim_plugin.c.

Referenced by REST_reclaim_init().

◆ allow_methods

char* allow_methods

static

HTTP methods allows for this plugin.

Definition at line 88 of file reclaim_plugin.c.

Referenced by delete_finished_cb(), finished_cont(), options_cont(), REST_reclaim_done(), REST_reclaim_init(), and return_response().

◆ ego_head

struct EgoEntry* ego_head

static

Ego list.

Definition at line 93 of file reclaim_plugin.c.

Referenced by add_attribute_cont(), add_credential_cont(), delete_attribute_cont(), delete_credential_cont(), list_attribute_cont(), list_credential_cont(), list_ego(), list_tickets_cont(), REST_reclaim_done(), and revoke_ticket_cont().

◆ ego_tail

struct EgoEntry* ego_tail

static

Ego list.

Definition at line 98 of file reclaim_plugin.c.

Referenced by list_ego().

◆ state

int state

static

The processing state.

Definition at line 103 of file reclaim_plugin.c.

Referenced by list_ego(), and REST_reclaim_init().

◆ identity_handle

struct GNUNET_IDENTITY_Handle* identity_handle

static

Handle to Identity service.

Definition at line 108 of file reclaim_plugin.c.

Referenced by REST_reclaim_done(), and REST_reclaim_init().

◆ idp

struct GNUNET_RECLAIM_Handle* idp

static

Identity Provider.

Definition at line 113 of file reclaim_plugin.c.

Referenced by add_attribute_cont(), add_credential_cont(), consume_ticket_cont(), delete_attribute_cont(), delete_credential_cont(), list_attribute_cont(), list_credential_cont(), list_tickets_cont(), REST_reclaim_done(), REST_reclaim_init(), and revoke_ticket_cont().

◆ requests_head

struct RequestHandle* requests_head

static

DLL.

Definition at line 261 of file reclaim_plugin.c.

Referenced by cleanup_handle(), REST_reclaim_done(), and REST_reclaim_process_request().

◆ requests_tail

struct RequestHandle* requests_tail

static

DLL.

Definition at line 266 of file reclaim_plugin.c.

Referenced by cleanup_handle(), and REST_reclaim_process_request().

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

◆ GNUNET_REST_API_NS_RECLAIM

◆ GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES

◆ GNUNET_REST_API_NS_RECLAIM_CREDENTIAL

◆ GNUNET_REST_API_NS_IDENTITY_TICKETS

◆ GNUNET_REST_API_NS_IDENTITY_REVOKE

◆ GNUNET_REST_API_NS_IDENTITY_CONSUME

◆ ID_REST_STATE_INIT

◆ ID_REST_STATE_POST_INIT

Function Documentation

◆ cleanup_handle()

◆ do_error()

◆ do_timeout()

◆ collect_error_cb()

◆ finished_cont()

◆ delete_finished_cb()

◆ return_response()

◆ collect_finished_cb()

◆ ticket_collect()

◆ add_credential_cont()

◆ cred_collect()

◆ list_credential_cont()

◆ delete_credential_cont()

◆ list_tickets_cont()

◆ add_attribute_cont()

◆ parse_jwt()

◆ attr_collect()

◆ list_attribute_cont()

◆ delete_attribute_cont()

◆ revoke_ticket_cont()

◆ consume_cont()

◆ consume_ticket_cont()

◆ options_cont()

◆ list_ego()

◆ REST_reclaim_process_request()

◆ REST_reclaim_init()

◆ REST_reclaim_done()

Variable Documentation

◆ rcfg

◆ allow_methods

◆ ego_head

◆ ego_tail

◆ state

◆ identity_handle

◆ idp

◆ requests_head

◆ requests_tail