Reclaim attributes

Collaboration diagram for Reclaim attributes:

Data Structures
struct	GNUNET_RECLAIM_Identifier
	A reclaim identifier FIXME maybe put this in a different namespace. More...
struct	GNUNET_RECLAIM_Attribute
	An attribute. More...
struct	GNUNET_RECLAIM_Credential
	A credential. More...
struct	GNUNET_RECLAIM_Presentation
	A credential presentation. More...
struct	GNUNET_RECLAIM_AttributeList
	A list of GNUNET_RECLAIM_Attribute structures. More...
struct	GNUNET_RECLAIM_AttributeListEntry
struct	GNUNET_RECLAIM_CredentialList
	A list of GNUNET_RECLAIM_Credential structures. More...
struct	GNUNET_RECLAIM_CredentialListEntry
struct	GNUNET_RECLAIM_PresentationList
	A list of GNUNET_RECLAIM_Presentation structures. More...
struct	GNUNET_RECLAIM_PresentationListEntry

Macros
#define	GNUNET_RECLAIM_ID_LENGTH   (256 / 8)
	We want an ID to be a 256-bit symmetric key. More...
#define	GNUNET_RECLAIM_id_is_equal(a, b)
#define	GNUNET_RECLAIM_id_is_zero(a)
#define	GNUNET_RECLAIM_id_generate(id)

Enumerations
enum	GNUNET_RECLAIM_AttributeType { GNUNET_RECLAIM_ATTRIBUTE_TYPE_NONE = 0 , GNUNET_RECLAIM_ATTRIBUTE_TYPE_STRING = 1 }
enum	GNUNET_RECLAIM_CredentialType { GNUNET_RECLAIM_CREDENTIAL_TYPE_NONE = 0 , GNUNET_RECLAIM_CREDENTIAL_TYPE_JWT = 1 , GNUNET_RECLAIM_CREDENTIAL_TYPE_PABC = 2 }

Functions
struct GNUNET_RECLAIM_Attribute *	GNUNET_RECLAIM_attribute_new (const char *attr_name, const struct GNUNET_RECLAIM_Identifier *credential, uint32_t type, const void *data, size_t data_size)
	Create a new attribute claim. More...
size_t	GNUNET_RECLAIM_attribute_list_serialize_get_size (const struct GNUNET_RECLAIM_AttributeList *attrs)
	Get required size for serialization buffer. More...
void	GNUNET_RECLAIM_attribute_list_destroy (struct GNUNET_RECLAIM_AttributeList *attrs)
	Destroy claim list. More...
void	GNUNET_RECLAIM_attribute_list_add (struct GNUNET_RECLAIM_AttributeList *attrs, const char *attr_name, const struct GNUNET_RECLAIM_Identifier *credential, uint32_t type, const void *data, size_t data_size)
	Add a new attribute to a claim list. More...
size_t	GNUNET_RECLAIM_attribute_list_serialize (const struct GNUNET_RECLAIM_AttributeList *attrs, char *result)
	Serialize an attribute list. More...
struct GNUNET_RECLAIM_AttributeList *	GNUNET_RECLAIM_attribute_list_deserialize (const char *data, size_t data_size)
	Deserialize an attribute list. More...
size_t	GNUNET_RECLAIM_attribute_serialize_get_size (const struct GNUNET_RECLAIM_Attribute *attr)
	Get required size for serialization buffer. More...
size_t	GNUNET_RECLAIM_attribute_serialize (const struct GNUNET_RECLAIM_Attribute *attr, char *result)
	Serialize an attribute. More...
ssize_t	GNUNET_RECLAIM_attribute_deserialize (const char *data, size_t data_size, struct GNUNET_RECLAIM_Attribute **attr)
	Deserialize an attribute. More...
struct GNUNET_RECLAIM_AttributeList *	GNUNET_RECLAIM_attribute_list_dup (const struct GNUNET_RECLAIM_AttributeList *attrs)
	Make a (deep) copy of a claim list. More...
uint32_t	GNUNET_RECLAIM_attribute_typename_to_number (const char *typename)
	Convert a type name to the corresponding number. More...
int	GNUNET_RECLAIM_attribute_string_to_value (uint32_t type, const char *s, void **data, size_t *data_size)
	Convert human-readable version of a 'claim' of an attribute to the binary representation. More...
char *	GNUNET_RECLAIM_attribute_value_to_string (uint32_t type, const void *data, size_t data_size)
	Convert the 'claim' of an attribute to a string. More...
const char *	GNUNET_RECLAIM_attribute_number_to_typename (uint32_t type)
	Convert a type number to the corresponding type string. More...
size_t	GNUNET_RECLAIM_credential_list_serialize_get_size (const struct GNUNET_RECLAIM_CredentialList *credentials)
	Get required size for serialization buffer. More...
void	GNUNET_RECLAIM_credential_list_destroy (struct GNUNET_RECLAIM_CredentialList *credentials)
	Destroy credential list. More...
void	GNUNET_RECLAIM_credential_list_add (struct GNUNET_RECLAIM_CredentialList *attrs, const char *att_name, uint32_t type, const void *data, size_t data_size)
	Add a new attribute to a claim list. More...
size_t	GNUNET_RECLAIM_credential_list_serialize (const struct GNUNET_RECLAIM_CredentialList *credentials, char *result)
	Serialize a credential list. More...
struct GNUNET_RECLAIM_CredentialList *	GNUNET_RECLAIM_credential_list_deserialize (const char *data, size_t data_size)
	Deserialize an attribute list. More...
size_t	GNUNET_RECLAIM_credential_serialize_get_size (const struct GNUNET_RECLAIM_Credential *credential)
	Get required size for serialization buffer. More...
size_t	GNUNET_RECLAIM_credential_serialize (const struct GNUNET_RECLAIM_Credential *credential, char *result)
	Serialize an credential. More...
struct GNUNET_RECLAIM_Credential *	GNUNET_RECLAIM_credential_deserialize (const char *data, size_t data_size)
	Deserialize an credential. More...
struct GNUNET_RECLAIM_Credential *	GNUNET_RECLAIM_credential_new (const char *name, uint32_t type, const void *data, size_t data_size)
	Create a new credential. More...
char *	GNUNET_RECLAIM_credential_value_to_string (uint32_t type, const void *data, size_t data_size)
	Convert the 'claim' of an credential to a string. More...
int	GNUNET_RECLAIM_credential_string_to_value (uint32_t type, const char *s, void **data, size_t *data_size)
	Convert human-readable version of a 'claim' of an credential to the binary representation. More...
const char *	GNUNET_RECLAIM_credential_number_to_typename (uint32_t type)
	Convert an credential type number to the corresponding credential type string. More...
uint32_t	GNUNET_RECLAIM_credential_typename_to_number (const char *typename)
	Convert an credential type name to the corresponding number. More...
struct GNUNET_RECLAIM_AttributeList *	GNUNET_RECLAIM_credential_get_attributes (const struct GNUNET_RECLAIM_Credential *cred)
	Convert an credential type name to the corresponding number. More...
char *	GNUNET_RECLAIM_credential_get_issuer (const struct GNUNET_RECLAIM_Credential *cred)
int	GNUNET_RECLAIM_credential_get_expiration (const struct GNUNET_RECLAIM_Credential *cred, struct GNUNET_TIME_Absolute *exp)
size_t	GNUNET_RECLAIM_presentation_list_serialize_get_size (const struct GNUNET_RECLAIM_PresentationList *presentations)
	Get required size for serialization buffer. More...
void	GNUNET_RECLAIM_presentation_list_destroy (struct GNUNET_RECLAIM_PresentationList *presentations)
	Destroy presentations list. More...
size_t	GNUNET_RECLAIM_presentation_list_serialize (const struct GNUNET_RECLAIM_PresentationList *presentations, char *result)
	Serialize a presentation list. More...
struct GNUNET_RECLAIM_PresentationList *	GNUNET_RECLAIM_presentation_list_deserialize (const char *data, size_t data_size)
	Deserialize a presentation list. More...
size_t	GNUNET_RECLAIM_presentation_serialize_get_size (const struct GNUNET_RECLAIM_Presentation *presentation)
	Get required size for serialization buffer. More...
