GNUnet 0.22.0
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_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 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_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 78 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
@ GNUNET_NO
static const struct GNUNET_RECLAIM_Identifier GNUNET_RECLAIM_ID_ZERO

Definition at line 94 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 102 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 106 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 46 of file gnunet_reclaim_lib.h.

46 {
51
56};
@ 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 58 of file gnunet_reclaim_lib.h.

58 {
63
68
73};
@ 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

Definition at line 256 of file reclaim_attribute.c.

262{
263 struct GNUNET_RECLAIM_Attribute *attr;
264 char *write_ptr;
265 char *attr_name_tmp = GNUNET_strdup (attr_name);
266
267 GNUNET_STRINGS_utf8_tolower (attr_name, attr_name_tmp);
268
269 attr = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Attribute)
270 + strlen (attr_name_tmp) + 1 + data_size);
271 if (NULL != credential)
272 attr->credential = *credential;
273 attr->type = type;
274 attr->data_size = data_size;
275 attr->flag = 0;
276 write_ptr = (char *) &attr[1];
277 GNUNET_memcpy (write_ptr, attr_name_tmp, strlen (attr_name_tmp) + 1);
278 attr->name = write_ptr;
279 write_ptr += strlen (attr->name) + 1;
280 GNUNET_memcpy (write_ptr, data, data_size);
281 attr->data = write_ptr;
282 GNUNET_free (attr_name_tmp);
283 return attr;
284}
static char * data
The data to insert into the dht.
static uint32_t type
Type string converted to DNS type value.
static size_t data_size
Number of bytes in data.
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.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_utf8_tolower(const char *input, char *output)
Convert the utf-8 input string to lower case.
Definition: strings.c:450
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.

References attr_name, credential, GNUNET_RECLAIM_Attribute::credential, data, GNUNET_RECLAIM_Attribute::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, type, and GNUNET_RECLAIM_Attribute::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(), and parse_attr().

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 315 of file reclaim_attribute.c.

317{
319 size_t len = 0;
320
321 for (ale = al->list_head; NULL != ale; ale = ale->next)
322 {
323 GNUNET_assert (NULL != ale->attribute);
325 }
326 return len;
327}
#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(), GNUNET_RECLAIM_AttributeList::list_head, and GNUNET_RECLAIM_AttributeListEntry::next.

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

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
attrslist to destroy

Definition at line 427 of file reclaim_attribute.c.

429{
431 struct GNUNET_RECLAIM_AttributeListEntry *tmp_ale;
432
433 for (ale = al->list_head; NULL != ale;)
434 {
435 if (NULL != ale->attribute)
436 GNUNET_free (ale->attribute);
437 tmp_ale = ale;
438 ale = ale->next;
439 GNUNET_free (tmp_ale);
440 }
441 GNUNET_free (al);
442}

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

Definition at line 288 of file reclaim_attribute.c.

295{
297
299 ale->attribute =
302 GNUNET_CONTAINER_DLL_insert (al->list_head,
303 al->list_tail,
304 ale);
305}
#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 claim.

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

Definition at line 331 of file reclaim_attribute.c.

334{
336 size_t len;
337 size_t total_len;
338 char *write_ptr;
339 write_ptr = result;
340 total_len = 0;
341 for (ale = attrs->list_head; NULL != ale; ale = ale->next)
342 {
343 GNUNET_assert (NULL != ale->attribute);
344 len = GNUNET_RECLAIM_attribute_serialize (ale->attribute, write_ptr);
345 total_len += len;
346 write_ptr += len;
347 }
348 return total_len;
349}
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(), GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_AttributeListEntry::next, and result.

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

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 360 of file reclaim_attribute.c.

361{
364 size_t attr_len;
365 const char *read_ptr;
366 size_t left = data_size;
367
369 if (data_size < sizeof(struct Attribute))
370 return al;
371 read_ptr = data;
372 while (left >= sizeof(struct Attribute))
373 {
375 attr_len =
377 left,
378 &ale->attribute);
379 if (-1 == attr_len)
380 {
382 "Failed to deserialize malformed attribute.\n");
383 GNUNET_free (ale);
384 return al;
385 }
386 left -= attr_len;
388 read_ptr += attr_len;
389 }
390 return al;
391}
#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.
struct GNUNET_RECLAIM_AttributeListEntry * list_tail
List tail.

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 452 of file reclaim_attribute.c.

