GNUnet  0.11.x
Data Structures | Macros | Enumerations | Functions | Variables
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_AttributeGNUNET_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_AttributeListGNUNET_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_AttributeListGNUNET_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 claim 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 *attrs, char *result)
 Serialize an attribute list. More...
 
struct GNUNET_RECLAIM_CredentialListGNUNET_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_CredentialGNUNET_RECLAIM_credential_deserialize (const char *data, size_t data_size)
 Deserialize an credential. More...
 
struct GNUNET_RECLAIM_CredentialGNUNET_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_AttributeListGNUNET_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_PresentationListGNUNET_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_PresentationGNUNET_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_PresentationGNUNET_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_AttributeListGNUNET_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 74 of file gnunet_reclaim_lib.h.

◆ GNUNET_RECLAIM_id_is_equal

#define GNUNET_RECLAIM_id_is_equal (   a,
 
)
Value:
((0 == \
memcmp (a, \
b, \
? \
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
static const struct GNUNET_RECLAIM_Identifier GNUNET_RECLAIM_ID_ZERO

Definition at line 90 of file gnunet_reclaim_lib.h.

◆ GNUNET_RECLAIM_id_is_zero

#define GNUNET_RECLAIM_id_is_zero (   a)
Value:
& \
#define GNUNET_RECLAIM_id_is_equal(a, b)

Definition at line 98 of file gnunet_reclaim_lib.h.

◆ GNUNET_RECLAIM_id_generate

#define GNUNET_RECLAIM_id_generate (   id)
Value:
id, \
void GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
Fill block with a random values.
@ GNUNET_CRYPTO_QUALITY_STRONG
High-quality operations are desired.

Definition at line 102 of file gnunet_reclaim_lib.h.

Enumeration Type Documentation

◆ GNUNET_RECLAIM_AttributeType

Enumerator
GNUNET_RECLAIM_ATTRIBUTE_TYPE_NONE 

No value attribute.

GNUNET_RECLAIM_ATTRIBUTE_TYPE_STRING 

String attribute.

Definition at line 42 of file gnunet_reclaim_lib.h.

42  {
47 
52 };
@ GNUNET_RECLAIM_ATTRIBUTE_TYPE_STRING
String attribute.
@ GNUNET_RECLAIM_ATTRIBUTE_TYPE_NONE
No value attribute.

◆ 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 54 of file gnunet_reclaim_lib.h.

54  {
59 
64 
69 };
@ GNUNET_RECLAIM_CREDENTIAL_TYPE_JWT
A JSON Web Token credential.
@ GNUNET_RECLAIM_CREDENTIAL_TYPE_PABC
libpabc credential
@ GNUNET_RECLAIM_CREDENTIAL_TYPE_NONE
No value credential.

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_namethe attribute name
credentialID of the credential (may be NULL)
typethe attribute type
datathe attribute value. Must be attr_name if credential not NULL
data_sizethe attribute value size
Returns
the new attribute

Create a new attribute claim.

Parameters
attr_namethe attribute name
credentialcredential ID of the attribute (maybe NULL)
typethe attribute type
datathe attribute value
data_sizethe attribute value size
Returns
the new attribute

Definition at line 264 of file reclaim_attribute.c.

270 {
271  struct GNUNET_RECLAIM_Attribute *attr;
272  char *write_ptr;
273  char *attr_name_tmp = GNUNET_strdup (attr_name);
274 
275  GNUNET_STRINGS_utf8_tolower (attr_name, attr_name_tmp);
276 
277  attr = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Attribute)
278  + strlen (attr_name_tmp) + 1 + data_size);
279  if (NULL != credential)
280  attr->credential = *credential;
281  attr->type = type;
282  attr->data_size = data_size;
283  attr->flag = 0;
284  write_ptr = (char *) &attr[1];
285  GNUNET_memcpy (write_ptr, attr_name_tmp, strlen (attr_name_tmp) + 1);
286  attr->name = write_ptr;
287  write_ptr += strlen (attr->name) + 1;
288  GNUNET_memcpy (write_ptr, data, data_size);
289  attr->data = write_ptr;
290  GNUNET_free (attr_name_tmp);
291  return attr;
292 }
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
uint32_t data
The data value.
static char * attr_name
The attribute.
static struct GNUNET_RECLAIM_Identifier credential
Credential ID.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_STRINGS_utf8_tolower(const char *input, char *output)
Convert the utf-8 input string to lower case.
Definition: strings.c:444
const char * name
The name of the attribute.
struct GNUNET_RECLAIM_Identifier credential
Referenced ID of credential (may be GNUNET_RECLAIM_ID_ZERO if self-creded)
uint32_t type
Type of Claim.
const void * data
Binary value stored as attribute value.
size_t data_size
Number of bytes in data.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

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
attrsthe attribute list to serialize
Returns
the required buffer size

Definition at line 331 of file reclaim_attribute.c.

333 {
335  size_t len = 0;
336 
337  for (ale = al->list_head; NULL != ale; ale = ale->next)
338  {
339  GNUNET_assert (NULL != ale->attribute);
341  }
342  return len;
343 }
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
size_t GNUNET_RECLAIM_attribute_serialize_get_size(const struct GNUNET_RECLAIM_Attribute *attr)
Get required size for serialization buffer.
struct GNUNET_RECLAIM_Attribute * attribute
The attribute claim.
struct GNUNET_RECLAIM_AttributeListEntry * next
DLL.
struct GNUNET_RECLAIM_AttributeListEntry * list_head
List head.

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 al)