size_t	GNUNET_RECLAIM_presentation_serialize (const struct GNUNET_RECLAIM_Presentation *presentation, char *result)
	Serialize a presentation. More...
struct GNUNET_RECLAIM_Presentation *	GNUNET_RECLAIM_presentation_deserialize (const char *data, size_t data_size)
	Deserialize a presentation. More...
char *	GNUNET_RECLAIM_presentation_value_to_string (uint32_t type, const void *data, size_t data_size)
	Convert the 'claim' of a presentation to a string. More...
struct GNUNET_RECLAIM_Presentation *	GNUNET_RECLAIM_presentation_new (uint32_t type, const void *data, size_t data_size)
int	GNUNET_RECLAIM_presentation_string_to_value (uint32_t type, const char *s, void **data, size_t *data_size)
	Convert human-readable version of a 'claim' of a presentation to the binary representation. More...
const char *	GNUNET_RECLAIM_presentation_number_to_typename (uint32_t type)
	Convert a presentation type number to the corresponding credential type string. More...
struct GNUNET_RECLAIM_AttributeList *	GNUNET_RECLAIM_presentation_get_attributes (const struct GNUNET_RECLAIM_Presentation *cred)
char *	GNUNET_RECLAIM_presentation_get_issuer (const struct GNUNET_RECLAIM_Presentation *cred)
int	GNUNET_RECLAIM_presentation_get_expiration (const struct GNUNET_RECLAIM_Presentation *cred, struct GNUNET_TIME_Absolute *exp)
int	GNUNET_RECLAIM_credential_get_presentation (const struct GNUNET_RECLAIM_Credential *cred, const struct GNUNET_RECLAIM_AttributeList *attrs, struct GNUNET_RECLAIM_Presentation **presentation)
	Create a presentation from a credential and a lift of (selected) attributes in the credential. More...

Variables
static const struct GNUNET_RECLAIM_Identifier	GNUNET_RECLAIM_ID_ZERO

Detailed Description

Macro Definition Documentation

GNUNET_RECLAIM_ID_LENGTH

#define GNUNET_RECLAIM_ID_LENGTH   (256 / 8)

We want an ID to be a 256-bit symmetric key.

Definition at line 78 of file gnunet_reclaim_lib.h.

GNUNET_RECLAIM_id_is_equal

#define GNUNET_RECLAIM_id_is_equal	(		a,
			b
	)

Value:

                                          ((0 == \
                                          memcmp (a, \
                                                  b, \
                                                  sizeof (GNUNET_RECLAIM_ID_ZERO))) \
                                         ? \
                                         GNUNET_YES : GNUNET_NO)

Definition at line 94 of file gnunet_reclaim_lib.h.

GNUNET_RECLAIM_id_is_zero

#define GNUNET_RECLAIM_id_is_zero

(

a

)

Value:

                                                                 GNUNET_RECLAIM_id_is_equal (a, \
                                                                 & \
                                                                 GNUNET_RECLAIM_ID_ZERO)

Definition at line 102 of file gnunet_reclaim_lib.h.

GNUNET_RECLAIM_id_generate

#define GNUNET_RECLAIM_id_generate

(

id

)

Value:

  (GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_STRONG, \
                               id, \
                               sizeof (GNUNET_RECLAIM_ID_ZERO)))

Definition at line 106 of file gnunet_reclaim_lib.h.

Enumeration Type Documentation

GNUNET_RECLAIM_AttributeType

enum GNUNET_RECLAIM_AttributeType

Enumerator
GNUNET_RECLAIM_ATTRIBUTE_TYPE_NONE	No value attribute.
GNUNET_RECLAIM_ATTRIBUTE_TYPE_STRING	String attribute.

Definition at line 46 of file gnunet_reclaim_lib.h.

                                  {
  GNUNET_RECLAIM_ATTRIBUTE_TYPE_NONE = 0,
 
  GNUNET_RECLAIM_ATTRIBUTE_TYPE_STRING = 1
};

GNUNET_RECLAIM_CredentialType

enum GNUNET_RECLAIM_CredentialType

Enumerator
GNUNET_RECLAIM_CREDENTIAL_TYPE_NONE	No value credential.
GNUNET_RECLAIM_CREDENTIAL_TYPE_JWT	A JSON Web Token credential.
GNUNET_RECLAIM_CREDENTIAL_TYPE_PABC	libpabc credential

Definition at line 58 of file gnunet_reclaim_lib.h.

                                   {
  GNUNET_RECLAIM_CREDENTIAL_TYPE_NONE = 0,
 
  GNUNET_RECLAIM_CREDENTIAL_TYPE_JWT = 1,
 
  GNUNET_RECLAIM_CREDENTIAL_TYPE_PABC = 2
};

Function Documentation

GNUNET_RECLAIM_attribute_new()

struct GNUNET_RECLAIM_Attribute* GNUNET_RECLAIM_attribute_new	(	const char *	attr_name,
		const struct GNUNET_RECLAIM_Identifier *	credential,
		uint32_t	type,
		const void *	data,
		size_t	data_size
	)

Create a new attribute claim.

Parameters

attr_name	the attribute name
credential	ID of the credential (may be NULL)
type	the attribute type
data	the attribute value. Must be attr_name if credential not NULL
data_size	the attribute value size

Returns

the new attribute

Definition at line 254 of file reclaim_attribute.c.

{
  struct GNUNET_RECLAIM_Attribute *attr;
  char *write_ptr;
  char *attr_name_tmp = GNUNET_strdup (attr_name);
 
  GNUNET_STRINGS_utf8_tolower (attr_name, attr_name_tmp);
 
  attr = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Attribute)
                        + strlen (attr_name_tmp) + 1 + data_size);
  if (NULL != credential)
    attr->credential = *credential;
  attr->type = type;
  attr->data_size = data_size;
  attr->flag = 0;
  write_ptr = (char *) &attr[1];
  GNUNET_memcpy (write_ptr, attr_name_tmp, strlen (attr_name_tmp) + 1);
  attr->name = write_ptr;
  write_ptr += strlen (attr->name) + 1;
  GNUNET_memcpy (write_ptr, data, data_size);
  attr->data = write_ptr;
  GNUNET_free (attr_name_tmp);
  return attr;
}

References attr_name, GNUNET_RECLAIM_Attribute::credential, credential, GNUNET_RECLAIM_Attribute::data, data, data_size, GNUNET_RECLAIM_Attribute::data_size, GNUNET_RECLAIM_Attribute::flag, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), GNUNET_RECLAIM_Attribute::name, GNUNET_RECLAIM_Attribute::type, and type.

Referenced by attribute_list_merge(), consume_ticket(), GNUNET_RECLAIM_attribute_list_add(), GNUNET_RECLAIM_attribute_list_dup(), iter_cb(), iter_finished(), oidc_attr_collect(), parse_attr(), and parse_jwt().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_list_serialize_get_size()

size_t GNUNET_RECLAIM_attribute_list_serialize_get_size

(

const struct GNUNET_RECLAIM_AttributeList *

al

)

Get required size for serialization buffer.

Parameters

attrs

the attribute list to serialize

Returns

the required buffer size

Definition at line 313 of file reclaim_attribute.c.

{
  struct GNUNET_RECLAIM_AttributeListEntry *ale;
  size_t len = 0;
 
  for (ale = al->list_head; NULL != ale; ale = ale->next)
  {
    GNUNET_assert (NULL != ale->attribute);
    len += GNUNET_RECLAIM_attribute_serialize_get_size (ale->attribute);
  }
  return len;
}

References GNUNET_RECLAIM_AttributeListEntry::attribute, GNUNET_assert, GNUNET_RECLAIM_attribute_serialize_get_size(), len, GNUNET_RECLAIM_AttributeList::list_head, and GNUNET_RECLAIM_AttributeListEntry::next.

Referenced by check_code_challenge(), consume_result_cb(), and GNUNET_RECLAIM_ticket_issue().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_list_destroy()

void GNUNET_RECLAIM_attribute_list_destroy

(

struct GNUNET_RECLAIM_AttributeList *

attrs

)

Destroy claim list.

Parameters

attrs

list to destroy

Definition at line 425 of file reclaim_attribute.c.