454{
455 return sizeof(struct Attribute) + strlen (attr->name) + attr->data_size;
456}
static char * name
Name (label) of the records to list.

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 467 of file reclaim_attribute.c.

470{
471 size_t data_len_ser;
472 size_t name_len;
473 struct Attribute *attr_ser;
474 char *write_ptr;
475
476 attr_ser = (struct Attribute *) result;
477 attr_ser->attribute_type = htonl (attr->type);
478 attr_ser->attribute_flag = htonl (attr->flag);
479 attr_ser->attribute_id = attr->id;
480 attr_ser->credential_id = attr->credential;
481 name_len = strlen (attr->name);
482 attr_ser->name_len = htons (name_len);
483 write_ptr = (char *) &attr_ser[1];
484 GNUNET_memcpy (write_ptr, attr->name, name_len);
485 write_ptr += name_len;
486 // TODO plugin-ize
487 // data_len_ser = plugin->serialize_attribute_value (attr,
488 // &attr_ser[1]);
489 data_len_ser = attr->data_size;
490 GNUNET_memcpy (write_ptr, attr->data, attr->data_size);
491 attr_ser->data_size = htons (data_len_ser);
492
493 return sizeof(struct Attribute) + strlen (attr->name) + attr->data_size;
494}
struct GNUNET_RECLAIM_Identifier attribute_id
Attribute ID.
uint16_t name_len
Name length.
uint16_t data_size
Data size.
uint32_t attribute_type
Attribute type.
struct GNUNET_RECLAIM_Identifier credential_id
Credential ID.
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 506 of file reclaim_attribute.c.

508{
509 struct Attribute *attr_ser;
510 struct GNUNET_RECLAIM_Attribute *attribute;
511 size_t data_len;
512 size_t name_len;
513 char *write_ptr;
514
515 if (data_size < sizeof(struct Attribute))
516 return -1;
517
518 attr_ser = (struct Attribute *) data;
519 data_len = ntohs (attr_ser->data_size);
520 name_len = ntohs (attr_ser->name_len);
521 if (data_size < sizeof(struct Attribute) + data_len + name_len)
522 {
524 "Buffer too small to deserialize\n");
525 return -1;
526 }
527 attribute = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Attribute)
528 + data_len + name_len + 1);
529 attribute->type = ntohl (attr_ser->attribute_type);
530 attribute->flag = ntohl (attr_ser->attribute_flag);
531 attribute->id = attr_ser->attribute_id;
532 attribute->credential = attr_ser->credential_id;
533 attribute->data_size = data_len;
534
535 write_ptr = (char *) &attribute[1];
536 GNUNET_memcpy (write_ptr, &attr_ser[1], name_len);
537 write_ptr[name_len] = '\0';
538 attribute->name = write_ptr;
539
540 write_ptr += name_len + 1;
541 GNUNET_memcpy (write_ptr, (char *) &attr_ser[1] + name_len,
542 attribute->data_size);
543 *attr = attribute;
544 attribute->data = write_ptr;
545 return sizeof(struct Attribute) + data_len + name_len;
546}
@ GNUNET_ERROR_TYPE_ERROR

References Attribute::attribute_flag, Attribute::attribute_id, Attribute::attribute_type, GNUNET_RECLAIM_Attribute::credential, Attribute::credential_id, data, GNUNET_RECLAIM_Attribute::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
attrsclaim list to copy
Returns
copied claim list

Definition at line 395 of file reclaim_attribute.c.

397{
399 struct GNUNET_RECLAIM_AttributeListEntry *result_ale;
401
403 for (ale = attrs->list_head; NULL != ale; ale = ale->next)
404 {
405 result_ale = GNUNET_new (struct GNUNET_RECLAIM_AttributeListEntry);
406 GNUNET_assert (NULL != ale->attribute);
407 {
408 result_ale->attribute =
410 &ale->attribute->credential,
411 ale->attribute->type,
412 ale->attribute->data,
413 ale->attribute->data_size);
414
415 result_ale->attribute->id = ale->attribute->id;
416 result_ale->attribute->flag = ale->attribute->flag;
417 }
419 result->list_tail,
420 result_ale);
421 }
422 return result;
423}

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 147 of file reclaim_attribute.c.