Destroy claim list.

Parameters
attrslist to destroy

Definition at line 460 of file reclaim_attribute.c.

462 {
464  struct GNUNET_RECLAIM_AttributeListEntry *tmp_ale;
465 
466  for (ale = al->list_head; NULL != ale;)
467  {
468  if (NULL != ale->attribute)
469  GNUNET_free (ale->attribute);
470  tmp_ale = ale;
471  ale = ale->next;
472  GNUNET_free (tmp_ale);
473  }
474  GNUNET_free (al);
475 }

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_timeout(), cred_collect(), cred_iter_cb(), 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 al,
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
attrsthe attribute list to add to
attr_namethe name of the new attribute claim
credentialcredential ID (may be NULL)
typethe type of the claim
dataclaim payload
data_sizeclaim payload size
attr_namethe name of the new attribute claim
typethe type of the claim
dataclaim payload
data_sizeclaim payload size

Definition at line 304 of file reclaim_attribute.c.

311 {
313 
315  ale->attribute =
317  type, data, data_size);
319  al->list_tail,
320  ale);
321 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
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.
struct GNUNET_RECLAIM_AttributeListEntry * list_tail
List tail.

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 al,
char *  result 
)

Serialize an attribute list.

Parameters
attrsthe attribute list to serialize
resultthe serialized attribute
Returns
length of serialized data

Definition at line 354 of file reclaim_attribute.c.

357 {
359  size_t len;
360  size_t total_len;
361  char *write_ptr;
362  write_ptr = result;
363  total_len = 0;
364  for (ale = al->list_head; NULL != ale; ale = ale->next)
365  {
366  GNUNET_assert (NULL != ale->attribute);
368  total_len += len;
369  write_ptr += len;
370  }
371  return total_len;
372 }
static int result
Global testing status.
size_t GNUNET_RECLAIM_attribute_serialize(const struct GNUNET_RECLAIM_Attribute *attr, char *result)
Serialize an attribute.

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
datathe serialized attribute list
data_sizethe length of the serialized data
Returns
a GNUNET_IDENTITY_PROVIDER_AttributeList, must be free'd by caller

Definition at line 383 of file reclaim_attribute.c.

384 {
385  struct GNUNET_RECLAIM_AttributeList *al;
387  size_t attr_len;
388  const char *read_ptr;
389  size_t left = data_size;
390 
392  if (data_size < sizeof(struct Attribute))
393  return al;
394  read_ptr = data;
395  while (left >= sizeof(struct Attribute))
396  {
398  attr_len =
400  left,
401  &ale->attribute);
402  if (-1 == attr_len)
403  {
405  "Failed to deserialize malformed attribute.\n");
406  GNUNET_free (ale);
407  return al;
408  }
409  left -= attr_len;
411  read_ptr += attr_len;
412  }
413  return al;
414 }
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_WARNING
ssize_t GNUNET_RECLAIM_attribute_deserialize(const char *data, size_t data_size, struct GNUNET_RECLAIM_Attribute **attr)
Deserialize an attribute.
Serialized claim.
A list of GNUNET_RECLAIM_Attribute structures.

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
attrthe attribute to serialize
Returns
the required buffer size

Definition at line 485 of file reclaim_attribute.c.

487 {
488  return sizeof(struct Attribute) + strlen (attr->name) + attr->data_size;
489 }
const char * name

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
attrthe attribute to serialize
resultthe serialized attribute
Returns
length of serialized data

Definition at line 500 of file reclaim_attribute.c.