{
  struct GNUNET_RECLAIM_AttributeListEntry *ale;
  struct GNUNET_RECLAIM_AttributeListEntry *tmp_ale;
 
  for (ale = al->list_head; NULL != ale;)
  {
    if (NULL != ale->attribute)
      GNUNET_free (ale->attribute);
    tmp_ale = ale;
    ale = ale->next;
    GNUNET_free (tmp_ale);
  }
  GNUNET_free (al);
}

References GNUNET_RECLAIM_AttributeListEntry::attribute, GNUNET_free, GNUNET_RECLAIM_AttributeList::list_head, and GNUNET_RECLAIM_AttributeListEntry::next.

Referenced by cleanup_adh(), cleanup_cth(), cleanup_handle(), consume_fail(), cred_collect(), cred_iter_cb(), do_cleanup(), handle_consume_ticket_result(), handle_issue_ticket_message(), oidc_cred_collect_finished_cb(), and token_endpoint().

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_list_add()

void GNUNET_RECLAIM_attribute_list_add	(	struct GNUNET_RECLAIM_AttributeList *	attrs,
		const char *	attr_name,
		const struct GNUNET_RECLAIM_Identifier *	credential,
		uint32_t	type,
		const void *	data,
		size_t	data_size
	)

Add a new attribute to a claim list.

Parameters

attrs	the attribute list to add to
attr_name	the name of the new attribute claim
credential	credential ID (may be NULL)
type	the type of the claim
data	claim payload
data_size	claim payload size

Definition at line 286 of file reclaim_attribute.c.

{
  struct GNUNET_RECLAIM_AttributeListEntry *ale;
 
  ale = GNUNET_new (struct GNUNET_RECLAIM_AttributeListEntry);
  ale->attribute =
    GNUNET_RECLAIM_attribute_new (attr_name, credential,
                                  type, data, data_size);
  GNUNET_CONTAINER_DLL_insert (al->list_head,
                               al->list_tail,
                               ale);
}

References attr_name, GNUNET_RECLAIM_AttributeListEntry::attribute, credential, data, data_size, GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_RECLAIM_attribute_new(), GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_AttributeList::list_tail, and type.

Referenced by inspect_attrs(), and jwt_parse_attributes().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_list_serialize()

size_t GNUNET_RECLAIM_attribute_list_serialize	(	const struct GNUNET_RECLAIM_AttributeList *	attrs,
		char *	result
	)

Serialize an attribute list.

Parameters

attrs	the attribute list to serialize
result	the serialized attribute

Returns

length of serialized data

Definition at line 329 of file reclaim_attribute.c.

{
  struct GNUNET_RECLAIM_AttributeListEntry *ale;
  size_t len;
  size_t total_len;
  char *write_ptr;
  write_ptr = result;
  total_len = 0;
  for (ale = attrs->list_head; NULL != ale; ale = ale->next)
  {
    GNUNET_assert (NULL != ale->attribute);
    len = GNUNET_RECLAIM_attribute_serialize (ale->attribute, write_ptr);
    total_len += len;
    write_ptr += len;
  }
  return total_len;
}

References GNUNET_RECLAIM_AttributeListEntry::attribute, GNUNET_assert, GNUNET_RECLAIM_attribute_serialize(), len, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_AttributeListEntry::next, and result.

Referenced by check_code_challenge(), consume_result_cb(), and GNUNET_RECLAIM_ticket_issue().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_list_deserialize()

struct GNUNET_RECLAIM_AttributeList* GNUNET_RECLAIM_attribute_list_deserialize	(	const char *	data,
		size_t	data_size
	)

Deserialize an attribute list.

Parameters

data	the serialized attribute list
data_size	the length of the serialized data

Returns

a GNUNET_IDENTITY_PROVIDER_AttributeList, must be free'd by caller

Definition at line 358 of file reclaim_attribute.c.

{
  struct GNUNET_RECLAIM_AttributeList *al;
  struct GNUNET_RECLAIM_AttributeListEntry *ale;
  size_t attr_len;
  const char *read_ptr;
  size_t left = data_size;
 
  al = GNUNET_new (struct GNUNET_RECLAIM_AttributeList);
  if (data_size < sizeof(struct Attribute))
    return al;
  read_ptr = data;
  while (left >= sizeof(struct Attribute))
  {
    ale = GNUNET_new (struct GNUNET_RECLAIM_AttributeListEntry);
    attr_len =
      GNUNET_RECLAIM_attribute_deserialize (read_ptr,
                                            left,
                                            &ale->attribute);
    if (-1 == attr_len)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Failed to deserialize malformed attribute.\n");
      GNUNET_free (ale);
      return al;
    }
    left -= attr_len;
    GNUNET_CONTAINER_DLL_insert (al->list_head, al->list_tail, ale);
    read_ptr += attr_len;
  }
  return al;
}

References GNUNET_RECLAIM_AttributeListEntry::attribute, data, data_size, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_RECLAIM_attribute_deserialize(), GNUNET_RECLAIM_AttributeList::list_head, and GNUNET_RECLAIM_AttributeList::list_tail.

Referenced by handle_consume_ticket_result(), handle_issue_ticket_message(), and OIDC_parse_authz_code().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_serialize_get_size()

size_t GNUNET_RECLAIM_attribute_serialize_get_size

(

const struct GNUNET_RECLAIM_Attribute *

attr

)

Get required size for serialization buffer.

Parameters

attr	the attribute to serialize

Returns

the required buffer size

Definition at line 450 of file reclaim_attribute.c.

{
  return sizeof(struct Attribute) + strlen (attr->name) + attr->data_size;
}

References data_size, and name.

Referenced by attr_store_task(), GNUNET_RECLAIM_attribute_delete(), GNUNET_RECLAIM_attribute_list_serialize_get_size(), GNUNET_RECLAIM_attribute_store(), and rvk_move_attr_cb().

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_serialize()

size_t GNUNET_RECLAIM_attribute_serialize	(	const struct GNUNET_RECLAIM_Attribute *	attr,
		char *	result
	)

Serialize an attribute.

Parameters

attr	the attribute to serialize
result	the serialized attribute

Returns

length of serialized data

Definition at line 465 of file reclaim_attribute.c.

{
  size_t data_len_ser;
  size_t name_len;
  struct Attribute *attr_ser;
  char *write_ptr;
 
  attr_ser = (struct Attribute *) result;
  attr_ser->attribute_type = htonl (attr->type);
  attr_ser->attribute_flag = htonl (attr->flag);
  attr_ser->attribute_id = attr->id;
  attr_ser->credential_id = attr->credential;
  name_len = strlen (attr->name);
  attr_ser->name_len = htons (name_len);
  write_ptr = (char *) &attr_ser[1];
  GNUNET_memcpy (write_ptr, attr->name, name_len);
  write_ptr += name_len;
  // TODO plugin-ize
  // data_len_ser = plugin->serialize_attribute_value (attr,
  //                                                  &attr_ser[1]);
  data_len_ser = attr->data_size;
  GNUNET_memcpy (write_ptr, attr->data, attr->data_size);
  attr_ser->data_size = htons (data_len_ser);
 
  return sizeof(struct Attribute) + strlen (attr->name) + attr->data_size;
}

References Attribute::attribute_flag, Attribute::attribute_id, Attribute::attribute_type, GNUNET_RECLAIM_Attribute::credential, Attribute::credential_id, GNUNET_RECLAIM_Attribute::data, data_size, GNUNET_RECLAIM_Attribute::data_size, Attribute::data_size, GNUNET_RECLAIM_Attribute::flag, GNUNET_memcpy, GNUNET_RECLAIM_Attribute::id, name, GNUNET_RECLAIM_Attribute::name, Attribute::name_len, result, and GNUNET_RECLAIM_Attribute::type.

Referenced by attr_store_task(), GNUNET_RECLAIM_attribute_delete(), GNUNET_RECLAIM_attribute_list_serialize(), GNUNET_RECLAIM_attribute_store(), and rvk_move_attr_cb().

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_deserialize()

ssize_t GNUNET_RECLAIM_attribute_deserialize	(	const char *	data,
		size_t	data_size,
		struct GNUNET_RECLAIM_Attribute **	attr
	)

Deserialize an attribute.

Parameters