148{
149 unsigned int i;
150 struct Plugin *plugin;
151 uint32_t ret;
152
153 init ();
154 for (i = 0; i < num_plugins; i++)
155 {
156 plugin = attr_plugins[i];
157 if (UINT32_MAX !=
158 (ret = plugin->api->typename_to_number (plugin->api->cls, typename)))
159 return ret;
160 }
161 return UINT32_MAX;
162}
static int ret
Final status code.
Definition: gnunet-arm.c:93
static struct GNUNET_TESTING_PluginFunctions * plugin
Plugin to dynamically load a test case.
static struct Plugin ** attr_plugins
Plugins.
static unsigned int num_plugins
Number of plugins.
static void init()
Load plugins.
void * cls
Closure to pass to start_testcase.
Handle for a plugin.
Definition: block.c:38

References attr_plugins, GNUNET_TESTING_PluginFunctions::cls, init(), num_plugins, plugin, and ret.

Referenced by iter_finished(), and parse_attr().

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 201 of file reclaim_attribute.c.

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

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

Referenced by iter_finished(), and parse_attr().

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 233 of file reclaim_attribute.c.

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

References attr_plugins, GNUNET_TESTING_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 172 of file reclaim_attribute.c.

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

References attr_plugins, GNUNET_TESTING_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
credentialsthe attribute list to serialize
Returns
the required buffer size
Parameters
attrsthe attribute list to serialize
Returns
the required buffer size

Definition at line 289 of file reclaim_credential.c.

291{
293 size_t len = 0;
294
295 for (le = credentials->list_head; NULL != le; le = le->next)
296 {
297 GNUNET_assert (NULL != le->credential);
299 len += sizeof(struct GNUNET_RECLAIM_CredentialListEntry);
300 }
301 return len;
302}
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(), 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
credentialslist to destroy

Definition at line 397 of file reclaim_credential.c.

399{
402
403 for (ale = credentials->list_head; NULL != ale;)
404 {
405 if (NULL != ale->credential)
406 GNUNET_free (ale->credential);
407 tmp_ale = ale;
408 ale = ale->next;
409 GNUNET_free (tmp_ale);
410 }
411 GNUNET_free (credentials);
412}

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 a credential list.

Parameters
credentialsthe credential list to serialize
resultthe serialized credential
Returns
length of serialized data

Definition at line 306 of file reclaim_credential.c.

309{
311 size_t len;
312 size_t total_len;
313 char *write_ptr;
314 write_ptr = result;
315 total_len = 0;
316 for (le = credentials->list_head; NULL != le; le = le->next)
317 {
318 GNUNET_assert (NULL != le->credential);
319 len = GNUNET_RECLAIM_credential_serialize (le->credential, write_ptr);
320 total_len += len;
321 write_ptr += len;
322 }
323 return total_len;
324}
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(), 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

Definition at line 328 of file reclaim_credential.c.

329{
332 size_t att_len;
333 const char *read_ptr;
334
336
337 if ((data_size < sizeof(struct
339 + sizeof(struct GNUNET_RECLAIM_CredentialListEntry)))
340 return al;
341
342 read_ptr = data;
343 while (((data + data_size) - read_ptr) >= sizeof(struct Credential))
344 {
346 ale->credential =
348 data_size - (read_ptr - data));
349 if (NULL == ale->credential)
350 {
352 "Failed to deserialize malformed credential.\n");
353 GNUNET_free (ale);
354 return al;
355 }
358 read_ptr += att_len;
359 }
360 return al;
361}
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 422 of file reclaim_credential.c.

424{
425 return sizeof(struct Credential) + strlen (credential->name)
427}

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

Definition at line 431 of file reclaim_credential.c.