503 {
504  size_t data_len_ser;
505  size_t name_len;
506  struct Attribute *attr_ser;
507  char *write_ptr;
508 
509  attr_ser = (struct Attribute *) result;
510  attr_ser->attribute_type = htons (attr->type);
511  attr_ser->attribute_flag = htonl (attr->flag);
512  attr_ser->attribute_id = attr->id;
513  attr_ser->credential_id = attr->credential;
514  name_len = strlen (attr->name);
515  attr_ser->name_len = htons (name_len);
516  write_ptr = (char *) &attr_ser[1];
517  GNUNET_memcpy (write_ptr, attr->name, name_len);
518  write_ptr += name_len;
519  // TODO plugin-ize
520  // data_len_ser = plugin->serialize_attribute_value (attr,
521  // &attr_ser[1]);
522  data_len_ser = attr->data_size;
523  GNUNET_memcpy (write_ptr, attr->data, attr->data_size);
524  attr_ser->data_size = htons (data_len_ser);
525 
526  return sizeof(struct Attribute) + strlen (attr->name) + attr->data_size;
527 }
struct GNUNET_RECLAIM_Identifier attribute_id
Attribute ID.
uint32_t attribute_type
Attribute type.
uint32_t name_len
Name length.
struct GNUNET_RECLAIM_Identifier credential_id
Credential ID.
uint32_t data_size
Data size.
uint32_t attribute_flag
Attribute flag.
struct GNUNET_RECLAIM_Identifier id
ID.

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
datathe serialized attribute
data_sizethe length of the serialized data
attrdeserialized attribute. Will be allocated. Must be free'd
Returns
number of bytes read or -1 for error
Parameters
datathe serialized attribute
data_sizethe length of the serialized data
Returns
a GNUNET_IDENTITY_PROVIDER_Attribute, must be free'd by caller

Definition at line 539 of file reclaim_attribute.c.

541 {
542  struct Attribute *attr_ser;
543  struct GNUNET_RECLAIM_Attribute *attribute;
544  size_t data_len;
545  size_t name_len;
546  char *write_ptr;
547 
548  if (data_size < sizeof(struct Attribute))
549  return -1;
550 
551  attr_ser = (struct Attribute *) data;
552  data_len = ntohs (attr_ser->data_size);
553  name_len = ntohs (attr_ser->name_len);
554  if (data_size < sizeof(struct Attribute) + data_len + name_len)
555  {
557  "Buffer too small to deserialize\n");
558  return -1;
559  }
560  attribute = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Attribute)
561  + data_len + name_len + 1);
562  attribute->type = ntohs (attr_ser->attribute_type);
563  attribute->flag = ntohl (attr_ser->attribute_flag);
564  attribute->id = attr_ser->attribute_id;
565  attribute->credential = attr_ser->credential_id;
566  attribute->data_size = data_len;
567 
568  write_ptr = (char *) &attribute[1];
569  GNUNET_memcpy (write_ptr, &attr_ser[1], name_len);
570  write_ptr[name_len] = '\0';
571  attribute->name = write_ptr;
572 
573  write_ptr += name_len + 1;
574  GNUNET_memcpy (write_ptr, (char *) &attr_ser[1] + name_len,
575  attribute->data_size);
576  *attr = attribute;
577  attribute->data = write_ptr;
578  return sizeof(struct Attribute) + data_len + name_len;
579 }
@ GNUNET_ERROR_TYPE_ERROR

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 al)

Make a (deep) copy of a claim list.

Parameters
attrsclaim list to copy
Returns
copied claim list

Definition at line 423 of file reclaim_attribute.c.

425 {
427  struct GNUNET_RECLAIM_AttributeListEntry *result_ale;
429 
431  for (ale = al->list_head; NULL != ale; ale = ale->next)
432  {
433  result_ale = GNUNET_new (struct GNUNET_RECLAIM_AttributeListEntry);
434  GNUNET_assert (NULL != ale->attribute);
435  {
436  result_ale->attribute =
438  &ale->attribute->credential,
439  ale->attribute->type,
440  ale->attribute->data,
441  ale->attribute->data_size);
442 
443  result_ale->attribute->id = ale->attribute->id;
444  result_ale->attribute->flag = ale->attribute->flag;
445  }
447  result->list_tail,
448  result_ale);
449  }
450  return result;
451 }

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
typenamename to convert
Returns
corresponding number, UINT32_MAX on error

Definition at line 145 of file reclaim_attribute.c.