data	the serialized attribute
data_size	the length of the serialized data
attr	deserialized attribute. Will be allocated. Must be free'd

Returns

number of bytes read or -1 for error

Parameters

data	the serialized attribute
data_size	the length of the serialized data

Returns

a GNUNET_IDENTITY_PROVIDER_Attribute, must be free'd by caller

Definition at line 504 of file reclaim_attribute.c.

{
  struct Attribute *attr_ser;
  struct GNUNET_RECLAIM_Attribute *attribute;
  size_t data_len;
  size_t name_len;
  char *write_ptr;
 
  if (data_size < sizeof(struct Attribute))
    return -1;
 
  attr_ser = (struct Attribute *) data;
  data_len = ntohs (attr_ser->data_size);
  name_len = ntohs (attr_ser->name_len);
  if (data_size < sizeof(struct Attribute) + data_len + name_len)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Buffer too small to deserialize\n");
    return -1;
  }
  attribute = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Attribute)
                        + data_len + name_len + 1);
  attribute->type = ntohl (attr_ser->attribute_type);
  attribute->flag = ntohl (attr_ser->attribute_flag);
  attribute->id = attr_ser->attribute_id;
  attribute->credential = attr_ser->credential_id;
  attribute->data_size = data_len;
 
  write_ptr = (char *) &attribute[1];
  GNUNET_memcpy (write_ptr, &attr_ser[1], name_len);
  write_ptr[name_len] = '\0';
  attribute->name = write_ptr;
 
  write_ptr += name_len + 1;
  GNUNET_memcpy (write_ptr, (char *) &attr_ser[1] + name_len,
                attribute->data_size);
  *attr = attribute;
  attribute->data = write_ptr;
  return sizeof(struct Attribute) + data_len + name_len;
}

References Attribute::attribute_flag, Attribute::attribute_id, Attribute::attribute_type, GNUNET_RECLAIM_Attribute::credential, Attribute::credential_id, GNUNET_RECLAIM_Attribute::data, data, data_size, GNUNET_RECLAIM_Attribute::data_size, Attribute::data_size, GNUNET_RECLAIM_Attribute::flag, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_RECLAIM_Attribute::id, GNUNET_RECLAIM_Attribute::name, Attribute::name_len, and GNUNET_RECLAIM_Attribute::type.

Referenced by consistency_iter(), GNUNET_RECLAIM_attribute_list_deserialize(), handle_attribute_delete_message(), handle_attribute_result(), handle_attribute_store_message(), process_parallel_lookup_result(), and rvk_move_attr_cb().

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_list_dup()

struct GNUNET_RECLAIM_AttributeList* GNUNET_RECLAIM_attribute_list_dup

(

const struct GNUNET_RECLAIM_AttributeList *

attrs

)

Make a (deep) copy of a claim list.

Parameters

attrs

claim list to copy

Returns

copied claim list

Definition at line 393 of file reclaim_attribute.c.

{
  struct GNUNET_RECLAIM_AttributeListEntry *ale;
  struct GNUNET_RECLAIM_AttributeListEntry *result_ale;
  struct GNUNET_RECLAIM_AttributeList *result;
 
  result = GNUNET_new (struct GNUNET_RECLAIM_AttributeList);
  for (ale = attrs->list_head; NULL != ale; ale = ale->next)
  {
    result_ale = GNUNET_new (struct GNUNET_RECLAIM_AttributeListEntry);
    GNUNET_assert (NULL != ale->attribute);
    {
      result_ale->attribute =
        GNUNET_RECLAIM_attribute_new (ale->attribute->name,
                                      &ale->attribute->credential,
                                      ale->attribute->type,
                                      ale->attribute->data,
                                      ale->attribute->data_size);
 
      result_ale->attribute->id = ale->attribute->id;
      result_ale->attribute->flag = ale->attribute->flag;
    }
    GNUNET_CONTAINER_DLL_insert (result->list_head,
                                 result->list_tail,
                                 result_ale);
  }
  return result;
}

References GNUNET_RECLAIM_AttributeListEntry::attribute, GNUNET_RECLAIM_Attribute::credential, GNUNET_RECLAIM_Attribute::data, GNUNET_RECLAIM_Attribute::data_size, GNUNET_RECLAIM_Attribute::flag, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_RECLAIM_attribute_new(), GNUNET_RECLAIM_Attribute::id, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_Attribute::name, GNUNET_RECLAIM_AttributeListEntry::next, result, and GNUNET_RECLAIM_Attribute::type.

Referenced by RECLAIM_TICKETS_issue().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_typename_to_number()

uint32_t GNUNET_RECLAIM_attribute_typename_to_number

(

const char *

typename

)

Convert a type name to the corresponding number.

Parameters

typename

name to convert

Returns

corresponding number, UINT32_MAX on error

Definition at line 145 of file reclaim_attribute.c.

{
  unsigned int i;
  struct Plugin *plugin;
  uint32_t ret;
 
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = attr_plugins[i];
    if (UINT32_MAX !=
        (ret = plugin->api->typename_to_number (plugin->api->cls, typename)))
      return ret;
  }
  return UINT32_MAX;
}

References TestcasePlugin::api, attr_plugins, init(), num_plugins, plugin, and ret.

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_string_to_value()

int GNUNET_RECLAIM_attribute_string_to_value	(	uint32_t	type,
		const char *	s,
		void **	data,
		size_t *	data_size
	)

Convert human-readable version of a 'claim' of an attribute to the binary representation.

Parameters

type	type of the claim
s	human-readable string
data	set to value in binary encoding (will be allocated)
data_size	set to number of bytes in data

Returns

GNUNET_OK on success

Definition at line 199 of file reclaim_attribute.c.

{
  unsigned int i;
  struct Plugin *plugin;
 
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = attr_plugins[i];
    if (GNUNET_OK == plugin->api->string_to_value (plugin->api->cls,
                                                   type,
                                                   s,
                                                   data,
                                                   data_size))
      return GNUNET_OK;
  }
  return GNUNET_SYSERR;
}

References TestcasePlugin::api, attr_plugins, data, data_size, GNUNET_OK, GNUNET_SYSERR, init(), num_plugins, plugin, and type.

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_value_to_string()

char* GNUNET_RECLAIM_attribute_value_to_string	(	uint32_t	type,
		const void *	data,
		size_t	data_size
	)

Convert the 'claim' of an attribute to a string.

Parameters

type	the type of attribute
data	claim in binary encoding
data_size	number of bytes in data

Returns

NULL on error, otherwise human-readable representation of the claim

Definition at line 231 of file reclaim_attribute.c.

{
  unsigned int i;
  struct Plugin *plugin;
  char *ret;
 
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = attr_plugins[i];
    if (NULL != (ret = plugin->api->value_to_string (plugin->api->cls,
                                                     type,
                                                     data,
                                                     data_size)))
      return ret;
  }
  return NULL;
}

References TestcasePlugin::api, attr_plugins, data, data_size, init(), num_plugins, plugin, ret, and type.

Referenced by attr_collect(), consume_cont(), cred_collect(), cred_iter_cb(), generate_userinfo_json(), iter_cb(), and process_attrs().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_number_to_typename()

const char* GNUNET_RECLAIM_attribute_number_to_typename

(

uint32_t

type

)

Convert a type number to the corresponding type string.

Parameters

type	number of a type

Returns

corresponding typestring, NULL on error

Definition at line 170 of file reclaim_attribute.c.

{
  unsigned int i;
  struct Plugin *plugin;
  const char *ret;
 
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = attr_plugins[i];
    if (NULL !=
        (ret = plugin->api->number_to_typename (plugin->api->cls, type)))
      return ret;
  }
  return NULL;
}

References TestcasePlugin::api, attr_plugins, init(), num_plugins, plugin, ret, and type.

Referenced by attr_collect(), cred_collect(), iter_cb(), and process_attrs().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_list_serialize_get_size()

size_t GNUNET_RECLAIM_credential_list_serialize_get_size

(

const struct GNUNET_RECLAIM_CredentialList *

credentials

)

Get required size for serialization buffer.

Parameters

credentials

the attribute list to serialize

Returns

the required buffer size

Parameters

attrs

the attribute list to serialize

Returns

the required buffer size

Definition at line 288 of file reclaim_credential.c.