434{
435 size_t data_len_ser;
436 size_t name_len;
437 struct Credential *atts;
438 char *write_ptr;
439
440 atts = (struct Credential *) result;
441 atts->credential_type = htonl (credential->type);
442 atts->credential_flag = htonl (credential->flag);
443 atts->credential_id = credential->id;
444 name_len = strlen (credential->name);
445 atts->name_len = htons (name_len);
446 write_ptr = (char *) &atts[1];
447 GNUNET_memcpy (write_ptr, credential->name, name_len);
448 write_ptr += name_len;
449 // TODO plugin-ize
450 // data_len_ser = plugin->serialize_attribute_value (attr,
451 // &attr_ser[1]);
452 data_len_ser = credential->data_size;
453 GNUNET_memcpy (write_ptr, credential->data, credential->data_size);
454 atts->data_size = htons (data_len_ser);
455
456 return sizeof(struct Credential) + strlen (credential->name)
458}
uint16_t name_len
Name length.
struct GNUNET_RECLAIM_Identifier credential_id
Credential ID.
uint32_t credential_type
Credential type.
uint32_t credential_flag
Credential flag.
uint16_t data_size
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
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 470 of file reclaim_credential.c.

471{
473 struct Credential *atts;
474 size_t data_len;
475 size_t name_len;
476 char *write_ptr;
477
478 if (data_size < sizeof(struct Credential))
479 return NULL;
480
481 atts = (struct Credential *) data;
482 data_len = ntohs (atts->data_size);
483 name_len = ntohs (atts->name_len);
484 if (data_size < sizeof(struct Credential) + data_len + name_len)
485 {
487 "Buffer too small to deserialize\n");
488 return NULL;
489 }
491 + data_len + name_len + 1);
492 credential->type = ntohl (atts->credential_type);
493 credential->flag = ntohl (atts->credential_flag);
494 credential->id = atts->credential_id;
495 credential->data_size = data_len;
496
497 write_ptr = (char *) &credential[1];
498 GNUNET_memcpy (write_ptr, &atts[1], name_len);
499 write_ptr[name_len] = '\0';
500 credential->name = write_ptr;
501
502 write_ptr += name_len + 1;
503 GNUNET_memcpy (write_ptr, (char *) &atts[1] + name_len,
504 credential->data_size);
505 credential->data = write_ptr;
506 return credential;
507}

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
namethe credential name
typethe credential type
datathe credential value
data_sizethe credential value size
Returns
the new credential

Definition at line 255 of file reclaim_credential.c.

259{
260 struct GNUNET_RECLAIM_Credential *attr;
261 char *write_ptr;
262 char *attr_name_tmp = GNUNET_strdup (attr_name);
263
264 GNUNET_STRINGS_utf8_tolower (attr_name, attr_name_tmp);
265
266 attr = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Credential)
267 + strlen (attr_name_tmp) + 1 + data_size);
268 attr->type = type;
269 attr->data_size = data_size;
270 attr->flag = 0;
271 write_ptr = (char *) &attr[1];
272 GNUNET_memcpy (write_ptr, attr_name_tmp, strlen (attr_name_tmp) + 1);
273 attr->name = write_ptr;
274 write_ptr += strlen (attr->name) + 1;
275 GNUNET_memcpy (write_ptr, data, data_size);
276 attr->data = write_ptr;
277 GNUNET_free (attr_name_tmp);
278 return attr;
279}
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, data, GNUNET_RECLAIM_Credential::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, type, and GNUNET_RECLAIM_Credential::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 232 of file reclaim_credential.c.

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

References GNUNET_TESTING_PluginFunctions::cls, credential_plugins, data, data_size, 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_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 200 of file reclaim_credential.c.

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

References GNUNET_TESTING_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 171 of file reclaim_credential.c.

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

References GNUNET_TESTING_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 146 of file reclaim_credential.c.

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

References GNUNET_TESTING_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 511 of file reclaim_credential.c.

513{
514 unsigned int i;
515 struct Plugin *plugin;
517 init ();
518 for (i = 0; i < num_plugins; i++)
519 {
521 if (NULL !=
522 (ret = plugin->api->get_attributes (plugin->api->cls,
523 credential)))
524 return ret;
525 }
526 return NULL;
527}

References GNUNET_TESTING_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 531 of file reclaim_credential.c.

533{
534 unsigned int i;
535 struct Plugin *plugin;
536 char *ret;
537 init ();
538 for (i = 0; i < num_plugins; i++)
539 {
541 if (NULL !=
542 (ret = plugin->api->get_issuer (plugin->api->cls,
543 credential)))
544 return ret;
545 }
546 return NULL;
547}