146 {
147  unsigned int i;
148  struct Plugin *plugin;
149  uint32_t ret;
150 
151  init ();
152  for (i = 0; i < num_plugins; i++)
153  {
154  plugin = attr_plugins[i];
155  if (UINT32_MAX !=
156  (ret = plugin->api->typename_to_number (plugin->api->cls, typename)))
157  return ret;
158  }
159  return UINT32_MAX;
160 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
struct Plugin * plugin
The process handle to the testbed service.
static struct Plugin ** attr_plugins
Plugins.
static unsigned int num_plugins
Number of plugins.
static void init()
Load plugins.
void * cls
Closure for all of the callbacks.
Handle for a plugin.
Definition: block.c:38
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47

References Plugin::api, attr_plugins, GNUNET_BLOCK_PluginFunctions::cls, 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
typetype of the claim
shuman-readable string
dataset to value in binary encoding (will be allocated)
data_sizeset to number of bytes in data
Returns
GNUNET_OK on success

Definition at line 199 of file reclaim_attribute.c.

203 {
204  unsigned int i;
205  struct Plugin *plugin;
206 
207  init ();
208  for (i = 0; i < num_plugins; i++)
209  {
210  plugin = attr_plugins[i];
211  if (GNUNET_OK == plugin->api->string_to_value (plugin->api->cls,
212  type,
213  s,
214  data,
215  data_size))
216  return GNUNET_OK;
217  }
218  return GNUNET_SYSERR;
219 }
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_SYSERR
Definition: gnunet_common.h:93

References Plugin::api, attr_plugins, GNUNET_BLOCK_PluginFunctions::cls, 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
typethe type of attribute
dataclaim in binary encoding
data_sizenumber of bytes in data
Returns
NULL on error, otherwise human-readable representation of the claim

Definition at line 231 of file reclaim_attribute.c.

234 {
235  unsigned int i;
236  struct Plugin *plugin;
237  char *ret;
238 
239  init ();
240  for (i = 0; i < num_plugins; i++)
241  {
242  plugin = attr_plugins[i];
243  if (NULL != (ret = plugin->api->value_to_string (plugin->api->cls,
244  type,
245  data,
246  data_size)))
247  return ret;
248  }
249  return NULL;
250 }

References Plugin::api, attr_plugins, GNUNET_BLOCK_PluginFunctions::cls, 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
typenumber of a type
Returns
corresponding typestring, NULL on error

Definition at line 170 of file reclaim_attribute.c.

171 {
172  unsigned int i;
173  struct Plugin *plugin;
174  const char *ret;
175 
176  init ();
177  for (i = 0; i < num_plugins; i++)
178  {
179  plugin = attr_plugins[i];
180  if (NULL !=
181  (ret = plugin->api->number_to_typename (plugin->api->cls, type)))
182  return ret;
183  }
184  return NULL;
185 }

References Plugin::api, attr_plugins, GNUNET_BLOCK_PluginFunctions::cls, 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
attrsthe attribute list to serialize
Returns
the required buffer size

Definition at line 297 of file reclaim_credential.c.

299 {
301  size_t len = 0;
302 
303  for (le = credentials->list_head; NULL != le; le = le->next)
304  {
305  GNUNET_assert (NULL != le->credential);
307  len += sizeof(struct GNUNET_RECLAIM_CredentialListEntry);
308  }
309  return len;
310 }
size_t GNUNET_RECLAIM_credential_serialize_get_size(const struct GNUNET_RECLAIM_Credential *credential)
Get required size for serialization buffer.
struct GNUNET_RECLAIM_CredentialListEntry * next
DLL.
struct GNUNET_RECLAIM_Credential * credential
The credential.
struct GNUNET_RECLAIM_CredentialListEntry * list_head
List head.

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 al)

Destroy claim list.

Parameters
attrslist to destroy

Destroy claim list.

Parameters
attrslist to destroy

Definition at line 424 of file reclaim_credential.c.

426 {
428  struct GNUNET_RECLAIM_CredentialListEntry *tmp_ale;
429 
430  for (ale = al->list_head; NULL != ale;)
431  {
432  if (NULL != ale->credential)
433  GNUNET_free (ale->credential);
434  tmp_ale = ale;
435  ale = ale->next;
436  GNUNET_free (tmp_ale);
437  }
438  GNUNET_free (al);
439 }

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_namethe name of the new attribute claim
typethe type of the claim
dataclaim payload
data_sizeclaim payload size

◆ GNUNET_RECLAIM_credential_list_serialize()

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

Serialize an attribute list.

Parameters
attrsthe attribute list to serialize
resultthe serialized attribute
Returns
length of serialized data

Definition at line 321 of file reclaim_credential.c.

324 {
326  size_t len;
327  size_t total_len;
328  char *write_ptr;
329  write_ptr = result;
330  total_len = 0;
331  for (le = credentials->list_head; NULL != le; le = le->next)
332  {
333  GNUNET_assert (NULL != le->credential);
335  total_len += len;
336  write_ptr += len;
337  }
338  return total_len;
339 }
size_t GNUNET_RECLAIM_credential_serialize(const struct GNUNET_RECLAIM_Credential *credential, char *result)
Serialize an credential.

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
datathe serialized attribute list
data_sizethe length of the serialized data
Returns
a GNUNET_IDENTITY_PROVIDER_AttributeList, must be free'd by caller

Deserialize an attribute list.

Parameters
datathe serialized attribute list
data_sizethe length of the serialized data
Returns
a GNUNET_IDENTITY_PROVIDER_AttributeList, must be free'd by caller

Definition at line 350 of file reclaim_credential.c.