{
  struct GNUNET_RECLAIM_CredentialListEntry *le;
  size_t len = 0;
 
  for (le = credentials->list_head; NULL != le; le = le->next)
  {
    GNUNET_assert (NULL != le->credential);
    len += GNUNET_RECLAIM_credential_serialize_get_size (le->credential);
    len += sizeof(struct GNUNET_RECLAIM_CredentialListEntry);
  }
  return len;
}

References GNUNET_RECLAIM_CredentialListEntry::credential, GNUNET_assert, GNUNET_RECLAIM_credential_serialize_get_size(), len, GNUNET_RECLAIM_CredentialList::list_head, and GNUNET_RECLAIM_CredentialListEntry::next.

Here is the call graph for this function:

GNUNET_RECLAIM_credential_list_destroy()

void GNUNET_RECLAIM_credential_list_destroy

(

struct GNUNET_RECLAIM_CredentialList *

credentials

)

Destroy credential list.

Parameters

credentials

list to destroy

Definition at line 396 of file reclaim_credential.c.

{
  struct GNUNET_RECLAIM_CredentialListEntry *ale;
  struct GNUNET_RECLAIM_CredentialListEntry *tmp_ale;
 
  for (ale = credentials->list_head; NULL != ale;)
  {
    if (NULL != ale->credential)
      GNUNET_free (ale->credential);
    tmp_ale = ale;
    ale = ale->next;
    GNUNET_free (tmp_ale);
  }
  GNUNET_free (credentials);
}

References GNUNET_RECLAIM_CredentialListEntry::credential, GNUNET_free, GNUNET_RECLAIM_CredentialList::list_head, and GNUNET_RECLAIM_CredentialListEntry::next.

Referenced by cleanup_adh(), and cleanup_handle().

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_list_add()

void GNUNET_RECLAIM_credential_list_add	(	struct GNUNET_RECLAIM_CredentialList *	attrs,
		const char *	att_name,
		uint32_t	type,
		const void *	data,
		size_t	data_size
	)

Add a new attribute to a claim list.

Parameters

attr_name	the name of the new attribute claim
type	the type of the claim
data	claim payload
data_size	claim payload size

GNUNET_RECLAIM_credential_list_serialize()

size_t GNUNET_RECLAIM_credential_list_serialize	(	const struct GNUNET_RECLAIM_CredentialList *	credentials,
		char *	result
	)

Serialize a credential list.

Parameters

credentials	the credential list to serialize
result	the serialized credential

Returns

length of serialized data

Definition at line 305 of file reclaim_credential.c.

{
  struct GNUNET_RECLAIM_CredentialListEntry *le;
  size_t len;
  size_t total_len;
  char *write_ptr;
  write_ptr = result;
  total_len = 0;
  for (le = credentials->list_head; NULL != le; le = le->next)
  {
    GNUNET_assert (NULL != le->credential);
    len = GNUNET_RECLAIM_credential_serialize (le->credential, write_ptr);
    total_len += len;
    write_ptr += len;
  }
  return total_len;
}

References GNUNET_RECLAIM_CredentialListEntry::credential, GNUNET_assert, GNUNET_RECLAIM_credential_serialize(), len, GNUNET_RECLAIM_CredentialList::list_head, GNUNET_RECLAIM_CredentialListEntry::next, and result.

Here is the call graph for this function:

GNUNET_RECLAIM_credential_list_deserialize()

struct GNUNET_RECLAIM_CredentialList* GNUNET_RECLAIM_credential_list_deserialize	(	const char *	data,
		size_t	data_size
	)

Deserialize an attribute list.

Parameters

data	the serialized attribute list
data_size	the length of the serialized data

Returns

a GNUNET_IDENTITY_PROVIDER_AttributeList, must be free'd by caller

Definition at line 327 of file reclaim_credential.c.

{
  struct GNUNET_RECLAIM_CredentialList *al;
  struct GNUNET_RECLAIM_CredentialListEntry *ale;
  size_t att_len;
  const char *read_ptr;
 
  al = GNUNET_new (struct GNUNET_RECLAIM_CredentialList);
 
  if ((data_size < sizeof(struct
                          Credential)
       + sizeof(struct GNUNET_RECLAIM_CredentialListEntry)))
    return al;
 
  read_ptr = data;
  while (((data + data_size) - read_ptr) >= sizeof(struct Credential))
  {
    ale = GNUNET_new (struct GNUNET_RECLAIM_CredentialListEntry);
    ale->credential =
      GNUNET_RECLAIM_credential_deserialize (read_ptr,
                                             data_size - (read_ptr - data));
    if (NULL == ale->credential)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Failed to deserialize malformed credential.\n");
      GNUNET_free (ale);
      return al;
    }
    GNUNET_CONTAINER_DLL_insert (al->list_head, al->list_tail, ale);
    att_len = GNUNET_RECLAIM_credential_serialize_get_size (ale->credential);
    read_ptr += att_len;
  }
  return al;
}

References GNUNET_RECLAIM_CredentialListEntry::credential, data, data_size, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_RECLAIM_credential_deserialize(), GNUNET_RECLAIM_credential_serialize_get_size(), GNUNET_RECLAIM_CredentialList::list_head, and GNUNET_RECLAIM_CredentialList::list_tail.

Here is the call graph for this function:

GNUNET_RECLAIM_credential_serialize_get_size()

size_t GNUNET_RECLAIM_credential_serialize_get_size

(

const struct GNUNET_RECLAIM_Credential *

credential

)

Get required size for serialization buffer.

Parameters

credential

the credential to serialize

Returns

the required buffer size

Parameters

attr	the credential to serialize

Returns

the required buffer size

Definition at line 421 of file reclaim_credential.c.

{
  return sizeof(struct Credential) + strlen (credential->name)
         + credential->data_size;
}

References credential, data_size, and name.

Referenced by cred_add_cb(), GNUNET_RECLAIM_credential_delete(), GNUNET_RECLAIM_credential_list_deserialize(), GNUNET_RECLAIM_credential_list_serialize_get_size(), GNUNET_RECLAIM_credential_store(), and rvk_move_attr_cb().

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_serialize()

size_t GNUNET_RECLAIM_credential_serialize	(	const struct GNUNET_RECLAIM_Credential *	credential,
		char *	result
	)

Serialize an credential.

Parameters

credential	the credential to serialize
result	the serialized credential

Returns

length of serialized data

Definition at line 430 of file reclaim_credential.c.

{
  size_t data_len_ser;
  size_t name_len;
  struct Credential *atts;
  char *write_ptr;
 
  atts = (struct Credential *) result;
  atts->credential_type = htonl (credential->type);
  atts->credential_flag = htonl (credential->flag);
  atts->credential_id = credential->id;
  name_len = strlen (credential->name);
  atts->name_len = htons (name_len);
  write_ptr = (char *) &atts[1];
  GNUNET_memcpy (write_ptr, credential->name, name_len);
  write_ptr += name_len;
  // TODO plugin-ize
  // data_len_ser = plugin->serialize_attribute_value (attr,
  //                                                  &attr_ser[1]);
  data_len_ser = credential->data_size;
  GNUNET_memcpy (write_ptr, credential->data, credential->data_size);
  atts->data_size = htons (data_len_ser);
 
  return sizeof(struct Credential) + strlen (credential->name)
         + credential->data_size;
}

References credential, Credential::credential_flag, Credential::credential_id, Credential::credential_type, data_size, Credential::data_size, GNUNET_memcpy, GNUNET_RECLAIM_Identifier::id, name, Credential::name_len, and result.

Referenced by cred_add_cb(), GNUNET_RECLAIM_credential_delete(), GNUNET_RECLAIM_credential_list_serialize(), GNUNET_RECLAIM_credential_store(), and rvk_move_attr_cb().

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_deserialize()

struct GNUNET_RECLAIM_Credential* GNUNET_RECLAIM_credential_deserialize	(	const char *	data,
		size_t	data_size
	)

Deserialize an credential.

Parameters

data	the serialized credential
data_size	the length of the serialized data

Returns

a GNUNET_IDENTITY_PROVIDER_Attribute, must be free'd by caller

Definition at line 469 of file reclaim_credential.c.