References GNUNET_TESTING_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 551 of file reclaim_credential.c.

554{
555 unsigned int i;
556 struct Plugin *plugin;
557 init ();
558 for (i = 0; i < num_plugins; i++)
559 {
561 if (GNUNET_OK != plugin->api->get_expiration (plugin->api->cls,
563 exp))
564 continue;
565 return GNUNET_OK;
566 }
567 return GNUNET_SYSERR;
568}

References GNUNET_TESTING_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 706 of file reclaim_credential.c.

708{
710 size_t len = 0;
711
712 for (le = presentations->list_head; NULL != le; le = le->next)
713 {
714 GNUNET_assert (NULL != le->presentation);
716 }
717 return len;
718}
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(), GNUNET_RECLAIM_PresentationList::list_head, GNUNET_RECLAIM_PresentationListEntry::next, and GNUNET_RECLAIM_PresentationListEntry::presentation.

Referenced by consume_result_cb(), OIDC_build_authz_code(), 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
presentationslist to destroy

Definition at line 819 of file reclaim_credential.c.

821{
824
825 for (ale = presentations->list_head; NULL != ale;)
826 {
827 if (NULL != ale->presentation)
829 tmp_ale = ale;
830 ale = ale->next;
831 GNUNET_free (tmp_ale);
832 }
833 GNUNET_free (presentations);
834}

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

Definition at line 722 of file reclaim_credential.c.

725{
727 size_t len;
728 size_t total_len;
729 char *write_ptr;
730 write_ptr = result;
731 total_len = 0;
732 for (le = presentations->list_head; NULL != le; le = le->next)
733 {
734 GNUNET_assert (NULL != le->presentation);
736 total_len += len;
737 write_ptr += len;
738 }
739 return total_len;
740}
size_t GNUNET_RECLAIM_presentation_serialize(const struct GNUNET_RECLAIM_Presentation *presentation, char *result)
Serialize a presentation.

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

Referenced by consume_result_cb(), OIDC_build_authz_code(), 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 751 of file reclaim_credential.c.

753{
756 size_t att_len;
757 const char *read_ptr;
758
760
761 if (data_size < sizeof(struct Presentation))
762 return al;
763
764 read_ptr = data;
765 while (((data + data_size) - read_ptr) >= sizeof(struct Presentation))
766 {
768 ale->presentation =
770 data_size - (read_ptr - data));
771 if (NULL == ale->presentation)
772 {
774 "Failed to deserialize malformed presentation.\n");
775 GNUNET_free (ale);
776 return al;
777 }
780 ale->presentation);
781 read_ptr += att_len;
782 }
783 return al;
784}
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 844 of file reclaim_credential.c.

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

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

Definition at line 852 of file reclaim_credential.c.

855{
856 struct Presentation *atts;
857 char *write_ptr;
858
859 atts = (struct Presentation *) result;
860 atts->presentation_type = htonl (presentation->type);
861 atts->credential_id = presentation->credential_id;
862 write_ptr = (char *) &atts[1];
863 GNUNET_memcpy (write_ptr, presentation->data, presentation->data_size);
864 atts->data_size = htons (presentation->data_size);
865
866 return sizeof(struct Presentation) + presentation->data_size;
867}
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.
uint16_t data_size
Data size.
uint32_t presentation_type
Presentation type.

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 879 of file reclaim_credential.c.

880{
881 struct GNUNET_RECLAIM_Presentation *presentation;
882 struct Presentation *atts;
883 size_t data_len;
884 char *write_ptr;
885
886 if (data_size < sizeof(struct Presentation))
887 return NULL;
888
889 atts = (struct Presentation *) data;
890 data_len = ntohs (atts->data_size);
891 if (data_size < sizeof(struct Presentation) + data_len)
892 {
894 "Buffer too small to deserialize\n");
895 return NULL;
896 }
897 presentation = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Presentation)
898 + data_len);
899 presentation->type = ntohl (atts->presentation_type);
900 presentation->credential_id = atts->credential_id;
901 presentation->data_size = data_len;
902
903 write_ptr = (char *) &presentation[1];
904 GNUNET_memcpy (write_ptr, &atts[1], data_len);
905 presentation->data = write_ptr;
906 return presentation;
907}
A credential presentation.