351 {
354  size_t att_len;
355  const char *read_ptr;
356 
358 
359  if ((data_size < sizeof(struct
360  Credential)
361  + sizeof(struct GNUNET_RECLAIM_CredentialListEntry)))
362  return al;
363 
364  read_ptr = data;
365  while (((data + data_size) - read_ptr) >= sizeof(struct Credential))
366  {
368  ale->credential =
370  data_size - (read_ptr - data));
371  if (NULL == ale->credential)
372  {
374  "Failed to deserialize malformed credential.\n");
375  GNUNET_free (ale);
376  return al;
377  }
380  read_ptr += att_len;
381  }
382  return al;
383 }
struct GNUNET_RECLAIM_Credential * GNUNET_RECLAIM_credential_deserialize(const char *data, size_t data_size)
Deserialize an credential.
Serialized credential claim.
A list of GNUNET_RECLAIM_Credential structures.
struct GNUNET_RECLAIM_CredentialListEntry * list_tail
List tail.

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
credentialthe credential to serialize
Returns
the required buffer size
Parameters
attrthe credential to serialize
Returns
the required buffer size

Definition at line 449 of file reclaim_credential.c.

451 {
452  return sizeof(struct Credential) + strlen (credential->name)
454 }

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
credentialthe credential to serialize
resultthe serialized credential
Returns
length of serialized data
Parameters
attrthe credential to serialize
resultthe serialized credential
Returns
length of serialized data

Definition at line 465 of file reclaim_credential.c.

468 {
469  size_t data_len_ser;
470  size_t name_len;
471  struct Credential *atts;
472  char *write_ptr;
473 
474  atts = (struct Credential *) result;
475  atts->credential_type = htons (credential->type);
476  atts->credential_flag = htonl (credential->flag);
477  atts->credential_id = credential->id;
478  name_len = strlen (credential->name);
479  atts->name_len = htons (name_len);
480  write_ptr = (char *) &atts[1];
481  GNUNET_memcpy (write_ptr, credential->name, name_len);
482  write_ptr += name_len;
483  // TODO plugin-ize
484  // data_len_ser = plugin->serialize_attribute_value (attr,
485  // &attr_ser[1]);
486  data_len_ser = credential->data_size;
487  GNUNET_memcpy (write_ptr, credential->data, credential->data_size);
488  atts->data_size = htons (data_len_ser);
489 
490  return sizeof(struct Credential) + strlen (credential->name)
492 }
uint32_t data_size
Data size.
struct GNUNET_RECLAIM_Identifier credential_id
Credential ID.
uint32_t credential_type
Credential type.
uint32_t name_len
Name length.
uint32_t credential_flag
Credential flag.

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
datathe serialized credential
data_sizethe length of the serialized data
Returns
a GNUNET_IDENTITY_PROVIDER_Attribute, must be free'd by caller

Definition at line 504 of file reclaim_credential.c.

505 {
507  struct Credential *atts;
508  size_t data_len;
509  size_t name_len;
510  char *write_ptr;
511 
512  if (data_size < sizeof(struct Credential))
513  return NULL;
514 
515  atts = (struct Credential *) data;
516  data_len = ntohs (atts->data_size);
517  name_len = ntohs (atts->name_len);
518  if (data_size < sizeof(struct Credential) + data_len + name_len)
519  {
521  "Buffer too small to deserialize\n");
522  return NULL;
523  }
525  + data_len + name_len + 1);
526  credential->type = ntohs (atts->credential_type);
527  credential->flag = ntohl (atts->credential_flag);
528  credential->id = atts->credential_id;
529  credential->data_size = data_len;
530 
531  write_ptr = (char *) &credential[1];
532  GNUNET_memcpy (write_ptr, &atts[1], name_len);
533  write_ptr[name_len] = '\0';
534  credential->name = write_ptr;
535 
536  write_ptr += name_len + 1;
537  GNUNET_memcpy (write_ptr, (char *) &atts[1] + name_len,
538  credential->data_size);
539  credential->data = write_ptr;
540  return credential;
541 }

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 *  attr_name,
uint32_t  type,
const void *  data,
size_t  data_size 
)

Create a new credential.

Parameters
namethe credential name
typethe credential type
datathe credential value
data_sizethe credential value size
Returns
the new credential
Parameters
attr_namethe credential name
typethe credential type
datathe credential value
data_sizethe credential value size
Returns
the new credential

Definition at line 263 of file reclaim_credential.c.

267 {
268  struct GNUNET_RECLAIM_Credential *attr;
269  char *write_ptr;
270  char *attr_name_tmp = GNUNET_strdup (attr_name);
271 
272  GNUNET_STRINGS_utf8_tolower (attr_name, attr_name_tmp);
273 
274  attr = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Credential)
275  + strlen (attr_name_tmp) + 1 + data_size);
276  attr->type = type;
277  attr->data_size = data_size;
278  attr->flag = 0;
279  write_ptr = (char *) &attr[1];
280  GNUNET_memcpy (write_ptr, attr_name_tmp, strlen (attr_name_tmp) + 1);
281  attr->name = write_ptr;
282  write_ptr += strlen (attr->name) + 1;
283  GNUNET_memcpy (write_ptr, data, data_size);
284  attr->data = write_ptr;
285  GNUNET_free (attr_name_tmp);
286  return attr;
287 }
uint32_t type
Type/Format of Claim.
const char * name
The name of the credential.
const void * data
Binary value stored as credential value.
size_t data_size
Number of bytes in data.

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
typethe type of credential
dataclaim in binary encoding
data_sizenumber of bytes in data
Returns
NULL on error, otherwise human-readable representation of the claim