{
  struct GNUNET_RECLAIM_Credential *credential;
  struct Credential *atts;
  size_t data_len;
  size_t name_len;
  char *write_ptr;
 
  if (data_size < sizeof(struct Credential))
    return NULL;
 
  atts = (struct Credential *) data;
  data_len = ntohs (atts->data_size);
  name_len = ntohs (atts->name_len);
  if (data_size < sizeof(struct Credential) + data_len + name_len)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Buffer too small to deserialize\n");
    return NULL;
  }
  credential = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Credential)
                              + data_len + name_len + 1);
  credential->type = ntohl (atts->credential_type);
  credential->flag = ntohl (atts->credential_flag);
  credential->id = atts->credential_id;
  credential->data_size = data_len;
 
  write_ptr = (char *) &credential[1];
  GNUNET_memcpy (write_ptr, &atts[1], name_len);
  write_ptr[name_len] = '\0';
  credential->name = write_ptr;
 
  write_ptr += name_len + 1;
  GNUNET_memcpy (write_ptr, (char *) &atts[1] + name_len,
                 credential->data_size);
  credential->data = write_ptr;
  return credential;
}

References credential, Credential::credential_flag, Credential::credential_id, Credential::credential_type, data, data_size, Credential::data_size, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_RECLAIM_Identifier::id, and Credential::name_len.

Referenced by consistency_iter(), filter_tickets_cb(), GNUNET_RECLAIM_credential_list_deserialize(), handle_credential_delete_message(), handle_credential_result(), handle_credential_store_message(), and rvk_move_attr_cb().

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_new()

struct GNUNET_RECLAIM_Credential* GNUNET_RECLAIM_credential_new	(	const char *	name,
		uint32_t	type,
		const void *	data,
		size_t	data_size
	)

Create a new credential.

Parameters

name	the credential name
type	the credential type
data	the credential value
data_size	the credential value size

Returns

the new credential

Definition at line 254 of file reclaim_credential.c.

{
  struct GNUNET_RECLAIM_Credential *attr;
  char *write_ptr;
  char *attr_name_tmp = GNUNET_strdup (attr_name);
 
  GNUNET_STRINGS_utf8_tolower (attr_name, attr_name_tmp);
 
  attr = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Credential)
                        + strlen (attr_name_tmp) + 1 + data_size);
  attr->type = type;
  attr->data_size = data_size;
  attr->flag = 0;
  write_ptr = (char *) &attr[1];
  GNUNET_memcpy (write_ptr, attr_name_tmp, strlen (attr_name_tmp) + 1);
  attr->name = write_ptr;
  write_ptr += strlen (attr->name) + 1;
  GNUNET_memcpy (write_ptr, data, data_size);
  attr->data = write_ptr;
  GNUNET_free (attr_name_tmp);
  return attr;
}

References attr_name, GNUNET_RECLAIM_Credential::data, data, data_size, GNUNET_RECLAIM_Credential::data_size, GNUNET_RECLAIM_Credential::flag, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), GNUNET_RECLAIM_Credential::name, GNUNET_RECLAIM_Credential::type, and type.

Referenced by cred_iter_finished(), GNUNET_RECLAIM_credential_list_dup(), oidc_cred_collect(), and parse_credential().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_value_to_string()

char* GNUNET_RECLAIM_credential_value_to_string	(	uint32_t	type,
		const void *	data,
		size_t	data_size
	)

Convert the 'claim' of an credential to a string.

Parameters

type	the type of credential
data	claim in binary encoding
data_size	number of bytes in data

Returns

NULL on error, otherwise human-readable representation of the claim

Definition at line 231 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
  char *ret;
 
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (NULL != (ret = plugin->api->value_to_string (plugin->api->cls,
                                                     type,
                                                     data,
                                                     data_size)))
      return ret;
  }
  return NULL;
}

References TestcasePlugin::api, credential_plugins, data, data_size, init(), num_plugins, plugin, ret, and type.

Referenced by cred_collect(), cred_iter_cb(), and parse_jwt().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_string_to_value()

int GNUNET_RECLAIM_credential_string_to_value	(	uint32_t	type,
		const char *	s,
		void **	data,
		size_t *	data_size
	)

Convert human-readable version of a 'claim' of an credential to the binary representation.

Parameters

type	type of the claim
s	human-readable string
data	set to value in binary encoding (will be allocated)
data_size	set to number of bytes in data

Returns

GNUNET_OK on success

Definition at line 199 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
 
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (GNUNET_OK == plugin->api->string_to_value (plugin->api->cls,
                                                   type,
                                                   s,
                                                   data,
                                                   data_size))
      return GNUNET_OK;
  }
  return GNUNET_SYSERR;
}

References TestcasePlugin::api, credential_plugins, data, data_size, GNUNET_OK, GNUNET_SYSERR, init(), num_plugins, plugin, and type.

Referenced by parse_credential().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_number_to_typename()

const char* GNUNET_RECLAIM_credential_number_to_typename

(

uint32_t

type

)

Convert an credential type number to the corresponding credential type string.

Parameters

type	number of a type

Returns

corresponding typestring, NULL on error

Definition at line 170 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
  const char *ret;
 
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (NULL !=
        (ret = plugin->api->number_to_typename (plugin->api->cls, type)))
      return ret;
  }
  return NULL;
}

References TestcasePlugin::api, credential_plugins, init(), num_plugins, plugin, ret, and type.

Referenced by cred_collect(), and cred_iter_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_typename_to_number()

uint32_t GNUNET_RECLAIM_credential_typename_to_number

(

const char *

typename

)

Convert an credential type name to the corresponding number.

Parameters

typename

name to convert

Returns

corresponding number, UINT32_MAX on error

Definition at line 145 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
  uint32_t ret;
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (UINT32_MAX !=
        (ret = plugin->api->typename_to_number (plugin->api->cls,
                                                typename)))
      return ret;
  }
  return UINT32_MAX;
}

References TestcasePlugin::api, credential_plugins, init(), num_plugins, plugin, and ret.

Referenced by cred_iter_finished(), and parse_credential().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_get_attributes()

struct GNUNET_RECLAIM_AttributeList* GNUNET_RECLAIM_credential_get_attributes

(

const struct GNUNET_RECLAIM_Credential *

cred

)

Convert an credential type name to the corresponding number.

Parameters

typename

name to convert

Returns

corresponding number, UINT32_MAX on error

Definition at line 510 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
  struct GNUNET_RECLAIM_AttributeList *ret;
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (NULL !=
        (ret = plugin->api->get_attributes (plugin->api->cls,
                                            credential)))
      return ret;
  }
  return NULL;
}

References TestcasePlugin::api, credential, credential_plugins, init(), num_plugins, plugin, and ret.

Referenced by cred_collect(), and cred_iter_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_get_issuer()

char* GNUNET_RECLAIM_credential_get_issuer

(

const struct GNUNET_RECLAIM_Credential *

cred

)

Definition at line 530 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
  char *ret;
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (NULL !=
        (ret = plugin->api->get_issuer (plugin->api->cls,
                                        credential)))
      return ret;
  }
  return NULL;
}

References TestcasePlugin::api, credential, credential_plugins, init(), num_plugins, plugin, and ret.

Referenced by cred_collect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_get_expiration()

int GNUNET_RECLAIM_credential_get_expiration	(	const struct GNUNET_RECLAIM_Credential *	cred,
		struct GNUNET_TIME_Absolute *	exp
	)

Definition at line 550 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (GNUNET_OK !=  plugin->api->get_expiration (plugin->api->cls,
                                                   credential,
                                                   exp))
      continue;
    return GNUNET_OK;
  }
  return GNUNET_SYSERR;
}

References TestcasePlugin::api, credential, credential_plugins, GNUNET_OK, GNUNET_SYSERR, init(), num_plugins, and plugin.

Referenced by cred_collect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_presentation_list_serialize_get_size()

size_t GNUNET_RECLAIM_presentation_list_serialize_get_size

(

const struct GNUNET_RECLAIM_PresentationList *

presentations

)

Get required size for serialization buffer.

Parameters

presentations

the presentation list to serialize

Returns

the required buffer size

Parameters

attrs

the attribute list to serialize

Returns

the required buffer size

Definition at line 705 of file reclaim_credential.c.