References GNUNET_RECLAIM_Presentation::credential_id, Presentation::credential_id, data, GNUNET_RECLAIM_Presentation::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 658 of file reclaim_credential.c.

661{
662 unsigned int i;
663 struct Plugin *plugin;
664 char *ret;
665
666 init ();
667 for (i = 0; i < num_plugins; i++)
668 {
670 if (NULL != (ret = plugin->api->value_to_string_p (plugin->api->cls,
671 type,
672 data,
673 data_size)))
674 return ret;
675 }
676 return NULL;
677}

References GNUNET_TESTING_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 681 of file reclaim_credential.c.

684{
685 struct GNUNET_RECLAIM_Presentation *attr;
686 char *write_ptr;
687
688 attr = GNUNET_malloc (sizeof(struct GNUNET_RECLAIM_Presentation)
689 + data_size);
690 attr->type = type;
691 attr->data_size = data_size;
692 write_ptr = (char *) &attr[1];
693 GNUNET_memcpy (write_ptr, data, data_size);
694 attr->data = write_ptr;
695 return attr;
696}

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

Referenced by consume_ticket(), GNUNET_RECLAIM_presentation_list_dup(), jwt_create_presentation(), 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 626 of file reclaim_credential.c.

630{
631 unsigned int i;
632 struct Plugin *plugin;
633
634 init ();
635 for (i = 0; i < num_plugins; i++)
636 {
638 if (GNUNET_OK == plugin->api->string_to_value_p (plugin->api->cls,
639 type,
640 s,
641 data,
642 data_size))
643 return GNUNET_OK;
644 }
645 return GNUNET_SYSERR;
646}

References GNUNET_TESTING_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

Definition at line 597 of file reclaim_credential.c.

598{
599 unsigned int i;
600 struct Plugin *plugin;
601 const char *ret;
602
603 init ();
604 for (i = 0; i < num_plugins; i++)
605 {
607 if (NULL !=
608 (ret = plugin->api->number_to_typename_p (plugin->api->cls, type)))
609 return ret;
610 }
611 return NULL;
612}

References GNUNET_TESTING_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 911 of file reclaim_credential.c.

914{
915 unsigned int i;
916 struct Plugin *plugin;
918 init ();
919 for (i = 0; i < num_plugins; i++)
920 {
922 if (NULL !=
923 (ret = plugin->api->get_attributes_p (plugin->api->cls,
924 presentation)))
925 return ret;
926 }
927 return NULL;
928}

References GNUNET_TESTING_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 932 of file reclaim_credential.c.

935{
936 unsigned int i;
937 struct Plugin *plugin;
938 char *ret;
939 init ();
940 for (i = 0; i < num_plugins; i++)
941 {
943 if (NULL !=
944 (ret = plugin->api->get_issuer_p (plugin->api->cls,
945 presentation)))
946 return ret;
947 }
948 return NULL;
949}

References GNUNET_TESTING_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 953 of file reclaim_credential.c.

957{
958 unsigned int i;
959 struct Plugin *plugin;
960 init ();
961 for (i = 0; i < num_plugins; i++)
962 {
964 if (GNUNET_OK != plugin->api->get_expiration_p (plugin->api->cls,
965 presentation,
966 exp))
967 continue;
968 return GNUNET_OK;
969 }
970 return GNUNET_SYSERR;
971}

References GNUNET_TESTING_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 985 of file reclaim_credential.c.

989{
990 unsigned int i;
991 struct Plugin *plugin;
992 init ();
993 for (i = 0; i < num_plugins; i++)
994 {
996 if (GNUNET_OK != plugin->api->create_presentation (plugin->api->cls,
997 cred,
998 attrs,
999 presentation))
1000 continue;
1001 (*presentation)->credential_id = cred->id;
1002 return GNUNET_OK;
1003 }
1004 return GNUNET_SYSERR;
1005}
static gnutls_certificate_credentials_t cred
The credential.

References GNUNET_TESTING_PluginFunctions::cls, cred, credential_plugins, GNUNET_OK, GNUNET_SYSERR, 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 92 of file gnunet_reclaim_lib.h.

Referenced by start_process().