Definition at line 231 of file reclaim_credential.c.

234 {
235  unsigned int i;
236  struct Plugin *plugin;
237  char *ret;
238 
239  init ();
240  for (i = 0; i < num_plugins; i++)
241  {
243  if (NULL != (ret = plugin->api->value_to_string (plugin->api->cls,
244  type,
245  data,
246  data_size)))
247  return ret;
248  }
249  return NULL;
250 }
static unsigned int num_plugins
Number of plugins.
static void init()
Load plugins.
static struct Plugin ** credential_plugins
Plugins.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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
typetype of the claim
shuman-readable string
dataset to value in binary encoding (will be allocated)
data_sizeset to number of bytes in data
Returns
GNUNET_OK on success

Definition at line 199 of file reclaim_credential.c.

203 {
204  unsigned int i;
205  struct Plugin *plugin;
206 
207  init ();
208  for (i = 0; i < num_plugins; i++)
209  {
211  if (GNUNET_OK == plugin->api->string_to_value (plugin->api->cls,
212  type,
213  s,
214  data,
215  data_size))
216  return GNUNET_OK;
217  }
218  return GNUNET_SYSERR;
219 }

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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
typenumber of a type
Returns
corresponding typestring, NULL on error

Definition at line 170 of file reclaim_credential.c.

171 {
172  unsigned int i;
173  struct Plugin *plugin;
174  const char *ret;
175 
176  init ();
177  for (i = 0; i < num_plugins; i++)
178  {
180  if (NULL !=
181  (ret = plugin->api->number_to_typename (plugin->api->cls, type)))
182  return ret;
183  }
184  return NULL;
185 }

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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
typenamename to convert
Returns
corresponding number, UINT32_MAX on error

Definition at line 145 of file reclaim_credential.c.

146 {
147  unsigned int i;
148  struct Plugin *plugin;
149  uint32_t ret;
150  init ();
151  for (i = 0; i < num_plugins; i++)
152  {
154  if (UINT32_MAX !=
155  (ret = plugin->api->typename_to_number (plugin->api->cls,
156  typename)))
157  return ret;
158  }
159  return UINT32_MAX;
160 }

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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
typenamename to convert
Returns
corresponding number, UINT32_MAX on error

Definition at line 545 of file reclaim_credential.c.

547 {
548  unsigned int i;
549  struct Plugin *plugin;
551  init ();
552  for (i = 0; i < num_plugins; i++)
553  {
555  if (NULL !=
556  (ret = plugin->api->get_attributes (plugin->api->cls,
557  credential)))
558  return ret;
559  }
560  return NULL;
561 }

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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 565 of file reclaim_credential.c.

567 {
568  unsigned int i;
569  struct Plugin *plugin;
570  char *ret;
571  init ();
572  for (i = 0; i < num_plugins; i++)
573  {
575  if (NULL !=
576  (ret = plugin->api->get_issuer (plugin->api->cls,
577  credential)))
578  return ret;
579  }
580  return NULL;
581 }

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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 585 of file reclaim_credential.c.

588 {
589  unsigned int i;
590  struct Plugin *plugin;
591  init ();
592  for (i = 0; i < num_plugins; i++)
593  {
595  if (GNUNET_OK != plugin->api->get_expiration (plugin->api->cls,
596  credential,
597  exp))
598  continue;
599  return GNUNET_OK;
600  }
601  return GNUNET_SYSERR;
602 }

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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
presentationsthe presentation list to serialize
Returns
the required buffer size
Parameters
attrsthe attribute list to serialize
Returns
the required buffer size

Definition at line 746 of file reclaim_credential.c.

748 {
750  size_t len = 0;
751 
752  for (le = presentations->list_head; NULL != le; le = le->next)
753  {
754  GNUNET_assert (NULL != le->presentation);
756  }
757  return len;
758 }
size_t GNUNET_RECLAIM_presentation_serialize_get_size(const struct GNUNET_RECLAIM_Presentation *presentation)
Get required size for serialization buffer.
struct GNUNET_RECLAIM_Presentation * presentation
The credential.
struct GNUNET_RECLAIM_PresentationListEntry * next
DLL.
struct GNUNET_RECLAIM_PresentationListEntry * list_head
List head.

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 al)

Destroy presentations list.

Parameters
presentationslist to destroy

Destroy presentations list.

Parameters
attrslist to destroy

Definition at line 871 of file reclaim_credential.c.