{
  struct GNUNET_RECLAIM_PresentationListEntry *le;
  size_t len = 0;
 
  for (le = presentations->list_head; NULL != le; le = le->next)
  {
    GNUNET_assert (NULL != le->presentation);
    len += GNUNET_RECLAIM_presentation_serialize_get_size (le->presentation);
  }
  return len;
}

References GNUNET_assert, GNUNET_RECLAIM_presentation_serialize_get_size(), len, GNUNET_RECLAIM_PresentationList::list_head, GNUNET_RECLAIM_PresentationListEntry::next, and GNUNET_RECLAIM_PresentationListEntry::presentation.

Referenced by check_code_challenge(), consume_result_cb(), and send_ticket_result().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_presentation_list_destroy()

void GNUNET_RECLAIM_presentation_list_destroy

(

struct GNUNET_RECLAIM_PresentationList *

presentations

)

Destroy presentations list.

Parameters

presentations

list to destroy

Definition at line 818 of file reclaim_credential.c.

{
  struct GNUNET_RECLAIM_PresentationListEntry *ale;
  struct GNUNET_RECLAIM_PresentationListEntry *tmp_ale;
 
  for (ale = presentations->list_head; NULL != ale;)
  {
    if (NULL != ale->presentation)
      GNUNET_free (ale->presentation);
    tmp_ale = ale;
    ale = ale->next;
    GNUNET_free (tmp_ale);
  }
  GNUNET_free (presentations);
}

References GNUNET_free, GNUNET_RECLAIM_PresentationList::list_head, GNUNET_RECLAIM_PresentationListEntry::next, and GNUNET_RECLAIM_PresentationListEntry::presentation.

Referenced by cleanup_cth(), cleanup_handle(), consume_fail(), filter_tickets_cb(), handle_consume_ticket_result(), handle_ticket_result(), and token_endpoint().

Here is the caller graph for this function:

GNUNET_RECLAIM_presentation_list_serialize()

size_t GNUNET_RECLAIM_presentation_list_serialize	(	const struct GNUNET_RECLAIM_PresentationList *	presentations,
		char *	result
	)

Serialize a presentation list.

Parameters

presentations	the attribute list to serialize
result	the serialized list

Returns

length of serialized data

Definition at line 721 of file reclaim_credential.c.

{
  struct GNUNET_RECLAIM_PresentationListEntry *le;
  size_t len;
  size_t total_len;
  char *write_ptr;
  write_ptr = result;
  total_len = 0;
  for (le = presentations->list_head; NULL != le; le = le->next)
  {
    GNUNET_assert (NULL != le->presentation);
    len = GNUNET_RECLAIM_presentation_serialize (le->presentation, write_ptr);
    total_len += len;
    write_ptr += len;
  }
  return total_len;
}

References GNUNET_assert, GNUNET_RECLAIM_presentation_serialize(), len, GNUNET_RECLAIM_PresentationList::list_head, GNUNET_RECLAIM_PresentationListEntry::next, GNUNET_RECLAIM_PresentationListEntry::presentation, and result.

Referenced by check_code_challenge(), consume_result_cb(), and send_ticket_result().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_presentation_list_deserialize()

struct GNUNET_RECLAIM_PresentationList* GNUNET_RECLAIM_presentation_list_deserialize	(	const char *	data,
		size_t	data_size
	)

Deserialize a presentation list.

Parameters

data	the serialized list
data_size	the length of the serialized data

Returns

a GNUNET_RECLAIM_PresentationList, must be free'd by caller

Deserialize a presentation list.

Parameters

data	the serialized attribute list
data_size	the length of the serialized data

Returns

a GNUNET_IDENTITY_PROVIDER_AttributeList, must be free'd by caller

Definition at line 750 of file reclaim_credential.c.

{
  struct GNUNET_RECLAIM_PresentationList *al;
  struct GNUNET_RECLAIM_PresentationListEntry *ale;
  size_t att_len;
  const char *read_ptr;
 
  al = GNUNET_new (struct GNUNET_RECLAIM_PresentationList);
 
  if (data_size < sizeof(struct Presentation))
    return al;
 
  read_ptr = data;
  while (((data + data_size) - read_ptr) >= sizeof(struct Presentation))
  {
    ale = GNUNET_new (struct GNUNET_RECLAIM_PresentationListEntry);
    ale->presentation =
      GNUNET_RECLAIM_presentation_deserialize (read_ptr,
                                               data_size - (read_ptr - data));
    if (NULL == ale->presentation)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Failed to deserialize malformed presentation.\n");
      GNUNET_free (ale);
      return al;
    }
    GNUNET_CONTAINER_DLL_insert (al->list_head, al->list_tail, ale);
    att_len = GNUNET_RECLAIM_presentation_serialize_get_size (
      ale->presentation);
    read_ptr += att_len;
  }
  return al;
}

References data, data_size, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_RECLAIM_presentation_deserialize(), GNUNET_RECLAIM_presentation_serialize_get_size(), GNUNET_RECLAIM_PresentationList::list_head, GNUNET_RECLAIM_PresentationList::list_tail, and GNUNET_RECLAIM_PresentationListEntry::presentation.

Referenced by handle_consume_ticket_result(), handle_ticket_result(), and OIDC_parse_authz_code().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_presentation_serialize_get_size()

size_t GNUNET_RECLAIM_presentation_serialize_get_size

(

const struct GNUNET_RECLAIM_Presentation *

presentation

)

Get required size for serialization buffer.

Parameters

presentation

the presentation to serialize

Returns

the required buffer size

Parameters

attr	the presentation to serialize

Returns

the required buffer size

Definition at line 843 of file reclaim_credential.c.

{
  return sizeof(struct Presentation) + presentation->data_size;
}

References data_size.

Referenced by GNUNET_RECLAIM_presentation_list_deserialize(), GNUNET_RECLAIM_presentation_list_serialize_get_size(), and issue_ticket().

Here is the caller graph for this function:

GNUNET_RECLAIM_presentation_serialize()

size_t GNUNET_RECLAIM_presentation_serialize	(	const struct GNUNET_RECLAIM_Presentation *	presentation,
		char *	result
	)

Serialize a presentation.

Parameters

presentation	the presentation to serialize
result	the serialized presentation

Returns

length of serialized data

Definition at line 851 of file reclaim_credential.c.

{
  struct Presentation *atts;
  char *write_ptr;
 
  atts = (struct Presentation *) result;
  atts->presentation_type = htonl (presentation->type);
  atts->credential_id = presentation->credential_id;
  write_ptr = (char *) &atts[1];
  GNUNET_memcpy (write_ptr, presentation->data, presentation->data_size);
  atts->data_size = htons (presentation->data_size);
 
  return sizeof(struct Presentation) + presentation->data_size;
}

References GNUNET_RECLAIM_Presentation::credential_id, Presentation::credential_id, GNUNET_RECLAIM_Presentation::data, data_size, GNUNET_RECLAIM_Presentation::data_size, Presentation::data_size, GNUNET_memcpy, Presentation::presentation_type, result, and GNUNET_RECLAIM_Presentation::type.

Referenced by GNUNET_RECLAIM_presentation_list_serialize(), and issue_ticket().

Here is the caller graph for this function:

GNUNET_RECLAIM_presentation_deserialize()

struct GNUNET_RECLAIM_Presentation* GNUNET_RECLAIM_presentation_deserialize	(	const char *	data,
		size_t	data_size
	)

Deserialize a presentation.

Parameters

data	the serialized presentation
data_size	the length of the serialized data

Returns

a GNUNET_RECLAIM_Presentation, must be free'd by caller

Deserialize a presentation.

Parameters

data	the serialized presentation
data_size	the length of the serialized data

Returns

a GNUNET_IDENTITY_PROVIDER_Attribute, must be free'd by caller

Definition at line 878 of file reclaim_credential.c.