873 {
875  struct GNUNET_RECLAIM_PresentationListEntry *tmp_ale;
876 
877  for (ale = al->list_head; NULL != ale;)
878  {
879  if (NULL != ale->presentation)
880  GNUNET_free (ale->presentation);
881  tmp_ale = ale;
882  ale = ale->next;
883  GNUNET_free (tmp_ale);
884  }
885  GNUNET_free (al);
886 }

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

Referenced by cleanup_cth(), cleanup_handle(), consume_timeout(), 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
presentationsthe attribute list to serialize
resultthe serialized list
Returns
length of serialized data

Serialize a presentation list.

Parameters
attrsthe attribute list to serialize
resultthe serialized attribute
Returns
length of serialized data

Definition at line 769 of file reclaim_credential.c.

772 {
774  size_t len;
775  size_t total_len;
776  char *write_ptr;
777  write_ptr = result;
778  total_len = 0;
779  for (le = presentations->list_head; NULL != le; le = le->next)
780  {
781  GNUNET_assert (NULL != le->presentation);
783  total_len += len;
784  write_ptr += len;
785  }
786  return total_len;
787 }
size_t GNUNET_RECLAIM_presentation_serialize(const struct GNUNET_RECLAIM_Presentation *presentation, char *result)
Serialize an presentation.

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
datathe serialized list
data_sizethe length of the serialized data
Returns
a GNUNET_RECLAIM_PresentationList, must be free'd by caller

Deserialize a presentation list.

Parameters
datathe serialized attribute list
data_sizethe length of the serialized data
Returns
a GNUNET_IDENTITY_PROVIDER_AttributeList, must be free'd by caller

Definition at line 798 of file reclaim_credential.c.

800 {
803  size_t att_len;
804  const char *read_ptr;
805 
807 
808  if (data_size < sizeof(struct Presentation))
809  return al;
810 
811  read_ptr = data;
812  while (((data + data_size) - read_ptr) >= sizeof(struct Presentation))
813  {
815  ale->presentation =
817  data_size - (read_ptr - data));
818  if (NULL == ale->presentation)
819  {
821  "Failed to deserialize malformed presentation.\n");
822  GNUNET_free (ale);
823  return al;
824  }
827  ale->presentation);
828  read_ptr += att_len;
829  }
830  return al;
831 }
struct GNUNET_RECLAIM_Presentation * GNUNET_RECLAIM_presentation_deserialize(const char *data, size_t data_size)
Deserialize an presentation.
A list of GNUNET_RECLAIM_Presentation structures.
struct GNUNET_RECLAIM_PresentationListEntry * list_tail
List tail.
Serialized presentation claim.

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
presentationthe presentation to serialize
Returns
the required buffer size
Parameters
attrthe presentation to serialize
Returns
the required buffer size

Definition at line 896 of file reclaim_credential.c.

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

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
presentationthe presentation to serialize
resultthe serialized presentation
Returns
length of serialized data

Serialize a presentation.

Parameters
attrthe presentation to serialize
resultthe serialized presentation
Returns
length of serialized data

Definition at line 911 of file reclaim_credential.c.

914 {
915  struct Presentation *atts;
916  char *write_ptr;
917 
918  atts = (struct Presentation *) result;
919  atts->presentation_type = htons (presentation->type);
920  atts->credential_id = presentation->credential_id;
921  write_ptr = (char *) &atts[1];
922  GNUNET_memcpy (write_ptr, presentation->data, presentation->data_size);
923  atts->data_size = htons (presentation->data_size);
924 
925  return sizeof(struct Presentation) + presentation->data_size;
926 }
const void * data
Binary value stored as presentation value.
uint32_t type
Type/Format of Claim.
size_t data_size
Number of bytes in data.
struct GNUNET_RECLAIM_Identifier credential_id
The credential id of which this is a presentation.
struct GNUNET_RECLAIM_Identifier credential_id
Credential ID.
uint32_t presentation_type
Presentation type.
uint32_t data_size
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
datathe serialized presentation
data_sizethe length of the serialized data
Returns
a GNUNET_RECLAIM_Presentation, must be free'd by caller

Deserialize a presentation.

Parameters
datathe serialized presentation
data_sizethe length of the serialized data
Returns
a GNUNET_IDENTITY_PROVIDER_Attribute, must be free'd by caller

Definition at line 938 of file reclaim_credential.c.