{
  struct GNUNET_RECLAIM_Presentation *presentation;
  struct Presentation *atts;
  size_t data_len;
  char *write_ptr;
 
  if (data_size < sizeof(struct Presentation))
    return NULL;
 
  atts = (struct Presentation *) data;
  data_len = ntohs (atts->data_size);
  if (data_size < sizeof(struct Presentation) + data_len)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Buffer too small to deserialize\n");
    return NULL;
  }
  presentation = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Presentation)
                                + data_len);
  presentation->type = ntohl (atts->presentation_type);
  presentation->credential_id = atts->credential_id;
  presentation->data_size = data_len;
 
  write_ptr = (char *) &presentation[1];
  GNUNET_memcpy (write_ptr, &atts[1], data_len);
  presentation->data = write_ptr;
  return presentation;
}

References GNUNET_RECLAIM_Presentation::credential_id, Presentation::credential_id, GNUNET_RECLAIM_Presentation::data, data, data_size, GNUNET_RECLAIM_Presentation::data_size, Presentation::data_size, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, Presentation::presentation_type, and GNUNET_RECLAIM_Presentation::type.

Referenced by filter_tickets_cb(), GNUNET_RECLAIM_presentation_list_deserialize(), issue_ticket(), lookup_authz_cb(), and update_tickets().

Here is the caller graph for this function:

GNUNET_RECLAIM_presentation_value_to_string()

char* GNUNET_RECLAIM_presentation_value_to_string	(	uint32_t	type,
		const void *	data,
		size_t	data_size
	)

Convert the 'claim' of a presentation to a string.

Parameters

type	the type of presentation
data	presentation in binary encoding
data_size	number of bytes in data

Returns

NULL on error, otherwise human-readable representation of the claim

Convert the 'claim' of a presentation to a string.

Parameters

type	the type of presentation
data	claim in binary encoding
data_size	number of bytes in data

Returns

NULL on error, otherwise human-readable representation of the claim

Definition at line 657 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
  char *ret;
 
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (NULL != (ret = plugin->api->value_to_string_p (plugin->api->cls,
                                                       type,
                                                       data,
                                                       data_size)))
      return ret;
  }
  return NULL;
}

References TestcasePlugin::api, credential_plugins, data, data_size, init(), num_plugins, plugin, ret, and type.

Referenced by generate_userinfo_json().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_presentation_new()

struct GNUNET_RECLAIM_Presentation* GNUNET_RECLAIM_presentation_new	(	uint32_t	type,
		const void *	data,
		size_t	data_size
	)

Definition at line 680 of file reclaim_credential.c.

{
  struct GNUNET_RECLAIM_Presentation *attr;
  char *write_ptr;
 
  attr = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Presentation)
                        + data_size);
  attr->type = type;
  attr->data_size = data_size;
  write_ptr = (char *) &attr[1];
  GNUNET_memcpy (write_ptr, data, data_size);
  attr->data = write_ptr;
  return attr;
}

References GNUNET_RECLAIM_Presentation::data, data, data_size, GNUNET_RECLAIM_Presentation::data_size, GNUNET_malloc, GNUNET_memcpy, GNUNET_RECLAIM_Presentation::type, and type.

Referenced by consume_ticket(), GNUNET_RECLAIM_presentation_list_dup(), and pabc_create_presentation().

Here is the caller graph for this function:

GNUNET_RECLAIM_presentation_string_to_value()

int GNUNET_RECLAIM_presentation_string_to_value	(	uint32_t	type,
		const char *	s,
		void **	data,
		size_t *	data_size
	)

Convert human-readable version of a 'claim' of a presentation to the binary representation.

Parameters

type	type of the presentation
s	human-readable string
data	set to value in binary encoding (will be allocated)
data_size	set to number of bytes in data

Returns

GNUNET_OK on success

Convert human-readable version of a 'claim' of a presentation to the binary representation.

Parameters

type	type of the claim
s	human-readable string
data	set to value in binary encoding (will be allocated)
data_size	set to number of bytes in data

Returns

GNUNET_OK on success

Definition at line 625 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
 
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (GNUNET_OK == plugin->api->string_to_value_p (plugin->api->cls,
                                                     type,
                                                     s,
                                                     data,
                                                     data_size))
      return GNUNET_OK;
  }
  return GNUNET_SYSERR;
}

References TestcasePlugin::api, credential_plugins, data, data_size, GNUNET_OK, GNUNET_SYSERR, init(), num_plugins, plugin, and type.

Here is the call graph for this function:

GNUNET_RECLAIM_presentation_number_to_typename()

const char* GNUNET_RECLAIM_presentation_number_to_typename

(

uint32_t

type

)

Convert a presentation type number to the corresponding credential type string.

Parameters

type	number of a type

Returns

corresponding typestring, NULL on error

Definition at line 596 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
  const char *ret;
 
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (NULL !=
        (ret = plugin->api->number_to_typename_p (plugin->api->cls, type)))
      return ret;
  }
  return NULL;
}

References TestcasePlugin::api, credential_plugins, init(), num_plugins, plugin, ret, and type.

Referenced by generate_userinfo_json().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_presentation_get_attributes()

struct GNUNET_RECLAIM_AttributeList* GNUNET_RECLAIM_presentation_get_attributes

(

const struct GNUNET_RECLAIM_Presentation *

cred

)

Definition at line 910 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
  struct GNUNET_RECLAIM_AttributeList *ret;
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (NULL !=
        (ret = plugin->api->get_attributes_p (plugin->api->cls,
                                              presentation)))
      return ret;
  }
  return NULL;
}

References TestcasePlugin::api, credential_plugins, init(), num_plugins, plugin, and ret.

Referenced by process_attrs().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_presentation_get_issuer()

char* GNUNET_RECLAIM_presentation_get_issuer

(

const struct GNUNET_RECLAIM_Presentation *

cred

)

Definition at line 931 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
  char *ret;
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (NULL !=
        (ret = plugin->api->get_issuer_p (plugin->api->cls,
                                          presentation)))
      return ret;
  }
  return NULL;
}

References TestcasePlugin::api, credential_plugins, init(), num_plugins, plugin, and ret.

Here is the call graph for this function:

GNUNET_RECLAIM_presentation_get_expiration()

int GNUNET_RECLAIM_presentation_get_expiration	(	const struct GNUNET_RECLAIM_Presentation *	cred,
		struct GNUNET_TIME_Absolute *	exp
	)

Definition at line 952 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (GNUNET_OK !=  plugin->api->get_expiration_p (plugin->api->cls,
                                                     presentation,
                                                     exp))
      continue;
    return GNUNET_OK;
  }
  return GNUNET_SYSERR;
}

References TestcasePlugin::api, credential_plugins, GNUNET_OK, GNUNET_SYSERR, init(), num_plugins, and plugin.

Here is the call graph for this function:

GNUNET_RECLAIM_credential_get_presentation()

int GNUNET_RECLAIM_credential_get_presentation	(	const struct GNUNET_RECLAIM_Credential *	cred,
		const struct GNUNET_RECLAIM_AttributeList *	attrs,
		struct GNUNET_RECLAIM_Presentation **	presentation
	)

Create a presentation from a credential and a lift of (selected) attributes in the credential.

FIXME not yet implemented

Parameters

cred	the credential to use
attrs	the attributes to present from the credential
presentation	the credential presentation presenting the attributes according to the presentation mechanism of the credential or NULL on error.

Returns

GNUNET_OK on success.

Parameters

cred	the credential to use
attrs	the attributes to present from the credential

Returns

the credential presentation presenting the attributes according to the presentation mechanism of the credential or NULL on error.

Definition at line 984 of file reclaim_credential.c.

{
  unsigned int i;
  struct Plugin *plugin;
  init ();
  for (i = 0; i < num_plugins; i++)
  {
    plugin = credential_plugins[i];
    if (GNUNET_OK !=  plugin->api->create_presentation (plugin->api->cls,
                                                        cred,
                                                        attrs,
                                                        presentation))
      continue;
    (*presentation)->credential_id = cred->id;
    return GNUNET_OK;
  }
  return GNUNET_SYSERR;
}

References TestcasePlugin::api, credential_plugins, GNUNET_OK, GNUNET_SYSERR, GNUNET_RECLAIM_Credential::id, init(), num_plugins, and plugin.

Referenced by filter_tickets_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

GNUNET_RECLAIM_ID_ZERO

const struct GNUNET_RECLAIM_Identifier GNUNET_RECLAIM_ID_ZERO

static

Definition at line 1 of file gnunet_reclaim_lib.h.

Referenced by start_process().