939 {
940  struct GNUNET_RECLAIM_Presentation *presentation;
941  struct Presentation *atts;
942  size_t data_len;
943  char *write_ptr;
944 
945  if (data_size < sizeof(struct Presentation))
946  return NULL;
947 
948  atts = (struct Presentation *) data;
949  data_len = ntohs (atts->data_size);
950  if (data_size < sizeof(struct Presentation) + data_len)
951  {
953  "Buffer too small to deserialize\n");
954  return NULL;
955  }
956  presentation = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Presentation)
957  + data_len);
958  presentation->type = ntohs (atts->presentation_type);
959  presentation->credential_id = atts->credential_id;
960  presentation->data_size = data_len;
961 
962  write_ptr = (char *) &presentation[1];
963  GNUNET_memcpy (write_ptr, &atts[1], data_len);
964  presentation->data = write_ptr;
965  return presentation;
966 }
A credential 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
typethe type of presentation
datapresentation in binary encoding
data_sizenumber 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
typethe type of presentation
dataclaim in binary encoding
data_sizenumber of bytes in data
Returns
NULL on error, otherwise human-readable representation of the claim

Definition at line 698 of file reclaim_credential.c.

701 {
702  unsigned int i;
703  struct Plugin *plugin;
704  char *ret;
705 
706  init ();
707  for (i = 0; i < num_plugins; i++)
708  {
710  if (NULL != (ret = plugin->api->value_to_string_p (plugin->api->cls,
711  type,
712  data,
713  data_size)))
714  return ret;
715  }
716  return NULL;
717 }

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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 721 of file reclaim_credential.c.

724 {
725  struct GNUNET_RECLAIM_Presentation *attr;
726  char *write_ptr;
727 
728  attr = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Presentation)
729  + data_size);
730  attr->type = type;
731  attr->data_size = data_size;
732  write_ptr = (char *) &attr[1];
733  GNUNET_memcpy (write_ptr, data, data_size);
734  attr->data = write_ptr;
735  return attr;
736 }

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
typetype of the presentation
shuman-readable string
dataset to value in binary encoding (will be allocated)
data_sizeset 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
typetype of the claim
shuman-readable string
dataset to value in binary encoding (will be allocated)
data_sizeset to number of bytes in data
Returns
GNUNET_OK on success

Definition at line 666 of file reclaim_credential.c.

670 {
671  unsigned int i;
672  struct Plugin *plugin;
673 
674  init ();
675  for (i = 0; i < num_plugins; i++)
676  {
678  if (GNUNET_OK == plugin->api->string_to_value_p (plugin->api->cls,
679  type,
680  s,
681  data,
682  data_size))
683  return GNUNET_OK;
684  }
685  return GNUNET_SYSERR;
686 }

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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
typenumber of a type
Returns
corresponding typestring, NULL on error

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

Parameters
typenumber of a type
Returns
corresponding typestring, NULL on error

Definition at line 637 of file reclaim_credential.c.

638 {
639  unsigned int i;
640  struct Plugin *plugin;
641  const char *ret;
642 
643  init ();
644  for (i = 0; i < num_plugins; i++)
645  {
647  if (NULL !=
648  (ret = plugin->api->number_to_typename_p (plugin->api->cls, type)))
649  return ret;
650  }
651  return NULL;
652 }

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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 970 of file reclaim_credential.c.

973 {
974  unsigned int i;
975  struct Plugin *plugin;
977  init ();
978  for (i = 0; i < num_plugins; i++)
979  {
981  if (NULL !=
982  (ret = plugin->api->get_attributes_p (plugin->api->cls,
983  presentation)))
984  return ret;
985  }
986  return NULL;
987 }

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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 991 of file reclaim_credential.c.

994 {
995  unsigned int i;
996  struct Plugin *plugin;
997  char *ret;
998  init ();
999  for (i = 0; i < num_plugins; i++)
1000  {
1002  if (NULL !=
1003  (ret = plugin->api->get_issuer_p (plugin->api->cls,
1004  presentation)))
1005  return ret;
1006  }
1007  return NULL;
1008 }

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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 1012 of file reclaim_credential.c.

1016 {
1017  unsigned int i;
1018  struct Plugin *plugin;
1019  init ();
1020  for (i = 0; i < num_plugins; i++)
1021  {
1023  if (GNUNET_OK != plugin->api->get_expiration_p (plugin->api->cls,
1024  presentation,
1025  exp))
1026  continue;
1027  return GNUNET_OK;
1028  }
1029  return GNUNET_SYSERR;
1030 }

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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
credthe credential to use
attrsthe attributes to present from the credential
presentationthe credential presentation presenting the attributes according to the presentation mechanism of the credential or NULL on error.
Returns
GNUNET_OK on success.
Parameters
credthe credential to use
attrsthe 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 1044 of file reclaim_credential.c.

1048 {
1049  unsigned int i;
1050  struct Plugin *plugin;
1051  init ();
1052  for (i = 0; i < num_plugins; i++)
1053  {
1055  if (GNUNET_OK != plugin->api->create_presentation (plugin->api->cls,
1056  cred,
1057  attrs,
1058  presentation))
1059  continue;
1060  (*presentation)->credential_id = cred->id;
1061  return GNUNET_OK;
1062  }
1063  return GNUNET_SYSERR;
1064 }
struct GNUNET_RECLAIM_Identifier id
ID.

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, 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().